Tempo network support

Author: Lezek123

evm/evm-normalization/src/data.ts

@@ -36,7 +36,11 @@ export interface BlockHeader {
     excessBlobGas?: Qty,
     parentBeaconBlockRoot?: Bytes32,
     requestsHash?: Bytes32,
-    l1BlockNumber?: number
+    l1BlockNumber?: number,
+    // Tempo-specific block header fields
+    mainBlockGeneralGasLimit?: Qty,
+    sharedGasLimit?: Qty,
+    timestampMillisPart?: Qty,
 }
 
 
@@ -56,14 +60,75 @@ export interface EIP7702Authorization {
 }
 
 
+export interface TempoCall {
+    to?: Bytes20,
+    value: Qty,
+    input: Bytes
+}
+
+
+export interface TempoSecp256k1Signature {
+    type: 'secp256k1',
+    r: Bytes,
+    s: Bytes,
+    yParity?: number,
+    v?: number,
+}
+
+
+export interface TempoP256Signature {
+    type: 'p256',
+    r: Bytes,
+    s: Bytes,
+    pubKeyX: Bytes,
+    pubKeyY: Bytes,
+    preHash: boolean,
+}
+
+
+export interface TempoWebAuthnSignature {
+    type: 'webAuthn',
+    r: Bytes,
+    s: Bytes,
+    pubKeyX: Bytes,
+    pubKeyY: Bytes,
+    webauthnData: Bytes,
+}
+
+
+export type TempoPrimitiveSignature =
+    | TempoSecp256k1Signature
+    | TempoP256Signature
+    | TempoWebAuthnSignature
+
+
+export interface TempoKeychainSignature {
+    userAddress: Bytes20,
+    signature: TempoPrimitiveSignature,
+    version?: string
+}
+
+
+export type TempoSignature = TempoPrimitiveSignature | TempoKeychainSignature
+
+
+export interface TempoFeePayerSignature {
+    v: number,
+    r: Bytes,
+    s: Bytes
+}
+
+
 export interface Transaction {
     transactionIndex: number,
     hash: Bytes32,
     nonce: number,
     from: Bytes20,
     to?: Bytes20,
-    input: Bytes,
-    value: Qty,
+    // Optional for Tempo 0x76 transactions which use batched `calls` instead of `input`
+    input?: Bytes,
+    // Optional for Tempo 0x76 transactions which use batched `calls`
+    value?: Qty,
     type?: number,
     gas: Qty,
     gasPrice?: Qty,
@@ -78,6 +143,14 @@ export interface Transaction {
     maxFeePerBlobGas?: Qty,
     blobVersionedHashes?: Bytes32[],
     authorizationList?: EIP7702Authorization[],
+    // Tempo 0x76 transaction fields
+    calls?: TempoCall[],
+    nonceKey?: Bytes,
+    signature?: TempoSignature,
+    feeToken?: Bytes20,
+    feePayerSignature?: TempoFeePayerSignature,
+    validBefore?: Qty,
+    validAfter?: Qty,
     // transaction receipt
     contractAddress?: Bytes20,
     cumulativeGasUsed?: Qty,

evm/evm-normalization/src/mapping.ts

@@ -8,6 +8,11 @@ import {
     Transaction,
     AccessListItem,
     EIP7702Authorization,
+    TempoCall,
+    TempoPrimitiveSignature,
+    TempoKeychainSignature,
+    TempoSignature,
+    TempoFeePayerSignature,
     Log,
     Trace,
     TraceCreateAction,
@@ -407,15 +412,80 @@ function mapEIP7702Authorization(src: rpc.EIP7702Authorization): EIP7702Authoriz
 }
 
 
+function mapTempoCall(src: rpc.TempoCall): TempoCall {
+    return {
+        to: src.to ? src.to.toLowerCase() : undefined,
+        value: src.value,
+        input: src.input
+    }
+}
+
+
+function mapTempoPrimitiveSignature(src: rpc.TempoPrimitiveSignature): TempoPrimitiveSignature {
+    switch (src.type) {
+        case 'secp256k1':
+            return {
+                type: 'secp256k1',
+                r: src.r,
+                s: src.s,
+                yParity: src.yParity != null ? qty2Int(src.yParity) : undefined,
+                v: src.v != null ? qty2Int(src.v) : undefined,
+            }
+        case 'p256':
+            return {
+                type: 'p256',
+                r: src.r,
+                s: src.s,
+                pubKeyX: src.pubKeyX,
+                pubKeyY: src.pubKeyY,
+                preHash: src.preHash,
+            }
+        case 'webAuthn':
+            return {
+                type: 'webAuthn',
+                r: src.r,
+                s: src.s,
+                pubKeyX: src.pubKeyX,
+                pubKeyY: src.pubKeyY,
+                webauthnData: src.webauthnData,
+            }
+        default:
+            throw unexpectedCase((src as any).type)
+    }
+}
+
+
+function mapTempoSignature(src: rpc.TempoSignatureObject): TempoSignature {
+    if ('userAddress' in src) {
+        let result: TempoKeychainSignature = {
+            userAddress: src.userAddress.toLowerCase(),
+            signature: mapTempoPrimitiveSignature(src.signature)
+        }
+        if (src.version != null) result.version = src.version
+        return result
+    }
+    return mapTempoPrimitiveSignature(src as rpc.TempoPrimitiveSignature)
+}
+
+
+function mapTempoFeePayerSignature(src: {v: string, r: string, s: string}): TempoFeePayerSignature {
+    return {
+        v: qty2Int(src.v),
+        r: src.r,
+        s: src.s
+    }
+}
+
+
 function mapTransaction(src: rpc.Transaction, receipt?: rpc.Receipt): Transaction {
     return {
         transactionIndex: qty2Int(src.transactionIndex),
         hash: src.hash,
         nonce: qty2Int(src.nonce),
         from: src.from.toLowerCase(),
         to: src.to ? src.to.toLowerCase() : undefined,
-        input: src.input,
-        value: src.value,
+        input: src.input ?? undefined,
+        value: src.value ?? undefined,
         type: src.type ? qty2Int(src.type) : undefined,
         gas: src.gas,
         gasPrice: src.gasPrice ?? undefined,
@@ -430,6 +500,13 @@ function mapTransaction(src: rpc.Transaction, receipt?: rpc.Receipt): Transactio
         maxFeePerBlobGas: src.maxFeePerBlobGas ?? undefined,
         blobVersionedHashes: src.blobVersionedHashes ?? undefined,
         authorizationList: src.authorizationList?.map(mapEIP7702Authorization),
+        calls: src.calls?.map(mapTempoCall),
+        nonceKey: src.nonceKey ?? undefined,
+        signature: src.signature ? mapTempoSignature(src.signature) : undefined,
+        feeToken: src.feeToken ? src.feeToken.toLowerCase() : undefined,
+        feePayerSignature: src.feePayerSignature ? mapTempoFeePayerSignature(src.feePayerSignature) : undefined,
+        validBefore: src.validBefore ?? undefined,
+        validAfter: src.validAfter ?? undefined,
         contractAddress: receipt?.contractAddress ? receipt?.contractAddress.toLowerCase() : undefined,
         cumulativeGasUsed: receipt?.cumulativeGasUsed,
         effectiveGasPrice: receipt?.effectiveGasPrice ?? undefined,
@@ -474,7 +551,10 @@ function mapBlockHeader(src: rpc.GetBlock): BlockHeader {
         excessBlobGas: src.excessBlobGas ?? undefined,
         parentBeaconBlockRoot: src.parentBeaconBlockRoot ?? undefined,
         requestsHash: src.requestsHash ?? undefined,
-        l1BlockNumber: src.l1BlockNumber ? qty2Int(src.l1BlockNumber) : undefined
+        l1BlockNumber: src.l1BlockNumber ? qty2Int(src.l1BlockNumber) : undefined,
+        mainBlockGeneralGasLimit: src.mainBlockGeneralGasLimit ?? undefined,
+        sharedGasLimit: src.sharedGasLimit ?? undefined,
+        timestampMillisPart: src.timestampMillisPart ?? undefined,
     }
 }
 

evm/evm-rpc/src/chain-utils.ts

@@ -3,6 +3,7 @@ import {GetBlock, Log, Receipt, Transaction} from './rpc-data'
 import {Qty} from './types'
 import {
     blockHash,
+    tempoBlockHash,
     logsBloom,
     receiptsRoot,
     recoverTxSender,
@@ -17,15 +18,25 @@ export class ChainUtils {
     public isHyperliquidMainnet: boolean
     public isHyperliquidTestnet: boolean
     public isStable: boolean
+    public isTempo: boolean
 
     constructor(chainId: Qty) {
         this.isPolygonMainnet = chainId == '0x89'
         this.isHyperliquidMainnet = chainId == '0x3e7'
         this.isHyperliquidTestnet = chainId == '0x3e6'
         this.isStable = chainId == '0x3dc' || chainId == '0x899' // Chain ID 988 (mainnet) or 2201 (testnet)
+        // Tempo mainnet (4217), Moderato testnet (42431), Andantino testnet (42429)
+        // https://drpc.org/chainlist/tempo-mainnet-rpc
+        // https://drpc.org/chainlist/tempo-moderato-testnet-rpc
+        // https://drpc.org/chainlist/tempo-testnet-rpc
+        this.isTempo = chainId == '0x1079' || chainId == '0xa5bf' || chainId == '0xa5bd'
     }
 
     calculateBlockHash(block: GetBlock) {
+        // Tempo extends the Ethereum header with additional fields
+        if (this.isTempo) {
+            return tempoBlockHash(block)
+        }
         return blockHash(block)
     }
 
@@ -52,6 +63,18 @@ export class ChainUtils {
             transactions = transactions.filter(tx => !isHyperliquidSystemTx(tx))
         }
 
+        if (this.isTempo) {
+            // Tempo 0x77 tx type appears on the deprecated Andantino testnet, but:
+            // - is not documented anywhere,
+            // - is absent from the latest (Moderato) testnet,
+            // so skip verification for blocks containing 0x77 transactions
+            for (let tx of transactions) {
+                if (tx.type == '0x77') {
+                    return block.transactionsRoot
+                }
+            }
+        }
+
         return transactionsRoot(transactions)
     }
 
@@ -101,6 +124,13 @@ export class ChainUtils {
             if (isHyperliquidSystemTx(transaction)) return
         }
 
+        // Tempo system transactions are legacy txs with a fake signature (r=0, s=0)
+        // and sender set to Address::ZERO. They cannot be ECDSA-recovered.
+        // https://github.com/tempoxyz/tempo/blob/main/crates/primitives/src/transaction/envelope.rs
+        if (this.isTempo) {
+            if (isTempoSystemTx(transaction)) return
+        }
+
         return recoverTxSender(transaction)
     }
 }
@@ -112,6 +142,13 @@ function isHyperliquidSystemTx(tx: Transaction) {
 }
 
 
+function isTempoSystemTx(tx: Transaction) {
+    // Tempo system transactions are legacy (type 0x0) with a fake signature (r=0, s=0).
+    // https://github.com/tempoxyz/tempo/blob/main/crates/primitives/src/transaction/envelope.rs
+    return tx.type == '0x0' && tx.r == '0x0' && tx.s == '0x0'
+}
+
+
 function isHyperliquidSystemReceipt(receipt: Receipt) {
     // https://github.com/hl-archive-node/nanoreth/blob/732f8c574db2dde90344a29b0292189a5cddd2d1/src/addons/hl_node_compliance.rs#L365
     return receipt.cumulativeGasUsed == '0x0'