@crossmint/wallets-sdk 0.21.0 → 1.0.0-beta.2

package/dist/types-D-xASbms.d.cts

@@ -0,0 +1,425 @@
+import { VersionedTransaction, Keypair } from '@solana/web3.js';
+import { HandshakeParent } from '@crossmint/client-sdk-window';
+import { exportSignerOutboundEvents, exportSignerInboundEvents, signerOutboundEvents, signerInboundEvents } from '@crossmint/client-signers';
+import { Address, TypedDataDefinition, TypedData } from 'viem';
+import { Abi } from 'abitype';
+import { CreateWalletV2025Dto, WalletV2025ResponseDto, WalletV1Alpha2ErrorDto, CreateTransactionV2025Dto, WalletsTransactionV2025ResponseDto, WalletV1Alpha2TransactionErrorDto, SubmitApprovalV2025Dto, WalletsV2025ControllerSubmitApprovals2Error, WalletsV2025ControllerGetTransaction2Error, CreateSignatureV2025Dto, WalletsSignatureV2025ResponseDto, WalletsV2025ControllerCreateSignatureRequest2Error, WalletsV2025ControllerSubmitSignatureApprovals2Error, WalletsV2025ControllerGetSignature2Error, WalletsMultipleTransactionV2025ResponseDto, WalletsV2025ControllerGetTransactionsWithoutChain2Error, WalletsActivityResponseUnstableDto, WalletBalanceV20250609ResponseDto, BalanceControllerGetBalanceForLocator2Error, FundWalletAmountDto, BalanceControllerFundWallet2Responses, BalanceControllerFundWallet2Error, CreateSignerV2025InputDto, DelegatedSignerV2025Dto, WalletsV2025ControllerCreateDelegatedSigner2Error, WalletsV2025ControllerGetDelegatedSigner2Error, SendTokenDto, WalletsSendTokenControllerSendToken2Response } from './api/gen/types.gen.cjs';
+import { WebAuthnP256 } from 'ox';
+import { SolanaExternalWalletSignerConfig, StellarExternalWalletSignerConfig, EvmExternalWalletSignerConfig, Crossmint } from '@crossmint/common-sdk-base';
+import { Chain, SolanaChain, StellarChain, EVMSmartWalletChain } from './chains/chains.cjs';
+import { DeviceSignerKeyStorage } from './utils/device-signers/DeviceSignerKeyStorage.cjs';
+
+type ExternalWalletRegistrationConfig = {
+    type: "external-wallet";
+    address: string;
+};
+declare class AuthRejectedError extends Error {
+    constructor();
+}
+type EmailSignerConfig = {
+    type: "email";
+    email?: string;
+    locator?: string;
+};
+type PhoneSignerConfig = {
+    type: "phone";
+    phone?: string;
+    locator?: string;
+};
+type NonCustodialSignerType = PhoneSignerConfig["type"] | EmailSignerConfig["type"];
+type ExternalWalletSignerConfigForChain<C extends Chain> = C extends SolanaChain ? SolanaExternalWalletSignerConfig : C extends StellarChain ? StellarExternalWalletSignerConfig : EvmExternalWalletSignerConfig;
+type ApiKeySignerConfig = {
+    type: "api-key";
+};
+type ServerSignerConfig = {
+    type: "server";
+    secret: string;
+};
+type BaseSignerConfig<C extends Chain> = ExternalWalletSignerConfigForChain<C> | ApiKeySignerConfig | ServerSignerConfig;
+type PasskeySignerConfig = {
+    type: "passkey";
+    name?: string;
+    id?: string;
+    locator?: string;
+    onCreatePasskey?: (name: string) => Promise<{
+        id: string;
+        publicKey: {
+            x: string;
+            y: string;
+        };
+    }>;
+    onSignWithPasskey?: (message: string) => Promise<PasskeySignResult>;
+};
+type BaseInternalSignerConfig = {
+    locator: SignerLocator;
+    address: string;
+    crossmint: Crossmint;
+    clientTEEConnection?: HandshakeParent<typeof signerOutboundEvents, typeof signerInboundEvents>;
+};
+type EmailInternalSignerConfig = EmailSignerConfig & Omit<BaseInternalSignerConfig, "locator"> & {
+    locator: EmailSignerLocator;
+    onAuthRequired?: Callbacks["onAuthRequired"];
+};
+type PhoneInternalSignerConfig = PhoneSignerConfig & Omit<BaseInternalSignerConfig, "locator"> & {
+    locator: PhoneSignerLocator;
+    onAuthRequired?: Callbacks["onAuthRequired"];
+};
+type DeviceInternalSignerConfig = {
+    type: "device";
+    locator?: DeviceSignerLocator;
+    address: string;
+};
+type PasskeyInternalSignerConfig = PasskeySignerConfig & {
+    locator: PasskeySignerLocator;
+    id: string;
+};
+type ApiKeyInternalSignerConfig = ApiKeySignerConfig & {
+    locator: ApiKeySignerLocator;
+    address: string;
+};
+type ExternalWalletInternalSignerConfig<C extends Chain> = ExternalWalletSignerConfigForChain<C> & {
+    locator: ExternalWalletSignerLocator;
+};
+type ServerInternalSignerConfig = {
+    type: "server";
+    /** The derived chain-specific private key bytes */
+    derivedKeyBytes: Uint8Array;
+    locator: ServerSignerLocator;
+    address: string;
+};
+type InternalSignerConfig<C extends Chain> = EmailInternalSignerConfig | PhoneInternalSignerConfig | PasskeyInternalSignerConfig | ApiKeyInternalSignerConfig | ExternalWalletInternalSignerConfig<C> | DeviceInternalSignerConfig | ServerInternalSignerConfig;
+type BaseSignResult = {
+    signature: string;
+};
+type DeviceSignResult = {
+    signature: {
+        r: string;
+        s: string;
+    };
+};
+type PasskeySignResult = {
+    signature: {
+        r: string;
+        s: string;
+    };
+    metadata: WebAuthnP256.SignMetadata;
+};
+type DeviceSignerConfig = {
+    type: "device";
+    publicKey?: {
+        x: string;
+        y: string;
+    };
+    locator?: string;
+};
+type SignerConfigForChain<C extends Chain> = C extends SolanaChain ? EmailSignerConfig | PhoneSignerConfig | BaseSignerConfig<C> | DeviceSignerConfig : C extends StellarChain ? EmailSignerConfig | PhoneSignerConfig | BaseSignerConfig<C> | DeviceSignerConfig : EmailSignerConfig | PhoneSignerConfig | PasskeySignerConfig | BaseSignerConfig<C> | DeviceSignerConfig;
+type EmailSignerLocator = `email:${string}`;
+type PhoneSignerLocator = `phone:${string}`;
+type PasskeySignerLocator = `passkey:${string}`;
+type DeviceSignerLocator = `device:${string}`;
+type ExternalWalletSignerLocator = `external-wallet:${string}`;
+type ApiKeySignerLocator = "api-key" | `api-key:${string}`;
+type ServerSignerLocator = `server:${string}`;
+type SignerLocator = EmailSignerLocator | PhoneSignerLocator | PasskeySignerLocator | DeviceSignerLocator | ExternalWalletSignerLocator | ApiKeySignerLocator | ServerSignerLocator;
+type SignResultMap = {
+    email: BaseSignResult;
+    phone: BaseSignResult;
+    "api-key": BaseSignResult;
+    "external-wallet": BaseSignResult;
+    server: BaseSignResult;
+    passkey: PasskeySignResult;
+    device: DeviceSignResult;
+};
+interface Signer<T extends keyof SignResultMap = keyof SignResultMap> {
+    type: T;
+    locator(): SignerLocator;
+    address?(): string;
+    signMessage(message: string): Promise<SignResultMap[T]>;
+    signTransaction(transaction: string): Promise<SignResultMap[T]>;
+}
+interface ExportableSigner extends Signer {
+    _exportPrivateKey: (exportTEEConnection: ExportSignerTEEConnection) => Promise<void>;
+}
+declare function isExportableSigner(signer: Signer): signer is ExportableSigner;
+type ExportSignerTEEConnection = HandshakeParent<typeof exportSignerOutboundEvents, typeof exportSignerInboundEvents>;
+
+type CreateWalletParams = CreateWalletV2025Dto;
+type GetWalletSuccessResponse = WalletV2025ResponseDto;
+type CreateWalletResponse = GetWalletSuccessResponse | WalletV1Alpha2ErrorDto;
+type GetWalletResponse = GetWalletSuccessResponse | WalletV1Alpha2ErrorDto;
+type AdminSignerConfig = NonNullable<Extract<CreateWalletV2025Dto, {
+    config: {
+        adminSigner: Record<string, unknown>;
+    };
+}>["config"]>["adminSigner"];
+type CreateTransactionParams = CreateTransactionV2025Dto;
+type CreateTransactionSuccessResponse = WalletsTransactionV2025ResponseDto;
+type CreateTransactionResponse = CreateTransactionSuccessResponse | WalletV1Alpha2TransactionErrorDto;
+type ApproveTransactionParams = SubmitApprovalV2025Dto;
+type ApproveTransactionResponse = WalletsTransactionV2025ResponseDto | WalletsV2025ControllerSubmitApprovals2Error;
+type GetTransactionResponse = WalletsTransactionV2025ResponseDto | WalletsV2025ControllerGetTransaction2Error;
+type GetTransactionSuccessResponse = WalletsTransactionV2025ResponseDto;
+type CreateSignatureParams = CreateSignatureV2025Dto;
+type CreateSignatureResponse = WalletsSignatureV2025ResponseDto | WalletsV2025ControllerCreateSignatureRequest2Error;
+type ApproveSignatureParams = SubmitApprovalV2025Dto;
+type ApproveSignatureResponse = WalletsSignatureV2025ResponseDto | WalletsV2025ControllerSubmitSignatureApprovals2Error;
+type GetSignatureResponse = WalletsSignatureV2025ResponseDto | WalletsV2025ControllerGetSignature2Error;
+type GetTransactionsResponse = WalletsMultipleTransactionV2025ResponseDto | WalletsV2025ControllerGetTransactionsWithoutChain2Error;
+type GetBalanceResponse = WalletBalanceV20250609ResponseDto | BalanceControllerGetBalanceForLocator2Error;
+type GetBalanceSuccessResponse = WalletBalanceV20250609ResponseDto;
+type GetTransfersResponse = WalletsActivityResponseUnstableDto | WalletV1Alpha2ErrorDto;
+type Transfers = WalletsActivityResponseUnstableDto;
+type FundWalletParams = FundWalletAmountDto;
+type FundWalletResponse = BalanceControllerFundWallet2Responses | BalanceControllerFundWallet2Error;
+type RegisterSignerChain = Extract<CreateSignerV2025InputDto, {
+    chain: string;
+}>["chain"];
+type RegisterSignerPasskeyParams = Extract<CreateSignerV2025InputDto["signer"], {
+    type: "passkey";
+}>;
+type RegisterSignerParams = {
+    signer: SignerLocator | RegisterSignerPasskeyParams | SignerConfigForChain<Chain>;
+    chain?: RegisterSignerChain;
+};
+type RegisterSignerResponse = DelegatedSignerV2025Dto | WalletsV2025ControllerCreateDelegatedSigner2Error;
+type GetSignerResponse = DelegatedSignerV2025Dto | WalletsV2025ControllerGetDelegatedSigner2Error;
+type GetDelegatedSignersResponse = Array<DelegatedSignerV2025Dto> | WalletsV2025ControllerGetDelegatedSigner2Error;
+type DelegatedSigner$1 = DelegatedSignerV2025Dto;
+type SendParams = SendTokenDto;
+type SendResponse = WalletsSendTokenControllerSendToken2Response;
+type WalletType = "smart" | "mpc";
+type SolanaAddress = string;
+type EvmWalletLocator = `me:evm:${WalletType}` | Address;
+type SolanaWalletLocator = `me:solana:${WalletType}` | SolanaAddress;
+type WalletLocator = EvmWalletLocator | SolanaWalletLocator;
+
+type PrepareOnly<T extends boolean = boolean> = {
+    prepareOnly: T;
+};
+type SendTokenTransactionType = "onramp" | "regulated-transfer" | "direct";
+type TransactionInputOptions = PrepareOnly & {
+    signer?: string | ServerSignerConfig;
+};
+type SendTokenTransactionOptions = TransactionInputOptions & {
+    transactionType?: SendTokenTransactionType;
+};
+type SignatureInputOptions = PrepareOnly;
+type AddSignerOptions = PrepareOnly;
+type AddSignerReturnType<C extends Chain> = C extends "solana" | "stellar" ? DelegatedSigner & {
+    transactionId: string;
+} : DelegatedSigner & {
+    signatureId?: string;
+};
+type SignMessageInput = {
+    message: string;
+    options?: SignatureInputOptions;
+};
+type SignTypedDataInput = TypedDataDefinition<TypedData, string> & {
+    chain: EVMSmartWalletChain;
+    options?: SignatureInputOptions;
+};
+type ApproveResult<T extends ApproveParams> = T extends {
+    transactionId: string;
+} ? Transaction<false> : T extends {
+    signatureId: string;
+} ? Signature<false> : Error;
+type EVMTransactionInputBase = {
+    options?: TransactionInputOptions;
+};
+type EVMTransactionInput = EVMTransactionInputBase & ({
+    to: string;
+    functionName?: string;
+    args?: unknown[];
+    value?: bigint;
+    abi?: Abi;
+    data?: `0x${string}`;
+} | {
+    transaction: string;
+});
+type StellarTransactionInput = ({
+    contractId: string;
+    method: string;
+    memo?: string;
+    args: Record<string, unknown>;
+} | {
+    transaction: string;
+    contractId: string;
+}) & {
+    options?: TransactionInputOptions;
+};
+type SolanaTransactionInput = ({
+    transaction: VersionedTransaction;
+} | {
+    serializedTransaction: string;
+}) & {
+    additionalSigners?: Keypair[];
+    options?: TransactionInputOptions;
+};
+type FormattedEVMTransaction = {
+    to: string;
+    value: string;
+    data: string;
+} | {
+    transaction: string;
+};
+type SignerStatus = "success" | "pending" | "awaiting-approval" | "failed";
+type DelegatedSignerInput = {
+    signer: string | ServerSignerConfig;
+};
+type DelegatedSigner = {
+    type: "passkey";
+    id: string;
+    name: string;
+    publicKey: {
+        x: string;
+        y: string;
+    };
+    validatorContractVersion: string;
+    locator: string;
+    status: SignerStatus;
+} | {
+    type: "api-key";
+    address: string;
+    locator: string;
+    status: SignerStatus;
+} | {
+    type: "external-wallet";
+    address: string;
+    locator: string;
+    status: SignerStatus;
+} | {
+    type: "email";
+    email: string;
+    address: string;
+    locator: string;
+    status: SignerStatus;
+} | {
+    type: "phone";
+    phone: string;
+    address: string;
+    locator: string;
+    status: SignerStatus;
+} | {
+    type: "device";
+    publicKey: {
+        x: string;
+        y: string;
+    };
+    locator: string;
+    status: SignerStatus;
+} | {
+    type: "server";
+    address: string;
+    locator: string;
+    status: SignerStatus;
+};
+type PendingApproval = NonNullable<NonNullable<CreateTransactionSuccessResponse["approvals"]>["pending"]>[number];
+type Callbacks = {
+    onWalletCreationStart?: () => Promise<void>;
+    onTransactionStart?: () => Promise<void>;
+    onAuthRequired?: (signerType: "email" | "phone", signerLocator: string, needsAuth: boolean, sendOtp: () => Promise<void>, verifyOtp: (otp: string) => Promise<void>, reject: () => void) => Promise<void>;
+};
+type StellarWalletPlugin = string;
+type WalletPlugin<C extends Chain> = C extends StellarChain ? StellarWalletPlugin : never;
+type WalletOptions = {
+    callbacks?: Callbacks;
+    clientTEEConnection?: HandshakeParent<typeof signerOutboundEvents, typeof signerInboundEvents>;
+    deviceSignerKeyStorage?: DeviceSignerKeyStorage;
+};
+type WalletArgsFor<C extends Chain> = {
+    /** The blockchain to create the wallet on (e.g. "base-sepolia"). */
+    chain: C;
+    /** Optional owner identifier. */
+    owner?: string;
+    /** Optional array of wallet plugins. */
+    plugins?: WalletPlugin<C>[];
+    options?: WalletOptions;
+    /** Optional wallet alias. */
+    alias?: string;
+};
+type WalletCreateArgs<C extends Chain> = WalletArgsFor<C> & {
+    /** Recovery signer for wallet creation. Device signers cannot be recovery signers. */
+    recovery: Exclude<SignerConfigForChain<C>, DeviceSignerConfig>;
+    /** Signers to register on the wallet during creation. */
+    signers?: Array<SignerConfigForChain<C> | ExternalWalletRegistrationConfig>;
+    alias?: string;
+};
+/**
+ * A device signer descriptor containing the public key and locator.
+ * Returned by `createDeviceSigner`.
+ */
+type DeviceSignerDescriptor = {
+    type: "device";
+    publicKey: {
+        x: string;
+        y: string;
+    };
+    locator: DeviceSignerLocator;
+};
+type ClientSideWalletArgsFor<C extends Chain> = Omit<WalletArgsFor<C>, "owner">;
+type ClientSideWalletCreateArgs<C extends Chain> = Omit<WalletCreateArgs<C>, "owner">;
+type ChainExtras = {
+    solana: {
+        mintHash?: string;
+    };
+    stellar: {
+        contractId?: string;
+    };
+    evm: {
+        contractAddress?: string;
+    };
+};
+type ChainToExtrasKey<C extends Chain> = C extends "solana" ? "solana" : C extends "stellar" ? "stellar" : "evm";
+type TokenBalance<C extends Chain = Chain> = {
+    symbol: "sol" | "eth" | "usdc" | string;
+    name: string;
+    amount: string;
+    decimals?: number;
+    rawAmount?: string;
+} & ChainExtras[ChainToExtrasKey<C>];
+type Balances<C extends Chain = Chain> = {
+    nativeToken: TokenBalance<C>;
+    usdc: TokenBalance<C>;
+    tokens: TokenBalance<C>[];
+};
+type UserLocator = {
+    email: string;
+} | {
+    x: string;
+} | {
+    twitter: string;
+} | {
+    phone: string;
+} | {
+    userId: string;
+};
+type Transaction<TPrepareOnly extends boolean = false> = TPrepareOnly extends true ? {
+    hash?: string;
+    explorerLink?: string;
+    transactionId: string;
+} : {
+    hash: string;
+    explorerLink: string;
+    transactionId: string;
+};
+type Signature<TPrepareOnly extends boolean = false> = TPrepareOnly extends true ? {
+    signature?: string;
+    signatureId: string;
+} : {
+    signature: string;
+    signatureId: string;
+};
+type ApproveOptions = {
+    approval?: Approval;
+    additionalSigners?: Signer[];
+};
+type ApproveParams = {
+    transactionId?: string;
+    signatureId?: string;
+    options?: ApproveOptions;
+};
+type Approval = (BaseSignResult | PasskeySignResult | DeviceSignResult) & {
+    signer: string;
+};
+
+export { type ApproveParams as $, type ApiKeySignerLocator as A, type Balances as B, type ClientSideWalletArgsFor as C, type DelegatedSigner as D, type EVMTransactionInput as E, type ApiKeyInternalSignerConfig as F, type ExternalWalletInternalSignerConfig as G, type PasskeyInternalSignerConfig as H, type InternalSignerConfig as I, type PasskeySignResult as J, type DelegatedSigner$1 as K, type PrepareOnly as L, type SignMessageInput as M, type SignTypedDataInput as N, type TransactionInputOptions as O, type PhoneSignerConfig as P, type StellarTransactionInput as Q, type RegisterSignerPasskeyParams as R, type SignerStatus as S, type Transfers as T, type WalletLocator as U, type FundWalletResponse as V, type WalletArgsFor as W, type GetTransactionsResponse as X, type GetTransactionSuccessResponse as Y, type SendTokenTransactionOptions as Z, type UserLocator as _, type ClientSideWalletCreateArgs as a, type ApproveResult as a0, type AddSignerOptions as a1, type AddSignerReturnType as a2, type ApproveOptions as a3, type ApproveSignatureResponse as a4, type CreateWalletResponse as a5, type SendResponse as a6, type CreateWalletParams as a7, type GetTransactionResponse as a8, type EmailInternalSignerConfig as a9, type NonCustodialSignerType as aA, type ApiKeySignerConfig as aB, type BaseSignerConfig as aC, type PasskeySignerConfig as aD, type DeviceSignerConfig as aE, type ServerSignerLocator as aF, type SendTokenTransactionType as aG, type SignatureInputOptions as aH, type FormattedEVMTransaction as aI, type DelegatedSignerInput as aJ, type PendingApproval as aK, type StellarWalletPlugin as aL, type TokenBalance as aM, type Approval as aN, type PhoneInternalSignerConfig as aa, type BaseSignResult as ab, type ServerInternalSignerConfig as ac, type GetWalletResponse as ad, type CreateTransactionParams as ae, type CreateTransactionResponse as af, type ApproveTransactionParams as ag, type ApproveTransactionResponse as ah, type CreateSignatureParams as ai, type CreateSignatureResponse as aj, type ApproveSignatureParams as ak, type GetSignatureResponse as al, type GetTransfersResponse as am, type GetBalanceResponse as an, type FundWalletParams as ao, type RegisterSignerParams as ap, type RegisterSignerResponse as aq, type GetSignerResponse as ar, type SendParams as as, type GetWalletSuccessResponse as at, type AdminSignerConfig as au, type CreateTransactionSuccessResponse as av, type GetBalanceSuccessResponse as aw, type RegisterSignerChain as ax, type GetDelegatedSignersResponse as ay, AuthRejectedError as az, type DeviceSignerDescriptor as b, type Transaction as c, type WalletCreateArgs as d, type Callbacks as e, type WalletOptions as f, type WalletPlugin as g, type Signature as h, type SolanaTransactionInput as i, isExportableSigner as j, type EmailSignerConfig as k, type ExternalWalletRegistrationConfig as l, type ExternalWalletSignerConfigForChain as m, type ServerSignerConfig as n, type SignerConfigForChain as o, type SignerLocator as p, type EmailSignerLocator as q, type PhoneSignerLocator as r, type PasskeySignerLocator as s, type DeviceSignerLocator as t, type ExternalWalletSignerLocator as u, type ExportableSigner as v, type ExportSignerTEEConnection as w, type Signer as x, type DeviceInternalSignerConfig as y, type DeviceSignResult as z };

