ox 0.14.0 → 0.14.2

package/tempo/KeyAuthorization.ts

@@ -5,6 +5,7 @@ import * as Hex from '../core/Hex.js'
 import type { Compute } from '../core/internal/types.js'
 import * as Rlp from '../core/Rlp.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
+import * as TempoAddress from './TempoAddress.js'
 
 /**
  * Key authorization for provisioning access keys.
@@ -33,7 +34,7 @@ export type KeyAuthorization<
   numberType = number,
 > = {
   /** Address derived from the public key of the key type. */
-  address: Address.Address
+  address: TempoAddress.Address
   /** Chain ID for replay protection. */
   chainId: bigintType
   /** Unix timestamp when key expires (0 = never expires). */
@@ -107,7 +108,7 @@ export type Tuple<signed extends boolean = boolean> = signed extends true
  */
 export type TokenLimit<bigintType = bigint> = {
   /** Address of the TIP-20 token. */
-  token: Address.Address
+  token: TempoAddress.Address
   /** Maximum spending amount for this token (enforced over the key's lifetime). */
   limit: bigintType
 }
@@ -255,14 +256,28 @@ export function from<
   authorization: authorization | KeyAuthorization,
   options: from.Options<signature> = {},
 ): from.ReturnType<authorization, signature> {
-  if (typeof authorization.expiry === 'string')
-    return fromRpc(authorization as Rpc) as never
+  if ('keyId' in authorization) return fromRpc(authorization as Rpc) as never
+  const auth = authorization as KeyAuthorization & {
+    limits?: readonly { token: TempoAddress.Address; limit: bigint }[]
+  }
+  const resolved = {
+    ...auth,
+    address: TempoAddress.resolve(auth.address as TempoAddress.Address),
+    ...(auth.limits
+      ? {
+          limits: auth.limits.map((l) => ({
+            ...l,
+            token: TempoAddress.resolve(l.token as TempoAddress.Address),
+          })),
+        }
+      : {}),
+  }
   if (options.signature)
     return {
-      ...authorization,
+      ...resolved,
       signature: SignatureEnvelope.from(options.signature),
     } as never
-  return authorization as never
+  return resolved as never
 }
 
 export declare namespace from {
@@ -300,6 +315,7 @@ export declare namespace from {
  * import { KeyAuthorization } from 'ox/tempo'
  *
  * const keyAuthorization = KeyAuthorization.fromRpc({
+ *   chainId: '0x1079',
  *   expiry: '0x174876e800',
  *   keyId: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
  *   keyType: 'secp256k1',
@@ -619,7 +635,7 @@ export function toRpc(authorization: Signed): Rpc {
       token,
       limit: Hex.fromNumber(limit),
     })),
-    keyId: address,
+    keyId: TempoAddress.resolve(address),
     signature: SignatureEnvelope.toRpc(signature),
     keyType: type,
   }

package/tempo/PoolId.test.ts

@@ -30,4 +30,13 @@ test('from', () => {
     validatorToken: 1n,
   })
   expect(poolId4).toBe(poolId1)
+
+  // Test with tempo address inputs
+  const tempoAddr0 = 'tempo1qqsvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqv0ywuh'
+  const tempoAddr1 = 'tempo1qqsvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqyr9xgnd'
+  const poolId5 = PoolId.from({
+    userToken: tempoAddr0,
+    validatorToken: tempoAddr1,
+  })
+  expect(poolId5).toBe(poolId1)
 })

package/tempo/SignatureEnvelope.test.ts

@@ -1040,6 +1040,61 @@ describe('from', () => {
 
       expect(envelope.type).toBe('keychain')
     })
