emblem-vault-sdk 2.9.1 → 2.10.0

package/src/index.ts

@@ -1,8 +1,29 @@
 import { BigNumber } from '@ethersproject/bignumber'
-import { Collection, CuratedCollectionsResponse, MetaData, Ownership, Vault } from './types';
-import { COIN_TO_NETWORK, NFT_DATA, checkContentType, decryptKeys, evaluateFacts, fetchData, generateTemplate, genericGuard, getHandlerContract, getLegacyContract, getQuoteContractObject, getSatsConnectAddress, getTorusKeys, metadataAllProjects, metadataObj2Arr, pad, signPSBT, templateGuard } from './utils';
-import { getAddress, BitcoinNetworkType, AddressPurpose, signTransaction } from "sats-connect";
+import type {
+    Collection,
+    CuratedCollectionsResponse,
+    MetaData,
+    Ownership,
+    Vault,
+    ProgressCallback,
+    MintResult,
+    ClaimResult,
+    EmblemVaultClient,
+    SdkContext,
+} from './types';
+import { NFT_DATA, checkContentType, decryptKeys, fetchData, generateTemplate, genericGuard, getHandlerContract, getLegacyContract, getQuoteContractObject, getSatsConnectAddress, getTorusKeys, metadataAllProjects, metadataObj2Arr, signPSBT, templateGuard } from './utils';
 import { generateTaprootAddressFromMnemonic, getPsbtTxnSize } from './derive';
+import {
+    ETHEREUM_MAINNET_CHAIN_ID,
+} from './constants';
+import {
+    getChainConfig,
+    isV2Vault,
+    requiresOnChainUnvault,
+    getClaimIdentifier,
+} from './vault-utils';
+import { performMintEvm, performClaimEvm, deleteVaultEvm } from './evm-operations';
+
 const SDK_VERSION = '__SDK_VERSION__'; 
 
 class EmblemVaultSDK {
@@ -76,7 +97,7 @@ class EmblemVaultSDK {
                     item[key] = template[key];
                 });
                 // Return a new object that combines the properties of the item and the template
-                // return { ...item, ...template };  
+                return { ...item, ...template };  
                 return item;
             });
         return data
@@ -94,7 +115,14 @@ class EmblemVaultSDK {
         let url = `${this.baseUrl}/create-curated`;
         if (callback) { callback(`creating Vault for user`, template.toAddress)}     
         let vaultCreationResponse = await fetchData(url, this.apiKey, 'POST', template);
-        if (callback) { callback(`created Vault tokenId`, vaultCreationResponse.data.tokenId)}    
+
+        if (vaultCreationResponse?.err) {
+            if (callback) callback(`error creating Vault: ${vaultCreationResponse.msg}`)
+            return vaultCreationResponse
+        }
+
+        const { tokenId } = vaultCreationResponse.data
+        if (callback) { callback(`created Vault ${tokenId}`)}    
         return vaultCreationResponse.data
     }
 
@@ -132,14 +160,67 @@ class EmblemVaultSDK {
         return balance?.balances || [];
     }
 
