ox 0.13.2 → 0.14.1

package/tempo/TempoAddress.test.ts

@@ -1,4 +1,4 @@
-import { Address } from 'ox'
+import { Address, Bech32m } from 'ox'
 import { TempoAddress } from 'ox/tempo'
 import { describe, expect, test } from 'vitest'
 
@@ -6,30 +6,55 @@ const rawAddress = Address.checksum(
   '0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28',
 )
 
+describe('resolve', () => {
+  test('hex address passthrough', () => {
+    expect(TempoAddress.resolve(rawAddress)).toBe(rawAddress)
+  })
+
+  test('tempo address', () => {
+    const tempoAddr = TempoAddress.format(rawAddress)
+    expect(TempoAddress.resolve(tempoAddr)).toBe(rawAddress)
+  })
+
+  test('tempo zone address', () => {
+    const tempoAddr = TempoAddress.format(rawAddress, { zoneId: 1 })
+    expect(TempoAddress.resolve(tempoAddr)).toBe(rawAddress)
+  })
+})
+
 describe('format', () => {
   test('mainnet address', () => {
     expect(TempoAddress.format(rawAddress)).toMatchInlineSnapshot(
-      `"tempo1wskntnrxxnq9x2f95wuyf0y7wk2l90fg8zd8djs"`,
+      `"tempo1qp6z6dwvvc6vq5efyk3ms39une6etu4a9qtj2kk0"`,
     )
   })
 
+  test('tempo address input', () => {
+    const tempoAddr = TempoAddress.format(rawAddress)
+    expect(TempoAddress.format(tempoAddr)).toBe(tempoAddr)
+  })
+
   test('zone address (zone ID = 1)', () => {
     expect(
       TempoAddress.format(rawAddress, { zoneId: 1 }),
-    ).toMatchInlineSnapshot(`"tempoz1q96z6dwvvc6vq5efyk3ms39une6etu4a9zeqtx3q"`)
+    ).toMatchInlineSnapshot(
+      `"tempoz1qqqhgtf4e3nrfszn9yj68wzyhj08t90jh55q74d9uj"`,
+    )
   })
 
   test('zone address (zone ID = 252)', () => {
     expect(
       TempoAddress.format(rawAddress, { zoneId: 252 }),
-    ).toMatchInlineSnapshot(`"tempoz1l36z6dwvvc6vq5efyk3ms39une6etu4a9z8vgw44"`)
+    ).toMatchInlineSnapshot(
+      `"tempoz1qr78gtf4e3nrfszn9yj68wzyhj08t90jh55q9k62jd"`,
+    )
   })
 
   test('zone address (zone ID = 253)', () => {
     expect(
       TempoAddress.format(rawAddress, { zoneId: 253 }),
     ).toMatchInlineSnapshot(
-      `"tempoz1lh7sqapdxhxxvdxq2v5jtgacgj7fuav4727jsx0032us"`,
+      `"tempoz1qr7l6qr5956uce35cpfjjfdrhpzte8n4jhet62q0j8hus"`,
     )
   })
 
@@ -37,7 +62,7 @@ describe('format', () => {
     expect(
       TempoAddress.format(rawAddress, { zoneId: 65535 }),
     ).toMatchInlineSnapshot(
-      `"tempoz1lhll7apdxhxxvdxq2v5jtgacgj7fuav4727j37cldu7q"`,
+      `"tempoz1qr7lllm5956uce35cpfjjfdrhpzte8n4jhet62q8pdj6j"`,
     )
   })
 
@@ -45,7 +70,7 @@ describe('format', () => {
     expect(
       TempoAddress.format(rawAddress, { zoneId: 65536 }),
     ).toMatchInlineSnapshot(
-      `"tempoz1lcqqqqgqwskntnrxxnq9x2f95wuyf0y7wk2l90fga965qjc"`,
+      `"tempoz1qrlqqqqpqp6z6dwvvc6vq5efyk3ms39une6etu4a9qdupk5c"`,
     )
   })
 
@@ -53,7 +78,7 @@ describe('format', () => {
     expect(
       TempoAddress.format(rawAddress, { zoneId: 4294967295 }),
     ).toMatchInlineSnapshot(
-      `"tempoz1lmllllllwskntnrxxnq9x2f95wuyf0y7wk2l90fgxg58ulq"`,
+      `"tempoz1qrl0llllla6z6dwvvc6vq5efyk3ms39une6etu4a9qnk36qy"`,
     )
   })
 
