ox 0.14.24 → 0.14.26

package/tempo/e2e.test.ts

@@ -2662,4 +2662,334 @@ describe('behavior: keyAuthorization', () => {
       ).rejects.toThrow()
     },
   )
+
+  // TODO: remove skipIf when devnet/testnet have T5 (TIP-1053).
+  test.skipIf(nodeEnv !== 'localnet')(
+    'behavior: TIP-1053 witness round-trips through registration',
+    async () => {
+      const accessPrivateKey = Secp256k1.randomPrivateKey()
+      const accessAddress = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey: accessPrivateKey }),
+      )
+
+      // Application-defined challenge digest, bound to the authorization.
+      const witness = Hex.random(32)
+
+      const keyAuth = KeyAuthorization.from({
+        address: accessAddress,
+        chainId: BigInt(chainId),
+        type: 'secp256k1',
+        witness,
+      })
+
+      const keyAuth_signed = KeyAuthorization.from(keyAuth, {
+        signature: SignatureEnvelope.from(
+          Secp256k1.sign({
+            payload: KeyAuthorization.getSignPayload(keyAuth),
+            privateKey: root.privateKey,
+          }),
+        ),
+      })
+
+      const nonce = await getTransactionCount(client, {
+        address: root.address,
+        blockTag: 'pending',
+      })
+
+      const transaction = TxEnvelopeTempo.from({
+        calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+        chainId,
+        feeToken: '0x20c0000000000000000000000000000000000001',
+        keyAuthorization: keyAuth_signed,
+        nonce: BigInt(nonce),
+        gas: 1_000_000n,
+        maxFeePerGas: Value.fromGwei('20'),
+        maxPriorityFeePerGas: Value.fromGwei('10'),
+      })
+
+      const signature = Secp256k1.sign({
+        payload: TxEnvelopeTempo.getSignPayload(transaction, {
+          from: root.address,
+        }),
+        privateKey: accessPrivateKey,
+      })
+
+      const serialized_signed = TxEnvelopeTempo.serialize(transaction, {
+        signature: SignatureEnvelope.from({
+          userAddress: root.address,
+          inner: SignatureEnvelope.from(signature),
+          type: 'keychain',
+        }),
+      })
+
+      const receipt = (await client
+        .request({
+          method: 'eth_sendRawTransactionSync',
+          params: [serialized_signed],
+        })
+        .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+      expect(receipt.status).toBe('success')
+
+      const response = await client
+        .request({
+          method: 'eth_getTransactionByHash',
+          params: [receipt.transactionHash],
+        })
+        .then((tx) => Transaction.fromRpc(tx as any))
+      if (!response) throw new Error()
+
+      // The witness must survive the round trip through the node.
+      expect(response.keyAuthorization?.witness).toBe(witness)
+
+      // The signing hash of the round-tripped authorization equals the witness-bearing hash.
+      expect(KeyAuthorization.hash(response.keyAuthorization!)).toBe(
+        KeyAuthorization.hash(keyAuth_signed),
+      )
+    },
+  )
+
+  // TODO: remove skipIf when devnet/testnet have T5
+  test.skipIf(nodeEnv !== 'localnet')(
+    'behavior: TIP-1053 witness-less authorization is byte-equivalent to pre-TIP-1053',
+    async () => {
+      // Two authorizations with identical fields but different access keys; the witness-less
+      // shape must encode without a trailing witness slot.
+      const accessPrivateKey = Secp256k1.randomPrivateKey()
+      const accessAddress = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey: accessPrivateKey }),
+      )
+      const keyAuth = KeyAuthorization.from({
+        address: accessAddress,
+        chainId: BigInt(chainId),
+        type: 'secp256k1',
+      })
+      const [authTuple] = KeyAuthorization.toTuple(keyAuth)
+      expect((authTuple as unknown as unknown[]).length).toBe(3)
+
+      const keyAuth_signed = KeyAuthorization.from(keyAuth, {
+        signature: SignatureEnvelope.from(
+          Secp256k1.sign({
+            payload: KeyAuthorization.getSignPayload(keyAuth),
+            privateKey: root.privateKey,
+          }),
+        ),
+      })
+
+      const nonce = await getTransactionCount(client, {
+        address: root.address,
+        blockTag: 'pending',
+      })
+
+      const transaction = TxEnvelopeTempo.from({
+        calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+        chainId,
+        feeToken: '0x20c0000000000000000000000000000000000001',
+        keyAuthorization: keyAuth_signed,
+        nonce: BigInt(nonce),
+        gas: 1_000_000n,
+        maxFeePerGas: Value.fromGwei('20'),
+        maxPriorityFeePerGas: Value.fromGwei('10'),
+      })
+
+      const signature = Secp256k1.sign({
+        payload: TxEnvelopeTempo.getSignPayload(transaction, {
+          from: root.address,
+        }),
+        privateKey: accessPrivateKey,
+      })
+
+      const serialized_signed = TxEnvelopeTempo.serialize(transaction, {
+        signature: SignatureEnvelope.from({
+          userAddress: root.address,
+          inner: SignatureEnvelope.from(signature),
+          type: 'keychain',
+        }),
+      })
+
+      const receipt = (await client
+        .request({
+          method: 'eth_sendRawTransactionSync',
+          params: [serialized_signed],
+        })
+        .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+      expect(receipt.status).toBe('success')
+
+      const response = await client
+        .request({
+          method: 'eth_getTransactionByHash',
+          params: [receipt.transactionHash],
+        })
+        .then((tx) => Transaction.fromRpc(tx as any))
+      if (!response) throw new Error()
+
+      expect(response.keyAuthorization?.witness).toBeUndefined()
+    },
+  )
+
+  // TODO: remove skipIf when devnet/testnet have T6 (TIP-1049).
+  test.skipIf(nodeEnv !== 'localnet')(
+    'behavior: TIP-1049 admin access key round-trips through registration',
+    async () => {
+      const accessPrivateKey = Secp256k1.randomPrivateKey()
+      const accessAddress = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey: accessPrivateKey }),
+      )
+
+      const keyAuth = KeyAuthorization.from({
+        address: accessAddress,
+        account: root.address,
+        chainId: BigInt(chainId),
+        isAdmin: true,
+        type: 'secp256k1',
+      })
+
+      const keyAuth_signed = KeyAuthorization.from(keyAuth, {
+        signature: SignatureEnvelope.from(
+          Secp256k1.sign({
+            payload: KeyAuthorization.getSignPayload(keyAuth),
+            privateKey: root.privateKey,
+          }),
+        ),
+      })
+
+      const nonce = await getTransactionCount(client, {
+        address: root.address,
+        blockTag: 'pending',
+      })
+
+      const transaction = TxEnvelopeTempo.from({
+        calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+        chainId,
+        feeToken: '0x20c0000000000000000000000000000000000001',
+        keyAuthorization: keyAuth_signed,
+        nonce: BigInt(nonce),
+        gas: 1_000_000n,
+        maxFeePerGas: Value.fromGwei('20'),
+        maxPriorityFeePerGas: Value.fromGwei('10'),
+      })
+
+      // The admin access key signs and authorizes itself in the same tx
+      // (the canonical "auth+use" registration pattern).
+      const signature = Secp256k1.sign({
+        payload: TxEnvelopeTempo.getSignPayload(transaction, {
+          from: root.address,
+        }),
+        privateKey: accessPrivateKey,
+      })
+
+      const serialized_signed = TxEnvelopeTempo.serialize(transaction, {
+        signature: SignatureEnvelope.from({
+          userAddress: root.address,
+          inner: SignatureEnvelope.from(signature),
+          type: 'keychain',
+        }),
+      })
+
+      const receipt = (await client
+        .request({
+          method: 'eth_sendRawTransactionSync',
+          params: [serialized_signed],
+        })
+        .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+      expect(receipt.status).toBe('success')
+
+      const response = await client
+        .request({
+          method: 'eth_getTransactionByHash',
+          params: [receipt.transactionHash],
+        })
+        .then((tx) => Transaction.fromRpc(tx as any))
+      if (!response) throw new Error()
+
+      // isAdmin + account must survive the round trip through the node.
+      expect(response.keyAuthorization?.isAdmin).toBe(true)
+      expect(response.keyAuthorization?.account).toBe(root.address)
+
+      // The signing hash of the round-tripped authorization equals the
+      // admin-bearing hash.
+      expect(KeyAuthorization.hash(response.keyAuthorization!)).toBe(
+        KeyAuthorization.hash(keyAuth_signed),
+      )
+    },
+  )
+
+  // TODO: remove skipIf when devnet/testnet have T6.
+  test.skipIf(nodeEnv !== 'localnet')(
+    'behavior: TIP-1049 non-admin authorization is byte-equivalent to pre-TIP-1049',
+    async () => {
+      const accessPrivateKey = Secp256k1.randomPrivateKey()
+      const accessAddress = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey: accessPrivateKey }),
+      )
+
+      // Without isAdmin or account, the encoded tuple must not carry trailing
+      // TIP-1049 slots.
+      const keyAuth = KeyAuthorization.from({
+        address: accessAddress,
+        chainId: BigInt(chainId),
+        type: 'secp256k1',
+      })
+      const [authTuple] = KeyAuthorization.toTuple(keyAuth)
+      expect((authTuple as unknown as unknown[]).length).toBe(3)
+
+      const keyAuth_signed = KeyAuthorization.from(keyAuth, {
+        signature: SignatureEnvelope.from(
+          Secp256k1.sign({
+            payload: KeyAuthorization.getSignPayload(keyAuth),
+            privateKey: root.privateKey,
+          }),
+        ),
+      })
+
+      const nonce = await getTransactionCount(client, {
+        address: root.address,
+        blockTag: 'pending',
+      })
+
+      const transaction = TxEnvelopeTempo.from({
+        calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+        chainId,
+        feeToken: '0x20c0000000000000000000000000000000000001',
+        keyAuthorization: keyAuth_signed,
+        nonce: BigInt(nonce),
+        gas: 1_000_000n,
+        maxFeePerGas: Value.fromGwei('20'),
+        maxPriorityFeePerGas: Value.fromGwei('10'),
+      })
+
+      const signature = Secp256k1.sign({
+        payload: TxEnvelopeTempo.getSignPayload(transaction, {
+          from: root.address,
+        }),
+        privateKey: accessPrivateKey,
+      })
+
+      const serialized_signed = TxEnvelopeTempo.serialize(transaction, {
+        signature: SignatureEnvelope.from({
+          userAddress: root.address,
+          inner: SignatureEnvelope.from(signature),
+          type: 'keychain',
+        }),
+      })
+
+      const receipt = (await client
+        .request({
+          method: 'eth_sendRawTransactionSync',
+          params: [serialized_signed],
+        })
+        .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+      expect(receipt.status).toBe('success')
+
+      const response = await client
+        .request({
+          method: 'eth_getTransactionByHash',
+          params: [receipt.transactionHash],
+        })
+        .then((tx) => Transaction.fromRpc(tx as any))
+      if (!response) throw new Error()
+
+      expect(response.keyAuthorization?.isAdmin).toBeUndefined()
+      expect(response.keyAuthorization?.account).toBeUndefined()
+    },
+  )
 })