+
+    test('behavior: computes keyId from p256 inner publicKey', () => {
+      const envelope = SignatureEnvelope.from({
+        userAddress: '0x1234567890123456789012345678901234567890',
+        inner: signature_p256,
+      })
+
+      expect(envelope.keyId).toBe(Address.fromPublicKey(publicKey))
+    })
+
+    test('behavior: computes keyId from webAuthn inner publicKey', () => {
+      const envelope = SignatureEnvelope.from({
+        userAddress: '0x1234567890123456789012345678901234567890',
+        inner: signature_webauthn,
+      })
+
+      expect(envelope.keyId).toBe(Address.fromPublicKey(publicKey))
+    })
+
+    test('behavior: computes keyId from secp256k1 inner with payload', () => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const accessKeyPublicKey = Secp256k1.getPublicKey({ privateKey })
+      const payload = '0xdeadbeef'
+      const sig = Secp256k1.sign({ payload, privateKey })
+
+      const envelope = SignatureEnvelope.from(
+        {
+          userAddress: '0x1234567890123456789012345678901234567890',
+          inner: SignatureEnvelope.from(sig),
+        },
+        { payload },
+      )
+
+      expect(envelope.keyId).toBe(Address.fromPublicKey(accessKeyPublicKey))
+    })
+
+    test('behavior: does not compute keyId for secp256k1 without payload', () => {
+      const envelope = SignatureEnvelope.from({
+        userAddress: '0x1234567890123456789012345678901234567890',
+        inner: SignatureEnvelope.from(signature_secp256k1),
+      })
+
+      expect(envelope.keyId).toBeUndefined()
+    })
+
+    test('behavior: preserves explicit keyId', () => {
+      const explicitKeyId = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+      const envelope = SignatureEnvelope.from({
+        userAddress: '0x1234567890123456789012345678901234567890',
+        inner: signature_p256,
+        keyId: explicitKeyId,
+      })
+
+      expect(envelope.keyId).toBe(explicitKeyId)
+    })
   })
 })
 
@@ -2235,6 +2290,24 @@ describe('fromRpc', () => {
         },
       })
     })
+
+    test('behavior: preserves keyId from RPC', () => {
+      const rpc: SignatureEnvelope.KeychainRpc = {
+        type: 'keychain',
+        userAddress: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        keyId: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+        signature: {
+          type: 'secp256k1',
+          r: '0xa2bb71146c20ce932456c043ebb2973ed205e07cd32c35a60bdefca1285fd132',
+          s: '0x7cba10692bccdbfba9a215418443c2903dbee6fe5cb55c91172e47efc607840e',
+          yParity: '0x1',
+        },
+      }
+
+      const envelope = SignatureEnvelope.fromRpc(rpc)
+
+      expect(envelope.keyId).toBe('0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c')
+    })
   })
 })
 
@@ -2352,6 +2425,41 @@ describe('toRpc', () => {
       expect(typeof rpc.signature.pubKeyX).toBe('string')
       expect(typeof rpc.signature.webauthnData).toBe('string')
     })
+
+    test('behavior: preserves keyId in toRpc', () => {
+      const envelope: SignatureEnvelope.Keychain = {
+        type: 'keychain',
+        userAddress: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        keyId: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+        inner: {
+          signature: signature_secp256k1,
+          type: 'secp256k1',
+        },
+      }
+
+      const rpc = SignatureEnvelope.toRpc(
+        envelope,
+      ) as SignatureEnvelope.KeychainRpc
+
+      expect(rpc.keyId).toBe('0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c')
+    })
+
+    test('behavior: omits keyId in toRpc when not set', () => {
+      const envelope: SignatureEnvelope.Keychain = {
+        type: 'keychain',
+        userAddress: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        inner: {
+          signature: signature_secp256k1,
+          type: 'secp256k1',
+        },
+      }
+
+      const rpc = SignatureEnvelope.toRpc(
+        envelope,
+      ) as SignatureEnvelope.KeychainRpc
+
+      expect(rpc.keyId).toBeUndefined()
+    })
   })
 })
 

package/tempo/SignatureEnvelope.ts

