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

package/src/zod/tempo/_test/TransactionRequest.test.ts

@@ -44,6 +44,50 @@ describe('TransactionRequest', () => {
     )
   })
 
+  test('gas-model hints and capabilities round-trip', () => {
+    const hints = {
+      capabilities: { balanceDiffs: true },
+      keyData: '0x0578',
+      keyId: '0xcccccccccccccccccccccccccccccccccccccccc',
+      keyType: 'webAuthn',
+      multisigInit: {
+        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        threshold: 2,
+        owners: [
+          {
+            owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+            weight: 1,
+          },
+          {
+            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+            weight: 1,
+          },
+        ],
+      },
+      multisigSignatureCount: 2,
+    } as const
+
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, {
+      ...rpc,
+      ...hints,
+    })
+    expect(decoded).toMatchObject(hints)
+
+    const encoded = z.encode(z_TransactionRequest.TransactionRequest, decoded)
+    expect(encoded).toMatchObject(hints)
+    expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
+  })
+
+  test('feeToken is withheld until the fee payer signs (TIP-76)', () => {
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, rpc)
+    const pending = z.encode(z_TransactionRequest.TransactionRequest, {
+      ...decoded,
+      feePayer: true,
+    })
+    expect(pending.feeToken).toBeUndefined()
+    expect(pending.feePayer).toBe(true)
+  })
+
   test('rejects an invalid request', () => {
     expect(
       z.safeDecode(z_TransactionRequest.TransactionRequest, {
@@ -52,3 +96,32 @@ describe('TransactionRequest', () => {
     ).toBe(false)
   })
 })
+
+describe('TransactionRequestToRpc', () => {
+  test('accepts numberish encode inputs', () => {
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, rpc)
+    const strict = z.encode(z_TransactionRequest.TransactionRequest, decoded)
+
+    // numberish: bigint quantities as `number`/hex, calls value as `number`
+    expect(
+      z.encode(z_TransactionRequest.TransactionRequestToRpc, {
+        ...decoded,
+        maxFeePerGas: 2,
+        calls: [
+          {
+            data: '0xdeadbeef',
+            to: '0xcafebabecafebabecafebabecafebabecafebabe',
+            value: 700000000000000000n,
+          },
+        ],
+      }),
+    ).toEqual(strict)
+
+    expect(
+      z.encode(z_TransactionRequest.TransactionRequestToRpc, {
+        ...decoded,
+        maxFeePerGas: '0x2',
+      }),
+    ).toEqual(strict)
+  })
+})

package/src/zod/tempo/z.ts

@@ -6,7 +6,6 @@ export * as PoolId from './PoolId.js'
 export * as RpcSchemaTempo from './RpcSchemaTempo.js'
 export * as SignatureEnvelope from './SignatureEnvelope.js'
 export * as Tick from './Tick.js'
-export * as TokenId from './TokenId.js'
 export * as TokenRole from './TokenRole.js'
 export * as Transaction from './Transaction.js'
 export * as TransactionReceipt from './TransactionReceipt.js'

package/src/zod/z.ts

@@ -1,5 +1,15 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 export * from 'zod/mini'
+export * as Abi from './Abi.js'
+export * as AbiConstructor from './AbiConstructor.js'
+export * as AbiError from './AbiError.js'
+export * as AbiEvent from './AbiEvent.js'
+export * as AbiFallback from './AbiFallback.js'
+export * as AbiFunction from './AbiFunction.js'
+export * as AbiItem from './AbiItem.js'
+export * as AbiParameter from './AbiParameter.js'
+export * as AbiParameters from './AbiParameters.js'
+export * as AbiReceive from './AbiReceive.js'
 export * as AccountProof from './AccountProof.js'
 export * as AccessList from './AccessList.js'
 export * as Address from './Address.js'
@@ -15,11 +25,13 @@ export * as Log from './Log.js'
 export * as RpcResponse from './RpcResponse.js'
 export * as RpcSchema from './RpcSchema.js'
 export * as Signature from './Signature.js'
+export * as Solidity from './Solidity.js'
 export * as StateOverrides from './StateOverrides.js'
 export * as Transaction from './Transaction.js'
 export * as TransactionEnvelope from './TransactionEnvelope.js'
 export * as TransactionReceipt from './TransactionReceipt.js'
 export * as TransactionRequest from './TransactionRequest.js'
+export * as TypedData from './TypedData.js'
 export * as TxEnvelopeEip1559 from './TxEnvelopeEip1559.js'
 export * as TxEnvelopeEip2930 from './TxEnvelopeEip2930.js'
 export * as TxEnvelopeEip4844 from './TxEnvelopeEip4844.js'
@@ -27,7 +39,7 @@ export * as TxEnvelopeEip7702 from './TxEnvelopeEip7702.js'
 export * as TxEnvelopeLegacy from './TxEnvelopeLegacy.js'
 export * as Withdrawal from './Withdrawal.js'
 export * as tempo from './tempo/z.js'
-export { BigInt } from './BigInt.js'
+export { BigInt, BigIntToRpc } from './BigInt.js'
 export {
   Int,
   Int8,
@@ -63,9 +75,11 @@ export {
   Int248,
   Int256,
 } from './Int.js'
-export { Number } from './Number.js'
+export { Number, NumberToRpc } from './Number.js'
 export {
   Uint,
+  UintToRpc,
+  Uint8ToRpc,
   Uint8,
   Uint16,
   Uint24,

package/dist/tempo/TokenId.d.ts

@@ -1,87 +0,0 @@
-import * as Address from '../core/Address.js';
-import * as Hex from '../core/Hex.js';
-export type TokenId = bigint;
-export type TokenIdOrAddress = TokenId | Address.Address;
-/**
- * Converts a token ID or address to a token ID.
- *
- * TIP-20 is Tempo's native token standard for stablecoins with deterministic addresses
- * derived from sequential token IDs (prefix `0x20c0`).
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.from(1n)
- * ```
- *
- * @param tokenIdOrAddress - The token ID or address.
- * @returns The token ID.
- */
-export declare function from(tokenIdOrAddress: TokenIdOrAddress | number): TokenId;
-/**
- * Converts a TIP-20 token address to a token ID.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.fromAddress(
- *   '0x20c0000000000000000000000000000000000001'
- * )
- * ```
- *
- * @param address - The token address.
- * @returns The token ID.
- */
-export declare function fromAddress(address: Address.Address): TokenId;
-/**
- * Converts a TIP-20 token ID to an address.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const address = TokenId.toAddress(1n)
- * ```
- *
- * @param tokenId - The token ID.
- * @returns The address.
- */
-export declare function toAddress(tokenId: TokenIdOrAddress): Address.Address;
-/**
- * Computes a deterministic TIP-20 token address from a sender address and salt.
- *
- * The address is computed as: `TIP20_PREFIX (12 bytes) || keccak256(abi.encode(sender, salt))[:8]`
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const id = TokenId.compute({
- *   sender: '0x1234567890123456789012345678901234567890',
- *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001'
- * })
- * ```
- *
- * @param value - The sender address and salt.
- * @returns The computed TIP-20 token id.
- */
-export declare function compute(value: compute.Value): bigint;
-export declare namespace compute {
-    type Value = {
-        /** The salt (32 bytes). */
-        salt: Hex.Hex;
-        /** The sender address. */
-        sender: Address.Address;
-    };
-}
-//# sourceMappingURL=TokenId.d.ts.map

package/dist/tempo/TokenId.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TokenId.d.ts","sourceRoot":"","sources":["../../src/tempo/TokenId.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAE7C,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAA;AAIrC,MAAM,MAAM,OAAO,GAAG,MAAM,CAAA;AAC5B,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAA;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,MAAM,GAAG,OAAO,CAOzE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,OAAO,CAiB7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAQpE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,GAAG,MAAM,CAapD;AAED,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,KAAY,KAAK,GAAG;QAClB,2BAA2B;QAC3B,IAAI,EAAE,GAAG,CAAC,GAAG,CAAA;QACb,0BAA0B;QAC1B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAA;KACxB,CAAA;CACF"}

package/dist/tempo/TokenId.js

@@ -1,123 +0,0 @@
-import { keccak_256 } from '@noble/hashes/sha3.js';
-import * as Address from '../core/Address.js';
-import * as Bytes from '../core/Bytes.js';
-import * as Hex from '../core/Hex.js';
-const tip20Prefix = '0x20c0';
-/**
- * Converts a token ID or address to a token ID.
- *
- * TIP-20 is Tempo's native token standard for stablecoins with deterministic addresses
- * derived from sequential token IDs (prefix `0x20c0`).
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.from(1n)
- * ```
- *
- * @param tokenIdOrAddress - The token ID or address.
- * @returns The token ID.
- */
-export function from(tokenIdOrAddress) {
-    if (typeof tokenIdOrAddress === 'bigint' ||
-        typeof tokenIdOrAddress === 'number')
-        return BigInt(tokenIdOrAddress);
-    return fromAddress(tokenIdOrAddress);
-}
-/**
- * Converts a TIP-20 token address to a token ID.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.fromAddress(
- *   '0x20c0000000000000000000000000000000000001'
- * )
- * ```
- *
- * @param address - The token address.
- * @returns The token ID.
- */
-export function fromAddress(address) {
-    const resolved = address;
-    // The TIP-20 prefix check is case-insensitive, but most inputs are already
-    // lowercase, so peek the prefix bytes before falling back to a full
-    // `.toLowerCase()`.
-    const c2 = resolved.charCodeAt(2);
-    const c3 = resolved.charCodeAt(3);
-    const c4 = resolved.charCodeAt(4);
-    const c5 = resolved.charCodeAt(5);
-    const isPrefix = c2 === 50 /* '2' */ &&
-        c3 === 48 /* '0' */ &&
-        (c4 === 99 || c4 === 67) /* 'c' or 'C' */ &&
-        c5 === 48; /* '0' */
-    if (!isPrefix)
-        throw new Error('invalid tip20 address.');
-    // The trailing 36 hex characters encode the token id big-endian.
-    return BigInt(`0x${resolved.slice(tip20Prefix.length)}`);
-}
-/**
- * Converts a TIP-20 token ID to an address.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const address = TokenId.toAddress(1n)
- * ```
- *
- * @param tokenId - The token ID.
- * @returns The address.
- */
-export function toAddress(tokenId) {
-    if (typeof tokenId === 'string') {
-        Address.assert(tokenId);
-        return tokenId;
-    }
-    const tokenIdHex = Hex.fromNumber(tokenId, { size: 18 });
-    return Hex.concat(tip20Prefix, tokenIdHex);
-}
-/**
- * Computes a deterministic TIP-20 token address from a sender address and salt.
- *
- * The address is computed as: `TIP20_PREFIX (12 bytes) || keccak256(abi.encode(sender, salt))[:8]`
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const id = TokenId.compute({
- *   sender: '0x1234567890123456789012345678901234567890',
- *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001'
- * })
- * ```
- *
- * @param value - The sender address and salt.
- * @returns The computed TIP-20 token id.
- */
-export function compute(value) {
-    // ABI encoding of (address, bytes32) is the 32-byte left-padded address
-    // followed by the 32-byte salt. Build that 64-byte buffer directly and hash
-    // it, instead of round-tripping through `AbiParameters.encode`.
-    const buffer = new Uint8Array(64);
-    const addressBytes = Bytes.fromHex(value.sender);
-    buffer.set(addressBytes, 12);
-    buffer.set(Bytes.fromHex(value.salt, { size: 32 }), 32);
-    const hash = keccak_256(buffer);
-    // First 8 bytes of the digest, big-endian.
-    let id = 0n;
-    for (let i = 0; i < 8; i++)
-        id = (id << 8n) | BigInt(hash[i]);
-    return id;
-}
-//# sourceMappingURL=TokenId.js.map

package/dist/tempo/TokenId.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TokenId.js","sourceRoot":"","sources":["../../src/tempo/TokenId.ts"],"names":[],"mappings":"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"}

package/dist/zod/tempo/TokenId.d.ts

@@ -1,6 +0,0 @@
-import * as z from 'zod/mini';
-/** TIP-20 token id schema (non-negative bigint). */
-export declare const TokenId: z.ZodMiniBigInt<bigint>;
-/** Codec decoding a TIP-20 token address into a token id. */
-export declare const address: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniBigInt<bigint>>;
-//# sourceMappingURL=TokenId.d.ts.map

package/dist/zod/tempo/TokenId.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TokenId.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/TokenId.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,oDAAoD;AACpD,eAAO,MAAM,OAAO,yBAE2C,CAAA;AAE/D,6DAA6D;AAC7D,eAAO,MAAM,OAAO,kFAGlB,CAAA"}

package/dist/zod/tempo/TokenId.js

@@ -1,14 +0,0 @@
-/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
-import * as core_TokenId from '../../tempo/TokenId.js';
-import * as z_Address from '../Address.js';
-import * as z from 'zod/mini';
-/** TIP-20 token id schema (non-negative bigint). */
-export const TokenId = z
-    .bigint()
-    .check(z.refine((value) => value >= 0n, 'expected token id'));
-/** Codec decoding a TIP-20 token address into a token id. */
-export const address = z.codec(z_Address.Address, TokenId, {
-    decode: (value) => core_TokenId.fromAddress(value),
-    encode: (value) => core_TokenId.toAddress(value),
-});
-//# sourceMappingURL=TokenId.js.map

package/dist/zod/tempo/TokenId.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TokenId.js","sourceRoot":"","sources":["../../../src/zod/tempo/TokenId.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,OAAO,KAAK,YAAY,MAAM,wBAAwB,CAAA;AACtD,OAAO,KAAK,SAAS,MAAM,eAAe,CAAA;AAC1C,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,oDAAoD;AACpD,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC;KACrB,MAAM,EAAE;KACR,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,IAAI,EAAE,EAAE,mBAAmB,CAAC,CAAC,CAAA;AAE/D,6DAA6D;AAC7D,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE;IACzD,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC;IAClD,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC;CACjD,CAAC,CAAA"}

package/src/tempo/TokenId.bench.ts

@@ -1,36 +0,0 @@
-import { bench, describe } from 'vp/test'
-import * as TokenId from './TokenId.js'
-
-const sender = '0x1234567890123456789012345678901234567890' as const
-const salt =
-  '0x0000000000000000000000000000000000000000000000000000000000000001' as const
-
-const tokenIdAddress = '0x20c0000000000000000000000000000000000001' as const
-const tokenIdBigInt = 1n
-const tokenIdLargeBigInt = 0xdeadbeefcafebabe1234n
-
-describe('TokenId.compute', () => {
-  bench('hex sender', () => {
-    TokenId.compute({ sender, salt })
-  })
-})
-
-describe('TokenId.fromAddress', () => {
-  bench('hex address', () => {
-    TokenId.fromAddress(tokenIdAddress)
-  })
-})
-
-describe('TokenId.toAddress', () => {
-  bench('small bigint', () => {
-    TokenId.toAddress(tokenIdBigInt)
-  })
-
-  bench('large bigint', () => {
-    TokenId.toAddress(tokenIdLargeBigInt)
-  })
-
-  bench('hex address passthrough', () => {
-    TokenId.toAddress(tokenIdAddress)
-  })
-})

package/src/tempo/TokenId.test.ts

@@ -1,79 +0,0 @@
-import { Hex } from 'ox'
-import { TokenId } from 'ox/tempo'
-import { expect, test } from 'vp/test'
-
-test('from', () => {
-  expect(TokenId.from(0n)).toBe(0n)
-  expect(TokenId.from(0x1)).toBe(1n)
-  expect(TokenId.from(0xdef)).toBe(0xdefn)
-  expect(TokenId.from('0x20c0000000000000000000000000000000000000')).toBe(0n)
-  expect(TokenId.from('0x20c0000000000000000000000000000000000001')).toBe(1n)
-  expect(TokenId.from('0x20c0000000000000000000000000000000000def')).toBe(
-    0xdefn,
-  )
-})
-
-test('fromAddress', () => {
-  expect(
-    TokenId.fromAddress('0x20c0000000000000000000000000000000000000'),
-  ).toBe(0n)
-  expect(
-    TokenId.fromAddress('0x20c0000000000000000000000000000000000001'),
-  ).toBe(1n)
-  expect(
-    TokenId.fromAddress('0x20c0000000000000000000000000000000000def'),
-  ).toBe(0xdefn)
-})
-
-test('toAddress', () => {
-  expect(TokenId.toAddress(0n)).toBe(
-    '0x20c0000000000000000000000000000000000000',
-  )
-  expect(TokenId.toAddress('0x20c0000000000000000000000000000000000000')).toBe(
-    '0x20c0000000000000000000000000000000000000',
-  )
-  expect(TokenId.toAddress(1n)).toBe(
-    '0x20c0000000000000000000000000000000000001',
-  )
-  expect(TokenId.toAddress(0xdefn)).toBe(
-    '0x20c0000000000000000000000000000000000def',
-  )
-})
-
-test('compute', () => {
-  const sender = '0x1234567890123456789012345678901234567890'
-  const salt1 =
-    '0x0000000000000000000000000000000000000000000000000000000000000001'
-  const salt2 =
-    '0x0000000000000000000000000000000000000000000000000000000000000002'
-
-  const id1 = TokenId.compute({ sender, salt: salt1 })
-  const id2 = TokenId.compute({ sender, salt: salt2 })
-  const address1 = TokenId.toAddress(id1)
-  const address2 = TokenId.toAddress(id2)
-
-  // deterministic: same inputs produce same output
-  expect(TokenId.compute({ sender, salt: salt1 })).toBe(id1)
-
-  // different salts produce different addresses
-  expect(address1).not.toBe(address2)
-
-  // address suffix matches id
-  expect(Hex.slice(address1, 12)).toBe(Hex.fromNumber(id1, { size: 8 }))
-
-  // addresses have TIP-20 prefix (0x20c0 followed by zeroes for 12 bytes total)
-  expect(address1.toLowerCase().startsWith('0x20c000000000000000000000')).toBe(
-    true,
-  )
-  expect(address2.toLowerCase().startsWith('0x20c000000000000000000000')).toBe(
-    true,
-  )
-
-  // addresses are 20 bytes (40 hex chars + 0x prefix)
-  expect(address1.length).toBe(42)
-
-  // different senders produce different addresses
-  const otherSender = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd'
-  const address3 = TokenId.compute({ sender: otherSender, salt: salt1 })
-  expect(address3).not.toBe(address1)
-})

package/src/tempo/TokenId.ts

@@ -1,141 +0,0 @@
-import { keccak_256 } from '@noble/hashes/sha3.js'
-import * as Address from '../core/Address.js'
-import * as Bytes from '../core/Bytes.js'
-import * as Hex from '../core/Hex.js'
-
-const tip20Prefix = '0x20c0'
-
-export type TokenId = bigint
-export type TokenIdOrAddress = TokenId | Address.Address
-
-/**
- * Converts a token ID or address to a token ID.
- *
- * TIP-20 is Tempo's native token standard for stablecoins with deterministic addresses
- * derived from sequential token IDs (prefix `0x20c0`).
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.from(1n)
- * ```
- *
- * @param tokenIdOrAddress - The token ID or address.
- * @returns The token ID.
- */
-export function from(tokenIdOrAddress: TokenIdOrAddress | number): TokenId {
-  if (
-    typeof tokenIdOrAddress === 'bigint' ||
-    typeof tokenIdOrAddress === 'number'
-  )
-    return BigInt(tokenIdOrAddress)
-  return fromAddress(tokenIdOrAddress)
-}
-
-/**
- * Converts a TIP-20 token address to a token ID.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.fromAddress(
- *   '0x20c0000000000000000000000000000000000001'
- * )
- * ```
- *
- * @param address - The token address.
- * @returns The token ID.
- */
-export function fromAddress(address: Address.Address): TokenId {
-  const resolved = address
-  // The TIP-20 prefix check is case-insensitive, but most inputs are already
-  // lowercase, so peek the prefix bytes before falling back to a full
-  // `.toLowerCase()`.
-  const c2 = resolved.charCodeAt(2)
-  const c3 = resolved.charCodeAt(3)
-  const c4 = resolved.charCodeAt(4)
-  const c5 = resolved.charCodeAt(5)
-  const isPrefix =
-    c2 === 50 /* '2' */ &&
-    c3 === 48 /* '0' */ &&
-    (c4 === 99 || c4 === 67) /* 'c' or 'C' */ &&
-    c5 === 48 /* '0' */
-  if (!isPrefix) throw new Error('invalid tip20 address.')
-  // The trailing 36 hex characters encode the token id big-endian.
-  return BigInt(`0x${resolved.slice(tip20Prefix.length)}`)
-}
-
-/**
- * Converts a TIP-20 token ID to an address.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const address = TokenId.toAddress(1n)
- * ```
- *
- * @param tokenId - The token ID.
- * @returns The address.
- */
-export function toAddress(tokenId: TokenIdOrAddress): Address.Address {
-  if (typeof tokenId === 'string') {
-    Address.assert(tokenId)
-    return tokenId
-  }
-
-  const tokenIdHex = Hex.fromNumber(tokenId, { size: 18 })
-  return Hex.concat(tip20Prefix, tokenIdHex)
-}
-
-/**
- * Computes a deterministic TIP-20 token address from a sender address and salt.
- *
- * The address is computed as: `TIP20_PREFIX (12 bytes) || keccak256(abi.encode(sender, salt))[:8]`
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const id = TokenId.compute({
- *   sender: '0x1234567890123456789012345678901234567890',
- *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001'
- * })
- * ```
- *
- * @param value - The sender address and salt.
- * @returns The computed TIP-20 token id.
- */
-export function compute(value: compute.Value): bigint {
-  // ABI encoding of (address, bytes32) is the 32-byte left-padded address
-  // followed by the 32-byte salt. Build that 64-byte buffer directly and hash
-  // it, instead of round-tripping through `AbiParameters.encode`.
-  const buffer = new Uint8Array(64)
-  const addressBytes = Bytes.fromHex(value.sender)
-  buffer.set(addressBytes, 12)
-  buffer.set(Bytes.fromHex(value.salt, { size: 32 }), 32)
-  const hash = keccak_256(buffer)
-  // First 8 bytes of the digest, big-endian.
-  let id = 0n
-  for (let i = 0; i < 8; i++) id = (id << 8n) | BigInt(hash[i]!)
-  return id
-}
-
-export declare namespace compute {
-  export type Value = {
-    /** The salt (32 bytes). */
-    salt: Hex.Hex
-    /** The sender address. */
-    sender: Address.Address
-  }
-}

package/src/zod/tempo/TokenId.ts

@@ -1,15 +0,0 @@
-/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
-import * as core_TokenId from '../../tempo/TokenId.js'
-import * as z_Address from '../Address.js'
-import * as z from 'zod/mini'
-
-/** TIP-20 token id schema (non-negative bigint). */
-export const TokenId = z
-  .bigint()
-  .check(z.refine((value) => value >= 0n, 'expected token id'))
-
-/** Codec decoding a TIP-20 token address into a token id. */
-export const address = z.codec(z_Address.Address, TokenId, {
-  decode: (value) => core_TokenId.fromAddress(value),
-  encode: (value) => core_TokenId.toAddress(value),
-})