package/tempo/index.ts

@@ -36,53 +36,32 @@ export type {}
  */
 export * as AuthorizationTempo from './AuthorizationTempo.js'
 /**
- * TIP-20 channel reserve constants and deterministic hashing utilities.
+ * TIP-20 channel reserve descriptor, constants, and deterministic hashing utilities.
  *
- * The channel reserve precompile exposes helper methods for channel identifiers,
- * voucher sign payloads, and its EIP-712 domain separator. These utilities compute the
- * same values locally when the chain id and channel fields are known.
+ * Channel descriptors are emitted by `Channel.open` and then reused to settle,
+ * top up, close, request close, withdraw, or compute the channel ID. The channel
+ * reserve precompile exposes helper methods for channel identifiers, voucher sign
+ * payloads, and its EIP-712 domain separator. These utilities compute the same
+ * values locally when the chain id and channel fields are known.
  *
  * @example
  * ```ts twoslash
  * import { Channel } from 'ox/tempo'
  *
- * const channelId = Channel.computeId({
- *   authorizedSigner: '0x0000000000000000000000000000000000000000',
- *   chainId: 4217,
+ * const channel = Channel.from({
  *   expiringNonceHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
- *   operator: '0x0000000000000000000000000000000000000000',
  *   payee: '0x2222222222222222222222222222222222222222',
  *   payer: '0x1111111111111111111111111111111111111111',
  *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
  *   token: 1n,
  * })
- * ```
- *
- * @category Reference
- */
-export * as Channel from './Channel.js'
-/**
- * TIP-20 channel reserve descriptor utilities.
  *
- * Channel descriptors are emitted by `Channel.open` and then reused to settle,
- * top up, close, request close, withdraw, or compute the channel ID.
- *
- * @example
- * ```ts twoslash
- * import { ChannelDescriptor } from 'ox/tempo'
- *
- * const descriptor = ChannelDescriptor.from({
- *   expiringNonceHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
- *   payee: '0x2222222222222222222222222222222222222222',
- *   payer: '0x1111111111111111111111111111111111111111',
- *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
- *   token: 1n,
- * })
+ * const channelId = Channel.computeId(channel, { chainId: 4217 })
  * ```
  *
  * @category Reference
  */