@@ -122,6 +122,8 @@ export type Keychain<bigintType = bigint, numberType = number> = {
   userAddress: Address.Address
   /** The actual signature from the access key (can be Secp256k1, P256, or WebAuthn) */
   inner: SignatureEnvelope<bigintType, numberType>
+  /** The access key address (recovered address of the access key signer). */
+  keyId?: Address.Address | undefined
   type: 'keychain'
   /** Keychain signature version. @default 'v1' */
   version?: KeychainVersion | undefined
@@ -130,6 +132,7 @@ export type Keychain<bigintType = bigint, numberType = number> = {
 export type KeychainRpc = {
   type: 'keychain'
   userAddress: Address.Address
+  keyId?: Address.Address | undefined
   signature: SignatureEnvelopeRpc
   version?: KeychainVersion | undefined
 }
@@ -663,6 +666,7 @@ export function deserialize(value: Serialized): SignatureEnvelope {
  */
 export function from<const value extends from.Value>(
   value: value | from.Value,
+  options?: from.Options | undefined,
 ): from.ReturnValue<value> {
   if (typeof value === 'string') return deserialize(value) as never
 
@@ -679,20 +683,45 @@ export function from<const value extends from.Value>(
   return {
     ...value,
     ...(type === 'p256' ? { prehash: value.prehash } : {}),
-    ...(type === 'keychain' &&
-    !(
-      typeof value === 'object' &&
-      value !== null &&
-      'version' in value &&
-      value.version
-    )
-      ? { version: 'v1' }
+    ...(type === 'keychain'
+      ? {
+          ...(!(
+            typeof value === 'object' &&
+            value !== null &&
+            'version' in value &&
+            value.version
+          )
+            ? { version: 'v2' }
+            : {}),
+          ...(!(typeof value === 'object' && 'keyId' in value && value.keyId)
+            ? (() => {
+                const inner = (value as Keychain).inner
+                if (inner.type === 'p256' || inner.type === 'webAuthn')
+                  return { keyId: Address.fromPublicKey(inner.publicKey) }
+                if (inner.type === 'secp256k1' && options?.payload)
+                  return {
+                    keyId: Address.fromPublicKey(
+                      ox_Secp256k1.recoverPublicKey({
+                        payload: options.payload,
+                        signature: inner.signature,
+                      }),
+                    ),
+                  }
+                return {}
+              })()
+            : {}),
+        }
       : {}),
     type,
   } as never
 }
 
 export declare namespace from {
+  type Options = {
+    /** Payload that was signed. Used to recover `keyId` for keychain envelopes with secp256k1 inner signatures. */
+    payload?: Hex.Hex | Bytes.Bytes | undefined
+  }
+
   type Value =
     | UnionPartialBy<SignatureEnvelope, 'prehash' | 'type'>
     | Secp256k1Flat
@@ -706,7 +735,14 @@ export declare namespace from {
           ? Secp256k1
           : IsNarrowable<value, SignatureEnvelope> extends true
             ? SignatureEnvelope
-            : Assign<value, { readonly type: GetType<value> }>
+            : Assign<
+                value,
+                {
+                  readonly type: GetType<value>
+                } & (GetType<value> extends 'keychain'
+                  ? { keyId?: Address.Address | undefined }
+                  : {})
+              >
     >
   >
 }
@@ -806,6 +842,7 @@ export function fromRpc(envelope: SignatureEnvelopeRpc): SignatureEnvelope {
       type: 'keychain',
       userAddress: envelope.userAddress,
       inner: fromRpc(envelope.signature),
+      ...(envelope.keyId ? { keyId: envelope.keyId } : {}),
       ...(envelope.version ? { version: envelope.version } : {}),
     }
 
@@ -1053,6 +1090,7 @@ export function toRpc(envelope: SignatureEnvelope): SignatureEnvelopeRpc {
       type: 'keychain',
       userAddress: keychain.userAddress,
       signature: toRpc(keychain.inner),
+      ...(keychain.keyId ? { keyId: keychain.keyId } : {}),
       ...(keychain.version ? { version: keychain.version } : {}),
     }
   }

package/tempo/TempoAddress.test.ts

@@ -6,6 +6,22 @@ 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(
@@ -13,6 +29,11 @@ describe('format', () => {
     )
   })
 
+  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 }),

package/tempo/TempoAddress.ts

@@ -1,12 +1,45 @@
-import * as Address from '../core/Address.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 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.
@@ -35,18 +68,16 @@ export type TempoAddress = `tempo1${string}` | `tempoz1${string}`
  * @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 resolved = resolve(address)
   const hrp = zoneId != null ? 'tempoz' : 'tempo'
   const version = new Uint8Array([0x00])
   const zone = zoneId != null ? CompactSize.toBytes(zoneId) : new Uint8Array()
-  const data = Bytes.concat(version, zone, Bytes.fromHex(address))
+  const data = Bytes.concat(version, zone, Bytes.fromHex(resolved))
 
-  return Bech32m.encode(hrp, data) as TempoAddress
+  return Bech32m.encode(hrp, data) as Tempo
 }
 
 export declare namespace format {
@@ -126,7 +157,7 @@ export function parse(tempoAddress: string): parse.ReturnType {
       actual: rawAddress.length,
     })
 
-  const address = Address.checksum(Hex.fromBytes(rawAddress) as Address.Address)
+  const address = core_Address.checksum(Hex.fromBytes(rawAddress) as never)
 
   return { address, zoneId }
 }
@@ -134,7 +165,7 @@ 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: number | bigint | undefined
   }

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/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',
     }))

