> ## Documentation Index
> Fetch the complete documentation index at: https://docs.blockradar.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Signer

> Signez des messages, des données typées et des transactions brutes avec les clés de votre portefeuille

<Note>
  En bref<br />
  L'API de Signature Blockradar vous permet de signer cryptographiquement des messages texte, des données structurées (données typées) et des transactions brutes à l'aide des clés privées de votre portefeuille. Signez des messages pour prouver la propriété du portefeuille. Signez des transactions construites en externe (par ex., des swaps Jupiter sur Solana) sans exposer vos clés privées, et diffusez-les optionnellement sur la chaîne.
</Note>

## Prérequis

Avant d'utiliser l'API de Signature, assurez-vous d'avoir :

<Steps>
  <Step title="Clé API">
    Obtenez votre clé API depuis le [Tableau de bord Blockradar](https://dashboard.blockradar.co). Accédez à **Developers** pour en générer une.
  </Step>

  <Step title="Portefeuille créé">
    Créez un portefeuille principal depuis le [Tableau de bord Blockradar](https://dashboard.blockradar.co). Accédez à **Wallets** et créez-en un pour la blockchain souhaitée. Vous aurez besoin du `walletId` pour les opérations de signature.
  </Step>

  <Step title="Environnement">
    Choisissez entre **Testnet** (pour le développement) ou **Mainnet** (pour la production). Les portefeuilles sont isolés par environnement.
  </Step>
</Steps>

## Comment ça fonctionne

L'API de Signature produit une signature cryptographique qui prouve que vous contrôlez une adresse de portefeuille spécifique. Le résultat signé peut être vérifié par n'importe quel tiers sans accéder à vos clés privées.

<CardGroup cols={2}>
  <Card title="Signature de message" icon="pen">
    Signez des messages texte pour prouver la propriété du portefeuille. Fonctionne sur toutes les blockchains prises en charge : EVM, Tron et Solana.
  </Card>

  <Card title="Signature de données typées" icon="file-signature">
    Signez des données structurées selon le standard EIP-712. Utilisé pour les approbations sans gas (EIP-2612 Permit) et les transferts autorisés (EIP-3009). EVM uniquement.
  </Card>

  <Card title="Signature de transaction" icon="file-contract">
    Signez des transactions brutes construites en externe. Construisez un swap sur Jupiter, un appel de contrat via ethers.js ou un transfert TronWeb, puis envoyez la transaction non signée pour la faire signer sans exposer vos clés privées.
  </Card>

  <Card title="Broadcast de transaction" icon="tower-broadcast">
    Signez et diffusez une transaction brute en une seule étape. Blockradar signe la transaction et la soumet sur la chaîne via une file d'attente fiable avec des tentatives automatiques.
  </Card>
</CardGroup>

### Cas d'utilisation courants

* **Inscription auprès d'un fournisseur tiers** : prouvez que vous possédez une adresse lors de l'intégration avec des services comme Iron, Circle ou d'autres protocoles DeFi
* **Approbations de tokens sans gas** : signez des messages EIP-2612 Permit pour autoriser la dépense de tokens sans transaction on-chain
* **Transferts autorisés** : signez des messages EIP-3009 TransferWithAuthorization pour des transferts délégués
* **Attestations hors chaîne** : créez des preuves vérifiables d'intention ou d'accord liées à une adresse de portefeuille
* **Exécution de swaps externes** : construisez un swap Jupiter sur Solana, signez-le avec Blockradar et diffusez-le sur la chaîne
* **Interactions personnalisées avec des contrats** : construisez n'importe quelle transaction en externe et laissez Blockradar la signer et/ou la soumettre

## Portefeuille principal vs Adresse enfant

L'API de Signature est disponible à deux niveaux :

<CardGroup cols={2}>
  <Card title="Portefeuille principal" icon="wallet">
    Signez avec les clés du portefeuille principal. Idéal pour les opérations de trésorerie et les intégrations avec des fournisseurs.
  </Card>

  <Card title="Adresse enfant" icon="address-card">
    Signez avec les clés d'une adresse enfant spécifique. À utiliser lorsque le tiers exige une signature provenant d'une adresse de dépôt.
  </Card>
</CardGroup>

### Points de terminaison

| Opération                 | Portefeuille principal                            | Adresse enfant                                                          |
| ------------------------- | ------------------------------------------------- | ----------------------------------------------------------------------- |
| Signer un message         | `POST /v1/wallets/{walletId}/signing/message`     | `POST /v1/wallets/{walletId}/addresses/{addressId}/signing/message`     |
| Signer des données typées | `POST /v1/wallets/{walletId}/signing/typed-data`  | `POST /v1/wallets/{walletId}/addresses/{addressId}/signing/typed-data`  |
| Signer une transaction    | `POST /v1/wallets/{walletId}/signing/transaction` | `POST /v1/wallets/{walletId}/addresses/{addressId}/signing/transaction` |
| Signer + Broadcast        | `POST /v1/wallets/{walletId}/signing/broadcast`   | `POST /v1/wallets/{walletId}/addresses/{addressId}/signing/broadcast`   |

***

## Signature de message

Signez un message texte avec la clé privée de votre portefeuille. L'API signe le message, vérifie que la signature correspond à l'adresse du portefeuille et renvoie à la fois la signature et un enregistrement de transaction.

### Blockchains prises en charge

| Blockchain                                                   | Standard de signature    | Format de signature                                     |
| ------------------------------------------------------------ | ------------------------ | ------------------------------------------------------- |
| EVM (Ethereum, Polygon, BSC, Base, Arbitrum, Optimism, Celo) | EIP-191 (personal\_sign) | Encodé en hexadécimal avec les composants `r`, `s`, `v` |
| Tron                                                         | TronWeb signMessageV2    | Chaîne encodée en hexadécimal                           |
| Solana                                                       | Ed25519                  | Chaîne encodée en Base58                                |

### Paramètres de la requête

| Paramètre   | Type   | Requis | Description                                                                                                 |
| ----------- | ------ | ------ | ----------------------------------------------------------------------------------------------------------- |
| `message`   | string | Oui    | Le message texte à signer. Maximum 4 096 caractères.                                                        |
| `reference` | string | Non    | Votre identifiant de suivi interne. Utilisez-le pour l'idempotence. Les références en double sont rejetées. |
| `metadata`  | object | Non    | Paires clé-valeur personnalisées stockées avec l'enregistrement de transaction.                             |

### Exemple de signature de message

<CodeGroup>
  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.blockradar.co/v1/wallets/{walletId}/signing/message \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "message": "Please sign this message to verify your wallet ownership for Iron provider registration.",
      "reference": "iron-verification-001",
      "metadata": {
        "provider": "iron",
        "purpose": "wallet-verification"
      }
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://api.blockradar.co/v1/wallets/${walletId}/signing/message`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        message: 'Please sign this message to verify your wallet ownership for Iron provider registration.',
        reference: 'iron-verification-001',
        metadata: {
          provider: 'iron',
          purpose: 'wallet-verification'
        }
      })
    }
  ).then(r => r.json());

  console.log('Signature:', response.data.hash);
  console.log('Signed transaction:', response.data.signedTransaction);
  ```

  ```php PHP theme={null}
  <?php

  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.blockradar.co/v1/wallets/{walletId}/signing/message",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => json_encode([
      "message" => "Please sign this message to verify your wallet ownership for Iron provider registration.",
      "reference" => "iron-verification-001",
      "metadata" => [
        "provider" => "iron",
        "purpose" => "wallet-verification"
      ]
    ]),
    CURLOPT_HTTPHEADER => [
      "Content-Type: application/json",
      "x-api-key: <api-key>"
    ],
  ]);

  $response = curl_exec($curl);
  curl_close($curl);

  echo $response;
  ```
</CodeGroup>

### Réponse EVM

```json theme={null}
{
  "message": "Message signed successfully",
  "statusCode": 200,
  "data": {
    "id": "770f9100-7338-4823-b1ce-3658fc67db09",
    "hash": "0xdb095e6cbf235d630cee43e0953e60c351e46897bc4e65abfce3e975810e21335aa3918399dac1e01badb2dc8c59c171e65d0c328c92737de702da9d76b889b31b",
    "status": "SUCCESS",
    "type": "SIGNED",
    "senderAddress": "0x947514e4B803e312C312da0F1B41fEDdbe15ae7a",
    "recipientAddress": "0x947514e4B803e312C312da0F1B41fEDdbe15ae7a",
    "signedTransaction": {
      "r": "0xdb095e6cbf235d630cee43e0953e60c351e46897bc4e65abfce3e975810e2133",
      "s": "0x5aa3918399dac1e01badb2dc8c59c171e65d0c328c92737de702da9d76b889b3",
      "v": 27,
      "signature": "0xdb095e6cbf...b31b"
    },
    "reference": "iron-verification-001",
    "metadata": {
      "provider": "iron",
      "purpose": "wallet-verification"
    },
    "confirmed": true,
    "createdAt": "2025-03-02T19:00:52.000Z"
  }
}
```

### Réponse Tron / Solana

Pour Tron et Solana, l'objet `signedTransaction` contient uniquement le champ `signature` (pas de composants `r`, `s`, `v`) :

```json theme={null}
{
  "message": "Message signed successfully",
  "statusCode": 200,
  "data": {
    "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "hash": "3xYkZ9...",
    "status": "SUCCESS",
    "type": "SIGNED",
    "senderAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRT9Y",
    "recipientAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRT9Y",
    "signedTransaction": {
      "signature": "3xYkZ9..."
    },
    "reference": "tron-verification-001",
    "confirmed": true,
    "createdAt": "2025-03-02T19:00:52.000Z"
  }
}
```

### Champs de la réponse

| Champ               | Description                                                                                                                      |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `id`                | Identifiant unique de la transaction pour l'enregistrement de signature                                                          |
| `hash`              | La signature cryptographique. Pour EVM : chaîne hexadécimale. Pour Tron : chaîne hexadécimale. Pour Solana : chaîne base58.      |
| `status`            | Toujours `SUCCESS` pour les signatures complétées                                                                                |
| `type`              | Toujours `SIGNED` pour les transactions de signature                                                                             |
| `senderAddress`     | L'adresse du portefeuille qui a produit la signature                                                                             |
| `signedTransaction` | Composants de la signature. EVM inclut `r`, `s`, `v` et la `signature` complète. Tron et Solana incluent uniquement `signature`. |
| `reference`         | Votre chaîne de référence fournie (le cas échéant)                                                                               |
| `metadata`          | Votre objet de métadonnées fourni (le cas échéant)                                                                               |

***

## Signature de données typées (EVM uniquement)

Signez des données structurées selon le standard EIP-712. Ceci est utilisé pour les approbations sans gas, les transferts délégués et d'autres flux d'autorisation on-chain nécessitant une signature structurée.

<Warning>
  La signature de données typées est uniquement disponible pour les blockchains compatibles EVM (Ethereum, Polygon, BSC, Base, Arbitrum, Optimism, Celo). Tron et Solana ne prennent pas en charge EIP-712.
</Warning>

### Standards pris en charge

| Standard                             | Cas d'utilisation                                                               |
| ------------------------------------ | ------------------------------------------------------------------------------- |
| EIP-712                              | Signature générique de données structurées                                      |
| EIP-2612 (Permit)                    | Approbations de tokens sans gas. Approuver la dépense sans transaction on-chain |
| EIP-3009 (TransferWithAuthorization) | Transferts délégués. Autoriser un transfert qu'un tiers soumet                  |

### Paramètres de la requête

| Paramètre | Type   | Requis | Description                                                                                |
| --------- | ------ | ------ | ------------------------------------------------------------------------------------------ |
| `domain`  | object | Oui    | Séparateur de domaine EIP-712. Inclut `name`, `version`, `chainId` et `verifyingContract`. |
| `types`   | object | Oui    | Définitions de types pour les données structurées.                                         |
| `message` | object | Oui    | Les données à signer, conformes aux définitions de types.                                  |

### Exemple EIP-2612 Permit

<CodeGroup>
  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.blockradar.co/v1/wallets/{walletId}/signing/typed-data \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "domain": {
        "name": "USD Coin",
        "version": "2",
        "chainId": 11155111,
        "verifyingContract": "0xa0b86a33e6441b8c4c8c0c077bcdd28571685701"
      },
      "types": {
        "Permit": [
          { "name": "owner", "type": "address" },
          { "name": "spender", "type": "address" },
          { "name": "value", "type": "uint256" },
          { "name": "nonce", "type": "uint256" },
          { "name": "deadline", "type": "uint256" }
        ]
      },
      "message": {
        "owner": "0x742d35cc6634c0532925a3b8d4c9db96c4b4d8b6",
        "spender": "0x8ba1f109551bd432803012645aac136c4c8c8c0c",
        "value": "1000000000",
        "nonce": "0",
        "deadline": "1641081600"
      }
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://api.blockradar.co/v1/wallets/${walletId}/signing/typed-data`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        domain: {
          name: 'USD Coin',
          version: '2',
          chainId: 11155111,
          verifyingContract: '0xa0b86a33e6441b8c4c8c0c077bcdd28571685701'
        },
        types: {
          Permit: [
            { name: 'owner', type: 'address' },
            { name: 'spender', type: 'address' },
            { name: 'value', type: 'uint256' },
            { name: 'nonce', type: 'uint256' },
            { name: 'deadline', type: 'uint256' }
          ]
        },
        message: {
          owner: '0x742d35cc6634c0532925a3b8d4c9db96c4b4d8b6',
          spender: '0x8ba1f109551bd432803012645aac136c4c8c8c0c',
          value: '1000000000',
          nonce: '0',
          deadline: '1641081600'
        }
      })
    }
  ).then(r => r.json());

  console.log('Signature:', response.data.hash);
  console.log('r:', response.data.signedTransaction.r);
  console.log('s:', response.data.signedTransaction.s);
  console.log('v:', response.data.signedTransaction.v);
  ```
</CodeGroup>

### Réponse des données typées

```json theme={null}
{
  "message": "Typed data signed successfully",
  "statusCode": 200,
  "data": {
    "id": "770f9100-7338-4823-b1ce-3658fc67db09",
    "hash": "0xdb095e6cbf235d630cee43e0953e60c351e46897bc4e65abfce3e975810e21335aa3918399dac1e01badb2dc8c59c171e65d0c328c92737de702da9d76b889b31b",
    "status": "SUCCESS",
    "type": "SIGNED",
    "senderAddress": "0x947514e4B803e312C312da0F1B41fEDdbe15ae7a",
    "recipientAddress": "0x947514e4B803e312C312da0F1B41fEDdbe15ae7a",
    "signedTransaction": {
      "r": "0xdb095e6cbf235d630cee43e0953e60c351e46897bc4e65abfce3e975810e2133",
      "s": "0x5aa3918399dac1e01badb2dc8c59c171e65d0c328c92737de702da9d76b889b3",
      "v": 27,
      "signature": "0xdb095e6cbf...b31b"
    },
    "confirmed": true,
    "createdAt": "2025-03-02T19:00:52.000Z"
  }
}
```

### Champs de l'objet domaine

| Champ               | Type   | Requis | Description                                                                         |
| ------------------- | ------ | ------ | ----------------------------------------------------------------------------------- |
| `name`              | string | Oui    | Le nom du domaine de signature (par ex., le nom du token ou de la dApp)             |
| `version`           | string | Oui    | La version du domaine                                                               |
| `chainId`           | number | Oui    | L'identifiant de la chaîne. Doit correspondre au réseau blockchain du portefeuille. |
| `verifyingContract` | string | Oui    | L'adresse du contrat qui vérifiera la signature                                     |
| `salt`              | string | Non    | Sel de domaine optionnel pour EIP-712 v4                                            |

<Warning>
  Validation du Chain ID<br />
  Le `chainId` dans votre objet domaine doit correspondre à l'identifiant de chaîne du réseau blockchain du portefeuille. S'ils ne correspondent pas, l'API renvoie une erreur `400 Chain ID mismatch`.
</Warning>

***

## Signature avec une adresse enfant

Signez des messages, des données typées, des transactions ou effectuez un broadcast en utilisant une adresse enfant spécifique au lieu du portefeuille principal. Les quatre opérations de signature sont disponibles pour les adresses enfant :

<CodeGroup>
  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.blockradar.co/v1/wallets/{walletId}/addresses/{addressId}/signing/message \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "message": "Verify ownership of deposit address for provider onboarding.",
      "reference": "address-verify-001"
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://api.blockradar.co/v1/wallets/${walletId}/addresses/${addressId}/signing/message`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        message: 'Verify ownership of deposit address for provider onboarding.',
        reference: 'address-verify-001'
      })
    }
  ).then(r => r.json());

  console.log('Signature:', response.data.hash);
  ```
</CodeGroup>

<Tip>
  La signature avec une adresse enfant suit le même format de requête et de réponse que la signature avec le portefeuille principal. La seule différence est l'URL du point de terminaison, qui inclut le `addressId`.
</Tip>

***

## Événements webhook

Les opérations de signature déclenchent un webhook avec l'enregistrement de transaction :

| Événement        | Description                                                                                                                                                                                                       |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `signed.success` | Signature complétée avec succès. Pour la signature de message, données typées ou transaction, cet événement est déclenché immédiatement. Pour le broadcast, il est déclenché après la confirmation sur la chaîne. |
| `signed.failed`  | Le broadcast de la transaction a échoué après l'épuisement de toutes les tentatives. S'applique uniquement au endpoint `/broadcast`.                                                                              |

### Contenu du webhook (Signature de message ou données typées)

```json theme={null}
{
  "event": "signed.success",
  "data": {
    "id": "770f9100-7338-4823-b1ce-3658fc67db09",
    "reference": "iron-verification-001",
    "senderAddress": "0x947514e4B803e312C312da0F1B41fEDdbe15ae7a",
    "recipientAddress": "0x947514e4B803e312C312da0F1B41fEDdbe15ae7a",
    "hash": "0xdb095e6cbf235d630cee43e0953e60c351e46897bc4e65abfce3e975810e21335aa3918399dac1e01badb2dc8c59c171e65d0c328c92737de702da9d76b889b31b",
    "confirmed": true,
    "status": "SUCCESS",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Message signed",
    "network": "testnet",
    "chainId": 11155111,
    "metadata": {
      "provider": "iron",
      "purpose": "wallet-verification"
    },
    "signedTransaction": {
      "r": "0xdb095e6cbf235d630cee43e0953e60c351e46897bc4e65abfce3e975810e2133",
      "s": "0x5aa3918399dac1e01badb2dc8c59c171e65d0c328c92737de702da9d76b889b3",
      "v": 27,
      "signature": "0xdb095e6cbf235d630cee43e0953e60c351e46897bc4e65abfce3e975810e21335aa3918399dac1e01badb2dc8c59c171e65d0c328c92737de702da9d76b889b31b"
    },
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2025-03-02T19:00:52.000Z",
    "updatedAt": "2025-03-02T19:00:52.000Z",
    "wallet": {
      "id": "d236a191-c1d4-423c-a439-54ce6542ca41",
      "name": "Ethereum Master Wallet",
      "address": "0x947514e4B803e312C312da0F1B41fEDdbe15ae7a",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "85ffc132-3972-4c9e-99a5-5cf0ccb688bf",
      "name": "ethereum",
      "symbol": "eth",
      "slug": "ethereum",
      "isEvmCompatible": true,
      "tokenStandard": "ERC20"
    },
    "beneficiary": null
  }
}
```

### Contenu du webhook (Signature de transaction)

Pour la signature de transaction, le champ `signedTransaction` est une chaîne (et non un objet). Le format dépend de la blockchain.

```json theme={null}
{
  "event": "signed.success",
  "data": {
    "id": "782942da-48b0-416b-924b-8f657ae637a7",
    "reference": "52TQawmiqYpNiWD2Ks0P",
    "senderAddress": "0xC887a3Cb8E7AbA4A77D7275AD4B242f71cbd5446",
    "recipientAddress": "0xC887a3Cb8E7AbA4A77D7275AD4B242f71cbd5446",
    "hash": "0xac4c73ca084608ac6b981e54db948dc80c15b4ea3ffd0c9f5781f3af7ad6fe51",
    "confirmed": true,
    "status": "SUCCESS",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Transaction signed",
    "network": "testnet",
    "chainId": 11155111,
    "metadata": null,
    "signedTransaction": "0x02f87383aa36a763843b9aca008459682f0082520894000000000000000000000000000000000000dead865af3107a400080c080a0b760...",
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2026-03-19T13:34:24.937Z",
    "updatedAt": "2026-03-19T13:34:24.937Z",
    "wallet": {
      "id": "3f9aca5c-38ee-4e1d-ab67-c084a2e37bb2",
      "name": "Ethereum Wallet",
      "address": "0xC887a3Cb8E7AbA4A77D7275AD4B242f71cbd5446",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "85ffc132-3972-4c9e-99a5-5cf0ccb688bf",
      "name": "ethereum",
      "symbol": "eth",
      "slug": "ethereum",
      "isEvmCompatible": true,
      "tokenStandard": "ERC20"
    },
    "beneficiary": null
  }
}
```

### Contenu du webhook (Broadcast réussi)

Après que la file de broadcast confirme la transaction sur la chaîne, vous recevez ce webhook. Le champ `hash` est mis à jour avec le hash de transaction on-chain et `confirmed` passe à `true`.

```json theme={null}
{
  "event": "signed.success",
  "data": {
    "id": "f3efdbaa-a1f8-4365-b3b4-768413c9a92b",
    "reference": "docs-test-broadcast",
    "senderAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "recipientAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "hash": "5bKNw9RX8aXkrK1VEHg5aPa1xtckpShPyenSRET4mUBXh5uCkWLFV5MhGRi4cMACDJvFn6VfkoKb75Pk4KYw6xtw",
    "confirmed": true,
    "status": "SUCCESS",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Transaction signed and broadcast",
    "network": "testnet",
    "chainId": 103,
    "metadata": null,
    "signedTransaction": "AeWpW65y80rSu+TU0CSrcvFNovyDiybKRjSskCpfffAFLM0GIYzx...",
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2026-03-19T13:35:09.921Z",
    "updatedAt": "2026-03-19T13:35:09.921Z",
    "wallet": {
      "id": "c72a6f21-6ab5-48ad-9f99-fd90a2d6d311",
      "name": "Solana Testnet Wallet",
      "address": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "196badf5-380f-4480-ab4a-d0e4304e91f0",
      "name": "solana",
      "symbol": "sol",
      "slug": "solana",
      "isEvmCompatible": false,
      "tokenStandard": null
    },
    "beneficiary": null
  }
}
```

### Contenu du webhook (Broadcast échoué)

Si le broadcast échoue définitivement après toutes les tentatives, vous recevez ce webhook. Le `status` est `FAILED` et `confirmed` reste à `false`.

```json theme={null}
{
  "event": "signed.failed",
  "data": {
    "id": "f3efdbaa-a1f8-4365-b3b4-768413c9a92b",
    "reference": "docs-test-broadcast",
    "senderAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "recipientAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "hash": "5bKNw9RX8aXkrK1VEHg5aPa1xtckpShPyenSRET4mUBXh5uCkWLFV5MhGRi4cMACDJvFn6VfkoKb75Pk4KYw6xtw",
    "confirmed": false,
    "status": "FAILED",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Transaction broadcast failed",
    "network": "testnet",
    "chainId": 103,
    "metadata": null,
    "signedTransaction": "AeWpW65y80rSu+TU0CSrcvFNovyDiybKRjSskCpfffAFLM0GIYzx...",
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2026-03-19T13:35:09.921Z",
    "updatedAt": "2026-03-19T13:35:09.921Z",
    "wallet": {
      "id": "c72a6f21-6ab5-48ad-9f99-fd90a2d6d311",
      "name": "Solana Testnet Wallet",
      "address": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "196badf5-380f-4480-ab4a-d0e4304e91f0",
      "name": "solana",
      "symbol": "sol",
      "slug": "solana",
      "isEvmCompatible": false,
      "tokenStandard": null
    },
    "beneficiary": null
  }
}
```

***

## Signature de transaction

Signez une transaction brute non signée construite en externe. Vous construisez la transaction à l'aide de n'importe quel SDK (ethers.js, TronWeb, Solana web3.js, Jupiter API), puis vous envoyez la transaction non signée sérialisée à Blockradar pour signature et/ou diffusion, sans avoir besoin de construire ou gérer votre propre infrastructure ou nœuds blockchain.

### Blockchains et formats pris en charge

| Blockchain | Format du champ `transaction`                                                   | Comment construire                                                        |
| ---------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| Solana     | Base64 de `VersionedTransaction.serialize()`                                    | Réponse `/swap` de l'API Jupiter, ou `@solana/web3.js` TransactionMessage |
| EVM        | Chaîne JSON de `{to, value, data, nonce, chainId, gasLimit, maxFeePerGas, ...}` | `ethers.js` populateTransaction()                                         |
| Tron       | Chaîne JSON de l'objet transaction TronWeb `{txID, raw_data, raw_data_hex}`     | `tronWeb.transactionBuilder.triggerSmartContract()`                       |

### Paramètres de la requête

| Paramètre     | Type   | Requis | Description                                                                     |
| ------------- | ------ | ------ | ------------------------------------------------------------------------------- |
| `transaction` | string | Oui    | La transaction non signée sérialisée. Le format dépend de la blockchain.        |
| `reference`   | string | Non    | Votre identifiant de suivi interne.                                             |
| `metadata`    | object | Non    | Paires clé-valeur personnalisées stockées avec l'enregistrement de transaction. |

### Exemple de signature de transaction (Solana + Jupiter)

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';

  // Step 1: Build the swap transaction via Jupiter API
  const quoteResponse = await fetch(
    'https://quote-api.jup.ag/v6/quote?inputMint=SOL&outputMint=USDC&amount=1000000&slippageBps=50'
  ).then(r => r.json());

  const swapResponse = await fetch('https://quote-api.jup.ag/v6/swap', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      quoteResponse,
      userPublicKey: walletAddress, // Your Blockradar wallet's Solana address
      wrapAndUnwrapSol: true,
    })
  }).then(r => r.json());

  // Step 2: Send the unsigned transaction to Blockradar for signing
  const signResponse = await fetch(
    `https://api.blockradar.co/v1/wallets/${walletId}/signing/transaction`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        transaction: swapResponse.swapTransaction, // Base64 VersionedTransaction
        reference: 'jupiter-swap-001'
      })
    }
  ).then(r => r.json());

  console.log('Signed tx:', signResponse.data.signedTransaction);
  console.log('Hash:', signResponse.data.hash);
  ```

  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.blockradar.co/v1/wallets/{walletId}/signing/transaction \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "transaction": "<base64 unsigned VersionedTransaction>",
      "reference": "jupiter-swap-001"
    }'
  ```
