From 9876d04f79b69d2dcbaa1267dcbb81841d5612ae Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Tue, 2 Dec 2025 11:24:24 -0500 Subject: [PATCH 01/17] WIP first draft of how to use instant confirmations --- docs/building-on-etherlink/transactions.md | 85 ++++++++++++++++++++++ docs/building-on-etherlink/websockets.md | 24 ++++++ docs/network/architecture.md | 6 +- docs/progress/upgrades.md | 3 +- 4 files changed, 116 insertions(+), 2 deletions(-) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index 683b8b3d..0dc4a129 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -279,6 +279,91 @@ run(); ``` +## Getting instant confirmations + +Beginning with EVM node 0.48 and the version 6.0 upgrade, Etherlink supports instant confirmations. +You can send a transaction with the `eth_sendRawTransactionSync` method and receive an instant confirmation from the sequencer that it intends to put the transaction in the next block. +This confirmation includes a transaction receipt that provides information about the completed transaction, such as the status, hash, gas used, and index of the transaction in the next block. +The only information missing from the receipt is the hash of the next block, because it has not been created yet. + +Sending the transaction with the `eth_sendRawTransactionSync` method is done the same way as with the `eth_sendRawTransaction` method: you sign the transaction and include it in the `data` parameter plus the optional `pending` value, as in this example: + +```bash +curl --request POST \ + --url https://node.shadownet.etherlink.com \ + --header 'accept: application/json' \ + --header 'content-type: application/json' \ + --data ' +{ + "id": 1, + "jsonrpc": "2.0", + "params": [ + "0x88a747dbc7f84e8416dc4be31ddef0", + "pending" + ], + "method": "eth_sendRawTransactionSync" +} +' +``` + +If you pass `latest` instead of `pending`, the sequencer waits until the transaction is in a block to send the confirmation. +Etherlink supports this `pending` value only on the `eth_sendRawTransactionSync` method, not on any other methods. + +When the sequencer executes the transaction and intends to put it in the next block, the sequencer returns a receipt for the transaction that includes information such as its gas price and gas cost. +This receipt matches the specification for the [`eth_getTransactionReceipt`](https://ethereum.org/developers/docs/apis/json-rpc/#eth_gettransactionreceipt) endpoint except that the `blockHash` field is always `0x000...` because the block has not been created yet. +You can take this response as a confirmation that the sequencer will put the transaction in the next block. +If the sequencer does not intend to put the transaction in the next block (such as if the block is nearly complete or the transaction volume is high), it waits to provide the receipt until the transaction will be in the next block. + +The following JSON code is an example response from the `eth_sendRawTransactionSync` for an ERC-20 token transfer: + +```json +{ + "jsonrpc": "2.0", + "result": { + "transactionHash": "0xa428415e77f1b5328023e1980ebd7474fc215acb0ec803b56f991866921ec6eb", + "transactionIndex": "0x1", + "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "blockNumber": "0x2c5349", + "from": "0x45ff91b4bf16ac9907cf4a11436f9ce61be0650d", + "to": "0x03ff3337af6d6ed88c72df7bef31162edddb51ba", + "cumulativeGasUsed": "0xb5e6", + "effectiveGasPrice": "0x3b9aca00", + "gasUsed": "0xb5e6", + "logs": [ + { + "address": "0x03ff3337af6d6ed88c72df7bef31162edddb51ba", + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x00000000000000000000000045ff91b4bf16ac9907cf4a11436f9ce61be0650d", + "0x00000000000000000000000046899d4fa5ba90e3ef3b7ae8aae053c662c1ca1d" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "blockNumber": "0x2c5349", + "transactionHash": "0xa428415e77f1b5328023e1980ebd7474fc215acb0ec803b56f991866921ec6eb", + "transactionIndex": "0x1", + "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "logIndex": "0x1", + "removed": false + } + ], + "logsBloom": "0x00000000000000000020000000000000000000000000100000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000010000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082000000000000000000000000000000000000002000000200000000008000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "type": "0x2", + "status": "0x1", + "contractAddress": null + }, + "id": 1 +} +``` + +:::note + +The sequencer provides this confirmation as soon as it runs the transaction. +For even faster confirmations, you can use WebSockets to subscribe to the `tez_newIncludedTransactions` or `tez_newPreconfirmedReceipts` events. +These events provide confirmations of transactions that are ready to be executed and transactions that have been executed but not yet included in a block, respectively. +See [Getting updates with WebSockets](/building-on-etherlink/websockets). + +::: + ## Transferring ERC-20 tokens To transfer ERC-20 tokens, you can use the standard `transfer` entrypoint, as in this example: diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 081cceb0..72db6525 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -112,6 +112,25 @@ newBlocksSubscription.on('data', blockhead => { }); ``` +This example listens for instant confirmations of upcoming transactions: + +```javascript +import Web3 from 'web3'; + +const web3Instance = new Web3(new Web3.providers.WebsocketProvider('ws://127.0.0.1:8545/ws')); + +// Subscribe to new instant confirmations +const newConfirmationsSubscription = await web3Instance.eth.subscribe('tez_newIncludedTransactions'); +newConfirmationsSubscription.on('error', error => { + console.log('Error when subscribing to new instant confirmations:', error); +}); + +newConfirmationsSubscription.on('data', data => { + // Print information about transactions in the next block + console.log(data); +}); +``` + This example subscribes to the event logs for an ERC-20 contract and logs information about each transfer event: ```javascript @@ -179,4 +198,9 @@ You can use WebSockets to subscribe to these Etherlink events: ::: +- `tez_newIncludedTransactions`: Provides confirmations for transactions that the sequencer intends to put in the next block before it has executed them. + +- `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that the sequencer has executed and intends to put in the next block. +For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). + - `logs`: Returns the events emitted by smart contracts, including the address of the contract, the associated topics, and the data for the event diff --git a/docs/network/architecture.md b/docs/network/architecture.md index dae7a68a..dbbe5f82 100644 --- a/docs/network/architecture.md +++ b/docs/network/architecture.md @@ -143,7 +143,11 @@ Therefore, an Etherlink transaction is truly finalized two weeks after the block At this point, it is permanently part of the state of the Etherlink Smart Rollup and of Tezos. However, Etherlink is set up so users can be confident that transactions are irreversible much sooner than that. -Most users can assume that a transaction is irreversible and will be finalized after one of two milestones: +Most users can assume that a transaction is irreversible and will be finalized after one of these milestones: + +- **Transactions are executed on the Etherlink sequencer within 50ms.** +As described in [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations), the sequencer issues instant confirmations as soon as a transaction is executed and will be in the next block. +Users who trust the sequencer and these confirmations can take them as proof that the transaction will be in the next block. - **Transactions are confirmed on Etherlink within 500ms.** As described in [Sequencer](#sequencer), the sequencer puts transactions in blocks and distributes them to the EVM nodes. diff --git a/docs/progress/upgrades.md b/docs/progress/upgrades.md index 348f5c35..163b2205 100644 --- a/docs/progress/upgrades.md +++ b/docs/progress/upgrades.md @@ -102,7 +102,8 @@ The Etherlink 6.0 upgrade includes: - Support for EVM Osaka, including support for the count leading zeroes (CLZ) opcode (EIP-7939), the ecp256r1 Curve Support precompile (EIP-7951), and the increase in ModExp gas cost (EIP-7883) - The ability to provide instant confirmations, which allow users to know (within roughly 50ms) that their transactions will be in the next block and receive receipts with information about the completed transaction. -This update puts the functionality for instant confirmations in the kernel, but they are not available to users until the EVM node enables the functionality. +Users can call the `eth_sendRawTransactionSync` endpoint that is available in the EVM node version 0.48 and later to submit a transaction and wait for an instant confirmation from the sequencer. +For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). - The speed limit (also known as the target) is increased to 13.5 million gas units per second. The speed limit decides when the gas price raises. From 8b621cfba6cc303acb4ce2ed74a3c09ce4ec8ab6 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 10 Dec 2025 09:26:55 -0500 Subject: [PATCH 02/17] Examples for instant confirmation websockets --- docs/building-on-etherlink/transactions.md | 2 +- docs/building-on-etherlink/websockets.md | 64 ++++++++++++++++++++++ 2 files changed, 65 insertions(+), 1 deletion(-) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index 0dc4a129..14cf4f0b 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -360,7 +360,7 @@ The following JSON code is an example response from the `eth_sendRawTransactionS The sequencer provides this confirmation as soon as it runs the transaction. For even faster confirmations, you can use WebSockets to subscribe to the `tez_newIncludedTransactions` or `tez_newPreconfirmedReceipts` events. These events provide confirmations of transactions that are ready to be executed and transactions that have been executed but not yet included in a block, respectively. -See [Getting updates with WebSockets](/building-on-etherlink/websockets). +See [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). ::: diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 72db6525..975d5ab4 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -183,6 +183,70 @@ console.log("Listening for Transfer events..."); See the documentation for your WebSocket client library for how to manage the connection, receive messages, and close the connection. +## Subscribing to instant confirmations + +You can subscribe to WebSockets to receive instant confirmations, which are notices from the sequencer that a transaction will appear in the next block. +Using WebSockets for instant confirmations requires at least version 0.49 of the `octez-evm-node` binary. + +:::note + +The Ethers.js library does not support custom WebSocket events and therefore you cannot use it to subscribe to instant confirmation events. +For JavaScript/TypeScript, use the built-in Node.JS WebSocket library as in the examples below. + +::: + +Etherlink provides two custom WebSocket events that you can subscribe to for notice of upcoming transactions: + +- `tez_newIncludedTransactions`: Provides confirmations for transactions that the sequencer intends to put in the next block **before** it has executed them. + +- `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that the sequencer **has executed** and intends to put in the next block. + +For example, this JavaScript code subscribes to these events and prints information about them to the log: + +```javascript +// Create a WebSocket connection to a local EVM node +const socket = new WebSocket('ws://127.0.0.1:8545/ws'); + +// When the connection is established, subscribe to events +socket.addEventListener('open', _event => { + console.log('WebSocket connection established!'); + const includedTxPayload = { + jsonrpc: "2.0", + id: 1, + method: "eth_subscribe", + params: ["tez_newIncludedTransactions"], + }; + socket.send(JSON.stringify(includedTxPayload)); + const preconfirmedTxPayload = { + jsonrpc: "2.0", + id: 1, + method: "eth_subscribe", + params: ["tez_newPreconfirmedReceipts"], + }; + socket.send(JSON.stringify(preconfirmedTxPayload)); +}); + +// Listen for messages and executes when a message is received from the server. +socket.addEventListener('message', event => { + console.log('Message from server: ', event.data); +}); + +// Executes when the connection is closed, providing the close code and reason. +socket.addEventListener('close', event => { + console.log('WebSocket connection closed:', event.code, event.reason); +}); + +// Executes if an error occurs during the WebSocket communication. +socket.addEventListener('error', error => { + console.error('WebSocket error:', error); +}); +``` + +// TODO example responses? + +For more information about instant confirmations, see [Getting instant confirmations](/building-on-etherlink#getting-instant-confirmations) + + ## WebSocket subscriptions You can use WebSockets to subscribe to these Etherlink events: From f800eed135e027496e91ecd168db11802f9613a8 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 10 Dec 2025 09:27:52 -0500 Subject: [PATCH 03/17] web3 does not support this --- docs/building-on-etherlink/websockets.md | 19 ------------------- 1 file changed, 19 deletions(-) diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 975d5ab4..903f79cc 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -112,25 +112,6 @@ newBlocksSubscription.on('data', blockhead => { }); ``` -This example listens for instant confirmations of upcoming transactions: - -```javascript -import Web3 from 'web3'; - -const web3Instance = new Web3(new Web3.providers.WebsocketProvider('ws://127.0.0.1:8545/ws')); - -// Subscribe to new instant confirmations -const newConfirmationsSubscription = await web3Instance.eth.subscribe('tez_newIncludedTransactions'); -newConfirmationsSubscription.on('error', error => { - console.log('Error when subscribing to new instant confirmations:', error); -}); - -newConfirmationsSubscription.on('data', data => { - // Print information about transactions in the next block - console.log(data); -}); -``` - This example subscribes to the event logs for an ERC-20 contract and logs information about each transfer event: ```javascript From eff7015f4d7347fade9efd928d652c456fb93ab2 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 10 Dec 2025 09:28:32 -0500 Subject: [PATCH 04/17] Ethers.js and Web3.js libraries no worky --- docs/building-on-etherlink/websockets.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 903f79cc..51896df3 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -171,8 +171,8 @@ Using WebSockets for instant confirmations requires at least version 0.49 of the :::note -The Ethers.js library does not support custom WebSocket events and therefore you cannot use it to subscribe to instant confirmation events. -For JavaScript/TypeScript, use the built-in Node.JS WebSocket library as in the examples below. +The Ethers.js and Web3.js libraries do not support custom WebSocket events and therefore you cannot use them to subscribe to instant confirmation events. +For JavaScript/TypeScript, use the built-in Node.JS WebSocket library as in the example below. ::: From 780de9236228c1bd305326d0874e0df68f361722 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 10 Dec 2025 10:18:55 -0500 Subject: [PATCH 05/17] Broken link --- docs/building-on-etherlink/websockets.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 51896df3..6e57ea53 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -225,7 +225,7 @@ socket.addEventListener('error', error => { // TODO example responses? -For more information about instant confirmations, see [Getting instant confirmations](/building-on-etherlink#getting-instant-confirmations) +For more information about instant confirmations, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations) ## WebSocket subscriptions From 6ca248fb39a86a16ce8ada00514ccf8040632561 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 10 Dec 2025 10:21:05 -0500 Subject: [PATCH 06/17] Add info about WebSockets to upgrades page --- docs/progress/upgrades.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/docs/progress/upgrades.md b/docs/progress/upgrades.md index 163b2205..d73f40e3 100644 --- a/docs/progress/upgrades.md +++ b/docs/progress/upgrades.md @@ -102,8 +102,13 @@ The Etherlink 6.0 upgrade includes: - Support for EVM Osaka, including support for the count leading zeroes (CLZ) opcode (EIP-7939), the ecp256r1 Curve Support precompile (EIP-7951), and the increase in ModExp gas cost (EIP-7883) - The ability to provide instant confirmations, which allow users to know (within roughly 50ms) that their transactions will be in the next block and receive receipts with information about the completed transaction. -Users can call the `eth_sendRawTransactionSync` endpoint that is available in the EVM node version 0.48 and later to submit a transaction and wait for an instant confirmation from the sequencer. -For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). +Instant confirmations enable these features: + + - Users can call the `eth_sendRawTransactionSync` endpoint that is available in the EVM node version 0.48 and later to submit a transaction and wait for an instant confirmation from the sequencer when the transaction will be in the next block. + For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). + + - Uses can subscribe to notifications via WebSockets to get information about transactions that the sequencer will put in the next block. + For more information, see [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). - The speed limit (also known as the target) is increased to 13.5 million gas units per second. The speed limit decides when the gas price raises. From 78d4bc5d1c6eff81c3fe6f3954192fd29946401f Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 10 Dec 2025 10:35:24 -0500 Subject: [PATCH 07/17] Examples to websocket responses --- docs/building-on-etherlink/websockets.md | 61 +++++++++++++++++++++++- 1 file changed, 60 insertions(+), 1 deletion(-) diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 6e57ea53..1e58ddfa 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -223,7 +223,66 @@ socket.addEventListener('error', error => { }); ``` -// TODO example responses? +The response to the `tez_newIncludedTransactions` event includes basic information about the transaction including its hash but not the gas used (because the transaction has not been executed yet), as in this example: + +```json +{ + "jsonrpc": "2.0", + "method": "eth_subscription", + "params": { + "result": { + "type": "0x2", + "chainId": "0x1f308", + "hash": "0xfbb0025e811b8bf37034e508da4740c68164c33947089b1c22119be55258a3e1", + "nonce": "0x7", + "blockHash": null, + "blockNumber": null, + "transactionIndex": null, + "from": "0x45ff91b4bf16ac9907cf4a11436f9ce61be0650d", + "to": "0x46899d4fa5ba90e3ef3b7ae8aae053c662c1ca1d", + "value": "0x16345785d8a0000", + "gas": "0x98496", + "maxFeePerGas": "0x3b9aca00", + "maxPriorityFeePerGas": "0x0", + "gasPrice": "0x3b9aca00", + "accessList": [], + "input": "0x", + "v": "0x1", + "r": "0xe4d96c84fbf0ea73fb39ba5551acce44a41ba03b4502da1d93f1e4a02ce51a3e", + "s": "0x6bc2aaa1580b58213e6e6586ae7b38351c2304df370853c74812ae09f5e74275" + }, + "subscription": "0x40f582349eeac9b85b9ba3d936de0ebb" + } +} +``` + +The response to the `tez_newPreconfirmedReceipts` event is similar but also includes the number of the block and the gas used, as in this example: + +```json +{ + "jsonrpc": "2.0", + "method": "eth_subscription", + "params": { + "result": { + "transactionHash": "0x2096d81abf605780b56c0db5f415e0bff29c82fbd73912348106ac8c61a808cc", + "transactionIndex": "0x1", + "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "blockNumber": "0x2e4da9", + "from": "0x45ff91b4bf16ac9907cf4a11436f9ce61be0650d", + "to": "0x46899d4fa5ba90e3ef3b7ae8aae053c662c1ca1d", + "cumulativeGasUsed": "0x5208", + "effectiveGasPrice": "0x3b9aca00", + "gasUsed": "0x5208", + "logs": [], + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "type": "0x2", + "status": "0x1", + "contractAddress": null + }, + "subscription": "0x221fe712815043cf05255c8b568557c5" + } +} +``` For more information about instant confirmations, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations) From ea10cf027f6816396eb0215ef6729ac93fe8de6b Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Thu, 11 Dec 2025 09:27:54 -0500 Subject: [PATCH 08/17] Little more info about what these events return --- docs/building-on-etherlink/websockets.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 1e58ddfa..2918f304 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -179,8 +179,10 @@ For JavaScript/TypeScript, use the built-in Node.JS WebSocket library as in the Etherlink provides two custom WebSocket events that you can subscribe to for notice of upcoming transactions: - `tez_newIncludedTransactions`: Provides confirmations for transactions that the sequencer intends to put in the next block **before** it has executed them. +Returns a transaction object. - `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that the sequencer **has executed** and intends to put in the next block. +Returns a transaction receipt. For example, this JavaScript code subscribes to these events and prints information about them to the log: @@ -223,7 +225,7 @@ socket.addEventListener('error', error => { }); ``` -The response to the `tez_newIncludedTransactions` event includes basic information about the transaction including its hash but not the gas used (because the transaction has not been executed yet), as in this example: +The response to the `tez_newIncludedTransactions` event (a transaction object) includes basic information about the transaction including its hash but not the gas used (because the transaction has not been executed yet), as in this example: ```json { @@ -256,7 +258,7 @@ The response to the `tez_newIncludedTransactions` event includes basic informati } ``` -The response to the `tez_newPreconfirmedReceipts` event is similar but also includes the number of the block and the gas used, as in this example: +The response to the `tez_newPreconfirmedReceipts` event (a transaction receipt) is similar but also includes the number of the block and the gas used, as in this example: ```json { From 7c0ab25909c292afc6fe4b9a437ea33346dfab82 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Tue, 6 Jan 2026 18:37:03 -0500 Subject: [PATCH 09/17] typo --- docs/building-on-etherlink/websockets.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 2918f304..6e66f7db 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -258,7 +258,7 @@ The response to the `tez_newIncludedTransactions` event (a transaction object) i } ``` -The response to the `tez_newPreconfirmedReceipts` event (a transaction receipt) is similar but also includes the number of the block and the gas used, as in this example: +The response to the `tez_newPreconfirmedReceipts` event (a transaction receipt) is similar but also includes the number of the block and the gas used, as in this example: ```json { From 74a0a2b61c983b675411454a02ed251818c38dbc Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 7 Jan 2026 16:36:13 -0500 Subject: [PATCH 10/17] Small changes --- docs/building-on-etherlink/websockets.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 6e66f7db..001aeb7d 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -209,7 +209,7 @@ socket.addEventListener('open', _event => { socket.send(JSON.stringify(preconfirmedTxPayload)); }); -// Listen for messages and executes when a message is received from the server. +// Log when a message is received from the server. socket.addEventListener('message', event => { console.log('Message from server: ', event.data); }); @@ -288,7 +288,6 @@ The response to the `tez_newPreconfirmedReceipts` event (a transaction receipt) For more information about instant confirmations, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations) - ## WebSocket subscriptions You can use WebSockets to subscribe to these Etherlink events: From b4af185cf1d93673fd105cc5cbf769cf38624b63 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Tue, 13 Jan 2026 08:54:16 -0500 Subject: [PATCH 11/17] Clarification on how the information flows --- docs/building-on-etherlink/transactions.md | 7 +++---- docs/building-on-etherlink/websockets.md | 10 +++++----- docs/network/architecture.md | 11 +++++++---- docs/progress/upgrades.md | 2 +- 4 files changed, 16 insertions(+), 14 deletions(-) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index 14cf4f0b..6fa35878 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -282,7 +282,7 @@ run(); ## Getting instant confirmations Beginning with EVM node 0.48 and the version 6.0 upgrade, Etherlink supports instant confirmations. -You can send a transaction with the `eth_sendRawTransactionSync` method and receive an instant confirmation from the sequencer that it intends to put the transaction in the next block. +You can send a transaction with the `eth_sendRawTransactionSync` method and receive an instant confirmation that the sequencer intends to put the transaction in the next block. This confirmation includes a transaction receipt that provides information about the completed transaction, such as the status, hash, gas used, and index of the transaction in the next block. The only information missing from the receipt is the hash of the next block, because it has not been created yet. @@ -309,10 +309,10 @@ curl --request POST \ If you pass `latest` instead of `pending`, the sequencer waits until the transaction is in a block to send the confirmation. Etherlink supports this `pending` value only on the `eth_sendRawTransactionSync` method, not on any other methods. -When the sequencer executes the transaction and intends to put it in the next block, the sequencer returns a receipt for the transaction that includes information such as its gas price and gas cost. +When the sequencer enqueues the transaction for the next block, it notifies the nodes of the transaction and the nodes return a receipt for the transaction that includes information such as its gas price and gas cost. This receipt matches the specification for the [`eth_getTransactionReceipt`](https://ethereum.org/developers/docs/apis/json-rpc/#eth_gettransactionreceipt) endpoint except that the `blockHash` field is always `0x000...` because the block has not been created yet. You can take this response as a confirmation that the sequencer will put the transaction in the next block. -If the sequencer does not intend to put the transaction in the next block (such as if the block is nearly complete or the transaction volume is high), it waits to provide the receipt until the transaction will be in the next block. +If the sequencer does not intend to put the transaction in the next block (such as if the block is nearly complete or the transaction volume is high), the nodes wait to provide the receipt until the transaction will be in the next block. The following JSON code is an example response from the `eth_sendRawTransactionSync` for an ERC-20 token transfer: @@ -357,7 +357,6 @@ The following JSON code is an example response from the `eth_sendRawTransactionS :::note -The sequencer provides this confirmation as soon as it runs the transaction. For even faster confirmations, you can use WebSockets to subscribe to the `tez_newIncludedTransactions` or `tez_newPreconfirmedReceipts` events. These events provide confirmations of transactions that are ready to be executed and transactions that have been executed but not yet included in a block, respectively. See [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 001aeb7d..4acf0eee 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -166,7 +166,7 @@ See the documentation for your WebSocket client library for how to manage the co ## Subscribing to instant confirmations -You can subscribe to WebSockets to receive instant confirmations, which are notices from the sequencer that a transaction will appear in the next block. +You can subscribe to WebSockets to receive instant confirmations, which are notices that a transaction will appear in the next block. Using WebSockets for instant confirmations requires at least version 0.49 of the `octez-evm-node` binary. :::note @@ -176,12 +176,12 @@ For JavaScript/TypeScript, use the built-in Node.JS WebSocket library as in the ::: -Etherlink provides two custom WebSocket events that you can subscribe to for notice of upcoming transactions: +Etherlink nodes provide two custom WebSocket events that you can subscribe to for notice of upcoming transactions: -- `tez_newIncludedTransactions`: Provides confirmations for transactions that the sequencer intends to put in the next block **before** it has executed them. +- `tez_newIncludedTransactions`: Provides confirmations for transactions that the sequencer intends to put in the next block **before they have been executed**. Returns a transaction object. -- `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that the sequencer **has executed** and intends to put in the next block. +- `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that **have been executed** and will be in the next block. Returns a transaction receipt. For example, this JavaScript code subscribes to these events and prints information about them to the log: @@ -305,7 +305,7 @@ You can use WebSockets to subscribe to these Etherlink events: - `tez_newIncludedTransactions`: Provides confirmations for transactions that the sequencer intends to put in the next block before it has executed them. -- `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that the sequencer has executed and intends to put in the next block. +- `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that have been executed and will be in the next block. For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). - `logs`: Returns the events emitted by smart contracts, including the address of the contract, the associated topics, and the data for the event diff --git a/docs/network/architecture.md b/docs/network/architecture.md index dbbe5f82..1f566a06 100644 --- a/docs/network/architecture.md +++ b/docs/network/architecture.md @@ -86,7 +86,8 @@ The lifecycle of a typical operation under normal circumstances is as follows: 1. The EVM node forwards the transaction to the sequencer when it is valid. If users submit multiple transactions that depend on each other (that is, they have nonces that are not yet valid), the EVM node stores them until they are valid. 1. The sequencer puts the transaction in its pool. -1. The sequencer puts the transaction into a block as soon as possible (less than 500ms after receiving it in a nominal scenario). +1. The sequencer enqueues the transaction and sends an instant confirmation to the nodes that the transaction will be in the next block. +1. The sequencer puts the enqueued transactions into a block as soon as possible (less than 500ms after receiving it in a nominal scenario). 1. The sequencer publishes the block to the EVM nodes, which update their states based on the transactions in the block. 1. The sequencer publishes the block to the Smart Rollup inbox on layer 1 via a Smart Rollup node running in operator or batcher mode. 1. The Smart Rollup nodes tracking the state of Etherlink fetch the block from the Smart Rollup inbox, read its transactions, and update their states. @@ -135,7 +136,7 @@ To submit a transaction to the delayed inbox, see [Sending transactions to the d Transactions are considered finalized when you can trust that they cannot be reversed. -The source of truth of what Etherlink transactions are final is the state of the rollup, which Etherlink Smart Rollup nodes store and keep up to date. +The source of truth of what Etherlink transactions are final is the state of the Smart Rollup, which Etherlink Smart Rollup nodes store and keep up to date. They catch any misbehavior by the sequencer or other actors, accept only valid transactions, and challenge questionable behavior. As described in [Refutation periods](https://docs.tezos.com/architecture/smart-rollups#refutation-periods) on docs.tezos.com, Smart Rollup nodes have two weeks to challenge commitments made about the state of a Smart Rollup, although they usually challenge any questionable state as soon as possible. @@ -145,8 +146,10 @@ At this point, it is permanently part of the state of the Etherlink Smart Rollup However, Etherlink is set up so users can be confident that transactions are irreversible much sooner than that. Most users can assume that a transaction is irreversible and will be finalized after one of these milestones: -- **Transactions are executed on the Etherlink sequencer within 50ms.** -As described in [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations), the sequencer issues instant confirmations as soon as a transaction is executed and will be in the next block. +- **The sequencer provides confirmations within 50ms.** +As described in [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations), the sequencer notifies the nodes of the transactions that it intends to include in the next block. +The sequencer provides this notification as soon as it enqueues the transaction for the next block, before the transaction has been executed. +Users can subscribe to these notifications via the `tez_newIncludedTransactions` event, as described in [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). Users who trust the sequencer and these confirmations can take them as proof that the transaction will be in the next block. - **Transactions are confirmed on Etherlink within 500ms.** diff --git a/docs/progress/upgrades.md b/docs/progress/upgrades.md index d73f40e3..91b804fa 100644 --- a/docs/progress/upgrades.md +++ b/docs/progress/upgrades.md @@ -104,7 +104,7 @@ The Etherlink 6.0 upgrade includes: - The ability to provide instant confirmations, which allow users to know (within roughly 50ms) that their transactions will be in the next block and receive receipts with information about the completed transaction. Instant confirmations enable these features: - - Users can call the `eth_sendRawTransactionSync` endpoint that is available in the EVM node version 0.48 and later to submit a transaction and wait for an instant confirmation from the sequencer when the transaction will be in the next block. + - Users can call the `eth_sendRawTransactionSync` endpoint that is available in the EVM node version 0.48 and later to submit a transaction and wait for an instant confirmation from the node when the transaction will be in the next block. For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). - Uses can subscribe to notifications via WebSockets to get information about transactions that the sequencer will put in the next block. From 19e5ec503c86da807f13a19d2d5e57b6862967c7 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Tue, 13 Jan 2026 08:57:41 -0500 Subject: [PATCH 12/17] Clarify actors --- docs/building-on-etherlink/transactions.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index 6fa35878..1d61c26e 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -282,8 +282,8 @@ run(); ## Getting instant confirmations Beginning with EVM node 0.48 and the version 6.0 upgrade, Etherlink supports instant confirmations. -You can send a transaction with the `eth_sendRawTransactionSync` method and receive an instant confirmation that the sequencer intends to put the transaction in the next block. -This confirmation includes a transaction receipt that provides information about the completed transaction, such as the status, hash, gas used, and index of the transaction in the next block. +You can send a transaction to a node with the `eth_sendRawTransactionSync` method and receive an instant confirmation from the node that the sequencer intends to put the transaction in the next block. +This confirmation includes a transaction receipt that provides information about the transaction, such as the status, hash, gas used, and index of the transaction in the next block. The only information missing from the receipt is the hash of the next block, because it has not been created yet. Sending the transaction with the `eth_sendRawTransactionSync` method is done the same way as with the `eth_sendRawTransaction` method: you sign the transaction and include it in the `data` parameter plus the optional `pending` value, as in this example: From bd5dbaab953c4d9541af72471ef7109f8ac15245 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Tue, 13 Jan 2026 09:29:22 -0500 Subject: [PATCH 13/17] Actor correction --- docs/building-on-etherlink/transactions.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index 1d61c26e..c5bfd12a 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -306,7 +306,7 @@ curl --request POST \ ' ``` -If you pass `latest` instead of `pending`, the sequencer waits until the transaction is in a block to send the confirmation. +If you pass `latest` instead of `pending`, the node waits until the transaction is in a block to send the confirmation. Etherlink supports this `pending` value only on the `eth_sendRawTransactionSync` method, not on any other methods. When the sequencer enqueues the transaction for the next block, it notifies the nodes of the transaction and the nodes return a receipt for the transaction that includes information such as its gas price and gas cost. From 2fefb97ddcf6a1bc203f056b7ada252b410c6b13 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Tue, 13 Jan 2026 09:40:44 -0500 Subject: [PATCH 14/17] header --- docs/network/architecture.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/network/architecture.md b/docs/network/architecture.md index 1f566a06..472d87e0 100644 --- a/docs/network/architecture.md +++ b/docs/network/architecture.md @@ -146,7 +146,7 @@ At this point, it is permanently part of the state of the Etherlink Smart Rollup However, Etherlink is set up so users can be confident that transactions are irreversible much sooner than that. Most users can assume that a transaction is irreversible and will be finalized after one of these milestones: -- **The sequencer provides confirmations within 50ms.** +- **The sequencer provides instant confirmations within 50ms.** As described in [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations), the sequencer notifies the nodes of the transactions that it intends to include in the next block. The sequencer provides this notification as soon as it enqueues the transaction for the next block, before the transaction has been executed. Users can subscribe to these notifications via the `tez_newIncludedTransactions` event, as described in [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). From c6cb237a37bd947e3badb7c9e50f4d56214beedb Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 14 Jan 2026 08:50:22 -0500 Subject: [PATCH 15/17] use an Etherlink EVM node as close as possible to the sequencer --- docs/building-on-etherlink/transactions.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index c5bfd12a..33275b6c 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -286,6 +286,12 @@ You can send a transaction to a node with the `eth_sendRawTransactionSync` metho This confirmation includes a transaction receipt that provides information about the transaction, such as the status, hash, gas used, and index of the transaction in the next block. The only information missing from the receipt is the hash of the next block, because it has not been created yet. +:::note + +To receive instant confirmations with the lowest possible latency, use an Etherlink EVM node as close as possible to the sequencer, which is deployed to a data center in Tokyo, Japan. + +::: + Sending the transaction with the `eth_sendRawTransactionSync` method is done the same way as with the `eth_sendRawTransaction` method: you sign the transaction and include it in the `data` parameter plus the optional `pending` value, as in this example: ```bash From 733ca1ec9faa6b75714c06c823adddb000cf248f Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 14 Jan 2026 11:37:43 -0500 Subject: [PATCH 16/17] Capitalize Instant Confirmations --- docs/building-on-etherlink/transactions.md | 8 ++++---- docs/building-on-etherlink/websockets.md | 10 +++++----- docs/network/architecture.md | 6 +++--- docs/progress/upgrades.md | 8 ++++---- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index 33275b6c..294f1d1d 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -279,16 +279,16 @@ run(); ``` -## Getting instant confirmations +## Getting Instant Confirmations -Beginning with EVM node 0.48 and the version 6.0 upgrade, Etherlink supports instant confirmations. +Beginning with EVM node 0.48 and the version 6.0 upgrade, Etherlink supports Instant Confirmations. You can send a transaction to a node with the `eth_sendRawTransactionSync` method and receive an instant confirmation from the node that the sequencer intends to put the transaction in the next block. This confirmation includes a transaction receipt that provides information about the transaction, such as the status, hash, gas used, and index of the transaction in the next block. The only information missing from the receipt is the hash of the next block, because it has not been created yet. :::note -To receive instant confirmations with the lowest possible latency, use an Etherlink EVM node as close as possible to the sequencer, which is deployed to a data center in Tokyo, Japan. +To receive Instant Confirmations with the lowest possible latency, use an Etherlink EVM node as close as possible to the sequencer, which is deployed to a data center in Tokyo, Japan. ::: @@ -365,7 +365,7 @@ The following JSON code is an example response from the `eth_sendRawTransactionS For even faster confirmations, you can use WebSockets to subscribe to the `tez_newIncludedTransactions` or `tez_newPreconfirmedReceipts` events. These events provide confirmations of transactions that are ready to be executed and transactions that have been executed but not yet included in a block, respectively. -See [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). +See [Subscribing to Instant Confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). ::: diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 4acf0eee..2ef798ee 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -164,10 +164,10 @@ console.log("Listening for Transfer events..."); See the documentation for your WebSocket client library for how to manage the connection, receive messages, and close the connection. -## Subscribing to instant confirmations +## Subscribing to Instant Confirmations -You can subscribe to WebSockets to receive instant confirmations, which are notices that a transaction will appear in the next block. -Using WebSockets for instant confirmations requires at least version 0.49 of the `octez-evm-node` binary. +You can subscribe to WebSockets to receive Instant Confirmations, which are notices that a transaction will appear in the next block. +Using WebSockets for Instant Confirmations requires at least version 0.49 of the `octez-evm-node` binary. :::note @@ -286,7 +286,7 @@ The response to the `tez_newPreconfirmedReceipts` event (a transaction receipt) } ``` -For more information about instant confirmations, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations) +For more information about Instant Confirmations, see [Getting Instant Confirmations](/building-on-etherlink/transactions#getting-instant-confirmations) ## WebSocket subscriptions @@ -306,6 +306,6 @@ You can use WebSockets to subscribe to these Etherlink events: - `tez_newIncludedTransactions`: Provides confirmations for transactions that the sequencer intends to put in the next block before it has executed them. - `tez_newPreconfirmedReceipts`: Provides confirmations for transactions that have been executed and will be in the next block. -For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). +For more information, see [Getting Instant Confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). - `logs`: Returns the events emitted by smart contracts, including the address of the contract, the associated topics, and the data for the event diff --git a/docs/network/architecture.md b/docs/network/architecture.md index 472d87e0..a55905ed 100644 --- a/docs/network/architecture.md +++ b/docs/network/architecture.md @@ -146,10 +146,10 @@ At this point, it is permanently part of the state of the Etherlink Smart Rollup However, Etherlink is set up so users can be confident that transactions are irreversible much sooner than that. Most users can assume that a transaction is irreversible and will be finalized after one of these milestones: -- **The sequencer provides instant confirmations within 50ms.** -As described in [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations), the sequencer notifies the nodes of the transactions that it intends to include in the next block. +- **The sequencer provides Instant Confirmations within 50ms.** +As described in [Getting Instant Confirmations](/building-on-etherlink/transactions#getting-instant-confirmations), the sequencer notifies the nodes of the transactions that it intends to include in the next block. The sequencer provides this notification as soon as it enqueues the transaction for the next block, before the transaction has been executed. -Users can subscribe to these notifications via the `tez_newIncludedTransactions` event, as described in [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). +Users can subscribe to these notifications via the `tez_newIncludedTransactions` event, as described in [Subscribing to Instant Confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). Users who trust the sequencer and these confirmations can take them as proof that the transaction will be in the next block. - **Transactions are confirmed on Etherlink within 500ms.** diff --git a/docs/progress/upgrades.md b/docs/progress/upgrades.md index 91b804fa..6da8e3f0 100644 --- a/docs/progress/upgrades.md +++ b/docs/progress/upgrades.md @@ -101,14 +101,14 @@ The Etherlink 6.0 upgrade includes: - Support for EVM Osaka, including support for the count leading zeroes (CLZ) opcode (EIP-7939), the ecp256r1 Curve Support precompile (EIP-7951), and the increase in ModExp gas cost (EIP-7883) -- The ability to provide instant confirmations, which allow users to know (within roughly 50ms) that their transactions will be in the next block and receive receipts with information about the completed transaction. -Instant confirmations enable these features: +- The ability to provide Instant Confirmations, which allow users to know (within roughly 50ms) that their transactions will be in the next block and receive receipts with information about the completed transaction. +Instant Confirmations enable these features: - Users can call the `eth_sendRawTransactionSync` endpoint that is available in the EVM node version 0.48 and later to submit a transaction and wait for an instant confirmation from the node when the transaction will be in the next block. - For more information, see [Getting instant confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). + For more information, see [Getting Instant Confirmations](/building-on-etherlink/transactions#getting-instant-confirmations). - Uses can subscribe to notifications via WebSockets to get information about transactions that the sequencer will put in the next block. - For more information, see [Subscribing to instant confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). + For more information, see [Subscribing to Instant Confirmations](/building-on-etherlink/websockets#subscribing-to-instant-confirmations). - The speed limit (also known as the target) is increased to 13.5 million gas units per second. The speed limit decides when the gas price raises. From be3c1c8e6fda40d83c675f140d4455e668548ea6 Mon Sep 17 00:00:00 2001 From: Tim McMackin Date: Wed, 14 Jan 2026 12:32:46 -0500 Subject: [PATCH 17/17] Experimental feature --- docs/building-on-etherlink/transactions.md | 6 ++++++ docs/building-on-etherlink/websockets.md | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/docs/building-on-etherlink/transactions.md b/docs/building-on-etherlink/transactions.md index 294f1d1d..f5f261ad 100644 --- a/docs/building-on-etherlink/transactions.md +++ b/docs/building-on-etherlink/transactions.md @@ -281,6 +281,12 @@ run(); ## Getting Instant Confirmations +:::note + +Instant Confirmations are an experimental feature. + +::: + Beginning with EVM node 0.48 and the version 6.0 upgrade, Etherlink supports Instant Confirmations. You can send a transaction to a node with the `eth_sendRawTransactionSync` method and receive an instant confirmation from the node that the sequencer intends to put the transaction in the next block. This confirmation includes a transaction receipt that provides information about the transaction, such as the status, hash, gas used, and index of the transaction in the next block. diff --git a/docs/building-on-etherlink/websockets.md b/docs/building-on-etherlink/websockets.md index 2ef798ee..4dce1f2f 100644 --- a/docs/building-on-etherlink/websockets.md +++ b/docs/building-on-etherlink/websockets.md @@ -166,6 +166,12 @@ See the documentation for your WebSocket client library for how to manage the co ## Subscribing to Instant Confirmations +:::note + +Instant Confirmations are an experimental feature. + +::: + You can subscribe to WebSockets to receive Instant Confirmations, which are notices that a transaction will appear in the next block. Using WebSockets for Instant Confirmations requires at least version 0.49 of the `octez-evm-node` binary.