ox 0.9.16 → 0.10.0

package/_types/tempo/KeyAuthorization.d.ts

@@ -0,0 +1,437 @@
+import type * as Address from '../core/Address.js';
+import type * as Errors from '../core/Errors.js';
+import * as Hash from '../core/Hash.js';
+import * as Hex from '../core/Hex.js';
+import type { Compute } from '../core/internal/types.js';
+import * as Rlp from '../core/Rlp.js';
+import * as SignatureEnvelope from './SignatureEnvelope.js';
+/**
+ * Key authorization for provisioning access keys.
+ *
+ * Access keys allow a root key (e.g., a passkey) to delegate transaction signing to secondary
+ * keys with customizable permissions including expiry timestamps and per-TIP-20 token spending
+ * limits. This enables a user to sign transactions without repeated passkey prompts.
+ *
+ * The root key signs a `KeyAuthorization` to grant an access key permission to sign transactions
+ * on its behalf. The authorization is attached to a transaction (which can be signed by the access
+ * key itself), and the protocol validates the authorization before storing the key in the
+ * AccountKeychain precompile.
+ *
+ * Key authorization fields:
+ * - `address`: Address derived from the access key's public key (the "key ID")
+ * - `chainId`: Chain ID for replay protection (0 = valid on any chain)
+ * - `expiry`: Unix timestamp when the key expires (undefined = never expires)
+ * - `limits`: Per-TIP-20 token spending limits (only applies to `transfer()` and `approve()` calls)
+ * - `type`: Key type (`secp256k1`, `p256`, or `webAuthn`)
+ *
+ * [Access Keys Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#access-keys)
+ */
+export type KeyAuthorization<signed extends boolean = boolean, bigintType = bigint, numberType = number> = {
+    /** Address derived from the public key of the key type. */
+    address: Address.Address;
+    /** Chain ID for replay protection (0 = valid on any chain). */
+    chainId?: bigintType | undefined;
+    /** Unix timestamp when key expires (0 = never expires). */
+    expiry?: numberType | undefined;
+    /** TIP20 spending limits for this key. */
+    limits?: readonly TokenLimit<bigintType>[] | undefined;
+    /** Key type. (secp256k1, P256, WebAuthn). */
+    type: SignatureEnvelope.Type;
+} & (signed extends true ? {
+    signature: SignatureEnvelope.SignatureEnvelope<bigintType, numberType>;
+} : {
+    signature?: SignatureEnvelope.SignatureEnvelope<bigintType, numberType> | undefined;
+});
+/** RPC representation of an {@link ox#KeyAuthorization.KeyAuthorization}. */
+export type Rpc = Omit<KeyAuthorization<false, Hex.Hex, Hex.Hex>, 'address' | 'signature' | 'type'> & {
+    keyId: Address.Address;
+    keyType: SignatureEnvelope.Type;
+    signature: SignatureEnvelope.SignatureEnvelopeRpc;
+};
+/** Signed representation of a Key Authorization. */
+export type Signed<bigintType = bigint, numberType = number> = KeyAuthorization<true, bigintType, numberType>;
+type BaseTuple = readonly [
+    chainId: Hex.Hex,
+    keyType: Hex.Hex,
+    keyId: Address.Address
+];
+/** Tuple representation of a Key Authorization. */
+export type Tuple<signed extends boolean = boolean> = signed extends true ? readonly [
+    authorization: BaseTuple | readonly [...BaseTuple, expiry: Hex.Hex] | readonly [
+        ...BaseTuple,
+        expiry: Hex.Hex,
+        limits: readonly [token: Address.Address, limit: Hex.Hex][]
+    ],
+    signature: Hex.Hex
+] : readonly [
+    authorization: BaseTuple | readonly [...BaseTuple, expiry: Hex.Hex] | readonly [
+        ...BaseTuple,
+        expiry: Hex.Hex,
+        limits: readonly [token: Address.Address, limit: Hex.Hex][]
+    ]
+];
+/**
+ * Token spending limit for access keys.
+ *
+ * Defines a per-TIP-20 token spending limit for an access key. Limits deplete as tokens
+ * are spent and can be updated by the root key via `updateSpendingLimit()`.
+ *
+ * [Access Keys Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#access-keys)
+ */
+export type TokenLimit<bigintType = bigint> = {
+    /** Address of the TIP-20 token. */
+    token: Address.Address;
+    /** Maximum spending amount for this token (enforced over the key's lifetime). */
+    limit: bigintType;
+};
+/**
+ * Converts a Key Authorization object into a typed {@link ox#KeyAuthorization.KeyAuthorization}.
+ *
+ * Use this to create an unsigned key authorization, then sign it with the root key using
+ * {@link ox#KeyAuthorization.(getSignPayload:function)} and attach the signature. The signed authorization
+ * can be included in a {@link ox#TxEnvelopeTempo.TxEnvelopeTempo} via the
+ * `keyAuthorization` field to provision the access key on-chain.
+ *
+ * [Access Keys Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#access-keys)
+ *
+ * @example
+ * ### Secp256k1 Key
+ *
+ * Standard Ethereum ECDSA key using the secp256k1 curve.
+ *
+ * ```ts twoslash
+ * import { Address, Secp256k1, Value } from 'ox'
+ * import { KeyAuthorization } from 'ox/tempo'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ * const address = Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey }))
+ *
+ * const authorization = KeyAuthorization.from({
+ *   address,
+ *   expiry: 1234567890,
+ *   type: 'secp256k1',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6),
+ *   }],
+ * })
+ * ```
+ *
+ * @example
+ * ### WebCryptoP256 Key
+ *
+ * ```ts twoslash
+ * import { Address, WebCryptoP256, Value } from 'ox'
+ * import { KeyAuthorization } from 'ox/tempo'
+ *
+ * const keyPair = await WebCryptoP256.createKeyPair()
+ * const address = Address.fromPublicKey(keyPair.publicKey)
+ *
+ * const authorization = KeyAuthorization.from({
+ *   address,
+ *   expiry: 1234567890,
+ *   type: 'p256',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6),
+ *   }],
+ * })
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures (Secp256k1)
+ *
+ * Attach a signature to a Key Authorization using a Secp256k1 private key to
+ * authorize another Secp256k1 key on the account.
+ *
+ * ```ts twoslash
+ * import { Address, Secp256k1, Value } from 'ox'
+ * import { KeyAuthorization } from 'ox/tempo'
+ *
+ * const privateKey = '0x...'
+ * const address = Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey }))
+ *
+ * const authorization = KeyAuthorization.from({
+ *   address,
+ *   expiry: 1234567890,
+ *   type: 'secp256k1',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6),
+ *   }],
+ * })
+ *
+ * const rootPrivateKey = '0x...'
+ * const signature = Secp256k1.sign({
+ *   payload: KeyAuthorization.getSignPayload(authorization),
+ *   privateKey: rootPrivateKey,
+ * })
+ *
+ * const authorization_signed = KeyAuthorization.from(authorization, { signature })
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures (WebAuthn)
+ *
+ * Attach a signature to a Key Authorization using a WebAuthn credential to
+ * authorize a new WebCryptoP256 key on the account.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Address, Value, WebCryptoP256, WebAuthnP256 } from 'ox'
+ * import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
+ *
+ * const keyPair = await WebCryptoP256.createKeyPair()
+ * const address = Address.fromPublicKey(keyPair.publicKey)
+ *
+ * const authorization = KeyAuthorization.from({
+ *   address,
+ *   expiry: 1234567890,
+ *   type: 'p256',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6),
+ *   }],
+ * })
+ *
+ * const credential = await WebAuthnP256.createCredential({ name: 'Example' })
+ *
+ * const { metadata, signature } = await WebAuthnP256.sign({
+ *   challenge: KeyAuthorization.getSignPayload(authorization),
+ *   credentialId: credential.id,
+ * })
+ *
+ * const signatureEnvelope = SignatureEnvelope.from({ // [!code focus]
+ *   signature, // [!code focus]
+ *   publicKey: credential.publicKey, // [!code focus]
+ *   metadata, // [!code focus]
+ * })
+ * const authorization_signed = KeyAuthorization.from(
+ *   authorization,
+ *   { signature: signatureEnvelope }, // [!code focus]
+ * )
+ * ```
+ *
+ * @param authorization - A Key Authorization tuple in object format.
+ * @param options - Key Authorization options.
+ * @returns The {@link ox#KeyAuthorization.KeyAuthorization}.
+ */
+export declare function from<const authorization extends KeyAuthorization | Rpc, const signature extends SignatureEnvelope.from.Value | undefined = undefined>(authorization: authorization | KeyAuthorization, options?: from.Options<signature>): from.ReturnType<authorization, signature>;
+export declare namespace from {
+    type Options<signature extends SignatureEnvelope.from.Value | undefined = SignatureEnvelope.from.Value | undefined> = {
+        /** The {@link ox#SignatureEnvelope.SignatureEnvelope} to attach to the Key Authorization. */
+        signature?: signature | SignatureEnvelope.SignatureEnvelope | undefined;
+    };
+    type ReturnType<authorization extends KeyAuthorization | Rpc = KeyAuthorization, signature extends SignatureEnvelope.from.Value | undefined = SignatureEnvelope.from.Value | undefined> = Compute<authorization extends Rpc ? Signed : authorization & (signature extends SignatureEnvelope.from.Value ? {
+        signature: SignatureEnvelope.from.ReturnValue<signature>;
+    } : {})>;
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Converts an {@link ox#AuthorizationTempo.Rpc} to an {@link ox#AuthorizationTempo.AuthorizationTempo}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { KeyAuthorization } from 'ox/tempo'
+ *
+ * const keyAuthorization = KeyAuthorization.fromRpc({
+ *   expiry: '0x174876e800',
+ *   keyId: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ *   keyType: 'secp256k1',
+ *   limits: [{ token: '0x20c0000000000000000000000000000000000001', limit: '0xf4240' }],
+ *   signature: {
+ *     type: 'secp256k1',
+ *     r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+ *     s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+ *     yParity: '0x0'
+ *   },
+ * })
+ * ```
+ *
+ * @param authorization - The RPC-formatted Key Authorization.
+ * @returns A signed {@link ox#AuthorizationTempo.AuthorizationTempo}.
+ */
+export declare function fromRpc(authorization: Rpc): Signed;
+export declare namespace fromRpc {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Converts an {@link ox#KeyAuthorization.Tuple} to an {@link ox#KeyAuthorization.KeyAuthorization}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { KeyAuthorization } from 'ox/tempo'
+ *
+ * const authorization = KeyAuthorization.fromTuple([
+ *   [
+ *     '0x',
+ *     '0x00',
+ *     '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ *     '0x174876e800',
+ *     [['0x20c0000000000000000000000000000000000001', '0xf4240']],
+ *   ],
+ *   '0x01a068a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b907e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064',
+ * ])
+ * ```
+ *
+ * @example
+ * Unsigned Key Authorization tuple (no signature):
+ *
+ * ```ts twoslash
+ * import { KeyAuthorization } from 'ox/tempo'
+ *
+ * const authorization = KeyAuthorization.fromTuple([
+ *   [
+ *     '0x',
+ *     '0x00',
+ *     '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ *     '0x174876e800',
+ *     [['0x20c0000000000000000000000000000000000001', '0xf4240']],
+ *   ],
+ * ])
+ * ```
+ *
+ * @param tuple - The Key Authorization tuple.
+ * @returns The {@link ox#KeyAuthorization.KeyAuthorization}.
+ */
+export declare function fromTuple<const tuple extends Tuple>(tuple: tuple): fromTuple.ReturnType<tuple>;
+export declare namespace fromTuple {
+    type ReturnType<authorization extends Tuple = Tuple> = Compute<KeyAuthorization<authorization extends Tuple<true> ? true : false>>;
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Computes the sign payload for an {@link ox#KeyAuthorization.KeyAuthorization}.
+ *
+ * The root key must sign this payload to authorize the access key. The resulting signature
+ * is attached to the key authorization via {@link ox#KeyAuthorization.(from:function)} with the
+ * `signature` option.
+ *
+ * [Access Keys Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#access-keys)
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address, Secp256k1, Value } from 'ox'
+ * import { KeyAuthorization } from 'ox/tempo'
+ *
+ * const privateKey = '0x...'
+ * const address = Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey }))
+ *
+ * const authorization = KeyAuthorization.from({
+ *   address,
+ *   expiry: 1234567890,
+ *   type: 'secp256k1',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6),
+ *   }],
+ * })
+ *
+ * const payload = KeyAuthorization.getSignPayload(authorization) // [!code focus]
+ * ```
+ *
+ * @param authorization - The {@link ox#KeyAuthorization.KeyAuthorization}.
+ * @returns The sign payload.
+ */
+export declare function getSignPayload(authorization: KeyAuthorization): Hex.Hex;
+export declare namespace getSignPayload {
+    type ErrorType = hash.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Computes the hash for an {@link ox#KeyAuthorization.KeyAuthorization}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { KeyAuthorization } from 'ox/tempo'
+ * import { Value } from 'ox'
+ *
+ * const authorization = KeyAuthorization.from({
+ *   expiry: 1234567890,
+ *   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ *   type: 'secp256k1',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6)
+ *   }],
+ * })
+ *
+ * const hash = KeyAuthorization.hash(authorization) // [!code focus]
+ * ```
+ *
+ * @param authorization - The {@link ox#KeyAuthorization.KeyAuthorization}.
+ * @returns The hash.
+ */
+export declare function hash(authorization: KeyAuthorization): Hex.Hex;
+export declare namespace hash {
+    type ErrorType = toTuple.ErrorType | Hash.keccak256.ErrorType | Hex.concat.ErrorType | Rlp.fromHex.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Converts an {@link ox#KeyAuthorization.KeyAuthorization} to an {@link ox#KeyAuthorization.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { KeyAuthorization } from 'ox/tempo'
+ * import { Value } from 'ox'
+ *
+ * const authorization = KeyAuthorization.toRpc({
+ *   expiry: 1234567890,
+ *   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ *   type: 'secp256k1',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6)
+ *   }],
+ *   signature: {
+ *     type: 'secp256k1',
+ *     signature: {
+ *       r: 44944627813007772897391531230081695102703289123332187696115181104739239197517n,
+ *       s: 36528503505192438307355164441104001310566505351980369085208178712678799181120n,
+ *       yParity: 0,
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * @param authorization - A Key Authorization.
+ * @returns An RPC-formatted Key Authorization.
+ */
+export declare function toRpc(authorization: Signed): Rpc;
+export declare namespace toRpc {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Converts an {@link ox#KeyAuthorization.KeyAuthorization} to an {@link ox#KeyAuthorization.Tuple}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { KeyAuthorization } from 'ox/tempo'
+ * import { Value } from 'ox'
+ *
+ * const authorization = KeyAuthorization.from({
+ *   expiry: 1234567890,
+ *   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ *   type: 'secp256k1',
+ *   limits: [{
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     limit: Value.from('10', 6)
+ *   }],
+ * })
+ *
+ * const tuple = KeyAuthorization.toTuple(authorization) // [!code focus]
+ * // @log: [
+ * // @log:   '0x174876e800',
+ * // @log:   [['0x20c0000000000000000000000000000000000001', '0xf4240']],
+ * // @log:   '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ * // @log:   'secp256k1',
+ * // @log: ]
+ * ```
+ *
+ * @param authorization - The {@link ox#KeyAuthorization.KeyAuthorization}.
+ * @returns A Tempo Key Authorization tuple.
+ */
+export declare function toTuple<const authorization extends KeyAuthorization>(authorization: authorization): toTuple.ReturnType<authorization>;
+export declare namespace toTuple {
+    type ReturnType<authorization extends KeyAuthorization = KeyAuthorization> = Compute<Tuple<authorization extends KeyAuthorization<true> ? true : false>>;
+    type ErrorType = Errors.GlobalErrorType;
+}
+export {};
+//# sourceMappingURL=KeyAuthorization.d.ts.map

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

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

package/_types/tempo/PoolId.d.ts

@@ -0,0 +1,33 @@
+import * as Hex from '../core/Hex.js';
+import * as TokenId from './TokenId.js';
+/**
+ * Converts a user token and validator token to a pool ID.
+ *
+ * Pool IDs are deterministic keys derived from two token addresses (order-independent)
+ * used to identify trading pairs on Tempo's enshrined stablecoin DEX.
+ *
+ * [Stablecoin DEX Specification](https://docs.tempo.xyz/protocol/exchange/spec)
+ *
+ * @example
+ * ```ts twoslash
+ * import { PoolId } from 'ox/tempo'
+ *
+ * const poolId = PoolId.from({
+ *   userToken: 1n,
+ *   validatorToken: 2n,
+ * })
+ * ```
+ *
+ * @param value - User token and validator token.
+ * @returns The pool ID.
+ */
+export declare function from(value: from.Value): Hex.Hex;
+export declare namespace from {
+    type Value = {
+        /** User token. */
+        userToken: TokenId.TokenIdOrAddress;
+        /** Validator token. */
+        validatorToken: TokenId.TokenIdOrAddress;
+    };
+}
+//# sourceMappingURL=PoolId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PoolId.d.ts","sourceRoot":"","sources":["../../tempo/PoolId.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAA;AACrC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAO/C;AAED,MAAM,CAAC,OAAO,WAAW,IAAI,CAAC;IAC5B,KAAY,KAAK,GAAG;QAClB,kBAAkB;QAClB,SAAS,EAAE,OAAO,CAAC,gBAAgB,CAAA;QACnC,uBAAuB;QACvB,cAAc,EAAE,OAAO,CAAC,gBAAgB,CAAA;KACzC,CAAA;CACF"}