</CodeGroup>

### Exemple de signature de transaction (EVM)

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { ethers } from 'ethers';

  // Step 1: Build the unsigned transaction
  const provider = new ethers.providers.JsonRpcProvider('https://rpc.sepolia.org');
  const nonce = await provider.getTransactionCount(walletAddress);
  const feeData = await provider.getFeeData();

  const unsignedTx = JSON.stringify({
    to: '0xRecipientAddress',
    value: ethers.utils.parseEther('0.01').toHexString(),
    nonce,
    chainId: 11155111, // Sepolia
    gasLimit: ethers.utils.hexlify(21000),
    maxFeePerGas: feeData.maxFeePerGas.toHexString(),
    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas.toHexString(),
    type: 2,
  });

  // Step 2: Send to Blockradar for signing
  const signResponse = await fetch(
    `https://api.blockradar.co/v1/wallets/${walletId}/signing/transaction`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        transaction: unsignedTx,
        reference: 'eth-transfer-001'
      })
    }
  ).then(r => r.json());

  // The signed transaction can be broadcast via any RPC
  // await provider.sendTransaction(signResponse.data.signedTransaction);
  ```

  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.blockradar.co/v1/wallets/{walletId}/signing/transaction \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "transaction": "{\"to\":\"0xRecipient\",\"value\":\"0x2386F26FC10000\",\"nonce\":0,\"chainId\":11155111,\"gasLimit\":\"0x5208\",\"maxFeePerGas\":\"0x59682F00\",\"maxPriorityFeePerGas\":\"0x3B9ACA00\",\"type\":2}",
      "reference": "eth-transfer-001"
    }'
  ```
