ox 0.9.16 → 0.10.0

package/_types/tempo/SignatureEnvelope.d.ts

@@ -0,0 +1,438 @@
+import type * as Address from '../core/Address.js';
+import * as Errors from '../core/Errors.js';
+import * as Hex from '../core/Hex.js';
+import type { Assign, Compute, IsNarrowable, OneOf, PartialBy, UnionPartialBy } from '../core/internal/types.js';
+import type * as PublicKey from '../core/PublicKey.js';
+import * as Signature from '../core/Signature.js';
+import type * as WebAuthnP256 from '../core/WebAuthnP256.js';
+/**
+ * Statically determines the signature type of an envelope at compile time.
+ *
+ * @example
+ * ```ts twoslash
+ * import type { SignatureEnvelope } from 'ox/tempo'
+ *
+ * type Type = SignatureEnvelope.GetType<{ r: bigint; s: bigint; yParity: number }>
+ * // @log: 'secp256k1'
+ * ```
+ */
+export type GetType<envelope extends PartialBy<SignatureEnvelope, 'type'> | unknown> = unknown extends envelope ? envelope extends unknown ? Type : never : envelope extends {
+    type: infer T extends Type;
+} ? T : envelope extends {
+    signature: {
+        r: bigint;
+        s: bigint;
+    };
+    prehash: boolean;
+    publicKey: PublicKey.PublicKey;
+} ? 'p256' : envelope extends {
+    signature: {
+        r: bigint;
+        s: bigint;
+    };
+    metadata: any;
+    publicKey: PublicKey.PublicKey;
+} ? 'webAuthn' : envelope extends {
+    r: bigint;
+    s: bigint;
+    yParity: number;
+} ? 'secp256k1' : envelope extends {
+    signature: {
+        r: bigint;
+        s: bigint;
+        yParity: number;
+    };
+} ? 'secp256k1' : envelope extends {
+    userAddress: Address.Address;
+} ? 'keychain' : never;
+/**
+ * Represents a signature envelope that can contain different signature types.
+ *
+ * Tempo transactions support multiple signature types, each with different wire formats:
+ *
+ * - **secp256k1** (no type prefix, 65 bytes): Standard Ethereum ECDSA signature. The sender
+ *   address is recovered via `ecrecover`. Base transaction cost: 21,000 gas.
+ *
+ * - **p256** (type `0x01`, 130 bytes): P256/secp256r1 curve signature for passkey accounts.
+ *   Includes embedded public key (64 bytes) and prehash flag. Enables native WebCrypto
+ *   key support. Additional gas cost: +5,000 gas over secp256k1.
+ *
+ * - **webAuthn** (type `0x02`, 129-2049 bytes): WebAuthn signature with authenticator data
+ *   and clientDataJSON. Enables browser passkey authentication. The signature is also
+ *   charged as calldata (16 gas/non-zero byte, 4 gas/zero byte).
+ *
+ * - **keychain** (type `0x03`): Access key signature that wraps an inner signature (secp256k1,
+ *   p256, or webAuthn). Format: `0x03` + user_address (20 bytes) + inner signature. The
+ *   protocol validates the access key authorization via the AccountKeychain precompile.
+ *
+ * [Signature Types Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#signature-types)
+ */
+export type SignatureEnvelope<bigintType = bigint, numberType = number> = OneOf<Secp256k1<bigintType, numberType> | P256<bigintType, numberType> | WebAuthn<bigintType, numberType> | Keychain<bigintType, numberType>>;
+/**
+ * RPC-formatted signature envelope.
+ */
+export type SignatureEnvelopeRpc = OneOf<Secp256k1Rpc | P256Rpc | WebAuthnRpc | KeychainRpc>;
+export type Keychain<bigintType = bigint, numberType = number> = {
+    /** Root account address that this transaction is being executed for */
+    userAddress: Address.Address;
+    /** The actual signature from the access key (can be Secp256k1, P256, or WebAuthn) */
+    inner: SignatureEnvelope<bigintType, numberType>;
+    type: 'keychain';
+};
+export type KeychainRpc = {
+    type: 'keychain';
+    userAddress: Address.Address;
+    signature: SignatureEnvelopeRpc;
+};
+export type P256<bigintType = bigint, numberType = number> = {
+    prehash: boolean;
+    publicKey: PublicKey.PublicKey;
+    signature: Signature.Signature<false, bigintType, numberType>;
+    type: 'p256';
+};
+export type P256Rpc = {
+    prehash: boolean;
+    pubKeyX: Hex.Hex;
+    pubKeyY: Hex.Hex;
+    r: Hex.Hex;
+    s: Hex.Hex;
+    type: 'p256';
+};
+export type Secp256k1<bigintType = bigint, numberType = number> = {
+    signature: Signature.Signature<true, bigintType, numberType>;
+    type: 'secp256k1';
+};
+export type Secp256k1Rpc = Compute<Signature.Rpc<true> & {
+    v?: Hex.Hex | undefined;
+    type: 'secp256k1';
+}>;
+export type Secp256k1Flat<bigintType = bigint, numberType = number> = Signature.Signature<true, bigintType, numberType> & {
+    type?: 'secp256k1' | undefined;
+};
+export type WebAuthn<bigintType = bigint, numberType = number> = {
+    metadata: Pick<WebAuthnP256.SignMetadata, 'authenticatorData' | 'clientDataJSON'>;
+    signature: Signature.Signature<false, bigintType, numberType>;
+    publicKey: PublicKey.PublicKey;
+    type: 'webAuthn';
+};
+export type WebAuthnRpc = {
+    pubKeyX: Hex.Hex;
+    pubKeyY: Hex.Hex;
+    r: Hex.Hex;
+    s: Hex.Hex;
+    type: 'webAuthn';
+    webauthnData: Hex.Hex;
+};
+/** Hex-encoded serialized signature envelope. */
+export type Serialized = Hex.Hex;
+/** List of supported signature types. */
+export declare const types: readonly ["secp256k1", "p256", "webAuthn"];
+/** Union type of supported signature types. */
+export type Type = (typeof types)[number];
+/**
+ * Asserts that a {@link ox#SignatureEnvelope.SignatureEnvelope} is valid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * SignatureEnvelope.assert({
+ *   type: 'secp256k1',
+ *   signature: {
+ *     r: 0n,
+ *     s: 0n,
+ *     yParity: 0,
+ *   },
+ * })
+ * ```
+ *
+ * @param envelope - The signature envelope to assert.
+ * @throws `CoercionError` if the envelope type cannot be determined.
+ */
+export declare function assert(envelope: PartialBy<SignatureEnvelope, 'type'>): void;
+export declare namespace assert {
+    type ErrorType = CoercionError | MissingPropertiesError | Signature.assert.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Deserializes a hex-encoded signature envelope into a typed signature object.
+ *
+ * Wire format detection:
+ * - 65 bytes (no prefix): secp256k1 signature
+ * - Type `0x01` + 129 bytes: P256 signature (r, s, pubKeyX, pubKeyY, prehash)
+ * - Type `0x02` + variable: WebAuthn signature (webauthnData, r, s, pubKeyX, pubKeyY)
+ * - Type `0x03` + 20 bytes + inner: Keychain signature (userAddress + inner signature)
+ *
+ * [Signature Types](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#signature-types)
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const envelope = SignatureEnvelope.deserialize('0x...')
+ * ```
+ *
+ * @param serialized - The hex-encoded signature envelope to deserialize.
+ * @returns The deserialized signature envelope.
+ * @throws `CoercionError` if the serialized value cannot be coerced to a valid signature envelope.
+ */
+export declare function deserialize(serialized: Serialized): SignatureEnvelope;
+/**
+ * Coerces a value to a signature envelope.
+ *
+ * Accepts either a serialized hex string or an existing signature envelope object.
+ * Use this to wrap raw signatures from {@link ox#Secp256k1.(sign:function)}, {@link ox#P256.(sign:function)},
+ * {@link ox#WebCryptoP256.(sign:function)}, or {@link ox#WebAuthnP256.(sign:function)} into the envelope format
+ * required by Tempo transactions.
+ *
+ * [Signature Types](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#signature-types)
+ *
+ * @example
+ * ### Secp256k1
+ *
+ * Standard Ethereum ECDSA signature using the secp256k1 curve.
+ *
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ * const signature = Secp256k1.sign({ payload: '0xdeadbeef', privateKey })
+ *
+ * const envelope = SignatureEnvelope.from(signature)
+ * ```
+ *
+ * @example
+ * ### P256
+ *
+ * ECDSA signature using the P-256 (secp256r1) curve. Requires embedding the
+ * public key.
+ *
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const { privateKey, publicKey } = P256.createKeyPair()
+ * const signature = P256.sign({ payload: '0xdeadbeef', privateKey })
+ *
+ * const envelope = SignatureEnvelope.from({
+ *   signature,
+ *   publicKey,
+ * })
+ * ```
+ *
+ * @example
+ * ### P256 (WebCrypto)
+ *
+ * When using WebCrypto keys, `prehash` must be `true` since WebCrypto always
+ * SHA256 hashes the digest before signing.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { WebCryptoP256 } from 'ox'
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const { privateKey, publicKey } = await WebCryptoP256.createKeyPair()
+ * const signature = await WebCryptoP256.sign({ payload: '0xdeadbeef', privateKey })
+ *
+ * const envelope = SignatureEnvelope.from({
+ *   signature,
+ *   publicKey,
+ *   prehash: true,
+ * })
+ * ```
+ *
+ * @example
+ * ### WebAuthn
+ *
+ * Passkey-based signature using WebAuthn. Includes authenticator metadata
+ * (authenticatorData and clientDataJSON) along with the P-256 signature and
+ * public key.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { WebAuthnP256 } from 'ox'
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const credential = await WebAuthnP256.createCredential({
+ *   name: 'Example',
+ * })
+ *
+ * const { metadata, signature } = await WebAuthnP256.sign({
+ *   challenge: '0xdeadbeef',
+ *   credentialId: credential.id,
+ * })
+ *
+ * const envelope = SignatureEnvelope.from({
+ *   signature,
+ *   publicKey: credential.publicKey,
+ *   metadata,
+ * })
+ * ```
+ *
+ * @example
+ * ### Keychain
+ *
+ * Wraps another signature type with a user address, used for delegated signing
+ * via access keys on behalf of a root account.
+ *
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ * const signature = Secp256k1.sign({ payload: '0xdeadbeef', privateKey })
+ *
+ * const envelope = SignatureEnvelope.from({
+ *   userAddress: '0x1234567890123456789012345678901234567890',
+ *   inner: SignatureEnvelope.from(signature),
+ * })
+ * ```
+ *
+ * @param value - The value to coerce (either a hex string or signature envelope).
+ * @returns The signature envelope.
+ */
+export declare function from<const value extends from.Value>(value: value | from.Value): from.ReturnValue<value>;
+export declare namespace from {
+    type Value = UnionPartialBy<SignatureEnvelope, 'prehash' | 'type'> | Secp256k1Flat | Serialized;
+    type ReturnValue<value extends Value> = Compute<OneOf<value extends Serialized ? SignatureEnvelope : value extends Secp256k1Flat ? Secp256k1 : IsNarrowable<value, SignatureEnvelope> extends true ? SignatureEnvelope : Assign<value, {
+        readonly type: GetType<value>;
+    }>>>;
+}
+/**
+ * Converts an RPC-formatted signature envelope to a typed signature envelope.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const envelope = SignatureEnvelope.fromRpc({
+ *   r: '0x0',
+ *   s: '0x0',
+ *   yParity: '0x0',
+ *   type: 'secp256k1',
+ * })
+ * ```
+ *
+ * @param envelope - The RPC signature envelope to convert.
+ * @returns The signature envelope with bigint values.
+ */
+export declare function fromRpc(envelope: SignatureEnvelopeRpc): SignatureEnvelope;
+export declare namespace fromRpc {
+    type ErrorType = CoercionError | InvalidSerializedError | Signature.fromRpc.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Determines the signature type of an envelope.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const type = SignatureEnvelope.getType({
+ *   signature: { r: 0n, s: 0n, yParity: 0 },
+ * })
+ * // @log: 'secp256k1'
+ * ```
+ *
+ * @param envelope - The signature envelope to inspect.
+ * @returns The signature type ('secp256k1', 'p256', or 'webAuthn').
+ * @throws `CoercionError` if the envelope type cannot be determined.
+ */
+export declare function getType<envelope extends PartialBy<SignatureEnvelope, 'type'> | Secp256k1Flat | unknown>(envelope: envelope): GetType<envelope>;
+/**
+ * Serializes a signature envelope to a hex-encoded string.
+ *
+ * Wire format:
+ * - secp256k1: 65 bytes (no type prefix, for backward compatibility)
+ * - P256: `0x01` + r (32) + s (32) + pubKeyX (32) + pubKeyY (32) + prehash (1) = 130 bytes
+ * - WebAuthn: `0x02` + webauthnData (variable) + r (32) + s (32) + pubKeyX (32) + pubKeyY (32)
+ * - Keychain: `0x03` + userAddress (20) + inner signature (recursive)
+ *
+ * [Signature Types](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#signature-types)
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const serialized = SignatureEnvelope.serialize({
+ *   signature: { r: 0n, s: 0n, yParity: 0 },
+ *   type: 'secp256k1',
+ * })
+ * ```
+ *
+ * @param envelope - The signature envelope to serialize.
+ * @returns The hex-encoded serialized signature.
+ * @throws `CoercionError` if the envelope cannot be serialized.
+ */
+export declare function serialize(envelope: UnionPartialBy<SignatureEnvelope, 'prehash'>): Serialized;
+/**
+ * Converts a signature envelope to RPC format.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const rpc = SignatureEnvelope.toRpc({
+ *   signature: { r: 0n, s: 0n, yParity: 0 },
+ *   type: 'secp256k1',
+ * })
+ * ```
+ *
+ * @param envelope - The signature envelope to convert.
+ * @returns The RPC signature envelope with hex values.
+ */
+export declare function toRpc(envelope: SignatureEnvelope): SignatureEnvelopeRpc;
+export declare namespace toRpc {
+    type ErrorType = CoercionError | Signature.toRpc.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Validates a signature envelope. Returns `true` if the envelope is valid, `false` otherwise.
+ *
+ * @example
+ * ```ts twoslash
+ * import { SignatureEnvelope } from 'ox/tempo'
+ *
+ * const valid = SignatureEnvelope.validate({
+ *   signature: { r: 0n, s: 0n, yParity: 0 },
+ *   type: 'secp256k1',
+ * })
+ * // @log: true
+ * ```
+ *
+ * @param envelope - The signature envelope to validate.
+ * @returns `true` if valid, `false` otherwise.
+ */
+export declare function validate(envelope: PartialBy<SignatureEnvelope, 'type'>): boolean;
+export declare namespace validate {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Error thrown when a signature envelope cannot be coerced to a valid type.
+ */
+export declare class CoercionError extends Errors.BaseError {
+    readonly name = "SignatureEnvelope.CoercionError";
+    constructor({ envelope }: {
+        envelope: unknown;
+    });
+}
+/**
+ * Error thrown when a signature envelope is missing required properties.
+ */
+export declare class MissingPropertiesError extends Errors.BaseError {
+    readonly name = "SignatureEnvelope.MissingPropertiesError";
+    constructor({ envelope, missing, type, }: {
+        envelope: unknown;
+        missing: string[];
+        type: Type;
+    });
+}
+/**
+ * Error thrown when a serialized signature envelope cannot be deserialized.
+ */
+export declare class InvalidSerializedError extends Errors.BaseError {
+    readonly name = "SignatureEnvelope.InvalidSerializedError";
+    constructor({ reason, serialized, }: {
+        reason: string;
+        serialized: Hex.Hex;
+    });
+}
+//# sourceMappingURL=SignatureEnvelope.d.ts.map

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

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

package/_types/tempo/Tick.d.ts

@@ -0,0 +1,120 @@
+import * as Errors from '../core/Errors.js';
+/**
+ * Minimum allowed tick value (-2% from peg).
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ */
+export declare const minTick = -2000;
+/**
+ * Maximum allowed tick value (+2% from peg).
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ */
+export declare const maxTick = 2000;
+/**
+ * Price scaling factor (5 decimal places for 0.1 bps precision).
+ *
+ * The DEX uses a tick-based pricing system where `price = PRICE_SCALE + tick`.
+ * Orders must be placed at ticks divisible by `TICK_SPACING = 10` (1 bp grid).
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ */
+export declare const priceScale = 100000;
+/**
+ * Tick type.
+ */
+export type Tick = number;
+/**
+ * Converts a tick to a price string.
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ *
+ * @example
+ * ```ts
+ * import { Tick } from 'ox/tempo'
+ *
+ * // Tick 0 = price of 1.0
+ * const price1 = Tick.toPrice(0) // "1"
+ *
+ * // Tick 100 = price of 1.001 (0.1% higher)
+ * const price2 = Tick.toPrice(100) // "1.001"
+ *
+ * // Tick -100 = price of 0.999 (0.1% lower)
+ * const price3 = Tick.toPrice(-100) // "0.999"
+ * ```
+ *
+ * @param tick - The tick value (range: -2000 to +2000).
+ * @returns The price as a string with exact decimal representation.
+ * @throws `TickOutOfBoundsError` If tick is out of bounds.
+ */
+export declare function toPrice(tick: toPrice.Tick): toPrice.ReturnType;
+export declare namespace toPrice {
+    type Tick = number;
+    type ReturnType = string;
+}
+/**
+ * Converts a price string to a tick.
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ *
+ * @example
+ * ```ts
+ * import { Tick } from 'ox/tempo'
+ *
+ * // Price of 1.0 = tick 0
+ * const tick1 = Tick.fromPrice('1.0') // 0
+ * const tick2 = Tick.fromPrice('1.00000') // 0
+ *
+ * // Price of 1.001 = tick 100
+ * const tick3 = Tick.fromPrice('1.001') // 100
+ *
+ * // Price of 0.999 = tick -100
+ * const tick4 = Tick.fromPrice('0.999') // -100
+ * ```
+ *
+ * @param price - The price as a string (e.g., "1.001", "0.999").
+ * @returns The tick value.
+ */
+export declare function fromPrice(price: fromPrice.Price): fromPrice.ReturnType;
+export declare namespace fromPrice {
+    type Price = string;
+    type ReturnType = number;
+}
+/**
+ * Error thrown when a tick value is out of the allowed bounds.
+ */
+export declare class TickOutOfBoundsError extends Errors.BaseError {
+    readonly name = "Tick.TickOutOfBoundsError";
+    constructor(options: TickOutOfBoundsError.Options);
+}
+export declare namespace TickOutOfBoundsError {
+    type Options = {
+        tick: number;
+    };
+}
+/**
+ * Error thrown when a price string has an invalid format.
+ */
+export declare class InvalidPriceFormatError extends Errors.BaseError {
+    readonly name = "Tick.InvalidPriceFormatError";
+    constructor(options: InvalidPriceFormatError.Options);
+}
+export declare namespace InvalidPriceFormatError {
+    type Options = {
+        price: string;
+    };
+}
+/**
+ * Error thrown when a price string results in an out-of-bounds tick.
+ */
+export declare class PriceOutOfBoundsError extends Errors.BaseError {
+    readonly name = "Tick.PriceOutOfBoundsError";
+    constructor(options: PriceOutOfBoundsError.Options);
+}
+export declare namespace PriceOutOfBoundsError {
+    type Options = {
+        price: string;
+        tick: number;
+    };
+}
+//# sourceMappingURL=Tick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tick.d.ts","sourceRoot":"","sources":["../../tempo/Tick.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,OAAO,QAAQ,CAAA;AAE5B;;;;GAIG;AACH,eAAO,MAAM,OAAO,OAAO,CAAA;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,SAAU,CAAA;AAEjC;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAA;AAEzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC,UAAU,CAa9D;AAED,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,KAAY,IAAI,GAAG,MAAM,CAAA;IACzB,KAAY,UAAU,GAAG,MAAM,CAAA;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,UAAU,CAsBtE;AAED,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IACjC,KAAY,KAAK,GAAG,MAAM,CAAA;IAC1B,KAAY,UAAU,GAAG,MAAM,CAAA;CAChC;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,MAAM,CAAC,SAAS;IACxD,SAAkB,IAAI,+BAA8B;gBAExC,OAAO,EAAE,oBAAoB,CAAC,OAAO;CAKlD;AAED,MAAM,CAAC,OAAO,WAAW,oBAAoB,CAAC;IAC5C,KAAY,OAAO,GAAG;QACpB,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;CACF;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,MAAM,CAAC,SAAS;IAC3D,SAAkB,IAAI,kCAAiC;gBAE3C,OAAO,EAAE,uBAAuB,CAAC,OAAO;CAKrD;AAED,MAAM,CAAC,OAAO,WAAW,uBAAuB,CAAC;IAC/C,KAAY,OAAO,GAAG;QACpB,KAAK,EAAE,MAAM,CAAA;KACd,CAAA;CACF;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,SAAS;IACzD,SAAkB,IAAI,gCAA+B;gBAEzC,OAAO,EAAE,qBAAqB,CAAC,OAAO;CAQnD;AAED,MAAM,CAAC,OAAO,WAAW,qBAAqB,CAAC;IAC7C,KAAY,OAAO,GAAG;QACpB,KAAK,EAAE,MAAM,CAAA;QACb,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;CACF"}

package/_types/tempo/TokenId.d.ts

@@ -0,0 +1,55 @@
+import * as Address from '../core/Address.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('0x20c00000000000000000000000000000000000000001')
+ * ```
+ *
+ * @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;
+//# sourceMappingURL=TokenId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TokenId.d.ts","sourceRoot":"","sources":["../../tempo/TokenId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAK7C,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;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,OAAO,CAI7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAQpE"}

package/_types/tempo/TokenRole.d.ts

@@ -0,0 +1,29 @@
+export declare const roles: readonly ["defaultAdmin", "pause", "unpause", "issuer", "burnBlocked"];
+export type TokenRole = (typeof roles)[number];
+export declare const toPreHashed: {
+    readonly defaultAdmin: "DEFAULT_ADMIN_ROLE";
+    readonly pause: "PAUSE_ROLE";
+    readonly unpause: "UNPAUSE_ROLE";
+    readonly issuer: "ISSUER_ROLE";
+    readonly burnBlocked: "BURN_BLOCKED_ROLE";
+};
+/**
+ * Serializes a token role to its keccak256 hash representation.
+ *
+ * TIP-20 includes a built-in RBAC system with roles like `ISSUER_ROLE` (mint/burn),
+ * `PAUSE_ROLE`/`UNPAUSE_ROLE` (emergency controls), and `BURN_BLOCKED_ROLE` (compliance).
+ *
+ * [TIP-20 RBAC](https://docs.tempo.xyz/protocol/tip20/overview#role-based-access-control-rbac)
+ *
+ * @example
+ * ```ts twoslash
+ * import { TokenRole } from 'ox/tempo'
+ *
+ * const hash = TokenRole.serialize('issuer')
+ * ```
+ *
+ * @param role - The token role to serialize.
+ * @returns The keccak256 hash of the role.
+ */
+export declare function serialize(role: TokenRole): `0x${string}`;
+//# sourceMappingURL=TokenRole.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TokenRole.d.ts","sourceRoot":"","sources":["../../tempo/TokenRole.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK,wEAMR,CAAA;AACV,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9C,eAAO,MAAM,WAAW;;;;;;CAMsB,CAAA;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,iBAMxC"}