ox 0.14.12 → 0.14.14

package/_types/tempo/RpcSchema.d.ts

@@ -0,0 +1,70 @@
+import type * as Block from '../core/Block.js';
+import type * as BlockOverrides from '../core/BlockOverrides.js';
+import type * as Hex from '../core/Hex.js';
+import type * as Log from '../core/Log.js';
+import type * as RpcSchema from '../core/RpcSchema.js';
+import type * as StateOverrides from '../core/StateOverrides.js';
+import type * as TransactionRequest from './TransactionRequest.js';
+/**
+ * Union of all JSON-RPC Methods for the `tempo_` namespace.
+ *
+ * @example
+ * ```ts twoslash
+ * import { RpcSchema } from 'ox/tempo'
+ *
+ * type Schema = RpcSchema.Tempo
+ * //   ^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ */
+export type Tempo = RpcSchema.From<{
+    Request: {
+        method: 'tempo_simulateV1';
+        params: [
+            {
+                blockStateCalls: readonly {
+                    blockOverrides?: BlockOverrides.Rpc | undefined;
+                    calls?: readonly TransactionRequest.Rpc[] | undefined;
+                    stateOverrides?: StateOverrides.Rpc | undefined;
+                }[];
+                returnFullTransactions?: boolean | undefined;
+                traceTransfers?: boolean | undefined;
+                validation?: boolean | undefined;
+            },
+            block: Block.Number<Hex.Hex> | Block.Tag | Block.Hash | Block.Identifier
+        ];
+    };
+    ReturnType: {
+        blocks: readonly (Block.Rpc & {
+            calls?: readonly {
+                error?: {
+                    data?: Hex.Hex | undefined;
+                    code: number;
+                    message: string;
+                } | undefined;
+                logs?: readonly Log.Rpc[] | undefined;
+                gasUsed: Hex.Hex;
+                returnData: Hex.Hex;
+                status: Hex.Hex;
+            }[] | undefined;
+        })[];
+        tokenMetadata: {
+            [address: Hex.Hex]: {
+                name: string;
+                symbol: string;
+                currency: string;
+            };
+        };
+    };
+}>;
+//# sourceMappingURL=RpcSchema.d.ts.map

package/_types/tempo/RpcSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcSchema.d.ts","sourceRoot":"","sources":["../../tempo/RpcSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,KAAK,cAAc,MAAM,2BAA2B,CAAA;AAChE,OAAO,KAAK,KAAK,GAAG,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,KAAK,GAAG,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,KAAK,SAAS,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,KAAK,cAAc,MAAM,2BAA2B,CAAA;AAChE,OAAO,KAAK,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAElE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC;IACjC,OAAO,EAAE;QACP,MAAM,EAAE,kBAAkB,CAAA;QAC1B,MAAM,EAAE;YACN;gBACE,eAAe,EAAE,SAAS;oBACxB,cAAc,CAAC,EAAE,cAAc,CAAC,GAAG,GAAG,SAAS,CAAA;oBAC/C,KAAK,CAAC,EAAE,SAAS,kBAAkB,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA;oBACrD,cAAc,CAAC,EAAE,cAAc,CAAC,GAAG,GAAG,SAAS,CAAA;iBAChD,EAAE,CAAA;gBACH,sBAAsB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;gBAC5C,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;gBACpC,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;aACjC;YACD,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,UAAU;SACzE,CAAA;KACF,CAAA;IACD,UAAU,EAAE;QACV,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG;YAC5B,KAAK,CAAC,EACF,SAAS;gBACP,KAAK,CAAC,EACF;oBACE,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,CAAA;oBAC1B,IAAI,EAAE,MAAM,CAAA;oBACZ,OAAO,EAAE,MAAM,CAAA;iBAChB,GACD,SAAS,CAAA;gBACb,IAAI,CAAC,EAAE,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA;gBACrC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAA;gBAChB,UAAU,EAAE,GAAG,CAAC,GAAG,CAAA;gBACnB,MAAM,EAAE,GAAG,CAAC,GAAG,CAAA;aAChB,EAAE,GACH,SAAS,CAAA;SACd,CAAC,EAAE,CAAA;QACJ,aAAa,EAAE;YACb,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,GAAG;gBAClB,IAAI,EAAE,MAAM,CAAA;gBACZ,MAAM,EAAE,MAAM,CAAA;gBACd,QAAQ,EAAE,MAAM,CAAA;aACjB,CAAA;SACF,CAAA;KACF,CAAA;CACF,CAAC,CAAA"}