</CodeGroup>

### Réponse signature seule (EVM)

```json theme={null}
{
  "statusCode": 200,
  "message": "Transaction signed successfully",
  "data": {
    "id": "782942da-48b0-416b-924b-8f657ae637a7",
    "reference": "52TQawmiqYpNiWD2Ks0P",
    "senderAddress": "0xC887a3Cb8E7AbA4A77D7275AD4B242f71cbd5446",
    "recipientAddress": "0xC887a3Cb8E7AbA4A77D7275AD4B242f71cbd5446",
    "hash": "0xac4c73ca084608ac6b981e54db948dc80c15b4ea3ffd0c9f5781f3af7ad6fe51",
    "confirmed": true,
    "status": "SUCCESS",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Transaction signed",
    "network": "testnet",
    "chainId": 11155111,
    "metadata": null,
    "signedTransaction": "0x02f87383aa36a763843b9aca008459682f0082520894000000000000000000000000000000000000dead865af3107a400080c080a0b760...",
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2026-03-19T13:34:24.937Z",
    "updatedAt": "2026-03-19T13:34:24.937Z",
    "wallet": {
      "id": "3f9aca5c-38ee-4e1d-ab67-c084a2e37bb2",
      "name": "Ethereum Wallet",
      "address": "0xC887a3Cb8E7AbA4A77D7275AD4B242f71cbd5446",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "85ffc132-3972-4c9e-99a5-5cf0ccb688bf",
      "name": "ethereum",
      "symbol": "eth",
      "slug": "ethereum",
      "isEvmCompatible": true,
      "tokenStandard": "ERC20"
    },
    "beneficiary": null
  }
}
```