package/dist/utils/constants.cjs

@@ -1,13 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-var _chunk3WZUNLYIcjs = require('../chunk-3WZUNLYI.cjs');
-require('../chunk-UO2J2ZB2.cjs');
-
-
-
-
-
-exports.SDK_NAME = _chunk3WZUNLYIcjs.SDK_NAME; exports.SDK_VERSION = _chunk3WZUNLYIcjs.SDK_VERSION; exports.STATUS_POLLING_INTERVAL_MS = _chunk3WZUNLYIcjs.STATUS_POLLING_INTERVAL_MS; exports.WALLETS_SERVICE = _chunk3WZUNLYIcjs.WALLETS_SERVICE;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkU7QSF6P7cjs = require('../chunk-U7QSF6P7.cjs');require('../chunk-2GKPWQBQ.cjs');exports.SDK_NAME = _chunkU7QSF6P7cjs.c; exports.SDK_VERSION = _chunkU7QSF6P7cjs.b; exports.STATUS_POLLING_INTERVAL_MS = _chunkU7QSF6P7cjs.d; exports.WALLETS_SERVICE = _chunkU7QSF6P7cjs.a;

package/dist/utils/constants.js

@@ -1,13 +1 @@
-import {
-  SDK_NAME,
-  SDK_VERSION,
-  STATUS_POLLING_INTERVAL_MS,
-  WALLETS_SERVICE
-} from "../chunk-GLUD6EBN.js";
-import "../chunk-ASE2FXWP.js";
-export {
-  SDK_NAME,
-  SDK_VERSION,
-  STATUS_POLLING_INTERVAL_MS,
-  WALLETS_SERVICE
-};
+import{a,b,c,d}from"../chunk-TYFWX53A.js";import"../chunk-J3R36SGJ.js";export{c as SDK_NAME,b as SDK_VERSION,d as STATUS_POLLING_INTERVAL_MS,a as WALLETS_SERVICE};