package/_types/tempo/index.d.ts

@@ -123,6 +123,25 @@ export * as Period from './Period.js';
  * @category Reference
  */
 export * as PoolId from './PoolId.js';
+/**
+ * Union of all JSON-RPC Methods for the `tempo_` namespace.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Provider, RpcSchema } from 'ox'
+ * import { RpcSchema as TempoRpcSchema } from 'ox/tempo'
+ *
+ * const schema = RpcSchema.from<
+ *   | RpcSchema.Default
+ *   | TempoRpcSchema.Tempo
+ * >()
+ *
+ * const provider = Provider.from(window.ethereum!, { schema })
+ * ```
+ *
+ * @category Reference
+ */
+export * as RpcSchema from './RpcSchema.js';
 /**
  * Signature envelope utilities for secp256k1, P256, WebAuthn, and keychain signatures.
  *

package/_types/tempo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA"}

package/_types/version.d.ts

@@ -1,3 +1,3 @@
 /** @internal */
-export declare const version = "0.14.12";
+export declare const version = "0.14.14";
 //# sourceMappingURL=version.d.ts.map

package/core/RpcSchema.ts

@@ -271,3 +271,88 @@ export type Default = ResolvedRegister['RpcSchema']
 export type MethodNameGeneric<schema extends Generic = Generic> =
   | schema['Request']['method']
   | (string & {})
+
+/**
+ * Converts an Ox {@link ox#RpcSchema.Generic} (union of `{ Request, ReturnType }`) to
+ * a [Viem-compatible RPC schema](https://viem.sh) (tuple of `{ Method, Parameters, ReturnType }`).
+ *
+ * @example
+ * ```ts twoslash
+ * import { RpcSchema } from 'ox'
+ *
+ * type ViemSchema = RpcSchema.ToViem<
+ *   | {
+ *       Request: { method: 'eth_blockNumber'; params?: undefined }
+ *       ReturnType: `0x${string}`
+ *     }
+ *   | {
+ *       Request: { method: 'eth_chainId'; params?: undefined }
+ *       ReturnType: `0x${string}`
+ *     }
+ * >
+ * // ^? [{ Method: 'eth_blockNumber'; Parameters?: undefined; ReturnType: `0x${string}` }, ...]
+ * ```
+ */
+export type ToViem<schema extends Generic> = UnionToTuple<
+  schema extends schema
+    ? {
+        Method: schema['Request']['method']
+        Parameters: schema['Request']['params']
+        ReturnType: schema extends { ReturnType: infer r } ? r : unknown
+      }
+    : never
+>
+
+/**
+ * Converts a [Viem-compatible RPC schema](https://viem.sh) (tuple of `{ Method, Parameters, ReturnType }`)
+ * to an Ox {@link ox#RpcSchema.Generic} (union of `{ Request, ReturnType }`).
+ *
+ * @example
+ * ```ts twoslash
+ * import { RpcSchema } from 'ox'
+ *
+ * type OxSchema = RpcSchema.FromViem<[
+ *   { Method: 'eth_blockNumber'; Parameters?: undefined; ReturnType: `0x${string}` },
+ *   { Method: 'eth_chainId'; Parameters?: undefined; ReturnType: `0x${string}` },
+ * ]>
+ * // ^? { Request: { method: 'eth_blockNumber'; params?: undefined }; ReturnType: `0x${string}` } | ...
+ * ```
+ */
+export type FromViem<schema extends readonly ViemSchemaItem[]> = {
+  [k in keyof schema]: schema[k] extends ViemSchemaItem
+    ? {
+        Request: {
+          method: schema[k]['Method']
+          params: schema[k]['Parameters']
+        }
+        ReturnType: schema[k]['ReturnType']
+      }
+    : never
+}[number]
+
+/** @internal */
+type ViemSchemaItem = {
+  Method: string
+  Parameters?: unknown
+  ReturnType?: unknown
+}
+
+// --- Union-to-tuple helpers (order is not guaranteed, but stable) ---
+/** @internal */
+type UnionToIntersection<union> = (
+  union extends unknown
+    ? (arg: () => union) => void
+    : never
+) extends (arg: infer intersection) => void
+  ? intersection
+  : never
+
+/** @internal */
+type UnionLast<union> = UnionToIntersection<union> extends () => infer last
+  ? last
+  : never
+
+/** @internal */
+type UnionToTuple<union, last = UnionLast<union>> = [union] extends [never]
+  ? []
+  : [...UnionToTuple<Exclude<union, last>>, last]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.14.12",
+  "version": "0.14.14",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -519,6 +519,11 @@
       "import": "./_esm/tempo/PoolId.js",
       "default": "./_cjs/tempo/PoolId.js"
     },