### Réponse signature seule (Solana)

```json theme={null}
{
  "statusCode": 200,
  "message": "Transaction signed successfully",
  "data": {
    "id": "02f404a5-d13e-4bcf-8ad5-c5f51c04fa49",
    "reference": "qZmQqDiIp9owMzQJcDbv",
    "senderAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "recipientAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "hash": "TjphHHAzjhRBn8t1qhhTRWpUxvkATBnzeRBB8fonWkYpR1gDh4t99rmgah3hrwoCbD3L9Ex1a7SYjjX2TePio3s",
    "confirmed": true,
    "status": "SUCCESS",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Transaction signed",
    "network": "testnet",
    "chainId": 103,
    "metadata": null,
    "signedTransaction": "ARcO4DT2IYg/wemCZy4iYXVRzlGruYHUTGqIcbWI/uWeWet6MNZKVVvUF4yT5GQjRqrb1QD1TaAoflyXXatxzAaAAQABA...",
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2026-03-19T13:38:45.326Z",
    "updatedAt": "2026-03-19T13:38:45.326Z",
    "wallet": {
      "id": "c72a6f21-6ab5-48ad-9f99-fd90a2d6d311",
      "name": "Solana Testnet Wallet",
      "address": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "196badf5-380f-4480-ab4a-d0e4304e91f0",
      "name": "solana",
      "symbol": "sol",
      "slug": "solana",
      "isEvmCompatible": false,
      "tokenStandard": null
    },
    "beneficiary": null
  }
}
```