-    async fetchVaultsOfType(vaultType: string, address: string): Promise<any> {
+    /**
+     * Fetch vaults of a specific type for an address.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param options - Optional pagination options
+     * @param options.page - Page number (1-indexed). If provided, returns paginated response.
+     * @param options.limit - Number of results per page (default: 100)
+     * @returns Array of vaults (unpaginated) or { data, pagination } object (paginated)
+     */
+    async fetchVaultsOfType(vaultType: string, address: string, options?: { page?: number; limit?: number }): Promise<any> {
         genericGuard(vaultType, "string", "vaultType");
         genericGuard(address, "string", "address");
         let url = `${this.baseUrl}/myvaults/${address}?vaultType=${vaultType}`;
+
+        // Add pagination params if provided
+        if (options?.page !== undefined || options?.limit !== undefined) {
+            if (options.page !== undefined) url += `&page=${options.page}`;
+            if (options.limit !== undefined) url += `&limit=${options.limit}`;
+        }
+
         let vaults = await fetchData(url, this.apiKey);
         return vaults;
     }
 
+    /**
+     * Fetch all vaults of a specific type, automatically handling pagination.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param onProgress - Optional callback for progress updates (page, totalPages, total)
+     * @returns Array of all vaults
+     */
+    async fetchAllVaultsOfType(vaultType: string, address: string, onProgress?: (page: number, totalPages: number, total: number) => void): Promise<any[]> {
+        genericGuard(vaultType, "string", "vaultType");
+        genericGuard(address, "string", "address");
+
+        const allVaults: any[] = [];
+        let page = 1;
+        let totalPages = 1;
+        const limit = 100;
+
+        while (page <= totalPages) {
+            const result = await this.fetchVaultsOfType(vaultType, address, { page, limit });
+
+            if (result.pagination) {
+                // Paginated response
+                allVaults.push(...result.data);
+                totalPages = result.pagination.totalPages;
+                if (onProgress) {
+                    onProgress(page, totalPages, result.pagination.total);
+                }
+            } else {
+                // Legacy non-paginated response (shouldn't happen with updated API)
+                return Array.isArray(result) ? result : [];
+            }
+
+            page++;
+        }
+
+        return allVaults;
+    }
+
     async generateJumpReport(address: string, hideUnMintable: boolean = false) {
         let vaultType = "unclaimed"
         let curated = await this.fetchCuratedContracts();
@@ -480,6 +561,66 @@ class EmblemVaultSDK {
         return results;
     }
 
+    // ========================================================================
+    // Remote Signer Methods (EmblemVaultClient) - Multi-Chain Support
+    // ========================================================================
+
+    private getSdkContext(): SdkContext {
+        return {
+            apiKey: this.apiKey,
+            baseUrl: this.baseUrl,
+            v3Url: this.v3Url,
+            sigUrl: this.sigUrl,
+            fetchMetadata: this.fetchMetadata.bind(this),
+            requestRemoteKey: this.requestRemoteKey.bind(this),
+            decryptVaultKeys: this.decryptVaultKeys.bind(this),
+        };
+    }
+
+    async performMintChainWithClient(
+        client: EmblemVaultClient,
+        tokenId: string,
+        chainId: number | 'solana' = ETHEREUM_MAINNET_CHAIN_ID,
+        callback?: ProgressCallback
+    ): Promise<MintResult> {
+        genericGuard(tokenId, "string", "tokenId");
+        getChainConfig(chainId);
+        return performMintEvm(this.getSdkContext(), client, tokenId, chainId as number, callback);
+    }
+
+    async performClaimChainWithClient(
+        client: EmblemVaultClient,
+        tokenId: string,
+        chainId: number | 'solana' = ETHEREUM_MAINNET_CHAIN_ID,
+        callback?: ProgressCallback
+    ): Promise<ClaimResult> {
+        genericGuard(tokenId, "string", "tokenId");
+        getChainConfig(chainId);
+
+        callback?.('Fetching vault metadata...');
+        const metadata = await this.fetchMetadata(tokenId, callback);
+        const claimIdentifier = getClaimIdentifier(metadata);
+        
+        // Check if this is a V2 vault by checking the deployment type (matches VaultActions.vue logic)
+        // metadata[chainId]?.type?.endsWith('V2') indicates a diamond/V2 contract
+        const deploymentInfo = (metadata as Record<string, unknown>)?.[chainId as number] as { type?: string } | undefined;
+        const vaultIsV2 = Boolean(deploymentInfo?.type?.endsWith?.('V2'));
+        const needsOnChainUnvault = requiresOnChainUnvault(metadata) && vaultIsV2;
+
+        return performClaimEvm(this.getSdkContext(), client, tokenId, chainId as number, metadata, claimIdentifier, vaultIsV2, needsOnChainUnvault, callback);
+    }
+
+    async deleteVaultWithClient(
+        client: EmblemVaultClient,
+        tokenId: string,
+        chainId: number | 'solana' = ETHEREUM_MAINNET_CHAIN_ID,
+        callback?: ProgressCallback
+    ): Promise<boolean> {
+        genericGuard(tokenId, "string", "tokenId");
+        getChainConfig(chainId);
+        return deleteVaultEvm(client, tokenId, chainId as number, callback);
+    }
+
     // BTC
 
     async sweepVaultUsingPhrase(phrase: string, satsPerByte: number = 20, broadcast: boolean = false) {     

package/src/signing-messages.ts

@@ -0,0 +1,16 @@
+export function buildMintMessage(tokenId: string): string {
+    return `Curated Minting: ${tokenId}`;
+}
+
+export function buildClaimMessage(identifier: string, isV2Vault: boolean): string {
+    const prefix = isV2Vault ? 'Unvault' : 'Claim';
+    return `${prefix}: ${identifier}`;
+}
+
+export function buildUnvaultMessage(identifier: string): string {
+    return `Unvault: ${identifier}`;
+}
+
+export function buildDeleteMessage(tokenId: string): string {
+    return `Delete: ${tokenId}`;
+}

package/src/types.ts

@@ -27,6 +27,14 @@ export type Collection = {
     balanceCheckers: string[] | null;
     tokenIdScheme: string | null;
     generateVaultBody: Function;
+    /**
+     * Returns a template ready to send to the create vault API
+     *
+     * @param {FillCreateVaultTemplateArgs} args - Arguments to fill the template
+     * @param {_this: Collection} _this - The collection context
+     * @returns {Object} - Filled create vault template
+     */
+    fillCreateVaultTemplate: (args: FillCreateVaultTemplateArgs, _this: Collection) => Object;
     generateCreateTemplate: Function;
 };
 
@@ -142,3 +150,91 @@ export type Ownership = {
 }
 
 export type CuratedCollectionsResponse = Collection[];
+
+// ============================================================================
+// Remote Signer Types (for EmblemVaultClient integration)
+// ============================================================================
+
+export type ChainIdentifier = number | 'solana';
+
+export type ProgressCallback = (message: string, data?: unknown) => void;
+
+export interface MintResult {
+    txHash: string;
+    tokenId: string;
+    chainId: ChainIdentifier;
+}
+
+export interface ClaimResult {
+    phrase?: string;
+    privateKey?: string;
+}
+
+export interface RemoteMintSignature {
+    _nftAddress: string;
+    _price: { hex: string } | string | number;
+    _to: string;
+    _tokenId: { hex: string } | string | number;
+    _nonce: { hex: string } | string | number;
+    _signature: string;
+    serialNumber: string;
+    error?: string;
+}
+
+export interface RemoteUnvaultSignature {
+    success: boolean;
+    _nftAddress: string;
+    _tokenId: { hex: string } | string | number;
+    _nonce: { hex: string } | string | number;
+    _price: { hex: string } | string | number;
+    _timestamp: { hex: string } | string | number;
+    _signature: string;
+    msg?: string;
+    err?: string;
+}
+
+// ============================================================================
+// EVM Signer Interface (matches emblem-vault-ai-signers EmblemEthersWallet)
+// ============================================================================
+
+export interface EvmSigner {
+    getAddress(): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    sendTransaction(tx: unknown): Promise<{ hash: string; wait(): Promise<unknown> }>;
+    setChainId?(chainId: number): void;
+}
+
+// ============================================================================
+// EmblemVaultClient Interface - matches emblem-vault-ai-signers
+// ============================================================================
+
+export interface EmblemVaultClient {
+    toEthersWallet(provider?: unknown): Promise<EvmSigner>;
+}
+
+// ============================================================================
+// SDK Context for operations modules
+// ============================================================================
+
+export interface SdkContext {
+    apiKey: string;
+    baseUrl: string;
+    v3Url: string;
+    sigUrl: string;
+    fetchMetadata: (tokenId: string, callback?: ProgressCallback) => Promise<MetaData>;
+    requestRemoteKey: (tokenId: string, jwt: unknown, callback?: ProgressCallback) => Promise<unknown>;
+    decryptVaultKeys: (tokenId: string, dkeys: unknown, callback?: ProgressCallback) => Promise<ClaimResult>;
+}
+
+export interface FillCreateVaultTemplateArgs {
+    fromAddress: string,
+    toAddress: string,
+    targetAsset: {
+        name: string,
+        image: string,
+        description?: string,
+        ownedImage?: string,
+        projectName?: string
+    },
+    chainId: number,
+}

package/src/utils.ts

@@ -1,5 +1,5 @@
 import CryptoJS from 'crypto-js'
-import { MetaData } from "./types";
+import { MetaData, FillCreateVaultTemplateArgs } from "./types";
 import metadataJson from './curated/metadata.json';
 import darkfarmsMetadataJson from './curated/darkfarms-metadata.json';
 import dot_idMetadataJson from './curated/dot_id.json';
@@ -552,6 +552,40 @@ export function generateTemplate(record: any) {
             
             return nameAndImage
         },
+        fillCreateVaultTemplate: (args: FillCreateVaultTemplateArgs, _this: any) => {
+            const template = _this.generateCreateTemplate(_this)
+
+            if (args.fromAddress) {
+                template.fromAddress = args.fromAddress
+            } else {
+                throw new Error("fromAddress is required to create vault")
+            }
+
+            if (args.toAddress) {
+                template.toAddress = args.toAddress
+            } else {
+                throw new Error("toAddress is required to create vault")
+            }
+
+            if (args.chainId) {
+                const chainIdAsString = String(args.chainId)
+                template.targetContract = {
+                    name: template.targetContract.name,
+                    [chainIdAsString]: template.targetContract[chainIdAsString]
+                }
+                template.chainId = args.chainId
+            } else {
+                throw new Error("chainId is required to create vault")
+            }
+
+            if (args.targetAsset) {
+                Object.assign(template.targetAsset, args.targetAsset)
+            } else {
+                template.targetAsset = undefined
+            }
+
+            return template
+        },
         generateCreateTemplate: (_this: any) =>{
             let template = {
                 fromAddress: { type: "user-provided" },
@@ -914,4 +948,9 @@ export async function signPSBT(psbtBase64: any, paymentAddress: any, indexes: nu
     });
 }
 
-
+export function parseBigIntValue(value: unknown): bigint {
+    if (typeof value === 'object' && value !== null && 'hex' in value) {
+        return BigInt((value as { hex: string }).hex);
+    }
+    return BigInt(String(value));
+}

package/src/vault-utils.ts

@@ -0,0 +1,89 @@
+import { ChainConfig, SUPPORTED_CHAINS } from "./constants";
+
+export function isV2Vault(metadata: { targetContract?: { name?: string } }): boolean {
+    return Boolean(metadata.targetContract?.name);
+}
+
+export function requiresOnChainUnvault(metadata: { status?: string; sealed?: boolean; live?: boolean }): boolean {
+    return metadata.status === 'unclaimed' && !metadata.sealed && Boolean(metadata.live);
+}
+
+/**
+ * Get the claim identifier for signing claim messages.
+ * This MUST match VaultActions.vue's getSerialNumber() logic:
+ * - ERC1155: use targetContract.serialNumber
+ * - ERC721a: use tokenId
+ * - Legacy: use tokenId
+ */
+export function getClaimIdentifier(metadata: { 
+    ownershipInfo?: { 
+        serialNumber?: string; 
+        category?: string;
+    }; 
+    tokenId?: string;
+    targetContract?: {
+        serialNumber?: string;
+        collectionType?: string;
+        tokenId?: string;
+    };
+}): string {
+    const { targetContract, ownershipInfo, tokenId } = metadata;
+    
+    // If no targetContract, fallback to tokenId
+    if (!targetContract) {
+        return tokenId || '';
+    }
+    
+    // ERC1155: use serialNumber
+    if (
+        targetContract.collectionType === 'ERC1155' ||
+        ownershipInfo?.category === 'erc1155'
+    ) {
+        return targetContract.serialNumber || tokenId || '';
+    }
+    
+    // ERC721a: use tokenId (NOT serialNumber!)
+    if (
+        targetContract.collectionType === 'ERC721a' ||
+        ownershipInfo?.category === 'erc721a'
+    ) {
+        return tokenId || '';
+    }
+    
+    // Default: use targetContract.tokenId or tokenId
+    return targetContract.tokenId || tokenId || '';
+}
+
+export function getHandlerContractAddress(chainId: number): string {
+    const config = getChainConfig(chainId);
+    if (!config.handlerContract) {
+        throw new Error(`No handler contract configured for chain ${chainId}`);
+    }
+    return config.handlerContract;
+}
+
+export function getUnvaultingContractAddress(chainId: number): string {
+    const config = getChainConfig(chainId);
+    if (!config.unvaultingContract) {
+        throw new Error(`No unvaulting contract configured for chain ${chainId}`);
+    }
+    return config.unvaultingContract;
+}
+
+export function getChainConfig(chainId: number | string): ChainConfig {
+    const config = SUPPORTED_CHAINS[chainId];
+    if (!config) {
+        const supportedList = Object.entries(SUPPORTED_CHAINS)
+            .map(([id, cfg]) => `${cfg.name} (${id})`)
+            .join(', ');
+        throw new Error(
+            `Unsupported chain: ${chainId}. Supported chains: ${supportedList}`
+        );
+    }
+    return config;
+}
+
+export function isEvmChain(chainId: number | string): boolean {
+    const config = SUPPORTED_CHAINS[chainId];
+    return config?.type === 'evm';
+}

package/types/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const ETHEREUM_MAINNET_CHAIN_ID = 1;
+export declare const POLYGON_MAINNET_CHAIN_ID = 137;
+export declare const SOLANA_CHAIN_IDENTIFIER = "solana";
+export type ChainType = 'evm' | 'solana';
+export interface ChainConfig {
+    type: ChainType;
+    name: string;
+    handlerContract?: string;
+    unvaultingContract?: string;
+}
+export declare const SUPPORTED_CHAINS: Record<number | string, ChainConfig>;
+export declare const HANDLER_CONTRACT_ADDRESS = "0x23859b51117dbFBcdEf5b757028B18d7759a4460";
+export declare const UNVAULTING_DIAMOND_ADDRESS = "0x214C964bBd3640971E111d3a994CbB89b296a9ad";
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const EMBLEM_API_V2 = "https://v2.emblemvault.io";
+export declare const EMBLEM_API_2 = "https://api2.emblemvault.io";
+export declare const TORUS_SIGNER_API = "https://tor-us-signer-coval.vercel.app";

package/types/evm-operations.d.ts

@@ -0,0 +1,4 @@
+import type { EmblemVaultClient, ProgressCallback, MintResult, ClaimResult, MetaData, SdkContext } from './types';
+export declare function performMintEvm(ctx: SdkContext, client: EmblemVaultClient, tokenId: string, chainId: number, callback?: ProgressCallback): Promise<MintResult>;
+export declare function performClaimEvm(ctx: SdkContext, client: EmblemVaultClient, tokenId: string, chainId: number, metadata: MetaData, claimIdentifier: string, vaultIsV2: boolean, needsOnChainUnvault: boolean, callback?: ProgressCallback): Promise<ClaimResult>;
+export declare function deleteVaultEvm(client: EmblemVaultClient, tokenId: string, chainId: number, callback?: ProgressCallback): Promise<boolean>;

package/types/index.d.ts

@@ -1,5 +1,5 @@
 import { BigNumber } from '@ethersproject/bignumber';
-import { Collection, CuratedCollectionsResponse, MetaData, Ownership, Vault } from './types';
+import type { Collection, CuratedCollectionsResponse, MetaData, Ownership, Vault, ProgressCallback, MintResult, ClaimResult, EmblemVaultClient } from './types';
 declare class EmblemVaultSDK {
     private apiKey;
     private baseUrl;
@@ -20,7 +20,27 @@ declare class EmblemVaultSDK {
     refreshOwnershipForAccount(account: string, callback?: any): Promise<Ownership[]>;
     fetchMetadata(tokenId: string, callback?: any): Promise<MetaData>;
     refreshBalance(tokenId: string, callback?: any): Promise<MetaData>;
-    fetchVaultsOfType(vaultType: string, address: string): Promise<any>;
+    /**
+     * Fetch vaults of a specific type for an address.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param options - Optional pagination options
+     * @param options.page - Page number (1-indexed). If provided, returns paginated response.
+     * @param options.limit - Number of results per page (default: 100)
+     * @returns Array of vaults (unpaginated) or { data, pagination } object (paginated)
+     */
+    fetchVaultsOfType(vaultType: string, address: string, options?: {
+        page?: number;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Fetch all vaults of a specific type, automatically handling pagination.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param onProgress - Optional callback for progress updates (page, totalPages, total)
+     * @returns Array of all vaults
+     */
+    fetchAllVaultsOfType(vaultType: string, address: string, onProgress?: (page: number, totalPages: number, total: number) => void): Promise<any[]>;
     generateJumpReport(address: string, hideUnMintable?: boolean): Promise<unknown>;
     generateMintReport(address: string, hideUnMintable?: boolean): Promise<unknown>;
     generateMigrateReport(address: string, hideUnMintable?: boolean): Promise<unknown>;
@@ -45,6 +65,10 @@ declare class EmblemVaultSDK {
     refreshLegacyOwnership(web3: any, address: string): Promise<void>;
     checkLiveliness(tokenId: string, chainId?: number): Promise<any>;
     checkLivelinessBulk(tokenIds: string[], chainId?: number): Promise<any[]>;
+    private getSdkContext;
+    performMintChainWithClient(client: EmblemVaultClient, tokenId: string, chainId?: number | 'solana', callback?: ProgressCallback): Promise<MintResult>;
+    performClaimChainWithClient(client: EmblemVaultClient, tokenId: string, chainId?: number | 'solana', callback?: ProgressCallback): Promise<ClaimResult>;
+    deleteVaultWithClient(client: EmblemVaultClient, tokenId: string, chainId?: number | 'solana', callback?: ProgressCallback): Promise<boolean>;
     sweepVaultUsingPhrase(phrase: string, satsPerByte?: number, broadcast?: boolean): Promise<unknown>;
 }
 declare global {

package/types/signing-messages.d.ts

@@ -0,0 +1,4 @@
+export declare function buildMintMessage(tokenId: string): string;
+export declare function buildClaimMessage(identifier: string, isV2Vault: boolean): string;
+export declare function buildUnvaultMessage(identifier: string): string;
+export declare function buildDeleteMessage(tokenId: string): string;

package/types/types.d.ts

@@ -26,6 +26,14 @@ export type Collection = {
     balanceCheckers: string[] | null;
     tokenIdScheme: string | null;
     generateVaultBody: Function;
+    /**
+     * Returns a template ready to send to the create vault API
+     *
+     * @param {FillCreateVaultTemplateArgs} args - Arguments to fill the template
+     * @param {_this: Collection} _this - The collection context
+     * @returns {Object} - Filled create vault template
+     */
+    fillCreateVaultTemplate: (args: FillCreateVaultTemplateArgs, _this: Collection) => Object;
     generateCreateTemplate: Function;
 };
 export interface MetaData {
@@ -133,3 +141,82 @@ export type Ownership = {
     network: string;
 };
 export type CuratedCollectionsResponse = Collection[];
+export type ChainIdentifier = number | 'solana';
+export type ProgressCallback = (message: string, data?: unknown) => void;
+export interface MintResult {
+    txHash: string;
+    tokenId: string;
+    chainId: ChainIdentifier;
+}
+export interface ClaimResult {
+    phrase?: string;
+    privateKey?: string;
+}
+export interface RemoteMintSignature {
+    _nftAddress: string;
+    _price: {
+        hex: string;
+    } | string | number;
+    _to: string;
+    _tokenId: {
+        hex: string;
+    } | string | number;
+    _nonce: {
+        hex: string;
+    } | string | number;
+    _signature: string;
+    serialNumber: string;
+    error?: string;
+}
+export interface RemoteUnvaultSignature {
+    success: boolean;
+    _nftAddress: string;
+    _tokenId: {
+        hex: string;
+    } | string | number;
+    _nonce: {
+        hex: string;
+    } | string | number;
+    _price: {
+        hex: string;
+    } | string | number;
+    _timestamp: {
+        hex: string;
+    } | string | number;
+    _signature: string;
+    msg?: string;
+    err?: string;
+}
+export interface EvmSigner {
+    getAddress(): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    sendTransaction(tx: unknown): Promise<{
+        hash: string;
+        wait(): Promise<unknown>;
+    }>;
+    setChainId?(chainId: number): void;
+}
+export interface EmblemVaultClient {
+    toEthersWallet(provider?: unknown): Promise<EvmSigner>;
+}
+export interface SdkContext {
+    apiKey: string;
+    baseUrl: string;
+    v3Url: string;
+    sigUrl: string;
+    fetchMetadata: (tokenId: string, callback?: ProgressCallback) => Promise<MetaData>;
+    requestRemoteKey: (tokenId: string, jwt: unknown, callback?: ProgressCallback) => Promise<unknown>;
+    decryptVaultKeys: (tokenId: string, dkeys: unknown, callback?: ProgressCallback) => Promise<ClaimResult>;
+}
+export interface FillCreateVaultTemplateArgs {
+    fromAddress: string;
+    toAddress: string;
+    targetAsset: {
+        name: string;
+        image: string;
+        description?: string;
+        ownedImage?: string;
+        projectName?: string;
+    };
+    chainId: number;
+}

package/types/utils.d.ts

@@ -40,4 +40,5 @@ interface SatsConnectAddress {
 }
 export declare function getSatsConnectAddress(): Promise<SatsConnectAddress>;
 export declare function signPSBT(psbtBase64: any, paymentAddress: any, indexes: number[], broadcast?: boolean): Promise<unknown>;
+export declare function parseBigIntValue(value: unknown): bigint;
 export {};

package/types/vault-utils.d.ts

@@ -0,0 +1,34 @@
+import { ChainConfig } from "./constants";
+export declare function isV2Vault(metadata: {
+    targetContract?: {
+        name?: string;
+    };
+}): boolean;
+export declare function requiresOnChainUnvault(metadata: {
+    status?: string;
+    sealed?: boolean;
+    live?: boolean;
+}): boolean;
+/**
+ * Get the claim identifier for signing claim messages.
+ * This MUST match VaultActions.vue's getSerialNumber() logic:
+ * - ERC1155: use targetContract.serialNumber
+ * - ERC721a: use tokenId
+ * - Legacy: use tokenId
+ */
+export declare function getClaimIdentifier(metadata: {
+    ownershipInfo?: {
+        serialNumber?: string;
+        category?: string;
+    };
+    tokenId?: string;
+    targetContract?: {
+        serialNumber?: string;
+        collectionType?: string;
+        tokenId?: string;
+    };
+}): string;
+export declare function getHandlerContractAddress(chainId: number): string;
+export declare function getUnvaultingContractAddress(chainId: number): string;
+export declare function getChainConfig(chainId: number | string): ChainConfig;
+export declare function isEvmChain(chainId: number | string): boolean;