+    "./tempo/RpcSchema": {
+      "types": "./_types/tempo/RpcSchema.d.ts",
+      "import": "./_esm/tempo/RpcSchema.js",
+      "default": "./_cjs/tempo/RpcSchema.js"
+    },
     "./tempo/SignatureEnvelope": {
       "types": "./_types/tempo/SignatureEnvelope.d.ts",
       "import": "./_esm/tempo/SignatureEnvelope.js",

package/tempo/KeyAuthorization.test.ts

@@ -1824,7 +1824,7 @@ describe('toTuple', () => {
       type: 'secp256k1',
       scopes: [
         {
-          contractAddress: '0x1234567890123456789012345678901234567890',
+          address: '0x1234567890123456789012345678901234567890',
         },
       ],
     })
@@ -1851,7 +1851,7 @@ describe('toTuple', () => {
     const serialized = KeyAuthorization.serialize(authorization)
     const restored = KeyAuthorization.deserialize(serialized)
     expect(restored.scopes).toHaveLength(1)
-    expect(restored.scopes?.[0]?.contractAddress).toBe(
+    expect(restored.scopes?.[0]?.address).toBe(
       '0x1234567890123456789012345678901234567890',
     )
     expect(restored.scopes?.[0]?.selector).toBeUndefined()
@@ -1864,11 +1864,11 @@ describe('toTuple', () => {
       type: 'secp256k1',
       scopes: [
         {
-          contractAddress: '0x1234567890123456789012345678901234567890',
+          address: '0x1234567890123456789012345678901234567890',
           selector: '0xa9059cbb', // transfer
         },
         {
-          contractAddress: '0x1234567890123456789012345678901234567890',
+          address: '0x1234567890123456789012345678901234567890',
           selector: '0x095ea7b3', // approve
         },
       ],
@@ -1889,7 +1889,7 @@ describe('toTuple', () => {
       type: 'secp256k1',
       scopes: [
         {
-          contractAddress: token,
+          address: token,
           selector: '0xa9059cbb',
           recipients: [
             '0x1111111111111111111111111111111111111111',
@@ -1952,7 +1952,7 @@ describe('toTuple', () => {
       ],
       scopes: [
         {
-          contractAddress: '0x1234567890123456789012345678901234567890',
+          address: '0x1234567890123456789012345678901234567890',
           selector: '0xa9059cbb',
           recipients: ['0x1111111111111111111111111111111111111111'],
         },
@@ -1975,7 +1975,7 @@ describe('toTuple', () => {
       type: 'secp256k1',
       scopes: [
         {
-          contractAddress: '0x1234567890123456789012345678901234567890',
+          address: '0x1234567890123456789012345678901234567890',
           selector: '0xa9059cbb',
         },
       ],
@@ -1992,7 +1992,7 @@ describe('toTuple', () => {
       type: 'secp256k1',
       scopes: [
         {
-          contractAddress: '0x1234567890123456789012345678901234567890',
+          address: '0x1234567890123456789012345678901234567890',
           selector: '0x095ea7b3',
         },
       ],
@@ -2000,6 +2000,101 @@ describe('toTuple', () => {
     expect(KeyAuthorization.hash(authorization2)).not.toBe(hash1)
   })
 
+  test('call scopes: selector from function signature string', () => {
+    const authorization = KeyAuthorization.from({
+      address,
+      chainId: 1n,
+      type: 'secp256k1',
+      scopes: [
+        {
+          address: '0x1234567890123456789012345678901234567890',
+          selector: 'function transfer(address,uint256)',
+        },
+        {
+          address: '0x1234567890123456789012345678901234567890',
+          selector: 'function approve(address,uint256)',
+        },
+      ],
+    })
+
+    const serialized = KeyAuthorization.serialize(authorization)
+    const restored = KeyAuthorization.deserialize(serialized)
+    expect(restored.scopes).toHaveLength(2)
+    // transfer(address,uint256) => 0xa9059cbb
+    expect(restored.scopes?.[0]?.selector).toBe('0xa9059cbb')
+    // approve(address,uint256) => 0x095ea7b3
+    expect(restored.scopes?.[1]?.selector).toBe('0x095ea7b3')
+  })
+
+  test('call scopes: selector from signature with recipients', () => {
+    const authorization = KeyAuthorization.from({
+      address,
+      chainId: 1n,
+      type: 'secp256k1',
+      scopes: [
+        {
+          address: token,
+          selector: 'function transfer(address,uint256)',
+          recipients: ['0x1111111111111111111111111111111111111111'],
+        },
+      ],
+    })
+
+    const serialized = KeyAuthorization.serialize(authorization)
+    const restored = KeyAuthorization.deserialize(serialized)
+    expect(restored.scopes?.[0]?.selector).toBe('0xa9059cbb')
+    expect(restored.scopes?.[0]?.recipients).toEqual([
+      '0x1111111111111111111111111111111111111111',
+    ])
+  })
+
+  test('call scopes: selector from bare signature (no function prefix)', () => {
+    const authorization = KeyAuthorization.from({
+      address,
+      chainId: 1n,
+      type: 'secp256k1',
+      scopes: [
+        {
+          address: '0x1234567890123456789012345678901234567890',
+          selector: 'transfer(address,uint256)',
+        },
+        {
+          address: '0x1234567890123456789012345678901234567890',
+          selector: 'approve(address,uint256)',
+        },
+      ],
+    })
+
+    const serialized = KeyAuthorization.serialize(authorization)
+    const restored = KeyAuthorization.deserialize(serialized)
+    expect(restored.scopes).toHaveLength(2)
+    expect(restored.scopes?.[0]?.selector).toBe('0xa9059cbb')
+    expect(restored.scopes?.[1]?.selector).toBe('0x095ea7b3')
+  })
+
+  test('call scopes: mixed hex and signature selectors', () => {
+    const authorization = KeyAuthorization.from({
+      address,
+      chainId: 1n,
+      type: 'secp256k1',
+      scopes: [
+        {
+          address: '0x1234567890123456789012345678901234567890',
+          selector: '0xa9059cbb',
+        },
+        {
+          address: '0x1234567890123456789012345678901234567890',
+          selector: 'function approve(address,uint256)',
+        },
+      ],
+    })
+
+    const serialized = KeyAuthorization.serialize(authorization)
+    const restored = KeyAuthorization.deserialize(serialized)
+    expect(restored.scopes?.[0]?.selector).toBe('0xa9059cbb')
+    expect(restored.scopes?.[1]?.selector).toBe('0x095ea7b3')
+  })
+
   test('toRpc/fromRpc roundtrip with period and scopes', () => {
     const authorization = KeyAuthorization.from(
       {
@@ -2016,7 +2111,7 @@ describe('toTuple', () => {
         ],
         scopes: [
           {
-            contractAddress: token,
+            address: token,
             selector: '0xa9059cbb',
             recipients: ['0x1111111111111111111111111111111111111111'],
           },
@@ -2031,7 +2126,7 @@ describe('toTuple', () => {
     const restored = KeyAuthorization.fromRpc(rpc)
 
     expect(restored.limits?.[0]?.period).toBe(2592000)
-    expect(restored.scopes?.[0]?.contractAddress).toBe(token)
+    expect(restored.scopes?.[0]?.address).toBe(token)
     expect(restored.scopes?.[0]?.selector).toBe('0xa9059cbb')
     expect(restored.scopes?.[0]?.recipients).toEqual([
       '0x1111111111111111111111111111111111111111',

package/tempo/KeyAuthorization.ts

@@ -1,3 +1,4 @@
+import * as AbiItem from '../core/AbiItem.js'
 import type * as Address from '../core/Address.js'
 import type * as Errors from '../core/Errors.js'
 import * as Hash from '../core/Hash.js'
@@ -153,21 +154,25 @@ export type Tuple<signed extends boolean = boolean> = signed extends true
 /**
  * Call scope entry restricting which contract, selector, and recipients an access key can use.
  *
- * Multiple entries with the same `contractAddress` are grouped by target on the wire.
+ * Multiple entries with the same `address` are grouped by target on the wire.
  *
- * - `{ contractAddress }` = any selector on this contract
- * - `{ contractAddress, selector }` = specific selector
- * - `{ contractAddress, selector, recipients }` = selector + recipient constraint
+ * - `{ address }` = any selector on this contract
+ * - `{ address, selector }` = specific selector
+ * - `{ address, selector, recipients }` = selector + recipient constraint
  *
  * [TIP-1011 Specification](https://docs.tempo.xyz/protocol/transactions/tip-1011)
  */
 export type Scope<addressType = Address.Address> = {
   /** Target contract address. */
-  contractAddress: addressType
+  address: addressType
   /**
-   * 4-byte function selector. Omit to allow any selector on this contract.
+   * 4-byte function selector, or a human-readable ABI signature
+   * (e.g. `'transfer(address,uint256)'` or `'function transfer(address,uint256)'`).
+   *
+   * Signatures are encoded into a 4-byte selector automatically.
+   * Omit to allow any selector on this contract.
    */
-  selector?: Hex.Hex | undefined
+  selector?: Hex.Hex | string | undefined
   /**
    * Recipient allowlist for this selector (first ABI `address` argument).
    *
@@ -352,8 +357,8 @@ export function from<
   const auth = authorization as KeyAuthorization & {
     limits?: readonly { token: TempoAddress.Address; limit: bigint }[]
     scopes?: readonly {
-      contractAddress: TempoAddress.Address
-      selector?: Hex.Hex
+      address: TempoAddress.Address
+      selector?: Hex.Hex | string
       recipients?: readonly TempoAddress.Address[]
     }[]
   }
@@ -372,7 +377,8 @@ export function from<
       ? {
           scopes: auth.scopes.map((scope) => ({
             ...scope,
-            contractAddress: TempoAddress.resolve(scope.contractAddress),
+            address: TempoAddress.resolve(scope.address),
+            selector: resolveSelector(scope.selector),
             ...(scope.recipients
               ? {
                   recipients: scope.recipients.map((r) =>
@@ -455,10 +461,10 @@ export function fromRpc(authorization: Rpc): Signed {
   const scopes = allowedCalls
     ? allowedCalls.flatMap((callScope) => {
         if (!callScope.selectorRules || callScope.selectorRules.length === 0)
-          return [{ contractAddress: callScope.target }] as Scope[]
+          return [{ address: callScope.target }] as Scope[]
         return callScope.selectorRules.map(
           (rule): Scope => ({
-            contractAddress: callScope.target,
+            address: callScope.target,
             selector: normalizeSelector(rule.selector),
             ...(rule.recipients && rule.recipients.length > 0
               ? { recipients: rule.recipients }
@@ -576,15 +582,15 @@ export function fromTuple<const tuple extends Tuple>(
     ...(typeof scopes !== 'undefined' && Array.isArray(scopes)
       ? {
           scopes: scopes.flatMap((scopeTuple: any) => {
-            const [contractAddress, selectorRules] = scopeTuple
+            const [address, selectorRules] = scopeTuple
             // If no selector rules, this is an address-only scope
             if (!Array.isArray(selectorRules) || selectorRules.length === 0)
-              return [{ contractAddress }]
+              return [{ address }]
             // Flatten each selector rule into a separate scope entry
             return selectorRules.map((ruleTuple: any) => {
               const [selector, recipients] = ruleTuple
               return {
-                contractAddress,
+                address,
                 selector,
                 ...(Array.isArray(recipients) && recipients.length > 0
                   ? { recipients }
@@ -800,16 +806,16 @@ export function toRpc(authorization: Signed): Rpc {
   const { address, scopes, chainId, expiry, limits, type, signature } =
     authorization
 
-  // Group flat scopes by contractAddress into nested allowedCalls wire format
+  // Group flat scopes by address into nested allowedCalls wire format
   const allowedCalls = (() => {
     if (!scopes) return undefined
     const grouped = new Map<string, RpcSelectorRule[]>()
     for (const scope of scopes) {
-      const key = scope.contractAddress as string
+      const key = scope.address as string
       if (!grouped.has(key)) grouped.set(key, [])
       if (scope.selector) {
         grouped.get(key)!.push({
-          selector: scope.selector,
+          selector: resolveSelector(scope.selector)!,
           ...(scope.recipients && scope.recipients.length > 0
             ? { recipients: scope.recipients }
             : {}),
@@ -899,7 +905,7 @@ export function toTuple<const authorization extends KeyAuthorization>(
     if (limit.period && limit.period > 0) tuple.push(numberToHex(limit.period))
     return tuple
   })
-  // Group flat scopes by contractAddress for wire format
+  // Group flat scopes by address for wire format
   const callsValue = (() => {
     if (!scopes) return undefined
     const grouped = new Map<
@@ -907,20 +913,20 @@ export function toTuple<const authorization extends KeyAuthorization>(
       [Hex.Hex, (readonly Address.Address[])[]][]
     >()
     for (const scope of scopes) {
-      const key = scope.contractAddress as string
+      const key = scope.address as string
       if (!grouped.has(key)) grouped.set(key, [])
       if (scope.selector) {
         grouped
           .get(key)!
           .push([
-            scope.selector,
+            resolveSelector(scope.selector)!,
             (scope.recipients ??
               []) as unknown as (readonly Address.Address[])[],
           ])
       }
     }
-    return [...grouped.entries()].map(([contractAddress, selectorRules]) => [
-      contractAddress,
+    return [...grouped.entries()].map(([address, selectorRules]) => [
+      address,
       selectorRules.map(([selector, recipients]) => [selector, recipients]),
     ])
   })()
@@ -971,3 +977,11 @@ function normalizeSelector(selector: Hex.Hex | number[]): Hex.Hex {
     return Hex.fromBytes(new Uint8Array(selector)) as Hex.Hex
   return selector
 }
+
+function resolveSelector(
+  selector: Hex.Hex | string | undefined,
+): Hex.Hex | undefined {
+  if (!selector) return undefined
+  if (selector.startsWith('0x')) return selector as Hex.Hex
+  return AbiItem.getSelector(selector)
+}

package/tempo/RpcSchema/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/RpcSchema.d.ts",
+  "main": "../../_cjs/tempo/RpcSchema.js",
+  "module": "../../_esm/tempo/RpcSchema.js"
+}

package/tempo/RpcSchema.ts

@@ -0,0 +1,74 @@
+import type * as Block from '../core/Block.js'
+import type * as BlockOverrides from '../core/BlockOverrides.js'
+import type * as Hex from '../core/Hex.js'
+import type * as Log from '../core/Log.js'
+import type * as RpcSchema from '../core/RpcSchema.js'
+import type * as StateOverrides from '../core/StateOverrides.js'
+import type * as TransactionRequest from './TransactionRequest.js'
+
+/**
+ * Union of all JSON-RPC Methods for the `tempo_` namespace.
+ *
+ * @example
+ * ```ts twoslash
+ * import { RpcSchema } from 'ox/tempo'
+ *
+ * type Schema = RpcSchema.Tempo
+ * //   ^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ */
+export type Tempo = RpcSchema.From<{
+  Request: {
+    method: 'tempo_simulateV1'
+    params: [
+      {
+        blockStateCalls: readonly {
+          blockOverrides?: BlockOverrides.Rpc | undefined
+          calls?: readonly TransactionRequest.Rpc[] | undefined
+          stateOverrides?: StateOverrides.Rpc | undefined
+        }[]
+        returnFullTransactions?: boolean | undefined
+        traceTransfers?: boolean | undefined
+        validation?: boolean | undefined
+      },
+      block: Block.Number<Hex.Hex> | Block.Tag | Block.Hash | Block.Identifier,
+    ]
+  }
+  ReturnType: {
+    blocks: readonly (Block.Rpc & {
+      calls?:
+        | readonly {
+            error?:
+              | {
+                  data?: Hex.Hex | undefined
+                  code: number
+                  message: string
+                }
+              | undefined
+            logs?: readonly Log.Rpc[] | undefined
+            gasUsed: Hex.Hex
+            returnData: Hex.Hex
+            status: Hex.Hex
+          }[]
+        | undefined
+    })[]
+    tokenMetadata: {
+      [address: Hex.Hex]: {
+        name: string
+        symbol: string
+        currency: string
+      }
+    }
+  }
+}>