### Réponse signature seule (Tron)

```json theme={null}
{
  "statusCode": 200,
  "message": "Transaction signed successfully",
  "data": {
    "id": "af44218f-d38b-472b-9834-49f461a20fd4",
    "reference": "J6RugzxXI6cdpeMXrhh",
    "senderAddress": "TMUZSkS3aF1pZxnTokWikUQH7SYt3bNb6G",
    "recipientAddress": "TMUZSkS3aF1pZxnTokWikUQH7SYt3bNb6G",
    "hash": "3180f971f692a78f62050278149d746abd946fbd1797a414f5ad0d5ed45c902b",
    "confirmed": true,
    "status": "SUCCESS",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Transaction signed",
    "network": "testnet",
    "chainId": 3448148188,
    "metadata": null,
    "signedTransaction": "{\"visible\":false,\"txID\":\"3180f971f692a78f...\",\"raw_data\":{\"contract\":[{\"parameter\":{\"value\":{\"to_address\":\"418840e6c55b9ada...\",\"owner_address\":\"417e3682ec8f5b98...\",\"amount\":1000000},\"type_url\":\"type.googleapis.com/protocol.TransferContract\"},\"type\":\"TransferContract\"}],\"ref_block_bytes\":\"513f\",\"ref_block_hash\":\"08c7d5da0ddd12fb\",\"expiration\":1773927585000,\"timestamp\":1773927525000},\"signature\":[\"d5adac23f23414083ef4f93b995a4a18...\"]}",
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2026-03-19T13:38:47.096Z",
    "updatedAt": "2026-03-19T13:38:47.096Z",
    "wallet": {
      "id": "c4bbebea-6cec-4021-b842-ffead75fd0f1",
      "name": "Tron Wallet",
      "address": "TMUZSkS3aF1pZxnTokWikUQH7SYt3bNb6G",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "fa91a922-3838-45f6-8a88-a4c771e1443a",
      "name": "tron",
      "symbol": "trx",
      "slug": "tron",
      "isEvmCompatible": false,
      "tokenStandard": "TRC20"
    },
    "beneficiary": null
  }
}
```