package/tempo/TxEnvelopeTempo.test.ts

@@ -692,6 +692,32 @@ describe('from', () => {
     }
   })
 
+  test('tempo address input for calls.to', () => {
+    const hexAddr = '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
+    const tempoAddr = 'tempo1qpcfj7tsc5vp9hp6qyx86qd4pcx30hreeqlrsqqr'
+
+    const envelope = TxEnvelopeTempo.from({
+      chainId: 1,
+      calls: [{ to: tempoAddr }],
+      nonce: 0n,
+      nonceKey: 0n,
+    })
+    expect(envelope.calls[0]!.to).toBe(Address.checksum(hexAddr))
+  })
+
+  test('tempo address input for from', () => {
+    const hexAddr = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'
+    const tempoAddr = 'tempo1qreel4h9r2kc3ah5ee4t3qnj088llwfzvccugvl7'
+
+    const envelope = TxEnvelopeTempo.from({
+      chainId: 1,
+      calls: [{}],
+      nonce: 0n,
+      from: tempoAddr as any,
+    })
+    expect(envelope.from).toBe(Address.checksum(hexAddr))
+  })
+
   test('options: signature', () => {
     const envelope = TxEnvelopeTempo.from(
       {
@@ -1382,6 +1408,29 @@ describe('getSignPayload', () => {
       `"0xe1222a45806457acbe3a13940aae4c34f3180659fa16613b5a45dc183adae07c"`,
     )
   })
+
+  test('tempo address input for from', () => {
+    const hexAddr = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'
+    const tempoAddr = 'tempo1qreel4h9r2kc3ah5ee4t3qnj088llwfzvccugvl7'
+
+    const transaction = TxEnvelopeTempo.from({
+      chainId: 1,
+      calls: [
+        {
+          to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+        },
+      ],
+      nonce: 0n,
+    })
+
+    const hashHex = TxEnvelopeTempo.getSignPayload(transaction, {
+      from: hexAddr,
+    })
+    const hashTempo = TxEnvelopeTempo.getSignPayload(transaction, {
+      from: tempoAddr,
+    })
+    expect(hashTempo).toBe(hashHex)
+  })
 })
 
 describe('getFeePayerSignPayload', () => {
@@ -1404,6 +1453,29 @@ describe('getFeePayerSignPayload', () => {
     )
   })
 
+  test('tempo address input for sender', () => {
+    const hexAddr = '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'
+    const tempoAddr = 'tempo1qreel4h9r2kc3ah5ee4t3qnj088llwfzvccugvl7'
+
+    const transaction = TxEnvelopeTempo.from({
+      chainId: 1,
+      calls: [
+        {
+          to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+        },
+      ],
+      nonce: 0n,
+    })
+
+    const hashHex = TxEnvelopeTempo.getFeePayerSignPayload(transaction, {
+      sender: hexAddr,
+    })
+    const hashTempo = TxEnvelopeTempo.getFeePayerSignPayload(transaction, {
+      sender: tempoAddr,
+    })
+    expect(hashTempo).toBe(hashHex)
+  })
+
   test('with feeToken', () => {
     const transaction = TxEnvelopeTempo.from({
       chainId: 1,