package/dist/utils/device-signers/DeviceSignerKeyStorage.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkD5YDWSO5cjs = require('../../chunk-D5YDWSO5.cjs');require('../../chunk-2GKPWQBQ.cjs');exports.DeviceSignerKeyStorage = _chunkD5YDWSO5cjs.a;

package/dist/utils/device-signers/DeviceSignerKeyStorage.d.cts

@@ -0,0 +1,66 @@
+/**
+ * Abstract storage interface for managing P-256 (secp256r1) device signer key pairs.
+ * Implementations handle key generation, persistence, retrieval, signing, and deletion.
+ */
+type BiometricPolicy = "always" | "session" | "none";
+declare abstract class DeviceSignerKeyStorage {
+    protected readonly apiKey: string;
+    constructor(apiKey: string);
+    /**
+     * Generate a new P-256 key pair and persist it.
+     * @param params - Key generation parameters.
+     * @param params.address - Optional wallet address to associate the key with. If omitted, the key
+     *                         should be stored under a temporary identifier until {@link mapAddressToKey} is called.
+     * @returns The uncompressed public key encoded as a base64 string.
+     */
+    abstract generateKey(params: {
+        address?: string;
+        biometricPolicy?: Exclude<BiometricPolicy, "session">;
+    }): Promise<string>;
+    abstract generateKey(params: {
+        address?: string;
+        biometricPolicy: "session";
+        biometricExpirationTime: number;
+    }): Promise<string>;
+    abstract generateKey(params: {
+        address?: string;
+        biometricPolicy?: BiometricPolicy;
+        biometricExpirationTime?: number;
+    }): Promise<string>;
+    /**
+     * Associate an already-generated key pair with a wallet address.
+     * Used when the wallet address is not yet known at the time of key generation.
+     * @param address - The wallet address to map the key to.
+     * @param publicKeyBase64 - The base64-encoded public key returned by {@link generateKey}.
+     */
+    abstract mapAddressToKey(address: string, publicKeyBase64: string): Promise<void>;
+    /**
+     * Retrieve the public key for a given wallet address.
+     * @param address - The wallet address whose public key to look up.
+     * @returns The base64-encoded public key, or `null` if no key is found for the address.
+     */
+    abstract getKey(address: string): Promise<string | null>;
+    /**
+     * Check if a key with the given public key exists on this device.
+     * @param publicKeyBase64 - The base64-encoded public key to look for.
+     * @returns `true` if the key exists on the device, `false` otherwise.
+     */
+    abstract hasKey(publicKeyBase64: string): Promise<boolean>;
+    /**
+     * Sign a message using the private key associated with the given wallet address.
+     * @param address - The wallet address whose private key to sign with.
+     * @param message - The message string to sign.
+     * @returns The ECDSA signature split into its `r` and `s` components, each as a hex string.
+     */
+    abstract signMessage(address: string, message: string): Promise<{
+        r: string;
+        s: string;
+    }>;
+    /**
+     * Delete the key pair associated with the given wallet address.
+     * @param address - The wallet address whose key pair to remove.
+     */
+    abstract deleteKey(address: string): Promise<void>;
+}
+
+export { type BiometricPolicy, DeviceSignerKeyStorage };