<Note>
  Pour la signature de transaction, `signedTransaction` est une **chaîne**, et non un objet. Ceci diffère de la signature de message qui renvoie un objet avec les composants de signature comme `r`, `s`, `v`.
</Note>

### Format de `signedTransaction` par chaîne

| Chaîne | Type   | Format                                                                                 | Que faire avec                                                                |
| ------ | ------ | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| Solana | string | Octets encodés en Base64 de la VersionedTransaction signée                             | Décoder en octets et passer à `connection.sendRawTransaction()`               |
| EVM    | string | Chaîne hexadécimale commençant par `0x` contenant la transaction signée encodée en RLP | Passer directement à `eth_sendRawTransaction` ou `provider.sendTransaction()` |
| Tron   | string | Chaîne JSON de l'objet transaction signé contenant un tableau `signature`              | Parser avec `JSON.parse()` et passer à `tronWeb.trx.sendRawTransaction()`     |

### Champ `hash` par chaîne

| Chaîne | Format                                  | Comment il est dérivé                                                                     |
| ------ | --------------------------------------- | ----------------------------------------------------------------------------------------- |
| Solana | Chaîne Base58                           | Première signature de la transaction signée                                               |
| EVM    | Chaîne hexadécimale commençant par `0x` | Hash Keccak256 des octets de la transaction signée                                        |
| Tron   | Chaîne hexadécimale                     | Le champ `txID` de l'objet transaction, calculé lors de la construction de la transaction |

