emblem-vault-sdk 2.3.6 → 3.0.0-experimental

package/src/index.ts

@@ -1,68 +1,192 @@
 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 { AiVaultInfo, Balance, Collection, CuratedCollectionsResponse, MetaData, Ownership, v3LocalMintSignature, Vault } 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 { BlockchainProvider, BlockchainType, detectProviderType, EthereumProvider, Web3ProviderAdapter } from './providers';
+import { ProviderManager } from './providers/ProviderManager';
+import { createEmblemVaultWalletClient, EmblemVaultWalletClient, EmblemVaultWalletClientConfig } from './clients/emblemVaultWalletClient';
+import { createEmblemVaultSolanaWalletClient, EmblemVaultSolanaWalletClient, EmblemVaultSolanaWalletClientConfig } from './clients/emblemVaultSolanaWalletClient';
+
 const SDK_VERSION = '__SDK_VERSION__'; 
 
-class EmblemVaultSDK {
+export class EmblemVaultSDK {
     private baseUrl: string;
     private v3Url: string;
     private sigUrl: string;
-    constructor(private apiKey: string, baseUrl?: string, v3Url?: string, sigUrl?: string) {
-        console.log('EmblemVaultSDK version:', SDK_VERSION)
+    private aiUrl: string;
+    private aiApiKey?: string;
+    private byoKey?: string;
+    private providerManager: ProviderManager;
+    version: string;
+    
+    constructor(private apiKey: string, baseUrl?: string, v3Url?: string, sigUrl?: string, aiUrl?: string, aiApiKey?: string, byoKey?: string) {
+        // console.log('EmblemVaultSDK version:', SDK_VERSION)
         if (!apiKey) {
             throw new Error('API key is required');
         }
         this.baseUrl = baseUrl || 'https://v2.emblemvault.io';
         this.v3Url = v3Url || 'https://v3.emblemvault.io';
         this.sigUrl = sigUrl || 'https://tor-us-signer-coval.vercel.app';
+        this.aiUrl = aiUrl || 'https://api.emblemvault.ai';
+        this.aiApiKey = aiApiKey || undefined;
+        this.byoKey = byoKey || undefined;
+        this.version = SDK_VERSION;
+        this.providerManager = new ProviderManager();
+    }
+
+    /**
+     * Register a blockchain provider for a specific blockchain type
+     * @param type The blockchain type
+     * @param provider The provider instance
+     */
+    registerProvider(type: BlockchainType, provider: any): void {
+        this.providerManager.registerProvider(type, provider);
+    }
+
+    /**
+     * Get a registered provider for a specific blockchain type
+     * @param type The blockchain type
+     * @returns The provider instance or undefined if not registered
+     */
+    getProvider(type: BlockchainType): any {
+        return this.providerManager.getProvider(type);
+    }
+
+    /**
+     * Check if a provider is registered for a specific blockchain type
+     * @param type The blockchain type
+     * @returns True if a provider is registered for the specified type
+     */
+    hasProvider(type: BlockchainType): boolean {
+        return this.providerManager.hasProvider(type);
+    }
+
+    /**
+     * Get or detect a provider for a specific blockchain type
+     * If a provider is registered, it will be returned
+     * Otherwise, it will try to detect a provider in the environment
+     * @param type The blockchain type
+     * @returns A promise that resolves to the provider instance
+     * @throws Error if no provider is available
+     */
+    async getOrDetectProvider(type: BlockchainType): Promise<any> {
+        return this.providerManager.getOrDetectProvider(type);
+    }
+
+    /**
+     * Creates a Wallet Client instance powered by the Emblem Vault TEE signer.
+     *
+     * @param config - Configuration specific to the wallet client, like the walletId.
+     * @returns An EmblemVaultWalletClient instance.
+     */
+    createWalletClient(config: Omit<EmblemVaultWalletClientConfig, 'sdk'>): EmblemVaultWalletClient {
+        if (!this.apiKey) {
+            throw new Error("SDK must be initialized with an API key before creating a wallet client.");
+        }
+        return createEmblemVaultWalletClient({
+            ...config,
+            sdk: this, // Pass the current SDK instance
+        });
     }
 
-    // Example method structure
-    generateUploadUrl() {
-        // Implementation goes here
+    /**
+     * Creates a Solana Wallet Client instance powered by the Emblem Vault TEE signer.
+     *
+     * @param config - Configuration specific to the Solana wallet client, like the walletId.
+     * @returns An EmblemVaultSolanaWalletClient instance.
+     */
+    createSolanaWalletClient(config: Omit<EmblemVaultSolanaWalletClientConfig, 'sdk'>): EmblemVaultSolanaWalletClient {
+        if (!this.apiKey) {
+            throw new Error("SDK must be initialized with an API key before creating a wallet client.");
+        }
+        return createEmblemVaultSolanaWalletClient({
+            ...config,
+            sdk: this, // Pass the current SDK instance
+        });
+    }
+
+    /**
+     * Ethereum Convenience
+     *
+     * @param config - Configuration specific to the Solana wallet client, like the walletId.
+     * @returns An EmblemVaultSolanaWalletClient instance.
+     */
+    async getConnectedEthAccount(): Promise<string> {
+        if (!this.hasProvider("ethereum")) {
+            await this.getOrDetectProvider("ethereum");
+        }
+        return (await this.getProvider("ethereum").eth.getAccounts())[0];
     }
 
     // ** Asset Metadata **
     //
-    getAssetMetadata(projectName: string, strict: boolean = false) {
+    getCuratedAssetMetadata(projectName: string, strict: boolean = false, overrideFunc: Function | null = null) {
+        return this.getAssetMetadata(projectName, strict, overrideFunc);
+    }
+    // @deprecated
+    getAssetMetadata(projectName: string, strict: boolean = false, overrideFunc: Function | null = null) {
         genericGuard(projectName, "string", "projectName");
-        const NFT_DATA_ARR = metadataObj2Arr(NFT_DATA)
+        const NFT_DATA_ARR = overrideFunc && typeof overrideFunc === 'function' ? metadataObj2Arr(overrideFunc()) : metadataObj2Arr(NFT_DATA);
         let filtered = strict ? 
-            NFT_DATA_ARR.filter(item => item.projectName === projectName) :
-            NFT_DATA_ARR.filter(item => item.projectName.toLowerCase() === projectName.toLowerCase());
+            NFT_DATA_ARR.filter((item: any) => item.projectName === projectName) :
+            NFT_DATA_ARR.filter((item: any) => item.projectName.toLowerCase() === projectName.toLowerCase());
         return filtered
     }
 
-    getAllAssetMetadata() {
-        return metadataObj2Arr(NFT_DATA)
+    getAllCuratedAssetMetadata(overrideFunc: Function | null = null) {
+        return this.getAllAssetMetadata(overrideFunc);
+    }
+    // @deprecated    
+    getAllAssetMetadata(overrideFunc: Function | null = null) {
+        if (overrideFunc && typeof overrideFunc === 'function') {
+            return overrideFunc();
+        }
+        const NFT_DATA_ARR = metadataObj2Arr(NFT_DATA);
+        return NFT_DATA_ARR
+    }
+
+    /**
+     * @deprecated 
+     * This method is deprecated and will be removed in a future version. 
+     * Please use `getInventoryAssetMetadataProject` instead.
+     */
+    async getRemoteAssetMetadataProjectList(overrideFunc: Function | null = null) {
+        const url = `${this.v3Url}/asset_metadata/projects`;
+        const NFT_DATA_ARR = overrideFunc && typeof overrideFunc === 'function' ? overrideFunc(this.apiKey) : await fetchData(url, this.apiKey);
+        return NFT_DATA_ARR
     }
 
-    getRemoteAssetMetadataProjectList() {
-        return fetchData(`${this.v3Url}/asset_metadata/projects`, this.apiKey);
+    async getInventoryAssetMetadataProject(projectName?: string, overrideFunc: Function | null = null) {
+        const url = `${this.v3Url}/asset_metadata/projects`;
+        const NFT_DATA_ARR = overrideFunc && typeof overrideFunc === 'function' ? overrideFunc(this.apiKey, {project: projectName}) : await fetchData(url, this.apiKey, projectName?'POST':undefined, projectName? {project: projectName}:undefined);
+        NFT_DATA_ARR && (await NFT_DATA_ARR).map((item: any) => { item.asset_name = item.assetName; }); // Backward compatibility
+        return NFT_DATA_ARR
     }
 
-    getRemoteAssetMetadata(asset_name: string) {
-        return fetchData(`${this.v3Url}/asset_metadata/${asset_name}`, this.apiKey);
+    async getInventoryAssetMetadata(asset_name: string, overrideFunc: Function | null = null) {
+        const url = `${this.v3Url}/asset_metadata/${asset_name}`;
+        const NFT_DATA_ARR = overrideFunc && typeof overrideFunc === 'function' ? overrideFunc(this.apiKey) : await fetchData(url, this.apiKey);
+        return NFT_DATA_ARR
     }
 
-    getRemoteAssetMetadataVaultedProjectList() {
-        return fetchData(`${this.v3Url}/asset_metadata/projects/vaulted`, this.apiKey);
+    async getInventoryAssetMetadataVaultedProjectList(overrideFunc: Function | null = null) {
+        const url = `${this.v3Url}/asset_metadata/projects/vaulted`;
+        const NFT_DATA_ARR = overrideFunc && typeof overrideFunc === 'function' ? overrideFunc(this.apiKey) : await fetchData(url, this.apiKey);
+        return NFT_DATA_ARR
     }
 
-    getAllProjects() {
-        const NFT_DATA_ARR = metadataObj2Arr(NFT_DATA)
+    getAllCuratedProjects(overrideFunc: Function | null = null) {
+        const NFT_DATA_ARR = overrideFunc && typeof overrideFunc === 'function' ? metadataObj2Arr(overrideFunc()) : metadataObj2Arr(NFT_DATA)
         const projects = metadataAllProjects(NFT_DATA_ARR)
         return projects
     }
 
     // ** Curated **
     //
-    async fetchCuratedContracts(hideUnMintable: boolean = false, overrideFunc: Function | boolean = false): Promise<CuratedCollectionsResponse> {
+    async fetchCuratedContracts(hideUnMintable: boolean = false, overrideFunc: Function | null = null): Promise<CuratedCollectionsResponse> {
         let url = `${this.baseUrl}/curated`;
         // Fetch using URL or override function
-        let data = typeof overrideFunc === 'function' ? await overrideFunc() : await fetchData(url, this.apiKey);
+        let data = overrideFunc? await overrideFunc(this.apiKey) : await fetchData(url, this.apiKey);
         // Filter out collections that are not mintable
         data = hideUnMintable? data.filter((collection: Collection) => collection.mintable): data;
         
@@ -76,82 +200,82 @@ 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;
+                return { ...item, ...template, mintTemplate: template.generateCreateTemplate(item) };
+                // return item;
             });
         return data
     }
 
-    async fetchCuratedContractByName(name: string, contracts: any = false): Promise<Collection | null> {
-        !contracts ? contracts = await this.fetchCuratedContracts(): null
+    async fetchCuratedContractByName(name: string, contracts: any = false, overrideFunc: Function | null = null): Promise<Collection | null> {
+        !contracts ? contracts = overrideFunc? await overrideFunc(this.apiKey, {name}) : await this.fetchCuratedContracts(): null
         let contract = contracts.find((contract: Collection) => contract.name === name);
         return contract || null;
     }
     
-    async createCuratedVault(template: any, callback: any = null): Promise<Vault> {
+    async createCuratedVault(template: any, callback: any = null, overrideFunc: Function | null = null): Promise<Vault> {
         templateGuard(template);
         template.chainId == 1? delete template.targetContract[5]: delete template.targetContract[1]
         let url = `${this.baseUrl}/create-curated`;
         if (callback) { callback(`creating Vault for user`, template.toAddress)}     
-        let vaultCreationResponse = await fetchData(url, this.apiKey, 'POST', template);
+        let vaultCreationResponse = overrideFunc? await overrideFunc(this.apiKey, template): await fetchData(url, this.apiKey, 'POST', template);
         if (callback) { callback(`created Vault tokenId`, vaultCreationResponse.data.tokenId)}    
         return vaultCreationResponse.data
     }
 
-    async refreshOwnershipForTokenId(tokenId: string, callback: any = null): Promise<Ownership[]> {
+    async refreshOwnershipForTokenId(tokenId: string, callback: any = null, overrideFunc: Function | null = null): Promise<Ownership[]> {
         genericGuard(tokenId, "string", "tokenId");
         let url = `${this.baseUrl}/refreshBalanceForTokenId`;
-        let response = await fetchData(url, this.apiKey, 'POST', {tokenId});
+        let response = overrideFunc? await overrideFunc(this.apiKey, {tokenId}):  await fetchData(url, this.apiKey, 'POST', {tokenId});
         if (callback) { callback(`Refreshed ownership for`, tokenId)} 
         return response;
     }
 
-    async refreshOwnershipForAccount(account: string, callback: any = null): Promise<Ownership[]> {
+    async refreshOwnershipForAccount(account: string, callback: any = null, overrideFunc: Function | null = null): Promise<Ownership[]> {
         genericGuard(account, "string", "account");
         let url = `${this.baseUrl}/refreshBalanceForAccount`;
-        let response = await fetchData(url, this.apiKey, 'POST', {account});
+        let response = overrideFunc? await overrideFunc(this.apiKey, {account}):  await fetchData(url, this.apiKey, 'POST', {account});
         if (callback) { callback(`Refreshed ownership for`, account)} 
         return response;
     }
 
-    async fetchMetadata(tokenId: string, callback: any = null): Promise<MetaData> {
+    async fetchMetadata(tokenId: string, callback: any = null, overrideFunc: Function | null = null): Promise<MetaData> {
         genericGuard(tokenId, "string", "tokenId");
         if (callback) { callback('getting Metadata')}  
         let url = `${this.baseUrl}/meta/${tokenId}`;
-        let metadata = await fetchData(url, this.apiKey);
+        let metadata = overrideFunc? await overrideFunc(this.apiKey, {tokenId}): await fetchData(url, this.apiKey);
         if (callback) { callback('received Metadata', metadata.tokenId)}  
         return metadata;
     }
 
-    async refreshBalance(tokenId: string, callback: any = null): Promise<MetaData> {
+    async refreshBalance(tokenId: string, callback: any = null, overrideFunc: Function | null = null): Promise<Balance[]> {
         genericGuard(tokenId, "string", "tokenId");
         if (callback) { callback('refreshing Balance')}  
         let url = `${this.v3Url}/vault/balance/${tokenId}?live=true`;
-        let balance = await fetchData(url, this.apiKey);
-        if (callback) { callback('received Balance', balance.balances)}
-        return balance?.balances || [];
+        let balance = overrideFunc? await overrideFunc(this.apiKey, {tokenId}): await fetchData(url, this.apiKey);
+        if (callback) { callback('received Balance', balance.values)}
+        return balance?.values || [];
     }
 
-    async fetchVaultsOfType(vaultType: string, address: string): Promise<any> {
+    async fetchVaultsOfType(vaultType: string, address: string, overrideFunc: Function | null = null): Promise<any> {
         genericGuard(vaultType, "string", "vaultType");
         genericGuard(address, "string", "address");
         let url = `${this.baseUrl}/myvaults/${address}?vaultType=${vaultType}`;
-        let vaults = await fetchData(url, this.apiKey);
+        let vaults = overrideFunc? await overrideFunc(this.apiKey, {vaultType, address}): await fetchData(url, this.apiKey);
         return vaults;
     }
 
-    async generateJumpReport(address: string, hideUnMintable: boolean = false) {
+    async generateJumpReport(address: string, hideUnMintable: boolean = false, overrideFunc: Function | null = null) {
         let vaultType = "unclaimed"
         let curated = await this.fetchCuratedContracts();
         return new Promise(async (resolve, reject) => {
             try {
                 let map: { [key: string]: any } = {};
-                let vaults = await this.fetchVaultsOfType(vaultType, address);
+                let vaults = overrideFunc? await overrideFunc('vaults_of_type', this.apiKey, {vaultType, address}): await this.fetchVaultsOfType(vaultType, address);
                 for (let vaultIndex = 0; vaultIndex < vaults.length; vaultIndex++) {
                     let item = vaults[vaultIndex];
                     let balances = item.ownership.balances || [];                        
                     if (item.targetContract) {
-                        let vaultTargetContract: any = await this.fetchCuratedContractByName(item.targetContract.name, curated);
+                        let vaultTargetContract: any = overrideFunc? await overrideFunc('curated_contract_by_name', this.apiKey, {name: item.targetContract.name}): await this.fetchCuratedContractByName(item.targetContract.name, curated);
                         let to = [];
                         for (let contractIndex = 0; contractIndex < curated.length; contractIndex++) {                            
                             let contract: any = curated[contractIndex];
@@ -177,15 +301,15 @@ class EmblemVaultSDK {
         });
     }
 
-    async generateMintReport(address: string, hideUnMintable: boolean = false) {
-        let vaults = await this.fetchVaultsOfType("created", address)
+    async generateMintReport(address: string, hideUnMintable: boolean = false, overrideFunc: Function | null = null) {
+        let vaults = await this.fetchVaultsOfType("created", address, overrideFunc)
         let curated = await this.fetchCuratedContracts();
         let map: { [key: string]: any } = {};
         return new Promise(async (resolve, reject) => {
             try {
                 vaults.forEach(async (vault: any) => {
-                    if (vault.targetContract) {                        
-                        let targetVault: any = await this.fetchCuratedContractByName(vault.targetContract.name, curated);
+                    if (vault.targetContract) {
+                        let targetVault: any = overrideFunc? await overrideFunc(this.apiKey, {name: vault.targetContract.name}): await this.fetchCuratedContractByName(vault.targetContract.name, curated);
                         let balance = vault.balances && vault.balances.length > 0 ? vault.balances : vault.ownership && vault.ownership.balances && vault.ownership.balances.length > 0? vault.ownership.balances: []
                         let allowed = targetVault.allowed(balance, targetVault)
                         if (allowed || !hideUnMintable) {
@@ -206,18 +330,18 @@ class EmblemVaultSDK {
         });
     }
 
-    async generateMigrateReport(address: string, hideUnMintable: boolean = false) {
+    async generateMigrateReport(address: string, hideUnMintable: boolean = false, overrideFunc: Function | null = null) {
         let vaultType = "unclaimed"
         let curated = await this.fetchCuratedContracts();
         return new Promise(async (resolve, reject) => {
             try {
                 let map: { [key: string]: any } = {};
-                let vaults = await this.fetchVaultsOfType(vaultType, address);
+                let vaults = overrideFunc? await overrideFunc(this.apiKey, {vaultType, address}): await this.fetchVaultsOfType(vaultType, address);
                 for (let vaultIndex = 0; vaultIndex < vaults.length; vaultIndex++) {
                     let item = vaults[vaultIndex];
                     let balances = item.ownership.balances || [];                        
                     if (!item.targetContract) {
-                        // let vaultTargetContract: any = await this.fetchCuratedContractByName(item.targetContract.name, curated);
+                        // let vaultTargetContract: any = await this.fetchCuratedContractByName(item.targetContract.name);
                         let to = [];
                         for (let contractIndex = 0; contractIndex < curated.length; contractIndex++) {                            
                             let contract: any = curated[contractIndex];
@@ -248,39 +372,46 @@ class EmblemVaultSDK {
     // Function to load web3 dynamically and attach it to the window object
     async loadWeb3(): Promise<any | undefined> {
         try {
-            // Dynamically import the Web3 module
-            const { default: Web3 } = await import('web3');
-    
-            // Check if MetaMask (window.ethereum) is available
-            if (window.ethereum) {                
-                await window.ethereum.request({ method: 'eth_requestAccounts' });
-                // Initialize Web3 with MetaMask's provider
-                const web3 = new Web3(window.ethereum);
-                
-                // Attach Web3 to the window object
-                window.web3 = web3;
-    
-                return web3;
-            } else {
-                console.error('MetaMask is not installed!');
-                return undefined;
+            const provider = await this.getOrDetectProvider('ethereum') as EthereumProvider;
+            // Check if it's our adapter and return the raw Web3 instance
+            if (provider instanceof Web3ProviderAdapter) {
+                return provider.getRawWeb3();
             }
+            // If it's a generic EIP-1193 provider, we might need to wrap it if direct Web3 usage is required
+            // For now, let's assume the adapter covers the primary case (MetaMask)
+            console.warn('loadWeb3: Detected Ethereum provider is not a Web3 instance. Returning the provider object itself.');
+            return provider; 
         } catch (error) {
-            console.error('Error loading Web3 or connecting to MetaMask', error);
+            console.error('Could not load or detect Ethereum provider:', error);
             return undefined;
         }
     }
 
-    async performMintChain(web3: any, tokenId: string, collectionName: string, callback: any = null) {
-        let collection = await this.fetchCuratedContractByName(collectionName);        
+    /**
+     * Performs a mint operation on the blockchain.
+     * @param web3 - The web3 instance to use for the transaction.
+     * @param tokenId - The ID of the token to mint.
+     * @param callback - Optional callback function to handle the transaction.
+     * @returns A promise that resolves to the mint response.
+     * @deprecated Use `performMintHelper` instead.
+     */
+    async performMintChain(web3: any, tokenId: string, callback: any = null) {
         let mintRequestSig = await this.requestLocalMintSignature(web3, tokenId, callback);
-        let remoteMintSig = await this.requestRemoteMintSignature(web3, tokenId, mintRequestSig, callback);
-        let quote = await this.getQuote(web3, collection? collection.price: remoteMintSig._price/1000000, callback);
-        let ethToSend = quote.mul(BigNumber.from(10).pow(6))
-        let mintResponse = await this.performMint(web3, ethToSend, remoteMintSig, callback);
+        let remoteMintSig = await this.requestRemoteMintSignature(web3, tokenId, mintRequestSig, callback);    
+        let mintResponse = await this.performMint(web3, remoteMintSig, callback);
         return {mintResponse}
     }
 
+    /**
+     * Stub for new mint chain helper
+     * @param amount - The amount of tokens to mint.
+     * @param callback - Optional callback function to handle the transaction.
+     * @returns A promise that resolves to the mint response.
+     */
+    async performMintHelper( amount: number, callback?: any): Promise<BigNumber> {
+        throw new Error('Not implemented');
+    }
+
     async performClaimChain(web3: any, tokenId: string, serialNumber: any, callback: any = null) {
         let sig = await this.requestLocalClaimSignature(web3, tokenId, serialNumber, callback)
         let jwt = await this.requestRemoteClaimToken(web3, tokenId, sig, callback)
@@ -288,6 +419,14 @@ class EmblemVaultSDK {
         return await this.decryptVaultKeys(tokenId, dkeys, callback)
     }
     
+    /**
+     * Stub for new mint signature request
+     * @param web3 - The web3 instance to use for the transaction.
+     * @param tokenId - The ID of the token to mint.
+     * @param callback - Optional callback function to handle the transaction.
+     * @returns A promise that resolves to the mint signature.
+     * @deprecated Use `requestV3LocalMintSignature` instead.
+     */
     async requestLocalMintSignature(web3: any, tokenId: string, callback: any = null) {
         if (callback) { callback('requesting User Mint Signature')}
         const message = `Curated Minting: ${tokenId.toString()}`;
@@ -297,51 +436,130 @@ class EmblemVaultSDK {
         return signature;
     }
 
-    async requestLocalClaimSignature(web3: any, tokenId: string, serialNumber: any, callback: any = null) {
-        if (callback) { callback('requesting User Claim Signature')}
-        const message = `Claim: ${serialNumber? serialNumber.toString(): tokenId.toString()}`;
-        const accounts = await web3.eth.getAccounts();
-        const signature = await web3.eth.personal.sign(message, accounts[0], '');
+    /**
+     * Requests a signature for a curated minting operation. (ONLY ETHEREUM FOR NOW)
+     * @param tokenId - The ID of the token to mint.
+     * @param callback - Optional callback function to handle the transaction.
+     * @param overrideFunc - Optional function to override the default behavior.
+     * @returns A promise that resolves to the mint signature.
+     */
+    async requestV3LocalMintSignature(tokenId: string, callback: any = null, overrideFunc: Function | null = null): Promise<v3LocalMintSignature> {
+        if (callback) { callback('requesting Owner Mint Signature')}
+        const provider = await this.getOrDetectProvider('ethereum');
+        const rawBlockNumber = await provider.eth.getBlockNumber();
+        const blockNumber = Number(rawBlockNumber).toString();
+        const message = `Curated Minting: ${tokenId.toString()} \n\nat Block# ${blockNumber}`;
+        const account = await this.getConnectedEthAccount();
+        if (!account) {
+            throw new Error('No connected wallet found');
+        }
+        const signature = overrideFunc? await overrideFunc(message, account): await provider.eth.personal.sign(message, account, callback? callback: '');
         if (callback) { callback(`signature`, signature)}
-        return signature;
+        return {message, signature};
+    }
+
+    /**
+     * Requests a signature for a curated minting operation. (ONLY ETHEREUM FOR NOW)
+     * @param tokenId - The ID of the token to mint.
+     * @param signature - The signature for the curated minting operation.
+     * @param callback - Optional callback function to handle the transaction.
+     * @param overrideFunc - Optional function to override the default behavior.
+     * @returns A promise that resolves to the remote mint signature.
+     * @deprecated Use `requestV3RemoteMintSignature` instead.
+     */
+    async requestRemoteMintSignature(web3: any, tokenId: string, signature: string, callback: any = null, overrideFunc: Function | null = null) {
+        if (callback) { callback('requesting Remote Mint signature')}  
+        const chainId = await web3.eth.getChainId();
+        let url = `${this.baseUrl}/mint-curated`;
+        let mintRequestBody = {method: 'buyWithSignedPrice', tokenId: tokenId, signature: signature, chainId: chainId.toString()}
+        let remoteMintResponse = overrideFunc? await overrideFunc(url, this.apiKey, 'POST', mintRequestBody): await fetchData(url, this.apiKey, 'POST', mintRequestBody);
+        if (remoteMintResponse.error) {
+            throw new Error(remoteMintResponse.error)
+        }
+        if (callback) { callback(`remote Mint signature`, remoteMintResponse)}
+        return remoteMintResponse
     }
 
-    async requestRemoteMintSignature(web3: any, tokenId: string, signature: string, callback: any = null) {
+    /**
+     * Requests a signature for a curated minting operation. (ONLY ETHEREUM FOR NOW)
+     * @param tokenId - The ID of the token to mint.
+     * @param signature - The signature for the curated minting operation.
+     * @param callback - Optional callback function to handle the transaction.
+     * @param overrideFunc - Optional function to override the default behavior.
+     * @returns A promise that resolves to the remote mint signature.
+     */
+    async requestV3RemoteMintSignature(tokenId: string, signature: string, callback: any = null, overrideFunc: Function | null = null) {
         if (callback) { callback('requesting Remote Mint signature')}  
-        const chainId = await web3.eth.getChainId();
+        const chainId = (await this.getOrDetectProvider('ethereum')).eth.getChainId();
         let url = `${this.baseUrl}/mint-curated`;
-        let remoteMintResponse = await fetchData(url, this.apiKey, 'POST',  {method: 'buyWithQuote', tokenId: tokenId, signature: signature, chainId: chainId.toString()});
+        const mintRequestBody = {method: 'buyWithSignedPrice', tokenId: tokenId, signature: signature, chainId: chainId.toString(), enhanced: true};
+        let remoteMintResponse = overrideFunc? await overrideFunc(url, this.apiKey, 'POST', mintRequestBody): await fetchData(url, this.apiKey, 'POST', mintRequestBody);
         if (remoteMintResponse.error) {
             throw new Error(remoteMintResponse.error)
         }
         if (callback) { callback(`remote Mint signature`, remoteMintResponse)}
         return remoteMintResponse
-    }    
+    }
+
+    async requestLocalClaimSignature(web3: any, tokenId: string, serialNumber: any, callback: any = null) {
+        if (callback) { callback('requesting User Claim Signature')}
+        const message = `Claim: ${serialNumber? serialNumber.toString(): tokenId.toString()}`;
+        const accounts = await web3.eth.getAccounts();
+        const signature = await web3.eth.personal.sign(message, accounts[0], '');
+        if (callback) { callback(`signature`, signature)}
+        return signature;
+    }
 
-    async requestRemoteClaimToken(web3: any, tokenId: string, signature: string, callback: any = null) {
+    async requestRemoteClaimToken(web3: any, tokenId: string, signature: string, callback: any = null, overrideFunc: Function | null = null) {
         if (callback) { callback('requesting Remote Claim token')}
         const chainId = await web3.eth.getChainId();
         let url = `${this.sigUrl}/sign`;
-        let remoteClaimResponse = await fetchData(url, this.apiKey, 'POST',  {signature: signature, tokenId: tokenId}, {chainid: chainId.toString()});
+        let remoteClaimResponse = overrideFunc? await overrideFunc(this.apiKey, {signature: signature, tokenId: tokenId, chainid: chainId.toString()}): await fetchData(url, this.apiKey, 'POST',  {signature: signature, tokenId: tokenId}, {chainid: chainId.toString()});
         if (callback) { callback(`remote Claim token`, remoteClaimResponse)}
         return remoteClaimResponse
     }
 
-    async requestRemoteKey(tokenId: string, jwt: any, callback: any = null) {
+    async requestRemoteKey(tokenId: string, jwt: any, callback: any = null, overrideFunc: Function | null = null) {
         if (callback) { callback('requesting Remote Key')}
-        let dkeys = await getTorusKeys(tokenId, jwt.token)
+        let dkeys = overrideFunc? await overrideFunc(this.apiKey, {tokenId: tokenId, jwt: jwt.token}): await getTorusKeys(tokenId, jwt.token)
         if (callback) { callback(`remote Key`, dkeys)}
         return dkeys
     }
 
-    async decryptVaultKeys(tokenId: string, dkeys: any, callback: any = null) {
+    async decryptVaultKeys(tokenId: string, dkeys: any, callback: any = null, overrideFunc: Function | null = null) {
         if (callback) { callback('decrypting Vault Keys')}
-        let metadata: any = await this.fetchMetadata(tokenId);
+        let metadata: any = overrideFunc? await overrideFunc(this.apiKey, {tokenId: tokenId}): await this.fetchMetadata(tokenId);
         let ukeys = await decryptKeys(metadata.ciphertextV2, dkeys, metadata.addresses)
         if (callback) { callback(`remote Key`, ukeys)}
         return ukeys
     }
 
+    async recoverSignerFromMessage(message: string, signature: string, overrideFunc: Function | null = null): Promise<string> {
+        const provider = await this.getOrDetectProvider('ethereum');
+        return overrideFunc? await overrideFunc(message, signature): await provider.eth.personal.recover(message, signature);
+    }
+
+    /**
+     * ** Emblem Vault AI **
+     *
+     * Be sure to allow api key requests, or api_key_hash and auth sig (wallet, socialAuth, oAuth)
+     * Here we will begin using the aiApiKey and the aiUrl to communicate with the ai vault system
+     * 
+     */
+
+    async vaultInfoFromApiKey(aiApiKey?: string, full?: boolean, overrideFunc: Function | null = null): Promise<AiVaultInfo> {
+        const url = `${this.aiUrl}/vault/${full ? 'info-complete' : 'info'}`;
+        const selectedKey = aiApiKey ? aiApiKey : this.aiApiKey ? this.aiApiKey : '';
+        const actionFunction = overrideFunc && typeof overrideFunc === 'function' ? overrideFunc: fetchData;
+        const vaultDetails =  await actionFunction(url, selectedKey, 'POST', null);
+        // vaultDetails.computedEthAddress = ethers.utils.computeAddress(vaultDetails.pkp.pub_key.replace('0x',''));
+        return vaultDetails;
+    }
+
+    /**
+     * @deprecated This method is deprecated and will be removed in a future version.
+     * Please use alternative methods for price quotation.
+     */
     async getQuote(web3: any, amount: number, callback: any = null) {
         if (callback) { callback('requesting Quote')}
         let quoteContract = await getQuoteContractObject(web3);
@@ -351,7 +569,8 @@ class EmblemVaultSDK {
         return quote
     }
 
-    async performMint(web3: any, quote: any, remoteMintSig: any, callback: any = null) {
+    // todo add contract overrides
+    async performMint(web3: any, remoteMintSig: any, callback: any = undefined) {
     // async performMint(web3, quote, remoteMintSig, callback = null) {
         if (callback) { callback('performing Mint') }
         const accounts = await web3.eth.getAccounts();
@@ -360,9 +579,10 @@ class EmblemVaultSDK {
         // Get current gas price from the network
         const gasPrice = await web3.eth.getGasPrice();
 
-        let createdTxObject = handlerContract.methods.buyWithQuote(
-            remoteMintSig._nftAddress, 
-            remoteMintSig._price, 
+        let createdTxObject = handlerContract.methods.buyWithSignedPrice(
+            remoteMintSig._nftAddress,
+            '0x0000000000000000000000000000000000000000',
+            remoteMintSig._price.hex,
             remoteMintSig._to, 
             remoteMintSig._tokenId, 
             remoteMintSig._nonce, 
@@ -372,12 +592,12 @@ class EmblemVaultSDK {
         )
         
         // Estimate gas limit for the transaction
-        const gasLimit = await createdTxObject.estimateGas({ from: accounts[0], value: Number(quote) });
+        const gasLimit = await createdTxObject.estimateGas({ from: accounts[0], value: remoteMintSig._price.hex });
     
         // Execute the transaction with the specified gas price and estimated gas limit
         let mintResponse = await createdTxObject.send({ 
             from: accounts[0], 
-            value: Number(quote),
+            value: remoteMintSig._price.hex,
             gasPrice: gasPrice, // Use the current gas price
             gas: gasLimit // Use the estimated gas limit
         }).on('transactionHash', (hash: any) => {
@@ -593,13 +813,11 @@ class EmblemVaultSDK {
 declare global {
     interface Window {
         EmblemVaultSDK: any;
-        web3: any;
-        ethereum: any
+        // web3: any;
+        // ethereum: any
     }
 }
 
 if (typeof window !== 'undefined') {
     window.EmblemVaultSDK = EmblemVaultSDK;
 }
-
-export default EmblemVaultSDK;