package/dist/utils/device-signers/DeviceSignerKeyStorage.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Abstract storage interface for managing P-256 (secp256r1) device signer key pairs.
+ * Implementations handle key generation, persistence, retrieval, signing, and deletion.
+ */
+type BiometricPolicy = "always" | "session" | "none";
+declare abstract class DeviceSignerKeyStorage {
+    protected readonly apiKey: string;
+    constructor(apiKey: string);
+    /**
+     * Generate a new P-256 key pair and persist it.
+     * @param params - Key generation parameters.
+     * @param params.address - Optional wallet address to associate the key with. If omitted, the key
+     *                         should be stored under a temporary identifier until {@link mapAddressToKey} is called.
+     * @returns The uncompressed public key encoded as a base64 string.
+     */
+    abstract generateKey(params: {
+        address?: string;
+        biometricPolicy?: Exclude<BiometricPolicy, "session">;
+    }): Promise<string>;
+    abstract generateKey(params: {
+        address?: string;
+        biometricPolicy: "session";
+        biometricExpirationTime: number;
+    }): Promise<string>;
+    abstract generateKey(params: {
+        address?: string;
+        biometricPolicy?: BiometricPolicy;
+        biometricExpirationTime?: number;
+    }): Promise<string>;
+    /**
+     * Associate an already-generated key pair with a wallet address.
+     * Used when the wallet address is not yet known at the time of key generation.
+     * @param address - The wallet address to map the key to.
+     * @param publicKeyBase64 - The base64-encoded public key returned by {@link generateKey}.
+     */
+    abstract mapAddressToKey(address: string, publicKeyBase64: string): Promise<void>;
+    /**
+     * Retrieve the public key for a given wallet address.
+     * @param address - The wallet address whose public key to look up.
+     * @returns The base64-encoded public key, or `null` if no key is found for the address.
+     */
+    abstract getKey(address: string): Promise<string | null>;
+    /**
+     * Check if a key with the given public key exists on this device.
+     * @param publicKeyBase64 - The base64-encoded public key to look for.
+     * @returns `true` if the key exists on the device, `false` otherwise.
+     */
+    abstract hasKey(publicKeyBase64: string): Promise<boolean>;
+    /**
+     * Sign a message using the private key associated with the given wallet address.
+     * @param address - The wallet address whose private key to sign with.
+     * @param message - The message string to sign.
+     * @returns The ECDSA signature split into its `r` and `s` components, each as a hex string.
+     */
+    abstract signMessage(address: string, message: string): Promise<{
+        r: string;
+        s: string;
+    }>;
+    /**
+     * Delete the key pair associated with the given wallet address.
+     * @param address - The wallet address whose key pair to remove.
+     */
+    abstract deleteKey(address: string): Promise<void>;
+}
+
+export { type BiometricPolicy, DeviceSignerKeyStorage };