***

## Broadcast de transaction

Signez **et** diffusez une transaction brute en une seule étape. Blockradar signe la transaction, puis la soumet sur la chaîne via une file d'attente fiable avec des tentatives automatiques. L'API renvoie immédiatement un statut `PENDING`. Vous recevrez un webhook `signed.success` ou `signed.failed` lorsque le résultat on-chain sera confirmé.

<Warning>
  Le broadcast nécessite des fonds testnet/mainnet dans le portefeuille pour payer les frais de gas. La transaction doit être valide et non expirée (les blockhashes Solana expirent en environ 90 secondes).
</Warning>

### Requête

Mêmes paramètres que la signature de transaction :

| Paramètre     | Type   | Requis | Description                           |
| ------------- | ------ | ------ | ------------------------------------- |
| `transaction` | string | Oui    | La transaction non signée sérialisée. |
| `reference`   | string | Non    | Votre identifiant de suivi interne.   |
| `metadata`    | object | Non    | Paires clé-valeur personnalisées.     |

### Exemple de broadcast

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Build the unsigned tx (same as sign-only examples above)
  const unsignedTx = swapResponse.swapTransaction; // Jupiter base64 tx

  // Sign + broadcast in one call
  const broadcastResponse = await fetch(
    `https://api.blockradar.co/v1/wallets/${walletId}/signing/broadcast`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        transaction: unsignedTx,
        reference: 'jupiter-swap-broadcast-001'
      })
    }
  ).then(r => r.json());

  console.log('Status:', broadcastResponse.data.status); // "PENDING"
  console.log('Transaction ID:', broadcastResponse.data.id);
  // Wait for webhook: signed.success or signed.failed
  ```

  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.blockradar.co/v1/wallets/{walletId}/signing/broadcast \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "transaction": "<base64 unsigned VersionedTransaction>",
      "reference": "jupiter-swap-broadcast-001"
    }'
  ```
</CodeGroup>

### Réponse du broadcast (exemple Solana, immédiate)

```json theme={null}
{
  "statusCode": 200,
  "message": "Transaction signed and broadcast initiated",
  "data": {
    "id": "f3efdbaa-a1f8-4365-b3b4-768413c9a92b",
    "reference": "docs-test-broadcast",
    "senderAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "recipientAddress": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
    "hash": "5bKNw9RX8aXkrK1VEHg5aPa1xtckpShPyenSRET4mUBXh5uCkWLFV5MhGRi4cMACDJvFn6VfkoKb75Pk4KYw6xtw",
    "confirmed": false,
    "status": "PENDING",
    "type": "SIGNED",
    "createdChannel": "api",
    "reason": "Transaction signed and broadcast",
    "network": "testnet",
    "chainId": 103,
    "metadata": null,
    "signedTransaction": "AeWpW65y80rSu+TU0CSrcvFNovyDiybKRjSskCpfffAFLM0GIYzx...",
    "amount": null,
    "amountUSD": "0.00",
    "fee": null,
    "feeUSD": null,
    "currency": "USD",
    "createdAt": "2026-03-19T13:35:09.921Z",
    "updatedAt": "2026-03-19T13:35:09.921Z",
    "wallet": {
      "id": "c72a6f21-6ab5-48ad-9f99-fd90a2d6d311",
      "name": "Solana Testnet Wallet",
      "address": "HKqZUT3wuyJrsPYmrYPcGduDdjXZTggbLrNsF9WHMvbw",
      "isActive": true,
      "status": "ACTIVE",
      "network": "testnet"
    },
    "asset": null,
    "blockchain": {
      "id": "196badf5-380f-4480-ab4a-d0e4304e91f0",
      "name": "solana",
      "symbol": "sol",
      "slug": "solana",
      "isEvmCompatible": false,
      "tokenStandard": null
    },
    "beneficiary": null
  }
}
```

### Cycle de vie du broadcast

La transaction passe par les états suivants :

| Statut    | Signification                                                                                             |
| --------- | --------------------------------------------------------------------------------------------------------- |
| `PENDING` | Transaction signée, broadcast en file d'attente. Vous recevez ce statut dans la réponse HTTP.             |
| `SUCCESS` | Transaction confirmée sur la chaîne. Le webhook `signed.success` est envoyé.                              |
| `FAILED`  | Le broadcast a échoué après l'épuisement de toutes les tentatives. Le webhook `signed.failed` est envoyé. |

<Tip>
  La file de broadcast effectue jusqu'à 10 tentatives avec des intervalles de 5 minutes. Pour Solana, si le blockhash expire, les tentatives supplémentaires ne seront pas efficaces. Vous devrez reconstruire la transaction avec un blockhash récent.
</Tip>

***

## Exemple de flux complet

Voici une implémentation complète pour signer un message et soumettre la signature à un fournisseur tiers :

```javascript theme={null}
async function signAndVerifyWithProvider(walletId, providerMessage) {
  const apiKey = process.env.BLOCKRADAR_API_KEY;
  const baseUrl = 'https://api.blockradar.co/v1';

  // Step 1: Sign the message
  const signResponse = await fetch(
    `${baseUrl}/wallets/${walletId}/signing/message`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        message: providerMessage,
        reference: `provider-verify-${Date.now()}`
      })
    }
  ).then(r => r.json());

  if (signResponse.statusCode !== 200) {
    throw new Error(`Signing failed: ${signResponse.message}`);
  }

  const { hash, senderAddress } = signResponse.data;

  // Step 2: Submit the signature to the third-party provider
  // The provider can verify the signature matches the wallet address
  // without accessing your private keys
  return {
    address: senderAddress,
    signature: hash,
    message: providerMessage
  };
}

// Usage
signAndVerifyWithProvider(
  'wallet-uuid',
  'I authorize Iron to manage assets on my behalf.'
);
```

***

## Réponses d'erreur