@@ -61,7 +86,7 @@ describe('format', () => {
     expect(
       TempoAddress.format(rawAddress, { zoneId: BigInt('4294967296') }),
     ).toMatchInlineSnapshot(
-      `"tempoz1luqqqqqqqyqqqqr5956uce35cpfjjfdrhpzte8n4jhet62pnyj7cc"`,
+      `"tempoz1qrlsqqqqqqqsqqqqwskntnrxxnq9x2f95wuyf0y7wk2l90fg4306kk"`,
     )
   })
 
@@ -69,6 +94,28 @@ describe('format', () => {
     const result = TempoAddress.format(rawAddress)
     expect(result).toBe(result.toLowerCase())
   })
+
+  test('spec test vectors', () => {
+    expect(TempoAddress.format(rawAddress)).toBe(
+      'tempo1qp6z6dwvvc6vq5efyk3ms39une6etu4a9qtj2kk0',
+    )
+    expect(TempoAddress.format(rawAddress, { zoneId: 1 })).toBe(
+      'tempoz1qqqhgtf4e3nrfszn9yj68wzyhj08t90jh55q74d9uj',
+    )
+    expect(TempoAddress.format(rawAddress, { zoneId: 1000 })).toBe(
+      'tempoz1qr77sqm5956uce35cpfjjfdrhpzte8n4jhet62qxx4zvx',
+    )
+    expect(TempoAddress.format(rawAddress, { zoneId: 100000 })).toBe(
+      'tempoz1qrl2ppspqp6z6dwvvc6vq5efyk3ms39une6etu4a9qg5477g',
+    )
+  })
+
+  test('address lengths match spec', () => {
+    expect(TempoAddress.format(rawAddress).length).toBe(46)
+    expect(TempoAddress.format(rawAddress, { zoneId: 1 }).length).toBe(49)
+    expect(TempoAddress.format(rawAddress, { zoneId: 1000 }).length).toBe(52)
+    expect(TempoAddress.format(rawAddress, { zoneId: 100000 }).length).toBe(55)
+  })
 })
 
 describe('parse', () => {
@@ -144,17 +191,26 @@ describe('parse', () => {
     `)
   })
 
-  test('case insensitive', () => {
+  test('all uppercase', () => {
     const encoded = TempoAddress.format(rawAddress)
-    const upper = encoded.slice(0, 6) + encoded.slice(6).toUpperCase()
+    const upper = encoded.toUpperCase()
     expect(TempoAddress.parse(upper).address).toBe(rawAddress)
   })
 
   test('error: invalid prefix', () => {
+    const encoded = Bech32m.encode('bitcoin', new Uint8Array(20))
     expect(() =>
-      TempoAddress.parse('bitcoin1abc'),
+      TempoAddress.parse(encoded),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[TempoAddress.InvalidPrefixError: Tempo address "bitcoin1abc" has an invalid prefix. Expected "tempo1" or "tempoz1".]`,
+      `[TempoAddress.InvalidPrefixError: Tempo address "${encoded}" has an invalid prefix. Expected "tempo1" or "tempoz1".]`,
+    )
+  })
+
+  test('error: unsupported version', () => {
+    const data = new Uint8Array([0x01, ...new Uint8Array(20)])
+    const encoded = Bech32m.encode('tempo', data)
+    expect(() => TempoAddress.parse(encoded)).toThrow(
+      TempoAddress.InvalidVersionError,
     )
   })
 
@@ -174,7 +230,7 @@ describe('parse', () => {
     expect(() =>
       TempoAddress.parse(swapped),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[TempoAddress.InvalidLengthError: Tempo address "${swapped}" has an invalid payload length. Expected 24 bytes, got 23.]`,
+      `[TempoAddress.InvalidChecksumError: Tempo address "tempoz1qp6z6dwvvc6vq5efyk3ms39une6etu4a9qtj2kk0" has an invalid checksum.]`,
     )
   })
 })

package/tempo/TempoAddress.ts

@@ -1,13 +1,45 @@
-import * as Address from '../core/Address.js'
-import * as Base32 from '../core/Base32.js'
+import * as core_Address from '../core/Address.js'
+import * as Bech32m from '../core/Bech32m.js'
 import * as Bytes from '../core/Bytes.js'
 import * as CompactSize from '../core/CompactSize.js'
 import * as Errors from '../core/Errors.js'
-import * as Hash from '../core/Hash.js'
 import * as Hex from '../core/Hex.js'
+import type { Compute } from '../core/internal/types.js'
+
+/** An address that can be either an Ethereum hex address or a Tempo bech32m address. */
+export type Address = core_Address.Address | Tempo
 
 /** Root type for a Tempo Address. */
-export type TempoAddress = `tempo1${string}` | `tempoz1${string}`
+export type Tempo = Compute<`tempo1${string}` | `tempoz1${string}`>
+
+/**
+ * Resolves an address input (either an Ethereum hex address or a Tempo bech32m address)
+ * to an Ethereum hex address.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TempoAddress } from 'ox/tempo'
+ *
+ * const address = TempoAddress.resolve('tempo1qp6z6dwvvc6vq5efyk3ms39une6etu4a9qtj2kk0')
+ * // @log: '0x742d35CC6634c0532925a3B844bc9e7595F2Bd28'
+ * ```
+ *
+ * @example
+ * ### Hex Address Passthrough
+ * ```ts twoslash
+ * import { TempoAddress } from 'ox/tempo'
+ *
+ * const address = TempoAddress.resolve('0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28')
+ * // @log: '0x742d35CC6634c0532925a3B844bc9e7595F2Bd28'
+ * ```
+ *
+ * @param address - An Ethereum hex address or Tempo bech32m address.
+ * @returns The resolved Ethereum hex address.
+ */
+export function resolve(address: Address): core_Address.Address {
+  if (address.startsWith('tempo')) return parse(address).address
+  return address as core_Address.Address
+}
 
 /**
  * Formats a raw Ethereum address (and optional zone ID) into a Tempo address string.
@@ -17,7 +49,7 @@ export type TempoAddress = `tempo1${string}` | `tempoz1${string}`
  * import { TempoAddress } from 'ox/tempo'
  *
  * const address = TempoAddress.format('0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28')
- * // @log: 'tempo1wskntnrxxnq9x2f95wuyf0y7wk2l90fg8zd8djs'
+ * // @log: 'tempo1qp6z6dwvvc6vq5efyk3ms39une6etu4a9qtj2kk0'
  * ```
  *
  * @example
@@ -29,36 +61,29 @@ export type TempoAddress = `tempo1${string}` | `tempoz1${string}`
  *   '0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28',
  *   { zoneId: 1 },
  * )
- * // @log: 'tempoz1q96z6dwvvc6vq5efyk3ms39une6etu4a9zeqtx3q'
+ * // @log: 'tempoz1qqqhgtf4e3nrfszn9yj68wzyhj08t90jh55q74d9uj'
  * ```
  *
  * @param address - The raw 20-byte Ethereum address.
  * @param options - Options.
  * @returns The encoded Tempo address string.
  */
-export function format(
-  address: Address.Address,
-  options: format.Options = {},
-): TempoAddress {
+export function format(address: Address, options: format.Options = {}): Tempo {
   const { zoneId } = options
 
-  const prefix = zoneId != null ? 'tempoz1' : 'tempo1'
+  const resolved = resolve(address)
+  const hrp = zoneId != null ? 'tempoz' : 'tempo'
+  const version = new Uint8Array([0x00])
   const zone = zoneId != null ? CompactSize.toBytes(zoneId) : new Uint8Array()
-  const address_bytes = Bytes.fromHex(address)
+  const data = Bytes.concat(version, zone, Bytes.fromHex(resolved))
 
-  const input = Bytes.concat(Bytes.fromString(prefix), zone, address_bytes)
-  const checksum = Hash.sha256(Hash.sha256(input, { as: 'Bytes' }), {
-    as: 'Bytes',
-  }).slice(0, 4)
-
-  const payload = Bytes.concat(zone, address_bytes, checksum)
-  return `${prefix}${Base32.fromBytes(payload)}` as TempoAddress
+  return Bech32m.encode(hrp, data) as Tempo
 }
 
 export declare namespace format {
   type Options = {
     /** Zone ID for zone addresses. */
-    zoneId?: bigint | number | undefined
+    zoneId?: number | bigint | undefined
   }
 
   type ErrorType = Errors.GlobalErrorType
@@ -73,9 +98,9 @@ export declare namespace format {
  * import { TempoAddress } from 'ox/tempo'
  *
  * const result = TempoAddress.parse(
- *   'tempo1wst8d6qejxtdg4y5r3zarvary0c5xw7kvmgh8pm',
+ *   'tempo1qp6z6dwvvc6vq5efyk3ms39une6etu4a9qtj2kk0',
  * )
- * // { address: '0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28' }
+ * // @log: { address: '0x742d35CC6634c0532925a3B844bc9e7595F2Bd28', zoneId: undefined }
  * ```
  *
  * @example
@@ -84,67 +109,55 @@ export declare namespace format {
  * import { TempoAddress } from 'ox/tempo'
  *
  * const result = TempoAddress.parse(
- *   'tempoz1qwst8d6qejxtdg4y5r3zarvary0c5xw7kvmgh8pm',
+ *   'tempoz1qqqhgtf4e3nrfszn9yj68wzyhj08t90jh55q74d9uj',
  * )
- * // { address: '0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28', zoneId: 1 }
+ * // @log: { address: '0x742d35CC6634c0532925a3B844bc9e7595F2Bd28', zoneId: 1 }
  * ```
  *
  * @param tempoAddress - The Tempo address string to parse.
  * @returns The parsed raw address and optional zone ID.
  */
 export function parse(tempoAddress: string): parse.ReturnType {
-  const lower = tempoAddress.toLowerCase()
-
-  let prefix: string
-  let hasZone: boolean
-  if (lower.startsWith('tempoz1')) {
-    prefix = 'tempoz1'
-    hasZone = true
-  } else if (lower.startsWith('tempo1')) {
-    prefix = 'tempo1'
-    hasZone = false
-  } else {
-    throw new InvalidPrefixError({ address: tempoAddress })
+  let hrp: string
+  let data: Uint8Array
+  try {
+    const decoded = Bech32m.decode(tempoAddress)
+    hrp = decoded.hrp
+    data = decoded.data
+  } catch {
+    throw new InvalidChecksumError({ address: tempoAddress })
   }
 
-  const payload = Base32.toBytes(lower.slice(prefix.length))
+  if (hrp !== 'tempo' && hrp !== 'tempoz')
+    throw new InvalidPrefixError({ address: tempoAddress })
+
+  if (data.length < 1 || data[0] !== 0x00)
+    throw new InvalidVersionError({
+      address: tempoAddress,
+      version: data.length > 0 ? data[0]! : undefined,
+    })
 
-  let zoneId: bigint | undefined
-  let remaining: Uint8Array
-  if (hasZone) {
+  const payload = data.slice(1)
+
+  let zoneId: number | bigint | undefined
+  let rawAddress: Uint8Array
+  if (hrp === 'tempoz') {
     const { value, size } = CompactSize.fromBytes(payload)
     zoneId = value
-    remaining = payload.slice(size)
+    rawAddress = payload.slice(size)
   } else {
     zoneId = undefined
-    remaining = payload
+    rawAddress = payload
   }
 
-  if (remaining.length !== 24)
+  if (rawAddress.length !== 20)
     throw new InvalidLengthError({
       address: tempoAddress,
-      expected: 24,
-      actual: remaining.length,
+      expected: 20,
+      actual: rawAddress.length,
     })
 
-  const rawAddress = remaining.slice(0, 20)
-  const checksum = remaining.slice(20, 24)
-
-  const zoneBytes =
-    zoneId != null ? CompactSize.toBytes(zoneId) : new Uint8Array()
-  const checksumInput = Bytes.concat(
-    Bytes.fromString(prefix),
-    zoneBytes,
-    rawAddress,
-  )
-  const expected = Hash.sha256(Hash.sha256(checksumInput, { as: 'Bytes' }), {
-    as: 'Bytes',
-  }).slice(0, 4)
-
-  if (!Bytes.isEqual(checksum, expected))
-    throw new InvalidChecksumError({ address: tempoAddress })
-
-  const address = Address.checksum(Hex.fromBytes(rawAddress) as Address.Address)
+  const address = core_Address.checksum(Hex.fromBytes(rawAddress) as never)
 
   return { address, zoneId }
 }
@@ -152,13 +165,14 @@ export function parse(tempoAddress: string): parse.ReturnType {
 export declare namespace parse {
   type ReturnType = {
     /** The raw 20-byte Ethereum address. */
-    address: Address.Address
+    address: core_Address.Address
     /** The zone ID, or `undefined` for mainnet addresses. */
-    zoneId: bigint | undefined
+    zoneId: number | bigint | undefined
   }
 
   type ErrorType =
     | InvalidPrefixError
+    | InvalidVersionError
     | InvalidLengthError
     | InvalidChecksumError
     | Errors.GlobalErrorType
@@ -172,9 +186,9 @@ export declare namespace parse {
  * import { TempoAddress } from 'ox/tempo'
  *
  * const valid = TempoAddress.validate(
- *   'tempo1wst8d6qejxtdg4y5r3zarvary0c5xw7kvmgh8pm',
+ *   'tempo1qp6z6dwvvc6vq5efyk3ms39une6etu4a9qtj2kk0',
  * )
- * // true
+ * // @log: true
  * ```
  *
  * @param tempoAddress - The Tempo address string to validate.
@@ -200,6 +214,20 @@ export class InvalidPrefixError extends Errors.BaseError {
   }
 }
 
+/** Thrown when a Tempo address has an unsupported version byte. */
+export class InvalidVersionError extends Errors.BaseError {
+  override readonly name = 'TempoAddress.InvalidVersionError'
+
+  constructor({
+    address,
+    version,
+  }: { address: string; version: number | undefined }) {
+    super(
+      `Tempo address "${address}" has unsupported version ${version === undefined ? '(missing)' : `0x${version.toString(16).padStart(2, '0')}`}. Only version 0x00 is supported.`,
+    )
+  }
+}
+
 /** Thrown when a Tempo address has an invalid payload length. */
 export class InvalidLengthError extends Errors.BaseError {
   override readonly name = 'TempoAddress.InvalidLengthError'

package/tempo/TokenId.test.ts

@@ -23,6 +23,10 @@ test('fromAddress', () => {
   expect(
     TokenId.fromAddress('0x20c0000000000000000000000000000000000def'),
   ).toBe(0xdefn)
+
+  // tempo address input
+  const tempoAddr = 'tempo1qqsvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqyr9xgnd'
+  expect(TokenId.fromAddress(tempoAddr)).toBe(1n)
 })
 
 test('toAddress', () => {
@@ -38,6 +42,12 @@ test('toAddress', () => {
   expect(TokenId.toAddress(0xdefn)).toBe(
     '0x20c0000000000000000000000000000000000def',
   )
+
+  // tempo address input
+  const tempoAddr = 'tempo1qqsvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqyr9xgnd'
+  expect(TokenId.toAddress(tempoAddr)).toBe(
+    '0x20C0000000000000000000000000000000000001',
+  )
 })
 
 test('compute', () => {
@@ -76,4 +86,8 @@ test('compute', () => {
   const otherSender = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd'
   const address3 = TokenId.compute({ sender: otherSender, salt: salt1 })
   expect(address3).not.toBe(address1)
+
+  // tempo address input produces same result
+  const tempoSender = 'tempo1qqfrg4ncjqfrg4ncjqfrg4ncjqfrg4ncjqgmv79k'
+  expect(TokenId.compute({ sender: tempoSender, salt: salt1 })).toBe(id1)
 })

package/tempo/TokenId.ts

@@ -2,11 +2,12 @@ import * as AbiParameters from '../core/AbiParameters.js'
 import * as Address from '../core/Address.js'
 import * as Hash from '../core/Hash.js'
 import * as Hex from '../core/Hex.js'
+import * as TempoAddress from './TempoAddress.js'
 
 const tip20Prefix = '0x20c0'
 
 export type TokenId = bigint
-export type TokenIdOrAddress = TokenId | Address.Address
+export type TokenIdOrAddress = TokenId | TempoAddress.Address
 
 /**
  * Converts a token ID or address to a token ID.
@@ -44,16 +45,17 @@ export function from(tokenIdOrAddress: TokenIdOrAddress | number): TokenId {
  * ```ts twoslash
  * import { TokenId } from 'ox/tempo'
  *
- * const tokenId = TokenId.fromAddress('0x20c00000000000000000000000000000000000000001')
+ * const tokenId = TokenId.fromAddress('0x20c0000000000000000000000000000000000001')
  * ```
  *
  * @param address - The token address.
  * @returns The token ID.
  */
-export function fromAddress(address: Address.Address): TokenId {
-  if (!address.toLowerCase().startsWith(tip20Prefix))
+export function fromAddress(address: TempoAddress.Address): TokenId {
+  const resolved = TempoAddress.resolve(address)
+  if (!resolved.toLowerCase().startsWith(tip20Prefix))
     throw new Error('invalid tip20 address.')
-  return Hex.toBigInt(Hex.slice(address, tip20Prefix.length))
+  return Hex.toBigInt(Hex.slice(resolved, tip20Prefix.length))
 }
 
 /**
@@ -73,8 +75,9 @@ export function fromAddress(address: Address.Address): TokenId {
  */
 export function toAddress(tokenId: TokenIdOrAddress): Address.Address {
   if (typeof tokenId === 'string') {
-    Address.assert(tokenId)
-    return tokenId
+    const resolved = TempoAddress.resolve(tokenId as TempoAddress.Address)
+    Address.assert(resolved)
+    return resolved
   }
 
   const tokenIdHex = Hex.fromNumber(tokenId, { size: 18 })
@@ -104,7 +107,7 @@ export function toAddress(tokenId: TokenIdOrAddress): Address.Address {
 export function compute(value: compute.Value): bigint {
   const hash = Hash.keccak256(
     AbiParameters.encode(AbiParameters.from('address, bytes32'), [
-      value.sender,
+      TempoAddress.resolve(value.sender),
       value.salt,
     ]),
   )
@@ -115,7 +118,7 @@ export declare namespace compute {
   export type Value = {
     /** The salt (32 bytes). */
     salt: Hex.Hex
-    /** The sender address. */
-    sender: Address.Address
+    /** The sender address. Accepts both hex and Tempo bech32m addresses. */
+    sender: TempoAddress.Address
   }
 }

package/tempo/Transaction.test.ts

@@ -164,6 +164,7 @@ describe('fromRpc', () => {
         },
       ],
       keyAuthorization: {
+        chainId: '0x1',
         expiry: '0xffffffffffff',
         keyId: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
         keyType: 'secp256k1',
@@ -224,7 +225,7 @@ describe('fromRpc', () => {
         "hash": "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
         "keyAuthorization": {
           "address": "0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c",
-          "chainId": 0n,
+          "chainId": 1n,
           "expiry": 281474976710655,
           "limits": [
             {
@@ -431,6 +432,7 @@ describe('toRpc', () => {
       data: undefined,
       keyAuthorization: {
         address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+        chainId: 1n,
         expiry: 281474976710655,
         type: 'secp256k1',
         limits: [
@@ -487,7 +489,7 @@ describe('toRpc', () => {
         "hash": "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
         "input": undefined,
         "keyAuthorization": {
-          "chainId": "0x",
+          "chainId": "0x1",
           "expiry": "0xffffffffffff",
           "keyId": "0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c",
           "keyType": "secp256k1",

package/tempo/TransactionRequest.ts

@@ -4,6 +4,7 @@ import type { Compute } from '../core/internal/types.js'
 import * as ox_TransactionRequest from '../core/TransactionRequest.js'
 import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
+import * as TempoAddress from './TempoAddress.js'
 import * as TokenId from './TokenId.js'
 import * as Transaction from './Transaction.js'
 import type { Call } from './TxEnvelopeTempo.js'
@@ -30,7 +31,7 @@ export type TransactionRequest<
     authorizationList?:
       | AuthorizationTempo.ListSigned<bigintType, numberType>
       | undefined
-    calls?: readonly Call<bigintType>[] | undefined
+    calls?: readonly Call<bigintType, TempoAddress.Address>[] | undefined
     keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined
     keyData?: Hex.Hex | undefined
     keyType?: KeyType | undefined
@@ -112,7 +113,7 @@ export function toRpc(request: TransactionRequest): Rpc {
     )
   if (request.calls)
     request_rpc.calls = request.calls.map((call) => ({
-      to: call.to,
+      to: call.to ? TempoAddress.resolve(call.to) : call.to,
       value: call.value ? Hex.fromNumber(call.value) : '0x',
       data: call.data ?? '0x',
     }))