ox 1.0.0-beta.13 → 1.0.0-beta.15

package/src/zod/tempo/TransactionRequest.ts

@@ -14,7 +14,6 @@ import * as z from 'zod/mini'
 import * as z_AuthorizationTempo from './AuthorizationTempo.js'
 import * as z_KeyAuthorization from './KeyAuthorization.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
-import * as z_TokenId from './TokenId.js'
 
 const fromRpcType = { '0x76': 'tempo' } as const
 const toRpcType = { tempo: '0x76' } as const
@@ -57,6 +56,16 @@ const CallToRpc = z.object({
   value: z.optional(uintBigintNumberish()),
 })
 
+const Capabilities = z.record(z.string(), z.unknown())
+
+const MultisigInit = z.object({
+  salt: z_Hex.Hex,
+  threshold: z.number(),
+  owners: z.readonly(
+    z.array(z.object({ owner: z_Address.Address, weight: z.number() })),
+  ),
+})
+
 /** RPC tempo transaction request schema. */
 export const Rpc = z.object({
   accessList: z.optional(z_AccessList.AccessList),
@@ -64,6 +73,7 @@ export const Rpc = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(CallRpc))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(z_Hex.Hex),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
@@ -75,10 +85,13 @@ export const Rpc = z.object({
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.Rpc),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(z_Hex.Hex),
   maxFeePerGas: z.optional(z_Hex.Hex),
   maxPriorityFeePerGas: z.optional(z_Hex.Hex),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
   r: z.optional(z_Hex.Hex),
@@ -114,21 +127,25 @@ export const Domain = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(Call))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(z.number()),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
   feePayerSignature: z.optional(z.union([SignatureDecoded, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(z.bigint()),
   gasPrice: z.optional(z.bigint()),
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.Domain),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(z.bigint()),
   maxFeePerGas: z.optional(z.bigint()),
   maxPriorityFeePerGas: z.optional(z.bigint()),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(z.bigint()),
   nonceKey: z.optional(z.union([z.bigint(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -150,21 +167,25 @@ export const DomainToRpc = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(CallToRpc))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(uintNumberNumberish()),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
   feePayerSignature: z.optional(z.union([SignatureDecoded, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(uintBigintNumberish()),
   gasPrice: z.optional(uintBigintNumberish()),
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.DomainToRpc),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(uintBigintNumberish()),
   maxFeePerGas: z.optional(uintBigintNumberish()),
   maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(uintBigintNumberish()),
   nonceKey: z.optional(z.union([uintBigintNumberish(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -232,6 +253,17 @@ function fromRpc(
       z_KeyAuthorization.KeyAuthorization,
       request.keyAuthorization as never,
     ) as never
+  if (typeof request.capabilities !== 'undefined')
+    request_.capabilities = request.capabilities
+  if (typeof request.feePayer !== 'undefined')
+    request_.feePayer = request.feePayer
+  if (typeof request.keyData !== 'undefined') request_.keyData = request.keyData
+  if (typeof request.keyId !== 'undefined') request_.keyId = request.keyId
+  if (typeof request.keyType !== 'undefined') request_.keyType = request.keyType
+  if (typeof request.multisigInit !== 'undefined')
+    request_.multisigInit = request.multisigInit
+  if (typeof request.multisigSignatureCount !== 'undefined')
+    request_.multisigSignatureCount = request.multisigSignatureCount
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = core_Hex.toNumber(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -251,6 +283,22 @@ function toRpc(
     authorizationList: undefined,
   } as never) as core_TransactionRequest.Rpc
 
+  const tempo =
+    typeof request.calls !== 'undefined' ||
+    typeof request.capabilities !== 'undefined' ||
+    typeof request.feePayer !== 'undefined' ||
+    typeof request.feeToken !== 'undefined' ||
+    typeof request.keyAuthorization !== 'undefined' ||
+    typeof request.keyData !== 'undefined' ||
+    typeof request.keyId !== 'undefined' ||
+    typeof request.keyType !== 'undefined' ||
+    typeof request.multisigInit !== 'undefined' ||
+    typeof request.multisigSignatureCount !== 'undefined' ||
+    typeof request.nonceKey !== 'undefined' ||
+    typeof request.validBefore !== 'undefined' ||
+    typeof request.validAfter !== 'undefined' ||
+    request.type === 'tempo'
+
   if (request.authorizationList)
     request_rpc.authorizationList = z.encode(
       z_AuthorizationTempo.ListSignedToRpc,
@@ -269,24 +317,41 @@ function toRpc(
       value: call.value ? encodeNumberish(call.value) : '0x',
       data: call.data ?? '0x',
     }))
-  else if (request.to || request.data || request.value)
+  else if (request.to || request.data || request.value || tempo)
     request_rpc.calls = [
       {
-        to: request.to ?? undefined,
+        to:
+          request.to ||
+          (tempo && (!request.data || request.data === '0x')
+            ? '0x0000000000000000000000000000000000000000'
+            : undefined),
         value: request.value ? encodeNumberish(request.value) : '0x',
         data: request.data ?? '0x',
       },
     ]
-  if (typeof request.feeToken !== 'undefined')
-    request_rpc.feeToken =
-      typeof request.feeToken === 'bigint'
-        ? z.encode(z_TokenId.address, request.feeToken)
-        : request.feeToken
+  if (
+    typeof request.feeToken !== 'undefined' &&
+    !(request.feePayer === true && !request.feePayerSignature)
+  )
+    request_rpc.feeToken = request.feeToken
   if (request.keyAuthorization)
     request_rpc.keyAuthorization = z.encode(
       z_KeyAuthorization.KeyAuthorizationToRpc,
       request.keyAuthorization as never,
     ) as never
+  if (typeof request.capabilities !== 'undefined')
+    request_rpc.capabilities = request.capabilities
+  if (typeof request.feePayer !== 'undefined')
+    request_rpc.feePayer = request.feePayer
+  if (typeof request.keyData !== 'undefined')
+    request_rpc.keyData = shimKeyData(request.keyData)
+  if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
+  if (typeof request.keyType !== 'undefined')
+    request_rpc.keyType = request.keyType
+  if (typeof request.multisigInit !== 'undefined')
+    request_rpc.multisigInit = request.multisigInit
+  if (typeof request.multisigSignatureCount !== 'undefined')
+    request_rpc.multisigSignatureCount = request.multisigSignatureCount
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = encodeNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -300,16 +365,7 @@ function toRpc(
   })()
   if (nonceKey) request_rpc.nonceKey = nonceKey
 
-  if (
-    typeof request.calls !== 'undefined' ||
-    typeof request.feePayer !== 'undefined' ||
-    typeof request.feeToken !== 'undefined' ||
-    typeof request.keyAuthorization !== 'undefined' ||
-    typeof request.nonceKey !== 'undefined' ||
-    typeof request.validBefore !== 'undefined' ||
-    typeof request.validAfter !== 'undefined' ||
-    request.type === 'tempo'
-  ) {
+  if (tempo) {
     request_rpc.type = toRpcType.tempo
     delete request_rpc.data
     delete request_rpc.input
@@ -320,6 +376,16 @@ function toRpc(
   return request_rpc
 }
 
+/**
+ * Shims key data longer than 4 bytes into a 2-byte big-endian length hint
+ * (the node's gas estimator only accepts 1, 2, or 4-byte key data).
+ */
+function shimKeyData(data: core_Hex.Hex): core_Hex.Hex {
+  const byteLength = core_Hex.size(data)
+  if (byteLength <= 4) return data
+  return core_Hex.fromNumber(byteLength, { size: 2 })
+}
+
 /** Decodes an RPC signature into a recovered signature. */
 function signatureFromRpc(signature: {
   r: core_Hex.Hex

package/src/zod/tempo/TxEnvelopeTempo.ts

@@ -31,7 +31,7 @@ const baseFields = {
   calls: z.readonly(z.array(Call)),
   chainId: z.number(),
   feePayerSignature: z.optional(z.union([FeePayerSignature, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(z.bigint()),
   keyAuthorization: z.optional(z_KeyAuthorization.Domain),

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, {

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