<AccordionGroup>
  <Accordion title="Portefeuille non trouvé">
    ```json theme={null}
    {
      "message": "Wallet not found",
      "statusCode": 404
    }
    ```

    Le `walletId` n'existe pas ou n'appartient pas à votre entreprise.
  </Accordion>

  <Accordion title="Adresse non trouvée">
    ```json theme={null}
    {
      "message": "Address not found",
      "statusCode": 404
    }
    ```

    Le `addressId` n'existe pas ou n'est pas associé au portefeuille spécifié.
  </Accordion>

  <Accordion title="Blockchain non prise en charge (données typées)">
    ```json theme={null}
    {
      "message": "Typed data signing is only supported for EVM blockchains",
      "statusCode": 400
    }
    ```

    La signature de données typées (EIP-712) est uniquement disponible sur les chaînes compatibles EVM. Utilisez la signature de message pour Tron et Solana.
  </Accordion>

  <Accordion title="Incompatibilité du Chain ID">
    ```json theme={null}
    {
      "message": "Chain ID mismatch",
      "statusCode": 400
    }
    ```

    Le `chainId` dans votre objet domaine de données typées ne correspond pas au réseau blockchain du portefeuille.
  </Accordion>

  <Accordion title="Échec de la vérification de la signature">
    ```json theme={null}
    {
      "message": "Signature verification failed",
      "statusCode": 400
    }
    ```

    La vérification aller-retour interne a échoué. Cela indique une erreur système. Veuillez contacter le support.
  </Accordion>

  <Accordion title="Format de transaction invalide (Solana)">
    ```json theme={null}
    {
      "message": "Invalid transaction format: expected a base64-encoded Solana VersionedTransaction",
      "statusCode": 400
    }
    ```

    Le champ `transaction` n'est pas un base64 valide, ou les octets décodés ne constituent pas une VersionedTransaction Solana valide.
  </Accordion>

  <Accordion title="Format de transaction invalide (EVM/Tron)">
    ```json theme={null}
    {
      "message": "Invalid transaction format: expected a JSON string",
      "statusCode": 400
    }
    ```

    Le champ `transaction` n'est pas un JSON valide. Les transactions EVM et Tron doivent être des objets sérialisés en JSON.
  </Accordion>
</AccordionGroup>

***

## Bonnes pratiques

### Sécurité

* **Utilisez des références** : suivez les opérations de signature avec des identifiants de référence uniques pour les pistes d'audit et l'idempotence
* **Vérifiez le message** : avant de signer, confirmez que le contenu du message correspond à ce que le service tiers attend
* **Limitez la longueur du message** : les messages sont limités à 4 096 caractères. Gardez les messages concis et spécifiques

### Intégration

* **Pas de frais de gas** : les opérations de signature sont hors chaîne et ne nécessitent pas de solde en tokens natifs
* **Réponse immédiate** : les signatures sont générées de manière synchrone. Aucun polling ou attente de webhook n'est nécessaire pour la signature elle-même
* **Écoutez les webhooks** : utilisez les webhooks pour maintenir une piste d'audit de tous les événements de signature

### Données typées

* **Faites correspondre les Chain IDs** : le `chainId` dans votre domaine doit correspondre au réseau du portefeuille. Utilisez les Chain IDs sandbox (testnet) pour les tests et les Chain IDs de production (mainnet) pour les opérations en direct
* **Vérifiez le contrat** : le `verifyingContract` doit être le contrat qui vérifiera la signature on-chain

### Signature de transaction

* **Construisez la transaction avec le bon expéditeur** : la transaction non signée doit utiliser la clé publique du portefeuille ou de l'adresse enfant comme payeur de frais (Solana) ou expéditeur (EVM/Tron). Si la clé ne correspond pas, la signature échouera.
* **Les blockhashes Solana expirent rapidement** : les blockhashes Solana sont valides pendant environ 60 à 90 secondes. Construisez la transaction et appelez le endpoint de signature rapidement. En cas de broadcast, les tentatives de la file d'attente ne seront pas efficaces une fois le blockhash expiré.
* **Gestion du nonce EVM** : définissez le nonce correctement. Si le nonce est déjà utilisé, le broadcast échouera. Interrogez le nonce depuis la chaîne juste avant de construire la transaction.
* **Expiration Tron** : les transactions Tron ont une fenêtre d'expiration de 24 heures définie lors de la construction. Cela laisse amplement le temps pour la signature et le broadcast.
* **Signature seule vs broadcast** : utilisez `/signing/transaction` lorsque vous souhaitez diffuser la transaction vous-même ou via un autre service. Utilisez `/signing/broadcast` lorsque vous souhaitez que Blockradar gère la soumission avec des tentatives automatiques.

***

## Référence API

### Points de terminaison du portefeuille principal

| Point de terminaison                                                                      | Description                              |
| ----------------------------------------------------------------------------------------- | ---------------------------------------- |
| [Signer un message](/fr/api-reference/signing/master-wallet-sign-message)                 | Signer un message texte                  |
| [Signer des données typées](/fr/api-reference/signing/master-wallet-typed-data)           | Signer des données structurées EIP-712   |
| [Signer une transaction](/fr/api-reference/signing/master-wallet-sign-transaction)        | Signer une transaction brute             |
| [Broadcast de transaction](/fr/api-reference/signing/master-wallet-broadcast-transaction) | Signer et diffuser une transaction brute |

### Points de terminaison de l'adresse enfant

| Point de terminaison                                                                      | Description                                                        |
| ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| [Signer un message](/fr/api-reference/signing/child-address-sign-message)                 | Signer un message texte depuis une adresse enfant                  |
| [Signer des données typées](/fr/api-reference/signing/child-address-typed-data)           | Signer des données structurées EIP-712 depuis une adresse enfant   |
| [Signer une transaction](/fr/api-reference/signing/child-address-sign-transaction)        | Signer une transaction brute depuis une adresse enfant             |
| [Broadcast de transaction](/fr/api-reference/signing/child-address-broadcast-transaction) | Signer et diffuser une transaction brute depuis une adresse enfant |