# Tokens d'actions Robinhood Chain : lire le multiplicateur, les détenteurs et l'activité quotidienne avec une seule API key

> Source: https://docs.blockvectra.com/fr/guides/stock-token-multiplier/

> Les données proviennent des registres publics on-chain et de l'état des smart contracts. Elles sont fournies à titre informatif uniquement et ne constituent pas un conseil en investissement. Les tokens d'actions sont soumis à des restrictions juridictionnelles.


Robinhood Chain prend en charge les actifs réels tokenisés (RWA), y compris les actions américaines et les fonds négociés en bourse (ETF) tokenisés. Alors que les jetons ERC-20 standard associent les soldes selon un ratio de 1:1, les actions tokenisées introduisent un multiplicateur d'opérations sur titres (corporate actions) afin de s'adapter aux fractionnements d'actions (stock splits) et aux ajustements de dividendes sans modifier les soldes des portefeuilles.

Ce guide explique le fonctionnement du multiplicateur de tokens d'actions, comment convertir les soldes de jetons bruts en nombre d'actions sous-jacentes, comment interroger `uiMultiplier` on-chain via le JSON-RPC `eth_call`, et comment récupérer le nombre quotidien de détenteurs et l'activité de transfert via la Data API de BlockVectra.

Pour les paramètres généraux du réseau, les politiques de méthodes et la configuration RPC, consultez le [guide Robinhood Chain](https://docs.blockvectra.com/fr/guides/robinhood-chain/). Pour une référence exhaustive des champs et les modèles d'utilisation des Compute Units (CU) pour ce jeu de données, consultez le [guide des actions tokenisées](https://docs.blockvectra.com/fr/guides/stocks/).

## Qu'est-ce que le multiplicateur de tokens d'actions

Les tokens d'actions Robinhood sont des jetons ERC-20 standard (à 18 décimales) émis par Robinhood Assets (Jersey) Limited (RHJ). Pour gérer les opérations sur titres telles que les fractionnements d'actions et les dividendes réinvestis, ces contrats implémentent l'**ERC-8056 (Scaled UI Amount Extension)**.

Le multiplicateur (`uiMultiplier`) définit le ratio `actions-par-token` :

* **Précision** : `uiMultiplier()` est représenté sous forme de nombre à virgule fixe à 18 décimales, où `1e18` équivaut à `1.0`.
* **Valeur initiale** : lors de l'émission du jeton, le multiplicateur est initialisé à `1e18` (un jeton représente une action sous-jacente).
* **Opérations sur titres** : lorsqu'un événement d'entreprise survient (tel qu'un fractionnement d'actions direct ou un dividende réinvesti), le contrat du jeton met à jour `uiMultiplier` et émet l'événement `UIMultiplierUpdated(uint256 oldMultiplier, uint256 newMultiplier, uint256 effectiveAtTimestamp)`.

### Soldes de jetons fixes lors des fractionnements

Les tokens d'actions ne sont **pas des jetons de rebasage (rebasing tokens)**. Lors d'opérations sur titres :

* Les soldes de portefeuille (`balanceOf(account)`) et l'émission totale de jetons (`totalSupply()`) **restent inchangés**.
* Seul le multiplicateur d'échelle change.

Par exemple, si une action sous-jacente réalise un fractionnement 2 pour 1 :

* Un détenteur possédant 10 jetons continue d'en détenir 10 dans `balanceOf`.
* Le contrat met à jour `uiMultiplier` de `1.0` (`1e18`) à `2.0` (`2e18`).
* Chaque jeton représente désormais 2 actions sous-jacentes, conférant au détenteur une exposition effective de 20 actions.

### Convertir les soldes en nombre d'actions

Pour calculer le nombre d'actions sous-jacentes représentées par un solde de jetons, utilisez la formule ERC-8056 :

```text
underlying shares = raw token amount × uiMultiplier ÷ 1e18
```

Les contrats de jetons ERC-8056 exposent également des fonctions d'assistance en lecture seule on-chain :

* `balanceOfUI(address account)` : renvoie directement le solde du compte exprimé en actions sous-jacentes (mis à l'échelle par `uiMultiplier`, 18 décimales).
* `totalSupplyUI()` : renvoie directement l'offre totale de jetons exprimée en actions sous-jacentes.

De plus, les transferts de jetons émettent l'événement `TransferWithScaledUI(address indexed from, address indexed to, uint256 value, uint256 uiValue)`, enregistrant à la fois le montant brut du jeton et le nombre d'actions sous-jacentes mis à l'échelle.

### Multiplicateur et flux de prix des oracles

Robinhood Chain déploie un flux de prix Chainlink dédié (`AggregatorV3Interface`) pour chaque token d'action :

* Le flux de prix Chainlink (`latestRoundData()`) **intègre déjà le multiplicateur**. Il reflète le prix de marché complet d'un jeton (le prix de l'action sous-jacente multiplié par le multiplicateur).
* Les applications lisant l'oracle Chainlink on-chain reçoivent directement le prix ajusté par le multiplicateur et **ne doivent pas** appliquer le multiplicateur une seconde fois.
* Les métadonnées hors-chaîne peuvent également être vérifiées via le point de terminaison REST de Robinhood `GET https://api.robinhood.com/rhj/assets`, qui fournit `currentMultiplier` et `pendingMultiplier`.

## Lire le multiplicateur avec le JSON-RPC eth\_call

Vous pouvez inspecter le multiplicateur de n'importe quelle action tokenisée directement via le point de terminaison JSON-RPC de BlockVectra pour Robinhood Chain à l'aide d'`eth_call`.

* **Fonction** : `uiMultiplier()`
* **Sélecteur de fonction à 4 octets** : `0xa60bf13d` (`bytes4(keccak256("uiMultiplier()"))`)
* **Format de retour** : `uint256` encodé en hexadécimal sur 32 octets (valeur à virgule fixe à 18 décimales)

BlockVectra dessert les requêtes JSON-RPC Robinhood Chain sous `https://api.blockvectra.com/v1/robinhood_mainnet`. Transmettez votre API key via l'en-tête `x-api-key` ou ajoutez-la au chemin (`https://api.blockvectra.com/v1/robinhood_mainnet/{api_key}`).

### Exemples de code

Les exemples ci-dessous interrogent `uiMultiplier()` sur le contrat de token d'action Everpure (`0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D`) :

**cURL**

```bash
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_call",
    "params": [
      {
        "to": "0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D",
        "data": "0xa60bf13d"
      },
      "latest"
    ]
  }'
```


  **viem (TypeScript)**

```ts
import { createPublicClient, defineChain, http, parseAbi } from "viem";

const robinhoodMainnet = defineChain({
  id: 4663,
  name: "Robinhood Chain",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: {
    default: { http: ["https://api.blockvectra.com/v1/robinhood_mainnet"] },
  },
});

const client = createPublicClient({
  chain: robinhoodMainnet,
  transport: http("https://api.blockvectra.com/v1/robinhood_mainnet", {
    fetchOptions: {
      headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! },
    },
  }),
});

const stockTokenAbi = parseAbi([
  "function uiMultiplier() external view returns (uint256)",
  "function balanceOfUI(address account) external view returns (uint256)",
  "function balanceOf(address account) external view returns (uint256)",
]);

const tokenAddress = "0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D";

// 1. Lire le multiplicateur d'opérations sur titres (18 décimales, 1e18 = 1.0)
const multiplier = await client.readContract({
  address: tokenAddress,
  abi: stockTokenAbi,
  functionName: "uiMultiplier",
});

console.log("uiMultiplier (raw uint256):", multiplier.toString());

// 2. Lire le solde brut et convertir en actions sous-jacentes
const holderAddress = "0x0000000000000000000000000000000000000001";
const rawBalance = await client.readContract({
  address: tokenAddress,
  abi: stockTokenAbi,
  functionName: "balanceOf",
  args: [holderAddress],
});

const underlyingShares = (rawBalance * multiplier) / 10n ** 18n;
console.log("Calculated underlying shares:", underlyingShares.toString());

// 3. Ou lire directement les actions pré-mises à l'échelle avec balanceOfUI
const directShares = await client.readContract({
  address: tokenAddress,
  abi: stockTokenAbi,
  functionName: "balanceOfUI",
  args: [holderAddress],
});
console.log("Direct balanceOfUI shares:", directShares.toString());
```


## Interroger les détenteurs et l'activité quotidienne avec la Data API

La Data API de BlockVectra fournit des synthèses quotidiennes pré-indexées pour les actions tokenisées. Utilisez `GET /v1/data/robinhood_mainnet/stocks` pour le classement de l'activité quotidienne et `GET /v1/data/robinhood_mainnet/stocks/{token}` pour les métadonnées d'un jeton et jusqu'à 30 jours de métriques quotidiennes. Pour les paramètres de requête, les champs de réponse et des exemples, consultez le [guide des actions tokenisées](https://docs.blockvectra.com/fr/guides/stocks/).

## Mentions réglementaires

Les tokens d'actions sont des titres de créance tokenisés émis par Robinhood Assets (Jersey) Limited (RHJ). Consultez la [documentation Robinhood RHJ](https://docs.robinhood.com/rhj) pour les prospectus, conditions définitives et avis de juridiction.

## Étapes suivantes

* [Parcourir le répertoire des jeux de données](https://blockvectra.com/fr/data/) pour voir chaque jeu de données indexé par BlockVectra.
* [Consulter le forfait gratuit et les tarifs](https://blockvectra.com/fr/pricing/#free) pour vérifier ce que comprend votre compte.
* [Se connecter à la console](https://console.blockvectra.com/login/?next=%2Fkeys%2F) pour créer une API key.