package/dist/utils/device-signers/DeviceSignerKeyStorage.js

@@ -0,0 +1 @@
+import{a}from"../../chunk-RLAW2ERD.js";import"../../chunk-J3R36SGJ.js";export{a as DeviceSignerKeyStorage};

package/dist/utils/device-signers/IframeDeviceSignerKeyStorage.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkYLRD3ANZcjs = require('../../chunk-YLRD3ANZ.cjs');require('../../chunk-D5YDWSO5.cjs');require('../../chunk-CCIGWTAO.cjs');require('../../chunk-S4O54O4C.cjs');require('../../chunk-U7QSF6P7.cjs');require('../../chunk-2GKPWQBQ.cjs');exports.IframeDeviceSignerKeyStorage = _chunkYLRD3ANZcjs.a;

package/dist/utils/device-signers/IframeDeviceSignerKeyStorage.d.cts

@@ -0,0 +1,48 @@
+import { DeviceSignerKeyStorage } from './DeviceSignerKeyStorage.cjs';
+
+/**
+ * Callback invoked before a WebAuthn ceremony to obtain user activation.
+ * Implementations should show a UI prompt and resolve when the user interacts (e.g. clicks a button).
+ * @param action - The biometric action being requested: `"createCredential"` for wallet creation, `"sign"` for transaction signing.
+ */
+type BiometricRequestHandler = (action: "createCredential" | "sign") => Promise<void>;
+/**
+ * DeviceSignerKeyStorage backed by a hidden iframe.
+ * All crypto operations are delegated to the iframe via postMessage RPC,
+ * keeping key material isolated in the iframe's origin.
+ */
+declare class IframeDeviceSignerKeyStorage extends DeviceSignerKeyStorage {
+    private iframePromise;
+    private reloading;
+    private readonly iframeUrl;
+    private biometricRequestHandler;
+    private biometricListener;
+    constructor(apiKey: string);
+    /**
+     * Set a handler that is called before each WebAuthn ceremony to obtain user activation.
+     * The handler should show a UI prompt (e.g. PasskeyPrompt) and resolve when the user clicks.
+     */
+    setBiometricRequestHandler(handler: BiometricRequestHandler): void;
+    generateKey(params?: Parameters<DeviceSignerKeyStorage["generateKey"]>[0]): Promise<string>;
+    mapAddressToKey(address: string, publicKeyBase64: string): Promise<void>;
+    getKey(address: string): Promise<string | null>;
+    hasKey(publicKeyBase64: string): Promise<boolean>;
+    signMessage(address: string, message: string): Promise<{
+        r: string;
+        s: string;
+    }>;
+    deleteKey(address: string): Promise<void>;
+    destroy(): void;
+    private rpc;
+    private sendRpc;
+    /**
+     * Destroy the current iframe and create a fresh one.
+     * Uses a single-flight pattern to prevent concurrent reloads.
+     */
+    private reloadIframe;
+    private setupBiometricListener;
+    private getIframe;
+    private createIframe;
+}
+
+export { type BiometricRequestHandler, IframeDeviceSignerKeyStorage };