ox 1.0.0-beta.2 → 1.0.0-beta.20

package/src/tempo/e2e.test.ts

@@ -110,7 +110,6 @@ test('behavior: default (secp256k1)', async () => {
     expect(rest).toMatchInlineSnapshot(`
       {
         "accessList": [],
-        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -118,14 +117,9 @@ test('behavior: default (secp256k1)', async () => {
             "value": 0n,
           },
         ],
-        "data": undefined,
-        "feePayerSignature": null,
         "gas": 500000n,
         "nonceKey": 0n,
         "type": "tempo",
-        "validAfter": null,
-        "validBefore": null,
-        "value": 0n,
       }
     `)
   }
@@ -323,7 +317,6 @@ test('behavior: default (p256)', async () => {
     expect(rest).toMatchInlineSnapshot(`
       {
         "accessList": [],
-        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -331,14 +324,9 @@ test('behavior: default (p256)', async () => {
             "value": 0n,
           },
         ],
-        "data": undefined,
-        "feePayerSignature": null,
         "gas": 500000n,
         "nonceKey": 0n,
         "type": "tempo",
-        "validAfter": null,
-        "validBefore": null,
-        "value": 0n,
       }
     `)
   }
@@ -468,7 +456,6 @@ test('behavior: default (p256 - webcrypto)', async () => {
     expect(rest).toMatchInlineSnapshot(`
       {
         "accessList": [],
-        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -476,14 +463,9 @@ test('behavior: default (p256 - webcrypto)', async () => {
             "value": 0n,
           },
         ],
-        "data": undefined,
-        "feePayerSignature": null,
         "gas": 500000n,
         "nonceKey": 0n,
         "type": "tempo",
-        "validAfter": null,
-        "validBefore": null,
-        "value": 0n,
       }
     `)
   }
@@ -620,7 +602,6 @@ test('behavior: default (webauthn)', async () => {
     expect(rest).toMatchInlineSnapshot(`
       {
         "accessList": [],
-        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -628,14 +609,9 @@ test('behavior: default (webauthn)', async () => {
             "value": 0n,
           },
         ],
-        "data": undefined,
-        "feePayerSignature": null,
         "gas": 500000n,
         "nonceKey": 0n,
         "type": "tempo",
-        "validAfter": null,
-        "validBefore": null,
-        "value": 0n,
       }
     `)
   }
@@ -1003,7 +979,6 @@ describe('behavior: keyAuthorization', () => {
       expect(rest).toMatchInlineSnapshot(`
         {
           "accessList": [],
-          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -1011,15 +986,10 @@ describe('behavior: keyAuthorization', () => {
               "value": 0n,
             },
           ],
-          "data": undefined,
-          "feePayerSignature": null,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "gas": 1000000n,
           "nonceKey": 0n,
           "type": "tempo",
-          "validAfter": null,
-          "validBefore": null,
-          "value": 0n,
         }
       `)
     }
@@ -1223,7 +1193,6 @@ describe('behavior: keyAuthorization', () => {
       expect(rest).toMatchInlineSnapshot(`
         {
           "accessList": [],
-          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -1231,15 +1200,10 @@ describe('behavior: keyAuthorization', () => {
               "value": 0n,
             },
           ],
-          "data": undefined,
-          "feePayerSignature": null,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "gas": 500000n,
           "nonceKey": 0n,
           "type": "tempo",
-          "validAfter": null,
-          "validBefore": null,
-          "value": 0n,
         }
       `)
     }
@@ -1445,7 +1409,6 @@ describe('behavior: keyAuthorization', () => {
       expect(rest).toMatchInlineSnapshot(`
         {
           "accessList": [],
-          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -1453,15 +1416,10 @@ describe('behavior: keyAuthorization', () => {
               "value": 0n,
             },
           ],
-          "data": undefined,
-          "feePayerSignature": null,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "gas": 500000n,
           "nonceKey": 0n,
           "type": "tempo",
-          "validAfter": null,
-          "validBefore": null,
-          "value": 0n,
         }
       `)
     }
@@ -3028,7 +2986,7 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
 
     const genesisConfig = MultisigConfig.from({
       // A fresh random salt yields a distinct account each run, exercising the
-      // salt-inclusive config-ID derivation against the node.
+      // salt-inclusive account derivation against the node.
       salt: Hex.random(32),
       threshold,
       owners: ownerKeys.map((key) => ({
@@ -3204,4 +3162,224 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
       }),
     ).rejects.toThrow()
   })
+
+  test('behavior: keychain access key (authorize via AccountKeychain + spend)', async () => {
+    const { account, genesisConfig, ownerKeys } = setup({
+      count: 2,
+      threshold: 2,
+    })
+
+    await fundAddress(client, { address: account })
+
+    // Fresh secp256k1 access key for the multisig account.
+    const access = (() => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const address = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey }),
+      )
+      return { address, privateKey } as const
+    })()
+
+    // Bootstrap the multisig (nonce 0).
+    const bootstrap = TxEnvelopeTempo.from({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      nonce: 0n,
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
+      signature: SignatureEnvelope.from({
+        genesisConfig,
+        init: true,
+        signatures: approve({
+          genesisConfig,
+          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
+          signers: ownerKeys,
+        }),
+      }),
+    })
+
+    const bootstrap_receipt = (await client
+      .request({
+        method: 'eth_sendRawTransactionSync',
+        params: [bootstrap_signed],
+      })
+      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+    expect(bootstrap_receipt.status).toBe('success')
+
+    // Authorize the access key (nonce 1): multisig transactions cannot carry
+    // a TIP-1049 `keyAuthorization`, so the multisig account calls the
+    // AccountKeychain precompile's `authorizeKey` directly.
+    const authorizeKey = AbiFunction.from(
+      'function authorizeKey(address keyId, uint8 signatureType, (uint64 expiry, bool enforceLimits, (address token, uint256 amount, uint64 period)[] limits, bool allowAnyCalls, (address target, (bytes4 selector, address[] recipients)[] selectorRules)[] allowedCalls) config)',
+    )
+
+    const authorize = TxEnvelopeTempo.from({
+      calls: [
+        {
+          to: '0xaaaaaaaa00000000000000000000000000000000',
+          data: AbiFunction.encodeData(authorizeKey, [
+            access.address,
+            0, // secp256k1
+            {
+              expiry: 18446744073709551615n, // u64 max (never expires)
+              enforceLimits: false,
+              limits: [],
+              allowAnyCalls: true,
+              allowedCalls: [],
+            },
+          ]),
+        },
+      ],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      nonce: 1n,
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const authorize_signed = TxEnvelopeTempo.serialize(authorize, {
+      signature: SignatureEnvelope.from({
+        genesisConfig,
+        signatures: approve({
+          genesisConfig,
+          payload: TxEnvelopeTempo.getSignPayload(authorize),
+          signers: ownerKeys,
+        }),
+      }),
+    })
+
+    const authorize_receipt = (await client
+      .request({
+        method: 'eth_sendRawTransactionSync',
+        params: [authorize_signed],
+      })
+      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+    expect(authorize_receipt.status).toBe('success')
+    expect(authorize_receipt.from).toBe(account)
+
+    // Spend with the access key (nonce 2): outer keychain signature with the
+    // multisig account as `userAddress` — no owner approvals involved.
+    const nonce = await getTransactionCount(client, {
+      address: account,
+      blockTag: 'pending',
+    })
+
+    const spend = TxEnvelopeTempo.from({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      nonce: BigInt(nonce),
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const spend_signature = Secp256k1.sign({
+      payload: TxEnvelopeTempo.getSignPayload(spend, { from: account }),
+      privateKey: access.privateKey,
+    })
+
+    const spend_signed = TxEnvelopeTempo.serialize(spend, {
+      signature: SignatureEnvelope.from({
+        userAddress: account,
+        inner: SignatureEnvelope.from(spend_signature),
+        type: 'keychain',
+      }),
+    })
+
+    const spend_receipt = (await client
+      .request({
+        method: 'eth_sendRawTransactionSync',
+        params: [spend_signed],
+      })
+      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+    expect(spend_receipt.status).toBe('success')
+    expect(spend_receipt.from).toBe(account)
+
+    {
+      const response = await client
+        .request({
+          method: 'eth_getTransactionByHash',
+          params: [spend_receipt.transactionHash],
+        })
+        .then((tx) => Transaction.fromRpc(tx as any))
+      if (!response) throw new Error()
+      expect(response.from).toBe(account)
+      expect(response.signature?.type).toBe('keychain')
+      expect(
+        (response.signature as SignatureEnvelope.Keychain | undefined)
+          ?.userAddress,
+      ).toBe(account)
+    }
+  })
+
+  test('behavior: rejects `keyAuthorization` on multisig transactions', async () => {
+    const { account, genesisConfig, ownerKeys } = setup({
+      count: 1,
+      threshold: 1,
+    })
+
+    await fundAddress(client, { address: account })
+
+    const access = (() => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const address = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey }),
+      )
+      return { address, privateKey } as const
+    })()
+
+    // TIP-1049 key authorizations are only valid on primitive/keychain
+    // transactions; multisig accounts must call the AccountKeychain
+    // precompile instead.
+    const keyAuth = KeyAuthorization.from({
+      address: access.address,
+      chainId: BigInt(chainId),
+      type: 'secp256k1',
+    })
+    const keyAuth_signed = KeyAuthorization.from(keyAuth, {
+      signature: SignatureEnvelope.from(
+        Secp256k1.sign({
+          payload: KeyAuthorization.getSignPayload(keyAuth),
+          privateKey: ownerKeys[0]!.privateKey,
+        }),
+      ),
+    })
+
+    const bootstrap = TxEnvelopeTempo.from({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      keyAuthorization: keyAuth_signed,
+      nonce: 0n,
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const serialized_signed = TxEnvelopeTempo.serialize(bootstrap, {
+      signature: SignatureEnvelope.from({
+        genesisConfig,
+        init: true,
+        signatures: approve({
+          genesisConfig,
+          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
+          signers: ownerKeys,
+        }),
+      }),
+    })
+
+    await expect(
+      client.request({
+        method: 'eth_sendRawTransactionSync',
+        params: [serialized_signed],
+      }),
+    ).rejects.toThrow()
+  })
 })

package/src/tempo/index.ts

@@ -57,7 +57,7 @@ export * as AuthorizationTempo from './AuthorizationTempo.js'
  *   payee: '0x2222222222222222222222222222222222222222',
  *   payer: '0x1111111111111111111111111111111111111111',
  *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
- *   token: 1n
+ *   token: '0x20c0000000000000000000000000000000000001'
  * })
  *
  * const channelId = Channel.computeId(channel, {
@@ -122,8 +122,8 @@ export * as KeyAuthorization from './KeyAuthorization.js'
 /**
  * Native multisig account utilities (TIP-1061).
  *
- * Derives stable multisig account addresses and permanent config IDs from a weighted
- * owner configuration, and computes the owner approval digest that owners sign.
+ * Derives stable multisig account addresses from a weighted owner
+ * configuration, and computes the owner approval digest that owners sign.
  *
  * [TIP-1061](https://tips.sh/1061)
  *
@@ -196,8 +196,9 @@ export * as Period from './Period.js'
  * import { PoolId } from 'ox/tempo'
  *
  * const poolId = PoolId.from({
- *   userToken: 1n,
- *   validatorToken: 2n
+ *   userToken: '0x20c0000000000000000000000000000000000001',
+ *   validatorToken:
+ *     '0x20c0000000000000000000000000000000000002'
  * })
  * ```
  *
@@ -292,27 +293,6 @@ export * as SignatureEnvelope from './SignatureEnvelope.js'
  * @category Reference
  */
 export * as Tick from './Tick.js'
-/**
- * TIP-20 token ID utilities for converting between token IDs and addresses.
- *
- * TIP-20 is Tempo's native token standard for stablecoins with deterministic addresses
- * derived from sequential token IDs. TIP-20 extends ERC-20 with payment features like
- * configurable fee tokens, transfer memos, and built-in role-based access control.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.from(1n)
- * const address = TokenId.toAddress(1n)
- * // '0x20c0000000000000000000000000000000000001'
- * ```
- *
- * @category Reference
- */
-export * as TokenId from './TokenId.js'
 /**
  * Token role utilities for serializing role identifiers to keccak256 hashes.
  *

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.0.0-beta.2'
+export const version = '1.0.0-beta.20'

package/src/zod/Abi.ts

@@ -0,0 +1,5 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiItem from './AbiItem.js'
+import * as z from 'zod/mini'
+
+export const Abi = z.readonly(z.array(z_AbiItem.AbiItem))

package/src/zod/AbiConstructor.ts

@@ -0,0 +1,24 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z from 'zod/mini'
+
+export const StateMutability = z.union([
+  z.literal('nonpayable'),
+  z.literal('payable'),
+])
+
+const Raw = z.object({
+  type: z.literal('constructor'),
+  inputs: z.readonly(z.array(z_AbiParameter.AbiParameter)),
+  payable: z.optional(z.boolean()),
+  stateMutability: z.optional(StateMutability),
+})
+
+export const AbiConstructor = z.pipe(
+  Raw,
+  z.transform((value) => ({
+    ...value,
+    stateMutability:
+      value.stateMutability ?? (value.payable ? 'payable' : 'nonpayable'),
+  })),
+)

package/src/zod/AbiError.ts

@@ -0,0 +1,9 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z from 'zod/mini'
+
+export const AbiError = z.object({
+  type: z.literal('error'),
+  inputs: z.readonly(z.array(z_AbiParameter.AbiParameter)),
+  name: z.string(),
+})

package/src/zod/AbiEvent.ts

@@ -0,0 +1,11 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z_Solidity from './Solidity.js'
+import * as z from 'zod/mini'
+
+export const AbiEvent = z.object({
+  type: z.literal('event'),
+  anonymous: z.optional(z.boolean()),
+  inputs: z.readonly(z.array(z_AbiParameter.AbiEventParameter)),
+  name: z_Solidity.Identifier,
+})

package/src/zod/AbiFallback.ts

@@ -0,0 +1,22 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z from 'zod/mini'
+
+export const StateMutability = z.union([
+  z.literal('nonpayable'),
+  z.literal('payable'),
+])
+
+const Raw = z.object({
+  type: z.literal('fallback'),
+  payable: z.optional(z.boolean()),
+  stateMutability: z.optional(StateMutability),
+})
+
+export const AbiFallback = z.pipe(
+  Raw,
+  z.transform((value) => ({
+    ...value,
+    stateMutability:
+      value.stateMutability ?? (value.payable ? 'payable' : 'nonpayable'),
+  })),
+)

package/src/zod/AbiFunction.ts

@@ -0,0 +1,32 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z_Solidity from './Solidity.js'
+import * as z from 'zod/mini'
+
+export const StateMutability = z.union([
+  z.literal('pure'),
+  z.literal('view'),
+  z.literal('nonpayable'),
+  z.literal('payable'),
+])
+
+const Raw = z.object({
+  type: z.literal('function'),
+  constant: z.optional(z.boolean()),
+  gas: z.optional(z.number()),
+  inputs: z.readonly(z.array(z_AbiParameter.AbiParameter)),
+  name: z_Solidity.Identifier,
+  outputs: z.readonly(z.array(z_AbiParameter.AbiParameter)),
+  payable: z.optional(z.boolean()),
+  stateMutability: z.optional(StateMutability),
+})
+
+export const AbiFunction = z.pipe(
+  Raw,
+  z.transform((value) => ({
+    ...value,
+    stateMutability:
+      value.stateMutability ??
+      (value.constant ? 'view' : value.payable ? 'payable' : 'nonpayable'),
+  })),
+)

package/src/zod/AbiItem.ts

@@ -0,0 +1,28 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiConstructor from './AbiConstructor.js'
+import * as z_AbiError from './AbiError.js'
+import * as z_AbiEvent from './AbiEvent.js'
+import * as z_AbiFallback from './AbiFallback.js'
+import * as z_AbiFunction from './AbiFunction.js'
+import * as z_AbiReceive from './AbiReceive.js'
+import * as z from 'zod/mini'
+
+export const Type = z.union([
+  z.literal('constructor'),
+  z.literal('event'),
+  z.literal('error'),
+  z.literal('fallback'),
+  z.literal('function'),
+  z.literal('receive'),
+])
+
+export const AbiItem = z.union([
+  z_AbiConstructor.AbiConstructor,
+  z_AbiError.AbiError,
+  z_AbiEvent.AbiEvent,
+  z_AbiFallback.AbiFallback,
+  z_AbiFunction.AbiFunction,
+  z_AbiReceive.AbiReceive,
+])
+
+export const AbiItemType = Type

package/src/zod/AbiParameter.ts

@@ -0,0 +1,36 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_Solidity from './Solidity.js'
+import * as z from 'zod/mini'
+
+const Name = z.union([z.optional(z_Solidity.Identifier), z.literal('')])
+const SimpleType = z.union([
+  z_Solidity.Address,
+  z_Solidity.Bool,
+  z_Solidity.Bytes,
+  z_Solidity.Function,
+  z_Solidity.String,
+  z_Solidity.Int,
+  z_Solidity.ArrayWithoutTuple,
+])
+const TupleType = z.union([z_Solidity.Tuple, z_Solidity.ArrayWithTuple])
+
+export const AbiParameter = z.intersection(
+  z.object({
+    name: Name,
+    internalType: z.optional(z.string()),
+  }),
+  z.union([
+    z.object({ type: SimpleType }),
+    z.object({
+      type: TupleType,
+      get components() {
+        return z.readonly(z.array(AbiParameter))
+      },
+    }),
+  ]),
+)
+
+export const AbiEventParameter = z.intersection(
+  AbiParameter,
+  z.object({ indexed: z.optional(z.boolean()) }),
+)

package/src/zod/AbiParameters.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z from 'zod/mini'
+
+export const AbiParameters = z.readonly(z.array(z_AbiParameter.AbiParameter))
+
+export const Parameter = z_AbiParameter.AbiParameter

package/src/zod/AbiReceive.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z from 'zod/mini'
+
+export const AbiReceive = z.object({
+  type: z.literal('receive'),
+  stateMutability: z.literal('payable'),
+})