-export * as ChannelDescriptor from './ChannelDescriptor.js'
+export * as Channel from './Channel.js'
 /**
  * Tempo key authorization utilities for provisioning and signing access keys.
  *

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.14.24'
+export const version = '0.14.26'

package/_cjs/tempo/ChannelDescriptor.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.from = from;
-const Address = require("../core/Address.js");
-const TokenId = require("./TokenId.js");
-const zeroAddress = '0x0000000000000000000000000000000000000000';
-function from(value) {
-    const { authorizedSigner = zeroAddress, expiringNonceHash, operator = zeroAddress, payee, payer, salt, token, } = value;
-    return {
-        authorizedSigner: resolveAddress(authorizedSigner),
-        expiringNonceHash,
-        operator: resolveAddress(operator),
-        payee: resolveAddress(payee),
-        payer: resolveAddress(payer),
-        salt,
-        token: typeof token === 'string'
-            ? resolveAddress(token)
-            : TokenId.toAddress(token),
-    };
-}
-function resolveAddress(address) {
-    return Address.from(address);
-}
-//# sourceMappingURL=ChannelDescriptor.js.map

package/_cjs/tempo/ChannelDescriptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChannelDescriptor.js","sourceRoot":"","sources":["../../tempo/ChannelDescriptor.ts"],"names":[],"mappings":";;AA4DA,oBAuBC;AAnFD,8CAA6C;AAG7C,wCAAuC;AAEvC,MAAM,WAAW,GACf,4CAA+E,CAAA;AAsDjF,SAAgB,IAAI,CAAC,KAAiB;IACpC,MAAM,EACJ,gBAAgB,GAAG,WAAW,EAC9B,iBAAiB,EACjB,QAAQ,GAAG,WAAW,EACtB,KAAK,EACL,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAG,KAAK,CAAA;IAET,OAAO;QACL,gBAAgB,EAAE,cAAc,CAAC,gBAAgB,CAAC;QAClD,iBAAiB;QACjB,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;QAClC,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC;QAC5B,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC;QAC5B,IAAI;QACJ,KAAK,EACH,OAAO,KAAK,KAAK,QAAQ;YACvB,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC;YACvB,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC;KAC/B,CAAA;AACH,CAAC;AA6BD,SAAS,cAAc,CAAC,OAAwB;IAC9C,OAAO,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;AAC9B,CAAC"}

package/_esm/tempo/ChannelDescriptor.js

@@ -1,43 +0,0 @@
-import * as Address from '../core/Address.js';
-import * as TokenId from './TokenId.js';
-const zeroAddress = '0x0000000000000000000000000000000000000000';
-/**
- * Instantiates a TIP-20 channel reserve descriptor.
- *
- * Accepts a TIP-20 token ID or address, and defaults `operator` and
- * `authorizedSigner` to the zero address.
- *
- * @example
- * ```ts twoslash
- * import { ChannelDescriptor } from 'ox/tempo'
- *
- * const descriptor = ChannelDescriptor.from({
- *   expiringNonceHash: '0x0000000000000000000000000000000000000000000000000000000000000002',
- *   payee: '0x2222222222222222222222222222222222222222',
- *   payer: '0x1111111111111111111111111111111111111111',
- *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
- *   token: 1n,
- * })
- * ```
- *
- * @param value - The descriptor input.
- * @returns The normalized channel descriptor.
- */
-export function from(value) {
-    const { authorizedSigner = zeroAddress, expiringNonceHash, operator = zeroAddress, payee, payer, salt, token, } = value;
-    return {
-        authorizedSigner: resolveAddress(authorizedSigner),
-        expiringNonceHash,
-        operator: resolveAddress(operator),
-        payee: resolveAddress(payee),
-        payer: resolveAddress(payer),
-        salt,
-        token: typeof token === 'string'
-            ? resolveAddress(token)
-            : TokenId.toAddress(token),
-    };
-}
-function resolveAddress(address) {
-    return Address.from(address);
-}
-//# sourceMappingURL=ChannelDescriptor.js.map

