From f90a5d014101dfb9385d0566665f5004bfea0855 Mon Sep 17 00:00:00 2001 From: Priyank Gupta Date: Tue, 27 Oct 2026 16:36:28 +0530 Subject: [PATCH 1/2] chore: first draft of intents page --- .../ccip/tutorials/ccip-intents-flow.svg | 74 ++++ src/config/sidebar/ccip-dynamic.ts | 11 + src/content/ccip/llms-full.txt | 311 ++++++++++++++++- src/content/ccip/llms.txt | 1 + .../application-developers/index.mdx | 12 +- .../v2/evm/tutorials/use-ccip-intents-api.mdx | 321 ++++++++++++++++++ 6 files changed, 724 insertions(+), 6 deletions(-) create mode 100644 public/images/ccip/tutorials/ccip-intents-flow.svg create mode 100644 src/content/ccip/v2/evm/tutorials/use-ccip-intents-api.mdx diff --git a/public/images/ccip/tutorials/ccip-intents-flow.svg b/public/images/ccip/tutorials/ccip-intents-flow.svg new file mode 100644 index 00000000000..1edac9cd85a --- /dev/null +++ b/public/images/ccip/tutorials/ccip-intents-flow.svg @@ -0,0 +1,74 @@ + + + + + + + + + + + + + + + + + Your App + + CCIP API + + Source Chain + + Destination Chain + + + + + 1. POST /intents/quotes + + + quote + transaction + + + 2. approve inputToken spend + + + 3. submit intent transaction + + + transactionHash + + + 4. GET /intents/tx/{txHash} + + + intentId(s) + + + 5. GET /intents/id/{intentId} + + + PENDING + + + COMPLETED + fulfillmentTxHash + + + + + + provider fulfills transfer + + + + + Your App + + CCIP API + + Source Chain + + Destination Chain + + diff --git a/src/config/sidebar/ccip-dynamic.ts b/src/config/sidebar/ccip-dynamic.ts index 8522c2934ba..20c19913fa7 100644 --- a/src/config/sidebar/ccip-dynamic.ts +++ b/src/config/sidebar/ccip-dynamic.ts @@ -475,6 +475,17 @@ export const CCIP_SIDEBAR_CONTENT: SectionEntry[] = [ chainTypes: ["evm"], pageId: "ptt-transfer-usdc", }, + { + title: "Intents", + type: "separator", + chainTypes: ["evm"], + }, + { + title: "Get Started with CCIP Intents", + url: "ccip/evm/tutorials/use-ccip-intents-api", + pageId: "ccip-intents-api-tutorial", + chainTypes: ["evm"], + }, ], }, { diff --git a/src/content/ccip/llms-full.txt b/src/content/ccip/llms-full.txt index 9924c1fc588..02e226c4fed 100644 --- a/src/content/ccip/llms-full.txt +++ b/src/content/ccip/llms-full.txt @@ -107088,9 +107088,9 @@ It provides guided workflows for token developers, abstracting away much of the # Application Developers Source: https://docs.chain.link/ccip/evm/tutorials/application-developers -Last Updated: 2025-07-21 +Last Updated: 2026-10-26 -These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, and USDC transfers with data. +These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, USDC transfers with data, and transfers with the CCIP Intents API. ## Pages @@ -107101,6 +107101,7 @@ These tutorials are for application developers building cross-chain functionalit - [Programmable Token Transfers - Defensive](/ccip/evm/tutorials/application-developers/programmable-token-transfers-defensive): A defensive example of programmable token transfers with extra safety checks. - [Manual Execution](/ccip/evm/tutorials/application-developers/manual-execution): Manually execute a CCIP message when the default executor fails or is unavailable. - [Transfer USDC with Data](/ccip/evm/tutorials/application-developers/usdc): Transfer USDC cross-chain with programmable instructions via CCTP. +- [Get Started with CCIP Intents](/ccip/evm/tutorials/use-ccip-intents-api): Transfer USDC cross-chain with the CCIP Intents API: create a quote, submit the intent transaction, and track the intent to completion. --- @@ -131204,6 +131205,312 @@ When your verification request is granted, the Token Manager will display a **Ve --- +# Get Started with CCIP Intents +Source: https://docs.chain.link/ccip/evm/tutorials/use-ccip-intents-api +Last Updated: 2026-10-26 + +An intent is basically a request for a cross-chain outcome. + +1. You specify what outcomes you want (desired token, destination chain, recipient on destination), and, +2. You specify what inputs you are providing for the transfer (e.g., source token and amount), and the protocol arranges fulfillment instead of you sending the message through the standard CCIP Router path yourself. + +This page will show you how to use the Chainlink's Intents API to move USDC from *Base* to *Ronin* on mainnet. + +## Intents vs standard CCIP transfers + +The same [CCIP API](https://docs.chain.link/ccip/tools/api/) serves both surfaces, but they model different things: + +| | Standard CCIP transfers | Intent-based transfers | +| :-------------- | :------------------------------------------------------------------------------ | :-------------------------------------------------------------------- | +| Execution model | Lock-and-mint / burn-and-mint message passing through the canonical CCIP router | Fulfillment-based: a provider fills your requested outcome | +| Identifier | CCIP `messageId` | Source transaction hash, then provider-prefixed `intentId` | +| Fees | Explicit fee token selection at send time | Implicit in the quote (`inputAmount` − expected output) | +| Status tracking | Onchain message state, or `GET /messages/{messageId}` | Intents API: `GET /intents/tx/{txHash}`, `GET /intents/id/{intentId}` | +| Arbitrary data | Fully programmable messaging | Limited customization options | + +## When to use intents + +Common use cases for intents instead of standard CCIP transfers: + +- **Fast transfers**: standard CCIP waits for full source-chain finality before executing on the destination chain, which takes roughly 18 minutes from *Base* and 12.8 from *Ethereum* ([finality times by chain](/ccip/concepts/execution-latency/finality-by-chain)). With intents, a provider fills your requested outcome instead, so you get the speed without opting into [Faster-Than-Finality](/ccip/concepts/execution-latency/ftf) at every layer of the message path or taking on its reorg risk. +- **Cross-chain swaps**: receive a different token on the destination chain than the one you sent, in a single transaction. Standard CCIP transfers deliver the same token you sent. +- **Routes and assets standard CCIP does not serve**: token support on standard CCIP requires the token issuer to deploy and register pools on each chain ([CCT overview](/ccip/concepts/cross-chain-token)), so coverage grows one token at a time. +- **Simpler fees and operations**: the fee is implicit in the quote, so you never select, hold, or approve a fee token. You also skip destination gas estimation and [manual execution](/ccip/concepts/manual-execution) handling. + +If you need arbitrary messaging or programmable token transfers, use the [standard CCIP transfer flow](/ccip/evm/tutorials) instead. Intents also serve mainnet routes only and require an API key; for anything outside the [supported routes](#supported-routes-and-tokens), use standard CCIP. + +## Access and prerequisites + +> **NOTE: Request access** +> +> The Intents endpoints are live in production and require an API key. [Contact +> Chainlink](https://chain.link/contact?ref_id=ccip) to request access for your use case. + +> **CAUTION: Real funds on mainnet** +> +> The Intents API serves mainnet routes only. This tutorial moves real USDC and spends real ETH for gas on *Base*. Start +> with a small amount and use a dedicated key that controls only what you are willing to spend. + +Before you begin: + +1. Obtain an Intents API key (see above). This tutorial refers to it as the `INTENTS_API_KEY` environment variable. +2. Hold ETH on *Base* for gas and USDC on *Base* to transfer. Both are real mainnet funds. +3. Install [`cast`](https://getfoundry.sh/introduction/installation) from Foundry to send the onchain transactions. + +## How it works + +An intent moves through five steps: + +![Sequence diagram of the CCIP intents flow: request a quote from the CCIP API, approve the token spend, submit the intent transaction on the source chain, look up the intent ID by transaction hash, and poll the intent status until it reaches a terminal state.](/images/ccip/tutorials/ccip-intents-flow.svg) + +1. **Quote**: `POST /intents/quotes` returns the expected output amount and an executable transaction. +2. **Approve**: you approve the token spend required by the quote. +3. **Submit**: you submit the quote's transaction on the source chain. +4. **Discover**: `GET /intents/tx/{txHash}` returns the intent ID (or IDs, for batched intents) created by that transaction. +5. **Track**: you poll `GET /intents/id/{intentId}` until the intent reaches a terminal status. + +## Step 1: Get a quote + +[`POST /intents/quotes`](https://docs.chain.link/ccip/tools/api/get-intent-quote) prices a cross-chain swap or bridge operation and returns executable transaction data. This request quotes a transfer of 1 USDC (USDC has 6 decimals, so `1000000` in smallest units) from *Base* to *Ronin*: + +```bash filename="Terminal" +export INTENTS_API_KEY="" +export SENDER_ADDRESS="" +export RECEIVER_ADDRESS="" + +curl -s -X POST "https://api.ccip.chain.link/v2/intents/quotes" \ + -H "accept: application/json" \ + -H "Content-Type: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" \ + --data @- <" \ + --value 0 \ + --rpc-url "$BASE_RPC_URL" \ + --private-key "$PRIVATE_KEY" +``` + +Save the transaction hash from this submission; the next step uses it. If the quote's `deadline` has passed by the time you submit, discard the transaction and request a fresh quote. + +## Step 3: Get the intent ID + +[`GET /intents/tx/{txHash}`](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) returns the status of every intent created in a transaction, as an array. A single transaction can create multiple batched intents. Use it to obtain the `intentId` after your submission confirms: + +```bash filename="Terminal" +export TX_HASH="" + +curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" +``` + +Example response (illustrative), a single-element array: + +```json filename="JSON response" +[ + { + "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", + "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", + "status": "PENDING", + "subStatus": "WaitingToFulfill", + "sourceChainSelector": "15971525489660198786", + "destChainSelector": "6916147374840168594", + "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "inputToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", + "outputToken": "0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc", + "inputAmount": "1000000", + "createdAt": 1734192060 + } +] +``` + +Intent IDs are provider-prefixed (for example, `EC-...` or `EO-...`). Raw `0x` transaction hashes are not valid intent IDs, which is why this lookup step exists. To extract the ID for the next step with [`jq`](https://jqlang.org/): + +```bash filename="Terminal" +export INTENT_ID=$(curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" | jq -r '.[0].intentId') +``` + +`.[0]` assumes the transaction created one intent; if you batch intents, select the right element instead. The lookup can also return `404` until the transaction is indexed, so retry after a few seconds if your submission just confirmed. + +Once you have the `intentId`, prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) for status queries. For the full schema, see [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash). + +## Step 4: Track the intent to completion + +Prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) to return the status of one intent: + +```bash filename="Terminal" +curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" +``` + +Poll until `status` reaches a terminal value: `COMPLETED` or `FAILED`. A 10-second interval is a reasonable default: + +```bash filename="Terminal" +while true; do + STATUS=$(curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" | jq -r '.status') + echo "$STATUS" + [ "$STATUS" = "COMPLETED" ] || [ "$STATUS" = "FAILED" ] && break + sleep 10 +done +``` + +When the intent completes, the response includes `outputAmount` (the actual amount delivered) and `fulfillmentTxHash` (the fulfillment transaction on the destination chain). For refunded intents, `fulfillmentTxHash` is the refund transaction on the source chain and `filledAt` carries the refund timestamp: + +```json filename="JSON response" +{ + "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", + "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", + "status": "COMPLETED", + "subStatus": null, + "sourceChainSelector": "16015286601757825753", + "destChainSelector": "3478487238524512106", + "fulfillmentTxHash": "0xdef4567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12", + "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "inputToken": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238", + "outputToken": "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d", + "inputAmount": "1000000", + "outputAmount": "998500", + "createdAt": 1734192060, + "filledAt": 1734192240 +} +``` + +For the full schema and playground, see [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id). + +## Intent attribute reference + +The values below cover what the tracking loop in this tutorial uses. For complete schemas, see the [CCIP Tools API reference](https://docs.chain.link/ccip/tools/api/). + +**`status`**: high-level intent state: + +| Value | Meaning | +| :---------- | :--------------------------------------------- | +| `PENDING` | The intent is processing. | +| `COMPLETED` | The intent has been fulfilled. | +| `FAILED` | The intent has failed and cannot be fulfilled. | + +**Other attributes:** + +| Attribute | Values / format | +| :---------------------------------- | :---------------------------------------------------------------------------------------- | +| `subStatus` | Route-specific detail, for display only. Example: `WaitingToFulfill`. | +| `intentId` | Provider-prefixed string (`EC-...`, `EO-...`). Obtain it from `GET /intents/tx/{txHash}`. | +| `chainFamily` | `EVM` for all served routes. | +| `transactionPurpose` | `INTENT`: the transaction is ready to submit onchain. | +| `inputAmount`, `outputAmount` | Decimal strings in the token's smallest unit. | +| `deadline`, `createdAt`, `filledAt` | Unix timestamps in seconds. | + +## Supported routes and tokens + +The Intents API serves mainnet routes only; no testnet routes are available. Route support is per chain/token pair and evolves as providers add support. The quote endpoint returns `404 ROUTE_NOT_FOUND` when no provider serves a requested pair; confirm production availability with your Chainlink representative before integrating a specific pair. + +## Routes served at the time of writing (mainnet) + +| Source chain | Destination chain | Tokens | +| :----------- | :---------------- | :--------- | +| *Ethereum* | *Ronin* | USDC, WETH | +| *Ronin* | *Ethereum* | USDC, WETH | +| *Base* | *Ronin* | USDC, WETH | +| *Ronin* | *Base* | USDC, WETH | + +Token contract addresses: + +| Token | *Ethereum* | *Base* | *Ronin* | +| :---- | :------------------------------------------- | :------------------------------------------- | :------------------------------------------- | +| USDC | `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | `0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc` | +| WETH | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` | `0x4200000000000000000000000000000000000006` | `0xc99a6A985eD2Cac1ef41640596C5A5f9F4E19Ef5` | + +## Next steps + +- API reference: [Create quote for intent](https://docs.chain.link/ccip/tools/api/get-intent-quote) +- API reference: [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) +- API reference: [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id) +- [CCIP Tools overview](https://docs.chain.link/ccip/tools/) +- [Transfer tokens with standard CCIP](/ccip/evm/tutorials/application-developers/transfer-tokens-from-contract) + +--- + # Build with AI Source: https://docs.chain.link/ccip/getting-started/build-with-ai diff --git a/src/content/ccip/llms.txt b/src/content/ccip/llms.txt index f872d35d8c7..5d5371e4a88 100644 --- a/src/content/ccip/llms.txt +++ b/src/content/ccip/llms.txt @@ -36,6 +36,7 @@ Use directory pages only when retrieving current chain, lane, token, or contract - [EVM Transfer Tokens from Contract](https://docs.chain.link/ccip/tutorials/evm/transfer-tokens-from-contract.md) - [EVM USDC Transfer](https://docs.chain.link/ccip/tutorials/evm/usdc.md) - [Test CCIP Locally](https://docs.chain.link/ccip/tutorials/evm/test-ccip-locally.md) +- [Get Started with CCIP Intents](https://docs.chain.link/ccip/evm/tutorials/use-ccip-intents-api.md) ## Operational Considerations diff --git a/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx b/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx index b5ce50e51d5..0ee22e8f614 100644 --- a/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx +++ b/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx @@ -3,16 +3,16 @@ section: ccip date: Last Modified title: "Application Developers" metadata: - description: "Browse CCIP tutorials for application developers: transfer tokens, send arbitrary messages, programmable token transfers, manual execution, and USDC transfers with data." - excerpt: "CCIP application developers, token transfers, arbitrary messaging, programmable token transfers, manual execution, USDC, EVM" + description: "Browse CCIP tutorials for application developers: transfer tokens, send arbitrary messages, programmable token transfers, manual execution, USDC transfers with data, and transfers with the CCIP Intents API." + excerpt: "CCIP application developers, token transfers, arbitrary messaging, programmable token transfers, manual execution, USDC, intents API, EVM" datePublished: "2025-07-21" - lastModified: "2025-07-21" + lastModified: "2026-10-26" isIndex: true --- import { DocCards, DocCard } from "@components" -These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, and USDC transfers with data. +These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, USDC transfers with data, and transfers with the CCIP Intents API. ## Pages @@ -47,4 +47,8 @@ These tutorials are for application developers building cross-chain functionalit Transfer USDC cross-chain with programmable instructions via CCTP. + + Transfer USDC cross-chain with the CCIP Intents API: create a quote, submit the intent transaction, and track the + intent to completion. + diff --git a/src/content/ccip/v2/evm/tutorials/use-ccip-intents-api.mdx b/src/content/ccip/v2/evm/tutorials/use-ccip-intents-api.mdx new file mode 100644 index 00000000000..c9c9dfe6cc3 --- /dev/null +++ b/src/content/ccip/v2/evm/tutorials/use-ccip-intents-api.mdx @@ -0,0 +1,321 @@ +--- +section: ccip +date: Last Modified +title: "Get Started with CCIP Intents" +metadata: + description: "Transfer USDC from Base to Ronin with the CCIP v2 Intents API: create a quote, submit the intent transaction onchain, and track intent status by transaction hash and intent ID." + image: "/images/ccip/tutorials/ccip-intents-flow.svg" + excerpt: "CCIP intents, Intents API, intent quote, cross-chain transfer, USDC, Base, Ronin, x-api-key, intent status" + datePublished: "2026-10-26" + lastModified: "2026-10-26" + estimatedTime: "30 minutes" + difficulty: "intermediate" +--- + +import { AnchoredAccordion, Aside, ClickToZoom } from "@components" + +An intent is basically a request for a cross-chain outcome. + +1. You specify what outcomes you want (desired token, destination chain, recipient on destination), and, +2. You specify what inputs you are providing for the transfer (e.g., source token and amount), and the protocol arranges fulfillment instead of you sending the message through the standard CCIP Router path yourself. + +This page will show you how to use the Chainlink's Intents API to move USDC from _Base_ to _Ronin_ on mainnet. + +## Intents vs standard CCIP transfers + +The same [CCIP API](https://docs.chain.link/ccip/tools/api/) serves both surfaces, but they model different things: + +| | Standard CCIP transfers | Intent-based transfers | +| :-------------- | :------------------------------------------------------------------------------ | :-------------------------------------------------------------------- | +| Execution model | Lock-and-mint / burn-and-mint message passing through the canonical CCIP router | Fulfillment-based: a provider fills your requested outcome | +| Identifier | CCIP `messageId` | Source transaction hash, then provider-prefixed `intentId` | +| Fees | Explicit fee token selection at send time | Implicit in the quote (`inputAmount` − expected output) | +| Status tracking | Onchain message state, or `GET /messages/{messageId}` | Intents API: `GET /intents/tx/{txHash}`, `GET /intents/id/{intentId}` | +| Arbitrary data | Fully programmable messaging | Limited customization options | + +## When to use intents + +Common use cases for intents instead of standard CCIP transfers: + +- **Fast transfers**: standard CCIP waits for full source-chain finality before executing on the destination chain, which takes roughly 18 minutes from _Base_ and 12.8 from _Ethereum_ ([finality times by chain](/ccip/concepts/execution-latency/finality-by-chain)). With intents, a provider fills your requested outcome instead, so you get the speed without opting into [Faster-Than-Finality](/ccip/concepts/execution-latency/ftf) at every layer of the message path or taking on its reorg risk. +- **Cross-chain swaps**: receive a different token on the destination chain than the one you sent, in a single transaction. Standard CCIP transfers deliver the same token you sent. +- **Routes and assets standard CCIP does not serve**: token support on standard CCIP requires the token issuer to deploy and register pools on each chain ([CCT overview](/ccip/concepts/cross-chain-token)), so coverage grows one token at a time. +- **Simpler fees and operations**: the fee is implicit in the quote, so you never select, hold, or approve a fee token. You also skip destination gas estimation and [manual execution](/ccip/concepts/manual-execution) handling. + +If you need arbitrary messaging or programmable token transfers, use the [standard CCIP transfer flow](/ccip/evm/tutorials) instead. Intents also serve mainnet routes only and require an API key; for anything outside the [supported routes](#supported-routes-and-tokens), use standard CCIP. + +## Access and prerequisites + + + + + +Before you begin: + +1. Obtain an Intents API key (see above). This tutorial refers to it as the `INTENTS_API_KEY` environment variable. +1. Hold ETH on _Base_ for gas and USDC on _Base_ to transfer. Both are real mainnet funds. +1. Install [`cast`](https://getfoundry.sh/introduction/installation) from Foundry to send the onchain transactions. + +## How it works + +An intent moves through five steps: + + + +1. **Quote**: `POST /intents/quotes` returns the expected output amount and an executable transaction. +1. **Approve**: you approve the token spend required by the quote. +1. **Submit**: you submit the quote's transaction on the source chain. +1. **Discover**: `GET /intents/tx/{txHash}` returns the intent ID (or IDs, for batched intents) created by that transaction. +1. **Track**: you poll `GET /intents/id/{intentId}` until the intent reaches a terminal status. + +## Step 1: Get a quote + +[`POST /intents/quotes`](https://docs.chain.link/ccip/tools/api/get-intent-quote) prices a cross-chain swap or bridge operation and returns executable transaction data. This request quotes a transfer of 1 USDC (USDC has 6 decimals, so `1000000` in smallest units) from _Base_ to _Ronin_: + +```bash filename="Terminal" +export INTENTS_API_KEY="" +export SENDER_ADDRESS="" +export RECEIVER_ADDRESS="" + +curl -s -X POST "https://api.ccip.chain.link/v2/intents/quotes" \ + -H "accept: application/json" \ + -H "Content-Type: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" \ + --data @- <" \ + --value 0 \ + --rpc-url "$BASE_RPC_URL" \ + --private-key "$PRIVATE_KEY" +``` + +Save the transaction hash from this submission; the next step uses it. If the quote's `deadline` has passed by the time you submit, discard the transaction and request a fresh quote. + +## Step 3: Get the intent ID + +[`GET /intents/tx/{txHash}`](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) returns the status of every intent created in a transaction, as an array. A single transaction can create multiple batched intents. Use it to obtain the `intentId` after your submission confirms: + +```bash filename="Terminal" +export TX_HASH="" + +curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" +``` + +Example response (illustrative), a single-element array: + +```json filename="JSON response" +[ + { + "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", + "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", + "status": "PENDING", + "subStatus": "WaitingToFulfill", + "sourceChainSelector": "15971525489660198786", + "destChainSelector": "6916147374840168594", + "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "inputToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", + "outputToken": "0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc", + "inputAmount": "1000000", + "createdAt": 1734192060 + } +] +``` + +Intent IDs are provider-prefixed (for example, `EC-...` or `EO-...`). Raw `0x` transaction hashes are not valid intent IDs, which is why this lookup step exists. To extract the ID for the next step with [`jq`](https://jqlang.org/): + +```bash filename="Terminal" +export INTENT_ID=$(curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" | jq -r '.[0].intentId') +``` + +`.[0]` assumes the transaction created one intent; if you batch intents, select the right element instead. The lookup can also return `404` until the transaction is indexed, so retry after a few seconds if your submission just confirmed. + +Once you have the `intentId`, prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) for status queries. For the full schema, see [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash). + +## Step 4: Track the intent to completion + +Prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) to return the status of one intent: + +```bash filename="Terminal" +curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" +``` + +Poll until `status` reaches a terminal value: `COMPLETED` or `FAILED`. A 10-second interval is a reasonable default: + +```bash filename="Terminal" +while true; do + STATUS=$(curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" | jq -r '.status') + echo "$STATUS" + [ "$STATUS" = "COMPLETED" ] || [ "$STATUS" = "FAILED" ] && break + sleep 10 +done +``` + +When the intent completes, the response includes `outputAmount` (the actual amount delivered) and `fulfillmentTxHash` (the fulfillment transaction on the destination chain). For refunded intents, `fulfillmentTxHash` is the refund transaction on the source chain and `filledAt` carries the refund timestamp: + +```json filename="JSON response" +{ + "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", + "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", + "status": "COMPLETED", + "subStatus": null, + "sourceChainSelector": "16015286601757825753", + "destChainSelector": "3478487238524512106", + "fulfillmentTxHash": "0xdef4567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12", + "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "inputToken": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238", + "outputToken": "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d", + "inputAmount": "1000000", + "outputAmount": "998500", + "createdAt": 1734192060, + "filledAt": 1734192240 +} +``` + +For the full schema and playground, see [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id). + +## Intent attribute reference + +The values below cover what the tracking loop in this tutorial uses. For complete schemas, see the [CCIP Tools API reference](https://docs.chain.link/ccip/tools/api/). + +**`status`**: high-level intent state: + +| Value | Meaning | +| :---------- | :--------------------------------------------- | +| `PENDING` | The intent is processing. | +| `COMPLETED` | The intent has been fulfilled. | +| `FAILED` | The intent has failed and cannot be fulfilled. | + +**Other attributes:** + +| Attribute | Values / format | +| :---------------------------------- | :---------------------------------------------------------------------------------------- | +| `subStatus` | Route-specific detail, for display only. Example: `WaitingToFulfill`. | +| `intentId` | Provider-prefixed string (`EC-...`, `EO-...`). Obtain it from `GET /intents/tx/{txHash}`. | +| `chainFamily` | `EVM` for all served routes. | +| `transactionPurpose` | `INTENT`: the transaction is ready to submit onchain. | +| `inputAmount`, `outputAmount` | Decimal strings in the token's smallest unit. | +| `deadline`, `createdAt`, `filledAt` | Unix timestamps in seconds. | + +## Supported routes and tokens + +The Intents API serves mainnet routes only; no testnet routes are available. Route support is per chain/token pair and evolves as providers add support. The quote endpoint returns `404 ROUTE_NOT_FOUND` when no provider serves a requested pair; confirm production availability with your Chainlink representative before integrating a specific pair. + + + +| Source chain | Destination chain | Tokens | +| :----------- | :---------------- | :--------- | +| _Ethereum_ | _Ronin_ | USDC, WETH | +| _Ronin_ | _Ethereum_ | USDC, WETH | +| _Base_ | _Ronin_ | USDC, WETH | +| _Ronin_ | _Base_ | USDC, WETH | + +Token contract addresses: + +| Token | _Ethereum_ | _Base_ | _Ronin_ | +| :---- | :------------------------------------------- | :------------------------------------------- | :------------------------------------------- | +| USDC | `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | `0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc` | +| WETH | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` | `0x4200000000000000000000000000000000000006` | `0xc99a6A985eD2Cac1ef41640596C5A5f9F4E19Ef5` | + + + +## Next steps + +- API reference: [Create quote for intent](https://docs.chain.link/ccip/tools/api/get-intent-quote) +- API reference: [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) +- API reference: [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id) +- [CCIP Tools overview](https://docs.chain.link/ccip/tools/) +- [Transfer tokens with standard CCIP](/ccip/evm/tutorials/application-developers/transfer-tokens-from-contract) From 0c46fdf0e52ce48045346312b7cf120ee78453a0 Mon Sep 17 00:00:00 2001 From: Priyank Gupta Date: Tue, 27 Oct 2026 17:27:22 +0530 Subject: [PATCH 2/2] chore: move ccip intents page from tutorials to concepts --- src/config/sidebar/ccip-dynamic.ts | 21 +- src/content/ccip/llms-full.txt | 763 +++++++++--------- src/content/ccip/llms.txt | 2 +- .../ccip-intents.mdx} | 2 +- .../application-developers/index.mdx | 12 +- 5 files changed, 397 insertions(+), 403 deletions(-) rename src/content/ccip/v2/evm/{tutorials/use-ccip-intents-api.mdx => concepts/ccip-intents.mdx} (99%) diff --git a/src/config/sidebar/ccip-dynamic.ts b/src/config/sidebar/ccip-dynamic.ts index 20c19913fa7..fdf56eda4d9 100644 --- a/src/config/sidebar/ccip-dynamic.ts +++ b/src/config/sidebar/ccip-dynamic.ts @@ -365,6 +365,16 @@ export const CCIP_SIDEBAR_CONTENT: SectionEntry[] = [ chainTypes: ["evm"], }, + // --------------------------------------------- + // CCIP Intents (EVM) + // --------------------------------------------- + { + title: "CCIP Intents", + pageId: "ccip-evm-concepts-intents", + url: "ccip/evm/concepts/ccip-intents", + chainTypes: ["evm"], + }, + // --------------------------------------------- // Canton — minimal, enterprise-focused IA (independent of other chain families) // --------------------------------------------- @@ -475,17 +485,6 @@ export const CCIP_SIDEBAR_CONTENT: SectionEntry[] = [ chainTypes: ["evm"], pageId: "ptt-transfer-usdc", }, - { - title: "Intents", - type: "separator", - chainTypes: ["evm"], - }, - { - title: "Get Started with CCIP Intents", - url: "ccip/evm/tutorials/use-ccip-intents-api", - pageId: "ccip-intents-api-tutorial", - chainTypes: ["evm"], - }, ], }, { diff --git a/src/content/ccip/llms-full.txt b/src/content/ccip/llms-full.txt index 02e226c4fed..c54143d8fa9 100644 --- a/src/content/ccip/llms-full.txt +++ b/src/content/ccip/llms-full.txt @@ -103262,6 +103262,312 @@ Maintain thorough documentation of multisig operations and provide training for --- +# CCIP Intents +Source: https://docs.chain.link/ccip/evm/concepts/ccip-intents +Last Updated: 2026-10-26 + +An intent is basically a request for a cross-chain outcome. + +1. You specify what outcomes you want (desired token, destination chain, recipient on destination), and, +2. You specify what inputs you are providing for the transfer (e.g., source token and amount), and the protocol arranges fulfillment instead of you sending the message through the standard CCIP Router path yourself. + +This page will show you how to use the Chainlink's Intents API to move USDC from *Base* to *Ronin* on mainnet. + +## Intents vs standard CCIP transfers + +The same [CCIP API](https://docs.chain.link/ccip/tools/api/) serves both surfaces, but they model different things: + +| | Standard CCIP transfers | Intent-based transfers | +| :-------------- | :------------------------------------------------------------------------------ | :-------------------------------------------------------------------- | +| Execution model | Lock-and-mint / burn-and-mint message passing through the canonical CCIP router | Fulfillment-based: a provider fills your requested outcome | +| Identifier | CCIP `messageId` | Source transaction hash, then provider-prefixed `intentId` | +| Fees | Explicit fee token selection at send time | Implicit in the quote (`inputAmount` − expected output) | +| Status tracking | Onchain message state, or `GET /messages/{messageId}` | Intents API: `GET /intents/tx/{txHash}`, `GET /intents/id/{intentId}` | +| Arbitrary data | Fully programmable messaging | Limited customization options | + +## When to use intents + +Common use cases for intents instead of standard CCIP transfers: + +- **Fast transfers**: standard CCIP waits for full source-chain finality before executing on the destination chain, which takes roughly 18 minutes from *Base* and 12.8 from *Ethereum* ([finality times by chain](/ccip/concepts/execution-latency/finality-by-chain)). With intents, a provider fills your requested outcome instead, so you get the speed without opting into [Faster-Than-Finality](/ccip/concepts/execution-latency/ftf) at every layer of the message path or taking on its reorg risk. +- **Cross-chain swaps**: receive a different token on the destination chain than the one you sent, in a single transaction. Standard CCIP transfers deliver the same token you sent. +- **Routes and assets standard CCIP does not serve**: token support on standard CCIP requires the token issuer to deploy and register pools on each chain ([CCT overview](/ccip/concepts/cross-chain-token)), so coverage grows one token at a time. +- **Simpler fees and operations**: the fee is implicit in the quote, so you never select, hold, or approve a fee token. You also skip destination gas estimation and [manual execution](/ccip/concepts/manual-execution) handling. + +If you need arbitrary messaging or programmable token transfers, use the [standard CCIP transfer flow](/ccip/evm/tutorials) instead. Intents also serve mainnet routes only and require an API key; for anything outside the [supported routes](#supported-routes-and-tokens), use standard CCIP. + +## Access and prerequisites + +> **NOTE: Request access** +> +> The Intents endpoints are live in production and require an API key. [Contact +> Chainlink](https://chain.link/contact?ref_id=ccip) to request access for your use case. + +> **CAUTION: Real funds on mainnet** +> +> The Intents API serves mainnet routes only. This tutorial moves real USDC and spends real ETH for gas on *Base*. Start +> with a small amount and use a dedicated key that controls only what you are willing to spend. + +Before you begin: + +1. Obtain an Intents API key (see above). This tutorial refers to it as the `INTENTS_API_KEY` environment variable. +2. Hold ETH on *Base* for gas and USDC on *Base* to transfer. Both are real mainnet funds. +3. Install [`cast`](https://getfoundry.sh/introduction/installation) from Foundry to send the onchain transactions. + +## How it works + +An intent moves through five steps: + +![Sequence diagram of the CCIP intents flow: request a quote from the CCIP API, approve the token spend, submit the intent transaction on the source chain, look up the intent ID by transaction hash, and poll the intent status until it reaches a terminal state.](/images/ccip/tutorials/ccip-intents-flow.svg) + +1. **Quote**: `POST /intents/quotes` returns the expected output amount and an executable transaction. +2. **Approve**: you approve the token spend required by the quote. +3. **Submit**: you submit the quote's transaction on the source chain. +4. **Discover**: `GET /intents/tx/{txHash}` returns the intent ID (or IDs, for batched intents) created by that transaction. +5. **Track**: you poll `GET /intents/id/{intentId}` until the intent reaches a terminal status. + +## Step 1: Get a quote + +[`POST /intents/quotes`](https://docs.chain.link/ccip/tools/api/get-intent-quote) prices a cross-chain swap or bridge operation and returns executable transaction data. This request quotes a transfer of 1 USDC (USDC has 6 decimals, so `1000000` in smallest units) from *Base* to *Ronin*: + +```bash filename="Terminal" +export INTENTS_API_KEY="" +export SENDER_ADDRESS="" +export RECEIVER_ADDRESS="" + +curl -s -X POST "https://api.ccip.chain.link/v2/intents/quotes" \ + -H "accept: application/json" \ + -H "Content-Type: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" \ + --data @- <" \ + --value 0 \ + --rpc-url "$BASE_RPC_URL" \ + --private-key "$PRIVATE_KEY" +``` + +Save the transaction hash from this submission; the next step uses it. If the quote's `deadline` has passed by the time you submit, discard the transaction and request a fresh quote. + +## Step 3: Get the intent ID + +[`GET /intents/tx/{txHash}`](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) returns the status of every intent created in a transaction, as an array. A single transaction can create multiple batched intents. Use it to obtain the `intentId` after your submission confirms: + +```bash filename="Terminal" +export TX_HASH="" + +curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" +``` + +Example response (illustrative), a single-element array: + +```json filename="JSON response" +[ + { + "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", + "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", + "status": "PENDING", + "subStatus": "WaitingToFulfill", + "sourceChainSelector": "15971525489660198786", + "destChainSelector": "6916147374840168594", + "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "inputToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", + "outputToken": "0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc", + "inputAmount": "1000000", + "createdAt": 1734192060 + } +] +``` + +Intent IDs are provider-prefixed (for example, `EC-...` or `EO-...`). Raw `0x` transaction hashes are not valid intent IDs, which is why this lookup step exists. To extract the ID for the next step with [`jq`](https://jqlang.org/): + +```bash filename="Terminal" +export INTENT_ID=$(curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" | jq -r '.[0].intentId') +``` + +`.[0]` assumes the transaction created one intent; if you batch intents, select the right element instead. The lookup can also return `404` until the transaction is indexed, so retry after a few seconds if your submission just confirmed. + +Once you have the `intentId`, prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) for status queries. For the full schema, see [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash). + +## Step 4: Track the intent to completion + +Prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) to return the status of one intent: + +```bash filename="Terminal" +curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" +``` + +Poll until `status` reaches a terminal value: `COMPLETED` or `FAILED`. A 10-second interval is a reasonable default: + +```bash filename="Terminal" +while true; do + STATUS=$(curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ + -H "accept: application/json" \ + -H "x-api-key: $INTENTS_API_KEY" | jq -r '.status') + echo "$STATUS" + [ "$STATUS" = "COMPLETED" ] || [ "$STATUS" = "FAILED" ] && break + sleep 10 +done +``` + +When the intent completes, the response includes `outputAmount` (the actual amount delivered) and `fulfillmentTxHash` (the fulfillment transaction on the destination chain). For refunded intents, `fulfillmentTxHash` is the refund transaction on the source chain and `filledAt` carries the refund timestamp: + +```json filename="JSON response" +{ + "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", + "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", + "status": "COMPLETED", + "subStatus": null, + "sourceChainSelector": "16015286601757825753", + "destChainSelector": "3478487238524512106", + "fulfillmentTxHash": "0xdef4567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12", + "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", + "inputToken": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238", + "outputToken": "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d", + "inputAmount": "1000000", + "outputAmount": "998500", + "createdAt": 1734192060, + "filledAt": 1734192240 +} +``` + +For the full schema and playground, see [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id). + +## Intent attribute reference + +The values below cover what the tracking loop in this tutorial uses. For complete schemas, see the [CCIP Tools API reference](https://docs.chain.link/ccip/tools/api/). + +**`status`**: high-level intent state: + +| Value | Meaning | +| :---------- | :--------------------------------------------- | +| `PENDING` | The intent is processing. | +| `COMPLETED` | The intent has been fulfilled. | +| `FAILED` | The intent has failed and cannot be fulfilled. | + +**Other attributes:** + +| Attribute | Values / format | +| :---------------------------------- | :---------------------------------------------------------------------------------------- | +| `subStatus` | Route-specific detail, for display only. Example: `WaitingToFulfill`. | +| `intentId` | Provider-prefixed string (`EC-...`, `EO-...`). Obtain it from `GET /intents/tx/{txHash}`. | +| `chainFamily` | `EVM` for all served routes. | +| `transactionPurpose` | `INTENT`: the transaction is ready to submit onchain. | +| `inputAmount`, `outputAmount` | Decimal strings in the token's smallest unit. | +| `deadline`, `createdAt`, `filledAt` | Unix timestamps in seconds. | + +## Supported routes and tokens + +The Intents API serves mainnet routes only; no testnet routes are available. Route support is per chain/token pair and evolves as providers add support. The quote endpoint returns `404 ROUTE_NOT_FOUND` when no provider serves a requested pair; confirm production availability with your Chainlink representative before integrating a specific pair. + +## Routes served at the time of writing (mainnet) + +| Source chain | Destination chain | Tokens | +| :----------- | :---------------- | :--------- | +| *Ethereum* | *Ronin* | USDC, WETH | +| *Ronin* | *Ethereum* | USDC, WETH | +| *Base* | *Ronin* | USDC, WETH | +| *Ronin* | *Base* | USDC, WETH | + +Token contract addresses: + +| Token | *Ethereum* | *Base* | *Ronin* | +| :---- | :------------------------------------------- | :------------------------------------------- | :------------------------------------------- | +| USDC | `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | `0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc` | +| WETH | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` | `0x4200000000000000000000000000000000000006` | `0xc99a6A985eD2Cac1ef41640596C5A5f9F4E19Ef5` | + +## Next steps + +- API reference: [Create quote for intent](https://docs.chain.link/ccip/tools/api/get-intent-quote) +- API reference: [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) +- API reference: [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id) +- [CCIP Tools overview](https://docs.chain.link/ccip/tools/) +- [Transfer tokens with standard CCIP](/ccip/evm/tutorials/application-developers/transfer-tokens-from-contract) + +--- + # Burn & Mint V1 -> V2 Source: https://docs.chain.link/ccip/evm/concepts/cross-chain-token/burn-mint-v1-to-v2 @@ -107088,9 +107394,9 @@ It provides guided workflows for token developers, abstracting away much of the # Application Developers Source: https://docs.chain.link/ccip/evm/tutorials/application-developers -Last Updated: 2026-10-26 +Last Updated: 2025-07-21 -These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, USDC transfers with data, and transfers with the CCIP Intents API. +These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, and USDC transfers with data. ## Pages @@ -107101,7 +107407,6 @@ These tutorials are for application developers building cross-chain functionalit - [Programmable Token Transfers - Defensive](/ccip/evm/tutorials/application-developers/programmable-token-transfers-defensive): A defensive example of programmable token transfers with extra safety checks. - [Manual Execution](/ccip/evm/tutorials/application-developers/manual-execution): Manually execute a CCIP message when the default executor fails or is unavailable. - [Transfer USDC with Data](/ccip/evm/tutorials/application-developers/usdc): Transfer USDC cross-chain with programmable instructions via CCTP. -- [Get Started with CCIP Intents](/ccip/evm/tutorials/use-ccip-intents-api): Transfer USDC cross-chain with the CCIP Intents API: create a quote, submit the intent transaction, and track the intent to completion. --- @@ -131081,433 +131386,127 @@ Before you can deploy a new token or add an existing token, you need to connect Make sure that your wallet contains gas tokens for each network where you're deploying your token, in order to pay for the deployment transactions. - If you selected more than two networks during the previous step, the *Remove* links are active, allowing you to remove a network before proceeding. If you only have two networks selected, the *Remove* links are intentionally not active. If you need to add more networks, navigate back to the **Networks** page. - -6. The **Deploy** page displays the steps that you need to complete for each network: - - - Deploy token and pool - - Accept admin role - - Accept token ownership - - Accept pool ownership - - ![Deployment steps](/images/ccip/token-manager/new/deployment-6.png) - - After the **Deploy token and pool** step is completed, you can initiate the other steps all at the same time by clicking **Accept** under each step. While these steps run concurrently, each step separately prompts you to confirm the corresponding transactions in your wallet. - - Once all of the steps for one network have been initiated, you can switch to the other network and repeat the same process. You do not have to wait for the first network deploy process to be complete before initiating the second network deploy process. - - When the deploy process is complete for all the networks you selected, the Token Manager marks them all as **Done**: - - ![Steps complete for all networks](/images/ccip/token-manager/new/done-7.png) - - Click **Continue**. The Token Manager displays a message showing that your configuration was successful: - - ![Success message](/images/ccip/token-manager/new/7-success-message.png) - -When everything is successfully set up for your token, you can view your new Token Page from the Token Manager Dashboard. It displays information about your CCT, enables configuration changes, and allows expansion to additional networks where you can deploy the token. - -## Add an existing token - -If you have existing token(s) that you've already deployed, you can use the Token Manager to create and configure a token pool for the token, and optionally deploy your token on additional networks. Note that tokens deployed to additional networks are automatically configured to use the Burn and Mint mechanism. - -1. On the **Details** page, enter the details for your token on each network where it has already been deployed. As you add each token contract address, the Token Manager displays validation checks for the token and the required admin registration functions in the contract. - - Use the *+ Add New Address* link to add additional token deployments. When you've added all the token deployments that you want to add at this time, select the checkbox to confirm *These are all of the tokens I currently want to enable on CCIP*. - -2. On the **Pools** page, you're prompted to select the token pool mechanism that's used to transfer value between networks — *Burn / Mint* or *Lock / Release*. Depending on your token contract, you may have more than one option for *Burn / Mint*: - - ![Selecting token pool types](/images/ccip/token-manager/existing/2-token-pool-type.png) - - Before selecting a token pool type, be sure to review [CCIP token handling mechanisms](/ccip/concepts/cross-chain-token/overview#token-handling-mechanisms). - -3. On the **Networks** page, select the additional blockchain networks where you'd like to deploy your new token. For additional networks, Token Manager Wizard workflow automatically configures all tokens with the Burn & Mint mechanism. (Refer to the [token contract](https://github.com/smartcontractkit/chainlink-evm/blob/contracts-v1.4.0/contracts/src/v0.8/shared/token/ERC20/BurnMintERC20.sol) and [token pool contract](https://github.com/smartcontractkit/chainlink-ccip/tree/contracts-ccip-v1.6.1/chains/evm/contracts/pools/BurnMintTokenPool.sol) for the Burn & Mint mechanism.) - -4. On the **Summary** page, each network you've selected appears along with an expandable list of the transactions the Token Manager will guide you through to deploy your token for each network. - - If you selected more than two networks during the previous step, the *Remove* links are active, allowing you to remove a network before proceeding. If you only have two networks selected, the *Remove* links are intentionally not active. If you need to add more networks, navigate back to the **Networks** page. - -5. The **Deploy** page displays the steps that you need to complete. - - For the tokens you're adding, the Token Manager guides you through each of these steps per network: - - - Deploy token pool for existing token - - Grant Burn / Mint privileges (**manual step**) - - Register admin - - Accept admin role of your token pool - - Set the token pool address - - Accept ownership of the new token pool - - > **CAUTION: Manually granting Burn/Mint privileges** - > - > Unlike the other steps where you're simply prompted to confirm transactions in your wallet, the Token Manager - > prompts you to grant Burn/Mint privileges manually, and then confirm that you've done so before proceeding with - > further steps. It's crucial to complete this manual step to ensure your CCIP transactions will work properly. - - For the other tokens in your network, the Token Manager also guides you through updating existing token pools to incorporate the tokens you're adding. - - At each step, you are prompted to confirm the corresponding transactions in your wallet. When each step is complete for all the networks you selected, the Token Manager displays a message showing that your configuration was successful. - -When everything is successfully set up for your token, you can view your new Token Page from the Token Manager Dashboard. It displays information about your CCT, enables configuration changes, and allows expansion to additional networks. - -## Token Manager Dashboard - -After you connect your wallet, you can see the Token Manager Dashboard: - -![Token dashboard](/images/ccip/token-manager/settings/dashboard.png) - -- If you click **Add new token**, you enter the Token Manager Wizard which prompts you to deploy a new token or to add an existing token. -- If the wallet you connected to the dashboard is a Token Admin address, the Token Manager automatically populates your tokens in the dashboard. -- If you have saved partial progress in the Token Manager Wizard, your token displays in a draft state so you can return and finish deploying it later. - -After you have deployed a new token or added an existing one, each token has its own page: - -![Token page](/images/ccip/token-manager/settings/token-page.png) - -The token page shows both the configured and unconfigured networks. - -- When you select any of the listed unconfigured networks, you can use the Token Manager Wizard to expand your token to those networks, either by deploying a new token or by adding an existing token and deploying a token pool. -- For configured networks, you can view details for each network-specific token, and you can expand a **Token Details** side panel with more information and admin actions. To expand the **Token Details** panel, click the *View* link next to the configured network. - -When expanded, the **Token Details** side panel provides more details about the inbound and outbound lanes for your token. If the connected wallet is a token admin or has permissions to update the token pool, the **Token Details** side panel also displays an **Actions** menu: - -![Token details actions menu](/images/ccip/token-manager/settings/token-details-actions-menu.png) - -If you have the appropriate permissions, you can edit your token's inbound and outbound rate limits, edit the router contract address, and propose a new token administrator. - -### Managing token settings - -1. Connect your wallet and select your token in the Token Manager home page. A detailed page for your token displays, showing both configured and unconfigured networks. -2. To access the **Settings** page, select the gear icon next to your token's name: - - ![Token settings icon](/images/ccip/token-manager/settings/1-gear-icon.png) - -### Verifying your token - -You can request token verification through the Token Manager; when verification is granted, it allows the token to be listed on the CCIP Directory and ensures information is consistent across other CCIP apps, like CCIP Explorer. - -> **CAUTION** -> -> CCIP allows users to register and manage tokens in a permissionless manner. A 'Verified' status of a token indicates -> only that the Token Creator has signed transactions evidencing their ownership. Users should conduct their own -> research before engaging with any tokens. - -If your token is unverified, an **Unverified** badge displays underneath the token's name at the top of the page. Be sure that all information is correct before your submission, as it requires a manual review process. If you need to make any further changes after submitting your request, you must use the [CCIP Contact Form](https://chain.link/ccip-contact?v=Token%20Manager%20support). - -You can send a request for verification from the **Settings** page: - -![Token settings page](/images/ccip/token-manager/settings/2-settings-page.png) - -1. The *Token Details* tab allows you to modify your token's name and ticker symbol with an off-chain transaction. You can also specify an avatar for your token. If you have made any changes in this tab, click **Save Changes**. -2. The *Project Details* tab prompts you to fill in your project's name and URL, and a contact email address. This information is kept private. It's optional to fill out, but required if you're requesting token verification. -3. The *Verification* tab has a **Verify my token** button that submits a verification request with the information you provided in the previous two tabs. - -When your verification request is granted, the Token Manager will display a **Verified** badge on the token page. - ---- - -# Get Started with CCIP Intents -Source: https://docs.chain.link/ccip/evm/tutorials/use-ccip-intents-api -Last Updated: 2026-10-26 - -An intent is basically a request for a cross-chain outcome. - -1. You specify what outcomes you want (desired token, destination chain, recipient on destination), and, -2. You specify what inputs you are providing for the transfer (e.g., source token and amount), and the protocol arranges fulfillment instead of you sending the message through the standard CCIP Router path yourself. - -This page will show you how to use the Chainlink's Intents API to move USDC from *Base* to *Ronin* on mainnet. - -## Intents vs standard CCIP transfers - -The same [CCIP API](https://docs.chain.link/ccip/tools/api/) serves both surfaces, but they model different things: - -| | Standard CCIP transfers | Intent-based transfers | -| :-------------- | :------------------------------------------------------------------------------ | :-------------------------------------------------------------------- | -| Execution model | Lock-and-mint / burn-and-mint message passing through the canonical CCIP router | Fulfillment-based: a provider fills your requested outcome | -| Identifier | CCIP `messageId` | Source transaction hash, then provider-prefixed `intentId` | -| Fees | Explicit fee token selection at send time | Implicit in the quote (`inputAmount` − expected output) | -| Status tracking | Onchain message state, or `GET /messages/{messageId}` | Intents API: `GET /intents/tx/{txHash}`, `GET /intents/id/{intentId}` | -| Arbitrary data | Fully programmable messaging | Limited customization options | - -## When to use intents - -Common use cases for intents instead of standard CCIP transfers: - -- **Fast transfers**: standard CCIP waits for full source-chain finality before executing on the destination chain, which takes roughly 18 minutes from *Base* and 12.8 from *Ethereum* ([finality times by chain](/ccip/concepts/execution-latency/finality-by-chain)). With intents, a provider fills your requested outcome instead, so you get the speed without opting into [Faster-Than-Finality](/ccip/concepts/execution-latency/ftf) at every layer of the message path or taking on its reorg risk. -- **Cross-chain swaps**: receive a different token on the destination chain than the one you sent, in a single transaction. Standard CCIP transfers deliver the same token you sent. -- **Routes and assets standard CCIP does not serve**: token support on standard CCIP requires the token issuer to deploy and register pools on each chain ([CCT overview](/ccip/concepts/cross-chain-token)), so coverage grows one token at a time. -- **Simpler fees and operations**: the fee is implicit in the quote, so you never select, hold, or approve a fee token. You also skip destination gas estimation and [manual execution](/ccip/concepts/manual-execution) handling. - -If you need arbitrary messaging or programmable token transfers, use the [standard CCIP transfer flow](/ccip/evm/tutorials) instead. Intents also serve mainnet routes only and require an API key; for anything outside the [supported routes](#supported-routes-and-tokens), use standard CCIP. - -## Access and prerequisites - -> **NOTE: Request access** -> -> The Intents endpoints are live in production and require an API key. [Contact -> Chainlink](https://chain.link/contact?ref_id=ccip) to request access for your use case. - -> **CAUTION: Real funds on mainnet** -> -> The Intents API serves mainnet routes only. This tutorial moves real USDC and spends real ETH for gas on *Base*. Start -> with a small amount and use a dedicated key that controls only what you are willing to spend. - -Before you begin: - -1. Obtain an Intents API key (see above). This tutorial refers to it as the `INTENTS_API_KEY` environment variable. -2. Hold ETH on *Base* for gas and USDC on *Base* to transfer. Both are real mainnet funds. -3. Install [`cast`](https://getfoundry.sh/introduction/installation) from Foundry to send the onchain transactions. - -## How it works - -An intent moves through five steps: - -![Sequence diagram of the CCIP intents flow: request a quote from the CCIP API, approve the token spend, submit the intent transaction on the source chain, look up the intent ID by transaction hash, and poll the intent status until it reaches a terminal state.](/images/ccip/tutorials/ccip-intents-flow.svg) - -1. **Quote**: `POST /intents/quotes` returns the expected output amount and an executable transaction. -2. **Approve**: you approve the token spend required by the quote. -3. **Submit**: you submit the quote's transaction on the source chain. -4. **Discover**: `GET /intents/tx/{txHash}` returns the intent ID (or IDs, for batched intents) created by that transaction. -5. **Track**: you poll `GET /intents/id/{intentId}` until the intent reaches a terminal status. - -## Step 1: Get a quote - -[`POST /intents/quotes`](https://docs.chain.link/ccip/tools/api/get-intent-quote) prices a cross-chain swap or bridge operation and returns executable transaction data. This request quotes a transfer of 1 USDC (USDC has 6 decimals, so `1000000` in smallest units) from *Base* to *Ronin*: - -```bash filename="Terminal" -export INTENTS_API_KEY="" -export SENDER_ADDRESS="" -export RECEIVER_ADDRESS="" + If you selected more than two networks during the previous step, the *Remove* links are active, allowing you to remove a network before proceeding. If you only have two networks selected, the *Remove* links are intentionally not active. If you need to add more networks, navigate back to the **Networks** page. -curl -s -X POST "https://api.ccip.chain.link/v2/intents/quotes" \ - -H "accept: application/json" \ - -H "Content-Type: application/json" \ - -H "x-api-key: $INTENTS_API_KEY" \ - --data @- <" \ - --value 0 \ - --rpc-url "$BASE_RPC_URL" \ - --private-key "$PRIVATE_KEY" -``` +2. On the **Pools** page, you're prompted to select the token pool mechanism that's used to transfer value between networks — *Burn / Mint* or *Lock / Release*. Depending on your token contract, you may have more than one option for *Burn / Mint*: -Save the transaction hash from this submission; the next step uses it. If the quote's `deadline` has passed by the time you submit, discard the transaction and request a fresh quote. + ![Selecting token pool types](/images/ccip/token-manager/existing/2-token-pool-type.png) -## Step 3: Get the intent ID + Before selecting a token pool type, be sure to review [CCIP token handling mechanisms](/ccip/concepts/cross-chain-token/overview#token-handling-mechanisms). -[`GET /intents/tx/{txHash}`](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) returns the status of every intent created in a transaction, as an array. A single transaction can create multiple batched intents. Use it to obtain the `intentId` after your submission confirms: +3. On the **Networks** page, select the additional blockchain networks where you'd like to deploy your new token. For additional networks, Token Manager Wizard workflow automatically configures all tokens with the Burn & Mint mechanism. (Refer to the [token contract](https://github.com/smartcontractkit/chainlink-evm/blob/contracts-v1.4.0/contracts/src/v0.8/shared/token/ERC20/BurnMintERC20.sol) and [token pool contract](https://github.com/smartcontractkit/chainlink-ccip/tree/contracts-ccip-v1.6.1/chains/evm/contracts/pools/BurnMintTokenPool.sol) for the Burn & Mint mechanism.) -```bash filename="Terminal" -export TX_HASH="" +4. On the **Summary** page, each network you've selected appears along with an expandable list of the transactions the Token Manager will guide you through to deploy your token for each network. -curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ - -H "accept: application/json" \ - -H "x-api-key: $INTENTS_API_KEY" -``` + If you selected more than two networks during the previous step, the *Remove* links are active, allowing you to remove a network before proceeding. If you only have two networks selected, the *Remove* links are intentionally not active. If you need to add more networks, navigate back to the **Networks** page. -Example response (illustrative), a single-element array: +5. The **Deploy** page displays the steps that you need to complete. -```json filename="JSON response" -[ - { - "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", - "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", - "status": "PENDING", - "subStatus": "WaitingToFulfill", - "sourceChainSelector": "15971525489660198786", - "destChainSelector": "6916147374840168594", - "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", - "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", - "inputToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", - "outputToken": "0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc", - "inputAmount": "1000000", - "createdAt": 1734192060 - } -] -``` + For the tokens you're adding, the Token Manager guides you through each of these steps per network: -Intent IDs are provider-prefixed (for example, `EC-...` or `EO-...`). Raw `0x` transaction hashes are not valid intent IDs, which is why this lookup step exists. To extract the ID for the next step with [`jq`](https://jqlang.org/): + - Deploy token pool for existing token + - Grant Burn / Mint privileges (**manual step**) + - Register admin + - Accept admin role of your token pool + - Set the token pool address + - Accept ownership of the new token pool -```bash filename="Terminal" -export INTENT_ID=$(curl -s "https://api.ccip.chain.link/v2/intents/tx/$TX_HASH" \ - -H "accept: application/json" \ - -H "x-api-key: $INTENTS_API_KEY" | jq -r '.[0].intentId') -``` + > **CAUTION: Manually granting Burn/Mint privileges** + > + > Unlike the other steps where you're simply prompted to confirm transactions in your wallet, the Token Manager + > prompts you to grant Burn/Mint privileges manually, and then confirm that you've done so before proceeding with + > further steps. It's crucial to complete this manual step to ensure your CCIP transactions will work properly. -`.[0]` assumes the transaction created one intent; if you batch intents, select the right element instead. The lookup can also return `404` until the transaction is indexed, so retry after a few seconds if your submission just confirmed. + For the other tokens in your network, the Token Manager also guides you through updating existing token pools to incorporate the tokens you're adding. -Once you have the `intentId`, prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) for status queries. For the full schema, see [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash). + At each step, you are prompted to confirm the corresponding transactions in your wallet. When each step is complete for all the networks you selected, the Token Manager displays a message showing that your configuration was successful. -## Step 4: Track the intent to completion +When everything is successfully set up for your token, you can view your new Token Page from the Token Manager Dashboard. It displays information about your CCT, enables configuration changes, and allows expansion to additional networks. -Prefer [`GET /intents/id/{intentId}`](https://docs.chain.link/ccip/tools/api/get-intent-by-id) to return the status of one intent: +## Token Manager Dashboard -```bash filename="Terminal" -curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ - -H "accept: application/json" \ - -H "x-api-key: $INTENTS_API_KEY" -``` +After you connect your wallet, you can see the Token Manager Dashboard: -Poll until `status` reaches a terminal value: `COMPLETED` or `FAILED`. A 10-second interval is a reasonable default: +![Token dashboard](/images/ccip/token-manager/settings/dashboard.png) -```bash filename="Terminal" -while true; do - STATUS=$(curl -s "https://api.ccip.chain.link/v2/intents/id/$INTENT_ID" \ - -H "accept: application/json" \ - -H "x-api-key: $INTENTS_API_KEY" | jq -r '.status') - echo "$STATUS" - [ "$STATUS" = "COMPLETED" ] || [ "$STATUS" = "FAILED" ] && break - sleep 10 -done -``` +- If you click **Add new token**, you enter the Token Manager Wizard which prompts you to deploy a new token or to add an existing token. +- If the wallet you connected to the dashboard is a Token Admin address, the Token Manager automatically populates your tokens in the dashboard. +- If you have saved partial progress in the Token Manager Wizard, your token displays in a draft state so you can return and finish deploying it later. -When the intent completes, the response includes `outputAmount` (the actual amount delivered) and `fulfillmentTxHash` (the fulfillment transaction on the destination chain). For refunded intents, `fulfillmentTxHash` is the refund transaction on the source chain and `filledAt` carries the refund timestamp: +After you have deployed a new token or added an existing one, each token has its own page: -```json filename="JSON response" -{ - "intentId": "EC-e429343c7b4c75e8c14ae8810b1fc8df20de32f05fa907c4839aa80a2c2db13e", - "transactionHash": "0xabc1234567890def1234567890abcdef1234567890abcdef1234567890abcdef", - "status": "COMPLETED", - "subStatus": null, - "sourceChainSelector": "16015286601757825753", - "destChainSelector": "3478487238524512106", - "fulfillmentTxHash": "0xdef4567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12", - "sender": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", - "receiver": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7", - "inputToken": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238", - "outputToken": "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d", - "inputAmount": "1000000", - "outputAmount": "998500", - "createdAt": 1734192060, - "filledAt": 1734192240 -} -``` +![Token page](/images/ccip/token-manager/settings/token-page.png) -For the full schema and playground, see [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id). +The token page shows both the configured and unconfigured networks. -## Intent attribute reference +- When you select any of the listed unconfigured networks, you can use the Token Manager Wizard to expand your token to those networks, either by deploying a new token or by adding an existing token and deploying a token pool. +- For configured networks, you can view details for each network-specific token, and you can expand a **Token Details** side panel with more information and admin actions. To expand the **Token Details** panel, click the *View* link next to the configured network. -The values below cover what the tracking loop in this tutorial uses. For complete schemas, see the [CCIP Tools API reference](https://docs.chain.link/ccip/tools/api/). +When expanded, the **Token Details** side panel provides more details about the inbound and outbound lanes for your token. If the connected wallet is a token admin or has permissions to update the token pool, the **Token Details** side panel also displays an **Actions** menu: -**`status`**: high-level intent state: +![Token details actions menu](/images/ccip/token-manager/settings/token-details-actions-menu.png) -| Value | Meaning | -| :---------- | :--------------------------------------------- | -| `PENDING` | The intent is processing. | -| `COMPLETED` | The intent has been fulfilled. | -| `FAILED` | The intent has failed and cannot be fulfilled. | +If you have the appropriate permissions, you can edit your token's inbound and outbound rate limits, edit the router contract address, and propose a new token administrator. -**Other attributes:** +### Managing token settings -| Attribute | Values / format | -| :---------------------------------- | :---------------------------------------------------------------------------------------- | -| `subStatus` | Route-specific detail, for display only. Example: `WaitingToFulfill`. | -| `intentId` | Provider-prefixed string (`EC-...`, `EO-...`). Obtain it from `GET /intents/tx/{txHash}`. | -| `chainFamily` | `EVM` for all served routes. | -| `transactionPurpose` | `INTENT`: the transaction is ready to submit onchain. | -| `inputAmount`, `outputAmount` | Decimal strings in the token's smallest unit. | -| `deadline`, `createdAt`, `filledAt` | Unix timestamps in seconds. | +1. Connect your wallet and select your token in the Token Manager home page. A detailed page for your token displays, showing both configured and unconfigured networks. +2. To access the **Settings** page, select the gear icon next to your token's name: -## Supported routes and tokens + ![Token settings icon](/images/ccip/token-manager/settings/1-gear-icon.png) -The Intents API serves mainnet routes only; no testnet routes are available. Route support is per chain/token pair and evolves as providers add support. The quote endpoint returns `404 ROUTE_NOT_FOUND` when no provider serves a requested pair; confirm production availability with your Chainlink representative before integrating a specific pair. +### Verifying your token -## Routes served at the time of writing (mainnet) +You can request token verification through the Token Manager; when verification is granted, it allows the token to be listed on the CCIP Directory and ensures information is consistent across other CCIP apps, like CCIP Explorer. -| Source chain | Destination chain | Tokens | -| :----------- | :---------------- | :--------- | -| *Ethereum* | *Ronin* | USDC, WETH | -| *Ronin* | *Ethereum* | USDC, WETH | -| *Base* | *Ronin* | USDC, WETH | -| *Ronin* | *Base* | USDC, WETH | +> **CAUTION** +> +> CCIP allows users to register and manage tokens in a permissionless manner. A 'Verified' status of a token indicates +> only that the Token Creator has signed transactions evidencing their ownership. Users should conduct their own +> research before engaging with any tokens. -Token contract addresses: +If your token is unverified, an **Unverified** badge displays underneath the token's name at the top of the page. Be sure that all information is correct before your submission, as it requires a manual review process. If you need to make any further changes after submitting your request, you must use the [CCIP Contact Form](https://chain.link/ccip-contact?v=Token%20Manager%20support). -| Token | *Ethereum* | *Base* | *Ronin* | -| :---- | :------------------------------------------- | :------------------------------------------- | :------------------------------------------- | -| USDC | `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | `0x0B7007c13325C48911F73A2daD5FA5dCBf808aDc` | -| WETH | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` | `0x4200000000000000000000000000000000000006` | `0xc99a6A985eD2Cac1ef41640596C5A5f9F4E19Ef5` | +You can send a request for verification from the **Settings** page: -## Next steps +![Token settings page](/images/ccip/token-manager/settings/2-settings-page.png) -- API reference: [Create quote for intent](https://docs.chain.link/ccip/tools/api/get-intent-quote) -- API reference: [Get all intent statuses for a transaction](https://docs.chain.link/ccip/tools/api/get-intents-by-tx-hash) -- API reference: [Get intent status by ID](https://docs.chain.link/ccip/tools/api/get-intent-by-id) -- [CCIP Tools overview](https://docs.chain.link/ccip/tools/) -- [Transfer tokens with standard CCIP](/ccip/evm/tutorials/application-developers/transfer-tokens-from-contract) +1. The *Token Details* tab allows you to modify your token's name and ticker symbol with an off-chain transaction. You can also specify an avatar for your token. If you have made any changes in this tab, click **Save Changes**. +2. The *Project Details* tab prompts you to fill in your project's name and URL, and a contact email address. This information is kept private. It's optional to fill out, but required if you're requesting token verification. +3. The *Verification* tab has a **Verify my token** button that submits a verification request with the information you provided in the previous two tabs. + +When your verification request is granted, the Token Manager will display a **Verified** badge on the token page. --- diff --git a/src/content/ccip/llms.txt b/src/content/ccip/llms.txt index 5d5371e4a88..2ca6b2b5899 100644 --- a/src/content/ccip/llms.txt +++ b/src/content/ccip/llms.txt @@ -21,6 +21,7 @@ Use directory pages only when retrieving current chain, lane, token, or contract - [Cross-Chain Token Overview](https://docs.chain.link/ccip/concepts/cross-chain-token/overview.md) - [Cross-Chain Token (EVM)](https://docs.chain.link/ccip/concepts/cross-chain-token/evm.md) - [Cross-Chain Token (SVM)](https://docs.chain.link/ccip/concepts/cross-chain-token/svm.md) +- [CCIP Intents](https://docs.chain.link/ccip/evm/concepts/ccip-intents.md) ## Execution Patterns @@ -36,7 +37,6 @@ Use directory pages only when retrieving current chain, lane, token, or contract - [EVM Transfer Tokens from Contract](https://docs.chain.link/ccip/tutorials/evm/transfer-tokens-from-contract.md) - [EVM USDC Transfer](https://docs.chain.link/ccip/tutorials/evm/usdc.md) - [Test CCIP Locally](https://docs.chain.link/ccip/tutorials/evm/test-ccip-locally.md) -- [Get Started with CCIP Intents](https://docs.chain.link/ccip/evm/tutorials/use-ccip-intents-api.md) ## Operational Considerations diff --git a/src/content/ccip/v2/evm/tutorials/use-ccip-intents-api.mdx b/src/content/ccip/v2/evm/concepts/ccip-intents.mdx similarity index 99% rename from src/content/ccip/v2/evm/tutorials/use-ccip-intents-api.mdx rename to src/content/ccip/v2/evm/concepts/ccip-intents.mdx index c9c9dfe6cc3..83c0b7feaf3 100644 --- a/src/content/ccip/v2/evm/tutorials/use-ccip-intents-api.mdx +++ b/src/content/ccip/v2/evm/concepts/ccip-intents.mdx @@ -1,7 +1,7 @@ --- section: ccip date: Last Modified -title: "Get Started with CCIP Intents" +title: "CCIP Intents" metadata: description: "Transfer USDC from Base to Ronin with the CCIP v2 Intents API: create a quote, submit the intent transaction onchain, and track intent status by transaction hash and intent ID." image: "/images/ccip/tutorials/ccip-intents-flow.svg" diff --git a/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx b/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx index 0ee22e8f614..b5ce50e51d5 100644 --- a/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx +++ b/src/content/ccip/v2/evm/tutorials/application-developers/index.mdx @@ -3,16 +3,16 @@ section: ccip date: Last Modified title: "Application Developers" metadata: - description: "Browse CCIP tutorials for application developers: transfer tokens, send arbitrary messages, programmable token transfers, manual execution, USDC transfers with data, and transfers with the CCIP Intents API." - excerpt: "CCIP application developers, token transfers, arbitrary messaging, programmable token transfers, manual execution, USDC, intents API, EVM" + description: "Browse CCIP tutorials for application developers: transfer tokens, send arbitrary messages, programmable token transfers, manual execution, and USDC transfers with data." + excerpt: "CCIP application developers, token transfers, arbitrary messaging, programmable token transfers, manual execution, USDC, EVM" datePublished: "2025-07-21" - lastModified: "2026-10-26" + lastModified: "2025-07-21" isIndex: true --- import { DocCards, DocCard } from "@components" -These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, USDC transfers with data, and transfers with the CCIP Intents API. +These tutorials are for application developers building cross-chain functionality with CCIP. They cover transferring tokens, sending arbitrary messages, programmable token transfers (tokens + data), manual execution, and USDC transfers with data. ## Pages @@ -47,8 +47,4 @@ These tutorials are for application developers building cross-chain functionalit Transfer USDC cross-chain with programmable instructions via CCTP. - - Transfer USDC cross-chain with the CCIP Intents API: create a quote, submit the intent transaction, and track the - intent to completion. -