@veridex/sdk 1.0.0-beta.22 → 1.0.0-beta.23

package/dist/EVMClient-CoOR_ywD.d.mts

@@ -0,0 +1,332 @@
+import { RegisterSessionParams, SessionValidationResult, RevokeSessionParams, SessionKey, IdentityState } from './types.mjs';
+import { ethers } from 'ethers';
+import { C as ChainClient, a as ChainConfig, T as TransferParams, E as ExecuteParams, B as BridgeParams, W as WebAuthnSignature, D as DispatchResult, V as VaultCreationResult } from './types-Bmk689Lw.mjs';
+
+interface EVMClientConfig {
+    chainId: number;
+    wormholeChainId: number;
+    rpcUrl: string;
+    hubContractAddress: string;
+    wormholeCoreBridge: string;
+    name?: string;
+    explorerUrl?: string;
+    vaultFactory?: string;
+    vaultImplementation?: string;
+    tokenBridge?: string;
+}
+/**
+ * EVM implementation of the ChainClient interface
+ */
+declare class EVMClient implements ChainClient {
+    private config;
+    private provider;
+    private hubContract;
+    private factoryContract;
+    private cachedImplementation;
+    constructor(config: EVMClientConfig);
+    getConfig(): ChainConfig;
+    getNonce(userKeyHash: string): Promise<bigint>;
+    /**
+     * Get user state from Hub (Issue #9/#10)
+     * Returns comprehensive state including last action hash
+     */
+    getUserState(userKeyHash: string): Promise<{
+        keyHash: string;
+        nonce: bigint;
+        lastActionHash: string;
+    }>;
+    /**
+     * Get user's last action hash from Hub (Issue #9/#10)
+     * Returns zero hash if user has no actions yet
+     */
+    getUserLastActionHash(userKeyHash: string): Promise<string>;
+    /**
+     * Register a new session key for temporary authentication
+     * Enables native L1 speed for repeat transactions without biometric auth
+     *
+     * @param params Session registration parameters
+     * @param signer Ethereum signer to pay gas
+     * @returns Transaction receipt
+     */
+    registerSession(params: RegisterSessionParams, signer: ethers.Signer): Promise<ethers.TransactionReceipt>;
+    /**
+     * Check if a session is currently active (queryable via Wormhole CCQ)
+     *
+     * @param userKeyHash Hash of the user's Passkey public key
+     * @param sessionKeyHash Hash of the session key to check
+     * @returns Session validation result
+     */
+    isSessionActive(userKeyHash: string, sessionKeyHash: string): Promise<SessionValidationResult>;
+    /**
+     * Revoke a session key immediately
+     *
+     * @param params Session revocation parameters
+     * @param signer Ethereum signer to pay gas
+     * @returns Transaction receipt
+     */
+    revokeSession(params: RevokeSessionParams, signer: ethers.Signer): Promise<ethers.TransactionReceipt>;
+    /**
+     * Get all sessions for a user
+     *
+     * @param userKeyHash Hash of the user's Passkey public key
+     * @returns Array of all sessions (active and expired/revoked)
+     */
+    getUserSessions(userKeyHash: string): Promise<SessionKey[]>;
+    /**
+     * Get the number of sessions for a user
+     *
+     * @param userKeyHash Hash of the user's Passkey public key
+     * @returns Number of sessions
+     */
+    getUserSessionCount(userKeyHash: string): Promise<number>;
+    getMessageFee(): Promise<bigint>;
+    buildTransferPayload(params: TransferParams): Promise<string>;
+    buildExecutePayload(params: ExecuteParams): Promise<string>;
+    buildBridgePayload(params: BridgeParams): Promise<string>;
+    dispatch(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, targetChain: number, actionPayload: string, nonce: bigint, signer: ethers.Signer): Promise<DispatchResult>;
+    /**
+     * Dispatch an action to the Hub via relayer (gasless)
+     * The relayer pays for gas and submits the transaction on behalf of the user
+     */
+    dispatchGasless(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, targetChain: number, actionPayload: string, nonce: bigint, relayerUrl: string): Promise<DispatchResult>;
+    getVaultAddress(userKeyHash: string): Promise<string | null>;
+    /**
+     * Compute vault address deterministically without querying the chain
+     * Uses CREATE2 with EIP-1167 minimal proxy pattern
+     */
+    computeVaultAddress(userKeyHash: string): string;
+    /**
+     * Build EIP-1167 minimal proxy initcode
+     */
+    private buildProxyInitCode;
+    vaultExists(userKeyHash: string): Promise<boolean>;
+    createVault(userKeyHash: string, signer: ethers.Signer): Promise<VaultCreationResult>;
+    /**
+     * Create a vault with a sponsor wallet paying for gas
+     *
+     * @param userKeyHash - The user's passkey hash
+     * @param sponsorPrivateKey - Private key of the wallet that will pay gas
+     * @param rpcUrl - Optional RPC URL to use (defaults to client's RPC)
+     * @returns VaultCreationResult with address and transaction details
+     */
+    createVaultSponsored(userKeyHash: string, sponsorPrivateKey: string, rpcUrl?: string): Promise<VaultCreationResult>;
+    estimateVaultCreationGas(userKeyHash: string): Promise<bigint>;
+    getFactoryAddress(): string | undefined;
+    getImplementationAddress(): string | undefined;
+    /**
+     * Fetch implementation address from factory contract
+     */
+    fetchImplementationAddress(): Promise<string | null>;
+    /**
+     * Get the provider instance
+     */
+    getProvider(): ethers.JsonRpcProvider;
+    /**
+     * Get native token balance for an address
+     */
+    getNativeBalance(address: string): Promise<bigint>;
+    /**
+     * Get ERC20 token balance for an address
+     */
+    getTokenBalance(tokenAddress: string, ownerAddress: string): Promise<bigint>;
+    /**
+     * Get token allowance
+     */
+    getTokenAllowance(tokenAddress: string, ownerAddress: string, spenderAddress: string): Promise<bigint>;
+    /**
+     * Estimate gas for a dispatch transaction
+     */
+    estimateDispatchGas(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, targetChain: number, actionPayload: string, nonce: bigint): Promise<bigint>;
+    /**
+     * Get current gas price
+     */
+    getGasPrice(): Promise<bigint>;
+    /**
+     * Get current block number
+     */
+    getBlockNumber(): Promise<number>;
+    /**
+     * Get transaction receipt
+     */
+    getTransactionReceipt(hash: string): Promise<ethers.TransactionReceipt | null>;
+    /**
+     * Wait for transaction confirmation
+     */
+    waitForTransaction(hash: string, confirmations?: number): Promise<ethers.TransactionReceipt | null>;
+    /**
+     * Get the identity for a given key hash
+     * Returns zero hash if key is not registered to any identity
+     *
+     * @param keyHash Hash of the passkey to look up
+     * @returns Identity (first passkey's keyHash) or zero hash
+     */
+    getIdentityForKey(keyHash: string): Promise<string>;
+    /**
+     * Get all authorized keys for an identity
+     *
+     * @param identity The identity key hash (first passkey's keyHash)
+     * @returns Array of authorized key hashes
+     */
+    getAuthorizedKeys(identity: string): Promise<string[]>;
+    /**
+     * Get count of authorized keys for an identity
+     *
+     * @param identity The identity key hash
+     * @returns Number of authorized keys
+     */
+    getAuthorizedKeyCount(identity: string): Promise<number>;
+    /**
+     * Check if a key is authorized for an identity
+     *
+     * @param identity The identity key hash
+     * @param keyHash The key hash to check
+     * @returns Whether the key is authorized
+     */
+    isAuthorizedForIdentity(identity: string, keyHash: string): Promise<boolean>;
+    /**
+     * Check if a key is the root identity key
+     *
+     * @param keyHash The key hash to check
+     * @returns Whether the key is a root identity
+     */
+    isIdentityRootKey(keyHash: string): Promise<boolean>;
+    /**
+     * Get comprehensive identity state for a key
+     *
+     * @param keyHash Hash of any key in the identity
+     * @returns Identity state including count, max, and root status
+     */
+    getIdentityState(keyHash: string): Promise<IdentityState>;
+    /**
+     * Register a new identity with the first passkey
+     * This makes the passkey the root identity key
+     *
+     * @param signature WebAuthn signature
+     * @param publicKeyX Passkey public key X coordinate
+     * @param publicKeyY Passkey public key Y coordinate
+     * @param signer Ethereum signer to pay gas
+     * @returns Transaction receipt and identity hash
+     */
+    registerIdentity(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        identity: string;
+    }>;
+    /**
+     * Add a backup passkey to an existing identity
+     * Requires WebAuthn signature from an authorized key
+     *
+     * @param signature WebAuthn signature from existing authorized key
+     * @param publicKeyX Existing key's X coordinate
+     * @param publicKeyY Existing key's Y coordinate
+     * @param newPublicKeyX New backup key's X coordinate
+     * @param newPublicKeyY New backup key's Y coordinate
+     * @param nonce Current nonce for the signing key
+     * @param signer Ethereum signer to pay gas
+     * @returns Transaction receipt and sequence number
+     */
+    addBackupKey(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, newPublicKeyX: bigint, newPublicKeyY: bigint, nonce: bigint, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Remove a passkey from an identity
+     * Cannot remove the last remaining key
+     *
+     * @param signature WebAuthn signature from an authorized key
+     * @param publicKeyX Signing key's X coordinate
+     * @param publicKeyY Signing key's Y coordinate
+     * @param keyToRemove Hash of the key to remove
+     * @param nonce Current nonce for the signing key
+     * @param signer Ethereum signer to pay gas
+     * @returns Transaction receipt and sequence number
+     */
+    removeKey(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, keyToRemove: string, nonce: bigint, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Setup guardians for an identity
+     * @param signature WebAuthn signature from owner
+     * @param publicKeyX Owner's public key X coordinate
+     * @param publicKeyY Owner's public key Y coordinate
+     * @param guardians Array of guardian key hashes
+     * @param threshold Required approvals for recovery
+     * @param signer Ethers signer for transaction
+     */
+    setupGuardians(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, guardians: string[], threshold: bigint, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Add a guardian to an identity
+     */
+    addGuardian(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, guardianKeyHash: string, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Remove a guardian from an identity
+     */
+    removeGuardian(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, guardianKeyHash: string, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Initiate recovery as a guardian
+     */
+    initiateRecovery(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, identityToRecover: string, newOwnerKeyHash: string, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Approve recovery as a guardian
+     */
+    approveRecovery(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, identityToRecover: string, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Execute recovery after timelock (anyone can call)
+     */
+    executeRecovery(identityToRecover: string, newPublicKeyX: bigint, newPublicKeyY: bigint, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Cancel recovery as owner
+     */
+    cancelRecovery(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, signer: ethers.Signer): Promise<{
+        receipt: ethers.TransactionReceipt;
+        sequence: bigint;
+    }>;
+    /**
+     * Get guardians for an identity
+     */
+    getGuardians(identityKeyHash: string): Promise<{
+        guardians: string[];
+        threshold: bigint;
+        isConfigured: boolean;
+    }>;
+    /**
+     * Get recovery status for an identity
+     */
+    getRecoveryStatus(identityKeyHash: string): Promise<{
+        isActive: boolean;
+        newOwnerKeyHash: string;
+        initiatedAt: bigint;
+        approvalCount: bigint;
+        threshold: bigint;
+        canExecuteAt: bigint;
+        expiresAt: bigint;
+    }>;
+    /**
+     * Check if a guardian has approved recovery
+     */
+    hasGuardianApproved(identityKeyHash: string, guardianKeyHash: string): Promise<boolean>;
+    /**
+     * Helper to extract sequence from transaction receipt
+     */
+    private _extractSequenceFromReceipt;
+}
+
+export { EVMClient as E, type EVMClientConfig as a };

package/dist/auth/prepareAuth.d.mts

@@ -1,4 +1,4 @@
-import { P as PasskeyCredential, T as TransferParams, E as ExecuteParams, B as BridgeParams } from '../types-DakHNZIP.mjs';
+import { P as PasskeyCredential, T as TransferParams, E as ExecuteParams, B as BridgeParams } from '../types-Bmk689Lw.mjs';
 
 type AuthenticateAndPrepareParams = {
     credential: PasskeyCredential;