package/_esm/tempo/ChannelDescriptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChannelDescriptor.js","sourceRoot":"","sources":["../../tempo/ChannelDescriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAG7C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,MAAM,WAAW,GACf,4CAA+E,CAAA;AAgCjF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,IAAI,CAAC,KAAiB;IACpC,MAAM,EACJ,gBAAgB,GAAG,WAAW,EAC9B,iBAAiB,EACjB,QAAQ,GAAG,WAAW,EACtB,KAAK,EACL,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAG,KAAK,CAAA;IAET,OAAO;QACL,gBAAgB,EAAE,cAAc,CAAC,gBAAgB,CAAC;QAClD,iBAAiB;QACjB,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;QAClC,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC;QAC5B,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC;QAC5B,IAAI;QACJ,KAAK,EACH,OAAO,KAAK,KAAK,QAAQ;YACvB,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC;YACvB,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC;KAC/B,CAAA;AACH,CAAC;AA6BD,SAAS,cAAc,CAAC,OAAwB;IAC9C,OAAO,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;AAC9B,CAAC"}

package/_types/tempo/ChannelDescriptor.d.ts

@@ -1,73 +0,0 @@
-import * as Address from '../core/Address.js';
-import type * as Errors from '../core/Errors.js';
-import type * as Hex from '../core/Hex.js';
-import * as TokenId from './TokenId.js';
-/**
- * TIP-20 channel reserve descriptor.
- *
- * Descriptors identify a channel without reading chain state. They are emitted
- * by `open` and reused by `settle`, `topUp`, `close`, `requestClose`, and
- * `withdraw`.
- */
-export type ChannelDescriptor<addressType = Address.Address, tokenType = TokenId.TokenIdOrAddress<addressType>> = {
-    /** Account that funded the channel and receives refunds. */
-    payer: addressType;
-    /** Account that receives settled voucher payments. */
-    payee: addressType;
-    /** Optional relayer allowed to submit `settle` for the payee. */
-    operator: addressType;
-    /** TIP-20 token address held by the channel. */
-    token: tokenType;
-    /** User-supplied salt to distinguish otherwise identical channels. */
-    salt: Hex.Hex;
-    /** Optional signer for vouchers. Zero means `payer` signs. */
-    authorizedSigner: addressType;
-    /** Transaction-derived hash assigned when the channel was opened. */
-    expiringNonceHash: Hex.Hex;
-};
-/** Hex-address-normalized {@link ox#ChannelDescriptor.ChannelDescriptor}. */
-export type Resolved = ChannelDescriptor<Address.Address, Address.Address>;
-/**
- * Instantiates a TIP-20 channel reserve descriptor.
- *
- * Accepts a TIP-20 token ID or address, and defaults `operator` and
- * `authorizedSigner` to the zero address.
- *
- * @example
- * ```ts twoslash
- * import { ChannelDescriptor } from 'ox/tempo'
- *
- * const descriptor = ChannelDescriptor.from({
- *   expiringNonceHash: '0x0000000000000000000000000000000000000000000000000000000000000002',
- *   payee: '0x2222222222222222222222222222222222222222',
- *   payer: '0x1111111111111111111111111111111111111111',
- *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
- *   token: 1n,
- * })
- * ```
- *
- * @param value - The descriptor input.
- * @returns The normalized channel descriptor.
- */
-export declare function from(value: from.Value): from.ReturnType;
-export declare namespace from {
-    type Value = {
-        /** Account that funded the channel and receives refunds. */
-        payer: Address.Address;
-        /** Account that receives settled voucher payments. */
-        payee: Address.Address;
-        /** Optional relayer allowed to submit `settle` for the payee. */
-        operator?: Address.Address | undefined;
-        /** TIP-20 token address or ID held by the channel. */
-        token: TokenId.TokenIdOrAddress<Address.Address>;
-        /** User-supplied salt to distinguish otherwise identical channels. */
-        salt: Hex.Hex;
-        /** Optional signer for vouchers. Zero means `payer` signs. */
-        authorizedSigner?: Address.Address | undefined;
-        /** Transaction-derived hash assigned when the channel was opened. */
-        expiringNonceHash: Hex.Hex;
-    };
-    type ReturnType = Resolved;
-    type ErrorType = Address.from.ErrorType | Hex.concat.ErrorType | Hex.fromNumber.ErrorType | Errors.GlobalErrorType;
-}
-//# sourceMappingURL=ChannelDescriptor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ChannelDescriptor.d.ts","sourceRoot":"","sources":["../../tempo/ChannelDescriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,GAAG,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAKvC;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,CAC3B,WAAW,GAAG,OAAO,CAAC,OAAO,EAC7B,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC,WAAW,CAAC,IAC/C;IACF,4DAA4D;IAC5D,KAAK,EAAE,WAAW,CAAA;IAClB,sDAAsD;IACtD,KAAK,EAAE,WAAW,CAAA;IAClB,iEAAiE;IACjE,QAAQ,EAAE,WAAW,CAAA;IACrB,gDAAgD;IAChD,KAAK,EAAE,SAAS,CAAA;IAChB,sEAAsE;IACtE,IAAI,EAAE,GAAG,CAAC,GAAG,CAAA;IACb,8DAA8D;IAC9D,gBAAgB,EAAE,WAAW,CAAA;IAC7B,qEAAqE;IACrE,iBAAiB,EAAE,GAAG,CAAC,GAAG,CAAA;CAC3B,CAAA;AAED,6EAA6E;AAC7E,MAAM,MAAM,QAAQ,GAAG,iBAAiB,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;AAE1E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,UAAU,CAuBvD;AAED,MAAM,CAAC,OAAO,WAAW,IAAI,CAAC;IAC5B,KAAK,KAAK,GAAG;QACX,4DAA4D;QAC5D,KAAK,EAAE,OAAO,CAAC,OAAO,CAAA;QACtB,sDAAsD;QACtD,KAAK,EAAE,OAAO,CAAC,OAAO,CAAA;QACtB,iEAAiE;QACjE,QAAQ,CAAC,EAAE,OAAO,CAAC,OAAO,GAAG,SAAS,CAAA;QACtC,sDAAsD;QACtD,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAChD,sEAAsE;QACtE,IAAI,EAAE,GAAG,CAAC,GAAG,CAAA;QACb,8DAA8D;QAC9D,gBAAgB,CAAC,EAAE,OAAO,CAAC,OAAO,GAAG,SAAS,CAAA;QAC9C,qEAAqE;QACrE,iBAAiB,EAAE,GAAG,CAAC,GAAG,CAAA;KAC3B,CAAA;IAED,KAAK,UAAU,GAAG,QAAQ,CAAA;IAE1B,KAAK,SAAS,GACV,OAAO,CAAC,IAAI,CAAC,SAAS,GACtB,GAAG,CAAC,MAAM,CAAC,SAAS,GACpB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B"}

package/tempo/ChannelDescriptor/package.json

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

package/tempo/ChannelDescriptor.test.ts

@@ -1,93 +0,0 @@
-import type { Address } from 'ox'
-import { ChannelDescriptor } from 'ox/tempo'
-import { describe, expect, test } from 'vitest'
-
-describe('from', () => {
-  test('default', () => {
-    expect(
-      ChannelDescriptor.from({
-        authorizedSigner: '0x3333333333333333333333333333333333333333',
-        expiringNonceHash:
-          '0x0000000000000000000000000000000000000000000000000000000000000002',
-        operator: '0x4444444444444444444444444444444444444444',
-        payee: '0x2222222222222222222222222222222222222222',
-        payer: '0x1111111111111111111111111111111111111111',
-        salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
-        token: 1n,
-      }),
-    ).toMatchInlineSnapshot(`
-      {
-        "authorizedSigner": "0x3333333333333333333333333333333333333333",
-        "expiringNonceHash": "0x0000000000000000000000000000000000000000000000000000000000000002",
-        "operator": "0x4444444444444444444444444444444444444444",
-        "payee": "0x2222222222222222222222222222222222222222",
-        "payer": "0x1111111111111111111111111111111111111111",
-        "salt": "0x0000000000000000000000000000000000000000000000000000000000000001",
-        "token": "0x20c0000000000000000000000000000000000001",
-      }
-    `)
-  })
-
-  test('default values', () => {
-    expect(
-      ChannelDescriptor.from({
-        expiringNonceHash:
-          '0x0000000000000000000000000000000000000000000000000000000000000002',
-        payee: '0x2222222222222222222222222222222222222222',
-        payer: '0x1111111111111111111111111111111111111111',
-        salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
-        token: 1n,
-      }),
-    ).toMatchInlineSnapshot(`
-      {
-        "authorizedSigner": "0x0000000000000000000000000000000000000000",
-        "expiringNonceHash": "0x0000000000000000000000000000000000000000000000000000000000000002",
-        "operator": "0x0000000000000000000000000000000000000000",
-        "payee": "0x2222222222222222222222222222222222222222",
-        "payer": "0x1111111111111111111111111111111111111111",
-        "salt": "0x0000000000000000000000000000000000000000000000000000000000000001",
-        "token": "0x20c0000000000000000000000000000000000001",
-      }
-    `)
-  })
-
-  test('token address input', () => {
-    expect(
-      ChannelDescriptor.from({
-        authorizedSigner: '0x3333333333333333333333333333333333333333',
-        expiringNonceHash:
-          '0x0000000000000000000000000000000000000000000000000000000000000002',
-        operator: '0x4444444444444444444444444444444444444444',
-        payee: '0x2222222222222222222222222222222222222222',
-        payer: '0x1111111111111111111111111111111111111111',
-        salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
-        token: '0x20c0000000000000000000000000000000000001',
-      }),
-    ).toMatchInlineSnapshot(`
-      {
-        "authorizedSigner": "0x3333333333333333333333333333333333333333",
-        "expiringNonceHash": "0x0000000000000000000000000000000000000000000000000000000000000002",
-        "operator": "0x4444444444444444444444444444444444444444",
-        "payee": "0x2222222222222222222222222222222222222222",
-        "payer": "0x1111111111111111111111111111111111111111",
-        "salt": "0x0000000000000000000000000000000000000000000000000000000000000001",
-        "token": "0x20c0000000000000000000000000000000000001",
-      }
-    `)
-  })
-
-  test('return type', () => {
-    const descriptor = ChannelDescriptor.from({
-      expiringNonceHash:
-        '0x0000000000000000000000000000000000000000000000000000000000000002',
-      payee: '0x2222222222222222222222222222222222222222',
-      payer: '0x1111111111111111111111111111111111111111',
-      salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
-      token: 1n,
-    })
-
-    descriptor satisfies ChannelDescriptor.Resolved
-    descriptor.payer satisfies Address.Address
-    descriptor.token satisfies Address.Address
-  })
-})