@ercworldio/blockchain-shared 1.0.0-dev.4

package/build/utils/solana.js

@@ -0,0 +1,658 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check_approve_delegate = exports.handle_create_versioned_transaction_spl = exports.estimate_withdraw_gas_cost = exports.create_versioned_transaction_solana = exports.get_token_account_info = exports.getSolanaConnectionPublic = exports.getSolanaConnection = exports.find_transfer_instruction = exports.handle_transfer_batch = exports.handle_sweep = exports.SplTransferCheckedLayout = exports.SolTransferInstructionLayout = exports.usdc_program_address = exports.solana_program_address = exports.min_solana_funding_lamports = void 0;
+const buffer_layout_utils_1 = require("@solana/buffer-layout-utils");
+const buffer_layout_1 = require("@solana/buffer-layout");
+const web3_js_1 = __importStar(require("@solana/web3.js"));
+const Utility_1 = require("./Utility");
+const spl_token_1 = require("@solana/spl-token");
+const ChainManager_1 = __importDefault(require("../services/ChainManager"));
+const WalletManager_1 = __importDefault(require("../services/WalletManager"));
+const Wallets_1 = require("./Wallets");
+const WithdrawalManager_1 = __importDefault(require("../services/WithdrawalManager"));
+const constants_1 = require("../constants");
+exports.min_solana_funding_lamports = 0.001 * web3_js_1.LAMPORTS_PER_SOL;
+exports.solana_program_address = "11111111111111111111111111111111";
+exports.usdc_program_address = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+const token_program_addresses = [exports.solana_program_address, exports.usdc_program_address];
+exports.SolTransferInstructionLayout = (0, buffer_layout_1.struct)([(0, buffer_layout_utils_1.u64)('lamports'), (0, buffer_layout_1.u32)("instruction_type")]);
+exports.SplTransferCheckedLayout = (0, buffer_layout_1.struct)([
+    (0, buffer_layout_1.u8)('disc'),
+    (0, buffer_layout_utils_1.u64)('amount'),
+    (0, buffer_layout_1.u8)('decimals')
+]);
+const handle_sweep = (payloads_1, chain_id_1, token_type_1, connection_1, payer_1, ...args_1) => __awaiter(void 0, [payloads_1, chain_id_1, token_type_1, connection_1, payer_1, ...args_1], void 0, function* (payloads, chain_id, token_type, connection, payer, is_funding = false, dbPool, config) {
+    if (payloads.length === 0)
+        return { status: true, signatures: [], success: [], failed: [] };
+    // Get approved token transfers based on payment token
+    let batches = [];
+    const max_tx_per_batch = config.serverConfig.maxInstructionsPerTxSolana;
+    // Create batches without mutating original array
+    for (let i = 0; i < payloads.length; i += max_tx_per_batch) {
+        const batch = payloads.slice(i, i + max_tx_per_batch);
+        batches.push(batch);
+    }
+    if (batches.length === 0)
+        return { status: true, signatures: [], success: [], failed: [] };
+    let success = [];
+    let failed = [];
+    let signatures = [];
+    for (let batch of batches) {
+        if (token_type === "spl") {
+            let { transfer_sig, blocknumber, fee, success: success_requests, failed: failed_requests } = yield (0, exports.handle_create_versioned_transaction_spl)(batch, connection, payer, is_funding, dbPool, config);
+            console.log(`Transferred spl tokens for ${batch.length} candidates. Signature: `, transfer_sig);
+            signatures.push(transfer_sig);
+            if (success_requests.length) {
+                let success_candidates = batch.map(r => { return Object.assign(Object.assign({}, r.candidate), { hash: transfer_sig }); });
+                success.push(...success_candidates);
+            }
+            if (failed_requests.length) {
+                let failed_candidates = batch.map(r => { return Object.assign(Object.assign({}, r.candidate), { hash: "" }); });
+                failed.push(...failed_candidates);
+            }
+        }
+        else {
+            let tx_result = yield (0, exports.create_versioned_transaction_solana)(batch, connection, is_funding, true, dbPool, config);
+            console.log(`Transferred SOL tokens for ${batch.length} candidates. Signature: `, tx_result);
+            if (tx_result.success) {
+                const sigs = tx_result.success.map(r => r.signature).filter(r => r !== null);
+                signatures.push(...sigs);
+                let success_candidates = tx_result.success.map(r => {
+                    const target_candidate = batch.find(b => b.id === r.id);
+                    if (!target_candidate)
+                        return undefined;
+                    return Object.assign(Object.assign({}, target_candidate.candidate), { hash: r.signature }); // todo: Add block number
+                })
+                    .filter(r => r !== undefined);
+                success.push(...success_candidates);
+            }
+            if (tx_result.failed) {
+                const failed_candidates = tx_result.failed.map(r => {
+                    const target_candidate = batch.find(b => b.id === r.id);
+                    if (!target_candidate)
+                        return undefined;
+                    return Object.assign(Object.assign({}, target_candidate.candidate), { hash: "" });
+                })
+                    .filter(r => r !== undefined);
+                failed.push(...failed_candidates);
+            }
+        }
+    }
+    return { status: true, signatures, success, failed };
+});
+exports.handle_sweep = handle_sweep;
+// Combines transfer requests into 1 list given a pre-sorted payloads array by chain id and blockchain
+// export const handle_transfer_batch = async (payloads: SolanaTransactionPayload[]) => {
+const handle_transfer_batch = (payloads_1, chain_id_1, token_type_1, connection_1, payer_1, ...args_1) => __awaiter(void 0, [payloads_1, chain_id_1, token_type_1, connection_1, payer_1, ...args_1], void 0, function* (payloads, chain_id, token_type, connection, payer, is_funding = false, dbPool, config) {
+    if (payloads.length === 0)
+        return { status: true, signatures: [], success: [], failed: [] };
+    // Get approved token transfers based on payment token
+    // const sanitized_requests = payloads.map(p => { return get_approved_requests(p.blockchain, p.chain_id, p.request) })
+    // const transfer_requests: SolanaTransactionRequest[] = sanitized_requests.flatMap(p => p);
+    let batches = [];
+    const max_tx_per_batch = config.serverConfig.maxInstructionsPerTxSolana;
+    // Create batches without mutating original array
+    for (let i = 0; i < payloads.length; i += max_tx_per_batch) {
+        const batch = payloads.slice(i, i + max_tx_per_batch);
+        console.log(`Adding ${batch.length} items to batch transaction...`);
+        batches.push(batch);
+    }
+    if (batches.length === 0)
+        return { status: true, signatures: [], success: [], failed: [] };
+    const withdraw_manager = new WithdrawalManager_1.default(dbPool, config);
+    let success = [];
+    let failed = [];
+    let signatures = [];
+    for (let batch of batches) {
+        if (token_type === "spl") {
+            try {
+                const executed_at = new Date();
+                let { transfer_sig, blocknumber, fee } = yield (0, exports.handle_create_versioned_transaction_spl)(batch, connection, payer, is_funding, dbPool, config);
+                console.log(`Transferred spl tokens for ${batch.length} candidates. Signature: `, transfer_sig);
+                signatures.push(transfer_sig);
+                let success_requests = batch.map(b => {
+                    return Object.assign(Object.assign({}, b), { signature: transfer_sig, blocknumber, gas_used: fee, fee: fee, executed_at });
+                });
+                success.push(...success_requests);
+            }
+            catch (error) {
+                failed.push(...batch);
+            }
+        }
+        else {
+            let tx_result = yield (0, exports.create_versioned_transaction_solana)(batch, connection, is_funding, true, dbPool, config);
+            console.log(`Transferred SOL tokens for ${batch.length} candidates. Signature: `, tx_result);
+            if (tx_result.success) {
+                const sigs = tx_result.success.map(r => r.signature).filter(r => r !== null);
+                signatures.push(...sigs);
+                success.push(...tx_result.success);
+            }
+            if (tx_result.failed) {
+                // const failed_requests = tx_result.failed.flatMap(r => r.requests);
+                failed.push(...tx_result.failed);
+                success.push();
+            }
+        }
+    }
+    return { status: true, signatures, success, failed };
+});
+exports.handle_transfer_batch = handle_transfer_batch;
+const find_transfer_instruction = (tx) => {
+    const message = tx.transaction[0].message[0];
+    const target_instruction = message.instructions.find(i => token_program_addresses.some(a => a === message.account_keys[parseInt(i.program_id_index)]));
+    if (!target_instruction)
+        throw new Error(`Cannot find program index for accepted payment tokens: ${token_program_addresses}`);
+    const program_index = target_instruction === null || target_instruction === void 0 ? void 0 : target_instruction.program_id_index;
+    return { instruction: target_instruction, is_native: tx.transaction[0].message[0].account_keys[parseInt(program_index)] === exports.solana_program_address };
+};
+exports.find_transfer_instruction = find_transfer_instruction;
+const getSolanaConnection = (chainId, config) => {
+    const network = ChainManager_1.default.getInstance(config).getChainConfigForChainIdSync(parseInt(chainId));
+    if (!network)
+        throw new Error(`Network config not set for ${chainId}`);
+    const url = `${network.rpcBaseUrl}/${config.config.ankrApiKey}`;
+    return new web3_js_1.Connection(url, 'confirmed');
+};
+exports.getSolanaConnection = getSolanaConnection;
+const getSolanaConnectionPublic = (chainId) => {
+    const url = chainId === '101'
+        ? (0, web3_js_1.clusterApiUrl)('mainnet-beta')
+        : chainId === '102'
+            ? (0, web3_js_1.clusterApiUrl)('testnet')
+            : (0, web3_js_1.clusterApiUrl)('devnet');
+    return new web3_js_1.Connection(url, 'confirmed');
+};
+exports.getSolanaConnectionPublic = getSolanaConnectionPublic;
+const get_token_account_info = (chainId, mint_address, owner_address, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = (0, exports.getSolanaConnection)(chainId, config);
+    const mintPk = new web3_js_1.PublicKey(mint_address);
+    const ownerPk = new web3_js_1.PublicKey(owner_address);
+    const parsedTokenAccounts = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getParsedTokenAccountsByOwner(ownerPk, { programId: spl_token_1.TOKEN_PROGRAM_ID }));
+    const targetAccount = parsedTokenAccounts.value.find(a => a.account.data.parsed.info.mint.toString() === mintPk.toString());
+    if (!targetAccount)
+        throw new Error("Token account not found");
+    const tokenInfo = yield connection.getAccountInfo(targetAccount.pubkey);
+    const sol_balance = tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.lamports;
+    const balance = targetAccount.account.data.parsed.info.tokenAmount.amount;
+    const balance_decimals = targetAccount.account.data.parsed.info.tokenAmount.uiAmount;
+    const decimals = targetAccount.account.data.parsed.info.tokenAmount.decimals;
+    return {
+        sol_balance_lamports: sol_balance,
+        spl_balance_lamports: balance,
+        spl_balance_decimals: balance_decimals,
+        decimals
+    };
+});
+exports.get_token_account_info = get_token_account_info;
+const is_payment_token = (blockchain, payment_tokens, target) => {
+    const entry = payment_tokens.find(p => (0, Wallets_1.normalizeAddress)(p, blockchain) === (0, Wallets_1.normalizeAddress)(target, blockchain));
+    return entry ? true : false;
+};
+const get_approved_requests = (blockchain, chain_id, requests, config) => {
+    // Ensure payment token is accepted
+    const chain_manager = ChainManager_1.default.getInstance(config);
+    const payment_tokens = chain_manager.getPaymentTokensForChain(parseInt(chain_id));
+    if (!payment_tokens)
+        throw new Error(`Payment tokens not found for chain ${chain_id}`);
+    const token_addresses = payment_tokens.map(t => t.address);
+    const accepted_requests = requests.filter(r => is_payment_token(blockchain, token_addresses, r.token));
+    return accepted_requests;
+};
+// const create_versioned_transaction_solana = async (chain_id: ChainId, from_address: string, to_address: string, amount_in_lamports: number) => {
+const create_versioned_transaction_solana = (requests_1, connection_1, ...args_1) => __awaiter(void 0, [requests_1, connection_1, ...args_1], void 0, function* (requests, connection, is_funding = false, is_sweep = false, dbPool, config) {
+    let min_rent = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getMinimumBalanceForRentExemption(0));
+    let { blockhash } = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getLatestBlockhash());
+    const walletManager = WalletManager_1.default.getInstance(config, dbPool);
+    const funding_wallet = walletManager.getEscrowFundsManagerWallet("solana");
+    const funding_address = funding_wallet.publicKey.toString();
+    if (is_funding) {
+        try {
+            const instructions = requests.map(p => web3_js_1.default.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(p.from_address),
+                toPubkey: new web3_js_1.PublicKey(p.to_address),
+                lamports: p.amount_in_lamports
+            }));
+            const message_v0 = new web3_js_1.default.TransactionMessage({
+                payerKey: funding_wallet.publicKey,
+                recentBlockhash: blockhash,
+                instructions: instructions
+            }).compileToV0Message();
+            const transaction = new web3_js_1.default.VersionedTransaction(message_v0);
+            transaction.sign([funding_wallet]);
+            const executed_at = new Date();
+            const tx_id = yield connection.sendTransaction(transaction);
+            let _reqs = requests.map(r => {
+                return Object.assign(Object.assign({}, r), { hash: tx_id });
+            });
+            yield (0, Utility_1.sleep)(200);
+            // Get the transaction details
+            const tx_data = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getParsedTransaction(tx_id, { maxSupportedTransactionVersion: 0, commitment: 'confirmed' }));
+            const success = _reqs.map(r => {
+                var _a, _b;
+                return Object.assign(Object.assign({}, r), { signature: tx_id, blocknumber: (tx_data === null || tx_data === void 0 ? void 0 : tx_data.slot) ? tx_data.slot : 0, gas_used: ((_a = tx_data === null || tx_data === void 0 ? void 0 : tx_data.meta) === null || _a === void 0 ? void 0 : _a.computeUnitsConsumed) ? tx_data.meta.computeUnitsConsumed : 0, fee: ((_b = tx_data === null || tx_data === void 0 ? void 0 : tx_data.meta) === null || _b === void 0 ? void 0 : _b.fee) ? tx_data.meta.fee / requests.length : 0, // average fee per instruction
+                    executed_at });
+            });
+            return { success: success, failed: [] };
+        }
+        catch (error) {
+            const _reqs = requests.map(r => { return Object.assign(Object.assign({}, r), { hash: "" }); });
+            return { success: [], failed: _reqs };
+        }
+    }
+    else {
+        const promises = yield Promise.allSettled(requests.map((r) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const payer = walletManager.deriveWallet(r.source_parent_index, r.source_child_index, "solana");
+                const onchainbalance = yield connection.getBalance(payer.wallet.publicKey);
+                // Transfer entire balance in case of sweeping
+                const amount_in_lamports = !is_sweep && onchainbalance >= BigInt(r.amount_in_lamports) ? BigInt(r.amount_in_lamports) : BigInt(onchainbalance);
+                let { amount_to_transfer, gas_cost } = yield estimate_gas_cost_transfer_sol(payer.wallet, r.from_address, funding_wallet.publicKey.toString(), amount_in_lamports, connection);
+                const instructions = [web3_js_1.default.SystemProgram.transfer({
+                        fromPubkey: new web3_js_1.PublicKey(r.from_address),
+                        toPubkey: funding_wallet.publicKey,
+                        lamports: amount_to_transfer
+                    })];
+                // Skip low balance
+                if (amount_to_transfer === BigInt(0)) {
+                    return { status: true, signature: "", requests: [Object.assign(Object.assign({}, r), { signature: "", blocknumber: 0, gas_used: 0 })] };
+                }
+                const block = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getLatestBlockhash());
+                const message_v0 = new web3_js_1.default.TransactionMessage({
+                    payerKey: payer.wallet.publicKey,
+                    recentBlockhash: blockhash,
+                    instructions: instructions
+                }).compileToV0Message();
+                const transaction = new web3_js_1.default.VersionedTransaction(message_v0);
+                transaction.sign([payer.wallet]);
+                try {
+                    const executed_at = new Date();
+                    const tx_id = yield connection.sendTransaction(transaction);
+                    yield (0, Utility_1.sleep)(100);
+                    // Get the transaction details
+                    const fee = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getParsedTransaction(tx_id, "confirmed"));
+                    const _reqs = [
+                        Object.assign(Object.assign({}, r), { signature: tx_id, blocknumber: block.lastValidBlockHeight, gas_used: ((_a = fee === null || fee === void 0 ? void 0 : fee.meta) === null || _a === void 0 ? void 0 : _a.computeUnitsConsumed) ? fee.meta.computeUnitsConsumed : 0, fee: ((_b = fee === null || fee === void 0 ? void 0 : fee.meta) === null || _b === void 0 ? void 0 : _b.fee) ? fee.meta.fee : 0, executed_at })
+                    ];
+                    return { status: true, signature: tx_id, requests: _reqs };
+                }
+                catch (error) {
+                    return { status: false, signature: null, requests: requests, error: error.message ? error.message : "Unexpected error occured while creating SOL transaction" };
+                }
+            }
+            catch (error) {
+                const _reqs = [Object.assign({}, r)];
+                return { status: false, signature: null, requests: _reqs, error: error.message ? error.message : "Unexpected error occured while creating SOL transaction" };
+            }
+        })));
+        //29999700
+        //29995000
+        //'Transfer: insufficient lamports 9995000, need 9999700'
+        //.009995000
+        //.009999700
+        const success = promises
+            .filter(r => r.status === "fulfilled")
+            .map(r => {
+            if (r.value.status === true) {
+                return r.value.requests;
+            }
+            return undefined;
+        })
+            .filter(r => r !== undefined)
+            .flatMap(r => r);
+        const failed = promises
+            .filter(r => r.status === "fulfilled")
+            .map(r => {
+            if (r.value.status === false) {
+                return r.value.requests;
+            }
+        })
+            .filter(r => r !== undefined)
+            .flatMap(r => r);
+        return { success: success, failed: failed };
+    }
+});
+exports.create_versioned_transaction_solana = create_versioned_transaction_solana;
+const estimate_gas_cost_transfer_sol = (signer, from_address, to_address, amount_in_lamports, connection) => __awaiter(void 0, void 0, void 0, function* () {
+    const fromPubkey = new web3_js_1.PublicKey(from_address);
+    const toPubkey = new web3_js_1.PublicKey(to_address);
+    // Build a message identical to the one you'll send (amount doesn't change fee)
+    const { blockhash } = yield connection.getLatestBlockhash();
+    const ix = web3_js_1.default.SystemProgram.transfer({
+        fromPubkey,
+        toPubkey,
+        lamports: amount_in_lamports
+    });
+    const msg = new web3_js_1.default.TransactionMessage({
+        payerKey: fromPubkey,
+        recentBlockhash: blockhash,
+        instructions: [ix],
+    }).compileToV0Message();
+    const feeResp = yield connection.getFeeForMessage(msg);
+    if (!feeResp || feeResp.value === null)
+        throw new Error("Failed to estimate transaction fee.");
+    const feeLamports = BigInt(feeResp.value);
+    const balanceLamports = BigInt(yield connection.getBalance(fromPubkey));
+    const spendable = balanceLamports > feeLamports ? (balanceLamports - feeLamports) : BigInt(0);
+    // Cap the amount to send by what's actually spendable after fees
+    const amount_to_transfer = amount_in_lamports > spendable ? spendable : amount_in_lamports;
+    return {
+        gas_cost: feeLamports,
+        balance: balanceLamports,
+        amount_to_transfer
+    };
+});
+const estimate_withdraw_gas_cost = (chain_id, transfer_requests, payer, dbPool, config) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!transfer_requests.length)
+        return 0;
+    const connection = (0, exports.getSolanaConnection)(chain_id, config);
+    const sol_requests = transfer_requests.filter(r => r.token === exports.solana_program_address);
+    const spl_requests = transfer_requests.filter(r => r.token !== exports.solana_program_address);
+    const sol_payload = sol_requests.map(r => {
+        return {
+            fromPubkey: new web3_js_1.PublicKey(r.from_address),
+            toPubkey: new web3_js_1.PublicKey(r.to_address),
+            lamports: BigInt(r.amount_in_lamports)
+        };
+    });
+    let sol_estimation = 0;
+    if (sol_payload.length) {
+        sol_estimation = yield estimate_batch_transfer_sol(sol_payload, payer, connection);
+    }
+    let spl_estimation = 0;
+    if (spl_requests.length) {
+        spl_estimation = yield estimate_gas_cost_transfer_spl(spl_requests, connection, payer, dbPool, config);
+    }
+    return sol_estimation + spl_estimation;
+});
+exports.estimate_withdraw_gas_cost = estimate_withdraw_gas_cost;
+const estimate_batch_transfer_sol = (transfer_requests, payer, connection) => __awaiter(void 0, void 0, void 0, function* () {
+    if (transfer_requests.length === 0)
+        return 0;
+    const block = yield connection.getLatestBlockhash();
+    const ixs = transfer_requests.map(p => {
+        return web3_js_1.default.SystemProgram.transfer(p);
+    });
+    const msg = new web3_js_1.default.TransactionMessage({
+        payerKey: payer.publicKey,
+        recentBlockhash: block.blockhash,
+        instructions: ixs
+    }).compileToV0Message();
+    const fee_res = yield connection.getFeeForMessage(msg);
+    if (!fee_res || fee_res.value === null)
+        throw new Error("Failed to estimate transaction fee.");
+    return fee_res.value;
+});
+const estimate_gas_cost_transfer_spl = (transfer_requests, connection, payer, dbPool, config) => __awaiter(void 0, void 0, void 0, function* () {
+    if (transfer_requests.length === 0)
+        return 0;
+    const blockhash = yield connection.getLatestBlockhash();
+    // TODO: CHeck is_funding
+    // Build the transaction instructions
+    const { transfer_transaction, signers } = yield build_transactions_spl(transfer_requests, connection, false, dbPool, config);
+    transfer_transaction.recentBlockhash = blockhash.blockhash;
+    transfer_transaction.feePayer = payer.publicKey;
+    // const estimated_fee = await retryWithExponentialBackoff(() => transfer_transaction.getEstimatedFee(connection));
+    const estimated_fee = yield (0, Utility_1.retryWithExponentialBackoff)(() => transfer_transaction.getEstimatedFee(connection));
+    // TODO: Return fallback value
+    if (estimated_fee === null)
+        throw new Error("Failed to estimated transaction cost");
+    return estimated_fee;
+});
+const handle_create_versioned_transaction_spl = (transfer_requests, connection, payer, is_funding, dbPool, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    if (transfer_requests.length > config.serverConfig.maxInstructionsPerTxSolana)
+        throw new Error(`Cannot exceed maxium instructions per transaction of ${config.serverConfig.maxInstructionsPerTxSolana}`);
+    const block = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getLatestBlockhash());
+    // Build the transaction instructions
+    const { transfer_transaction, signers } = yield build_transactions_spl(transfer_requests, connection, is_funding, dbPool, config);
+    let success_requests = [];
+    let failed_requests = [];
+    let signature = "";
+    let gas_used = 0;
+    let fee = 0;
+    try {
+        const executed_at = new Date();
+        // Sign and send the tx
+        signature = yield (0, Utility_1.retryWithExponentialBackoff)(() => (0, web3_js_1.sendAndConfirmTransaction)(connection, transfer_transaction, [payer, ...signers], { commitment: 'confirmed' }));
+        const tx = yield (0, Utility_1.retryWithExponentialBackoff)(() => connection.getParsedTransaction(signature, "confirmed"));
+        gas_used = ((_a = tx === null || tx === void 0 ? void 0 : tx.meta) === null || _a === void 0 ? void 0 : _a.computeUnitsConsumed) ? tx.meta.computeUnitsConsumed : 0;
+        fee = ((_b = tx === null || tx === void 0 ? void 0 : tx.meta) === null || _b === void 0 ? void 0 : _b.fee) ? (_c = tx.meta) === null || _c === void 0 ? void 0 : _c.fee : 0;
+        const fee_per_ix = fee / transfer_requests.length;
+        success_requests = transfer_requests.map(r => {
+            return Object.assign(Object.assign({}, r), { signature: signature, blocknumber: block.lastValidBlockHeight, gas_used: gas_used, fee: fee_per_ix, executed_at });
+        });
+    }
+    catch (error) {
+        failed_requests.push(...transfer_requests);
+    }
+    return {
+        success: success_requests,
+        failed: failed_requests,
+        transfer_sig: signature,
+        blocknumber: block.lastValidBlockHeight,
+        gas_cost: gas_used,
+        fee: fee
+    };
+});
+exports.handle_create_versioned_transaction_spl = handle_create_versioned_transaction_spl;
+const setup_spl_token_transfer = (token, from, to, connection) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const fromTokenAccountAddress = yield (0, spl_token_1.getAssociatedTokenAddress)(token, from, false, spl_token_1.TOKEN_PROGRAM_ID);
+    const toTokenAccountAddress = yield (0, spl_token_1.getAssociatedTokenAddress)(token, to, false, spl_token_1.TOKEN_PROGRAM_ID);
+    const info = yield connection.getParsedAccountInfo(token);
+    if (!info)
+        throw new Error(`Failed to get spl token account decimals for:  ${token.toString()}`);
+    return {
+        senderATA: fromTokenAccountAddress,
+        receiverATA: toTokenAccountAddress,
+        mint: token,
+        decimals: ((_a = info.value) === null || _a === void 0 ? void 0 : _a.data).parsed.decimals,
+    };
+});
+const build_solana_transactions = (transfer_requests, conection) => {
+    let instructions = [];
+    const transfer_transaction = new web3_js_1.Transaction();
+};
+const build_spl_instructions = (payloads, connection) => __awaiter(void 0, void 0, void 0, function* () {
+    let instructions = [];
+    const transfer_transaction = new web3_js_1.Transaction();
+    let signers = new Map();
+    for (let t of payloads) {
+        const { mint, senderATA, receiverATA } = yield setup_spl_token_transfer(new web3_js_1.PublicKey(t.token), new web3_js_1.PublicKey(t.from_address), new web3_js_1.PublicKey(t.to_address), connection);
+        const transfer_ix = (0, spl_token_1.createTransferCheckedInstruction)(senderATA, new web3_js_1.PublicKey(t.token), receiverATA, new web3_js_1.PublicKey(t.from_address), t.amount_in_lamports, t.decimals, [], spl_token_1.TOKEN_PROGRAM_ID);
+        instructions.push(transfer_ix);
+        // Add the instruction to the transaction
+        transfer_transaction.add(transfer_ix);
+        signers.set(t.from_address, t);
+    }
+    return { signers, instructions, transfer_transaction };
+});
+const build_transactions_spl = (transfer_requests_1, connection_1, ...args_1) => __awaiter(void 0, [transfer_requests_1, connection_1, ...args_1], void 0, function* (transfer_requests, connection, is_funding = false, dbPool, config) {
+    const wallet_manager = WalletManager_1.default.getInstance(config, dbPool);
+    const { signers, instructions, transfer_transaction } = yield build_spl_instructions(transfer_requests, connection);
+    let signer_keypairs = [];
+    for (let [address, request] of signers.entries()) {
+        let keypair = null;
+        if (is_funding) {
+            keypair = WalletManager_1.default.getInstance(config, dbPool).getEscrowFundsManagerWallet(constants_1.BLOCKCHAINS.SOLANA);
+            signer_keypairs.push(keypair);
+        }
+        else {
+            const keys = wallet_manager.deriveWallet(request.source_parent_index, request.source_child_index, "solana");
+            signer_keypairs.push(keys.wallet);
+        }
+    }
+    return { transfer_transaction, signers: signer_keypairs };
+});
+const check_approve_delegate = (chain_id, from_address, parent_index, child_index, token, dbPool, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const wallet_manager = WalletManager_1.default.getInstance(config, dbPool);
+    const connection = (0, exports.getSolanaConnection)(chain_id, config);
+    // const token_address = "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU";
+    const from_wallet = wallet_manager.deriveWallet(parent_index, child_index, "solana");
+    const payer = wallet_manager.getEscrowFundsManagerWallet("solana");
+    const delegate = payer;
+    // Fetch token account
+    const { decimals, associated_token_account, balance } = yield get_or_create_token_account(connection, from_wallet.wallet, token);
+    // Only create new approval if current amount is 0
+    const current_spending = yield get_approved_spending(connection, associated_token_account.address.toString());
+    if (current_spending.amount > 0)
+        return true;
+    // Fund wallet with sol
+    const res = yield (0, exports.create_versioned_transaction_solana)([{
+            id: 0,
+            // source_parent_index: config.config.fundsManagerIndices[1],
+            source_parent_index: 2,
+            source_child_index: 0,
+            from_address: payer.publicKey.toString(),
+            to_address: from_address,
+            decimals: decimals,
+            token,
+            amount_in_lamports: BigInt(1000000)
+        }], connection, true, false, dbPool, config);
+    yield (0, Utility_1.sleep)(200);
+    // Approve 
+    const is_approved = yield approve_delegate(connection, associated_token_account.address.toString(), token, from_wallet.wallet, delegate.publicKey.toString(), decimals);
+    if (!is_approved)
+        throw new Error("Failed to set spending allowance.");
+    // Get updated account details
+    let account_data = yield get_approved_spending(connection, associated_token_account.address.toString());
+    return true;
+});
+exports.check_approve_delegate = check_approve_delegate;
+const approve_delegate = (connection, associated_token_account_address, token_address, owner, delegate_address, decimals) => __awaiter(void 0, void 0, void 0, function* () {
+    const latest_blockhash = yield connection.getLatestBlockhash();
+    const approve_amount = BigInt(1000000000000000000);
+    // Create instruction
+    const approve_ix = (0, spl_token_1.createApproveCheckedInstruction)(new web3_js_1.PublicKey(associated_token_account_address), new web3_js_1.PublicKey(token_address), new web3_js_1.PublicKey(delegate_address), owner.publicKey, approve_amount, decimals, [], spl_token_1.TOKEN_PROGRAM_ID);
+    // Create transaction
+    const approve_tx = new web3_js_1.Transaction({
+        feePayer: owner.publicKey,
+        blockhash: latest_blockhash.blockhash,
+        lastValidBlockHeight: latest_blockhash.lastValidBlockHeight
+    }).add(approve_ix);
+    try {
+        // Send transaction
+        const tx_signature = yield (0, web3_js_1.sendAndConfirmTransaction)(connection, approve_tx, [owner]);
+        // Get updated spending
+        // const { delegate, amount } = await get_approved_spending(connection, associated_token_account_address);
+        return true;
+    }
+    catch (error) {
+        const solana_error = error;
+        const details = yield solana_error.getLogs(connection);
+        console.log(`Full solana error log: `, details);
+        throw error;
+    }
+});
+const get_approved_spending = (connection, associated_token_account_address) => __awaiter(void 0, void 0, void 0, function* () {
+    let _account_data = yield (0, spl_token_1.getAccount)(connection, new web3_js_1.PublicKey(associated_token_account_address), "confirmed", spl_token_1.TOKEN_PROGRAM_ID);
+    const _delegate = _account_data.delegate;
+    const _delegate_amt = _account_data.delegatedAmount;
+    return {
+        delegate: _delegate === null || _delegate === void 0 ? void 0 : _delegate.toString(),
+        amount: _delegate_amt
+    };
+});
+const get_token_account = () => {
+};
+const get_or_create_token_account = (connection, owner, token_address) => __awaiter(void 0, void 0, void 0, function* () {
+    const associated_token_account = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(connection, owner, new web3_js_1.PublicKey(token_address), new web3_js_1.PublicKey(owner.publicKey), false, "confirmed", undefined, spl_token_1.TOKEN_PROGRAM_ID, spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+    const account_balance = (yield connection.getTokenAccountBalance(associated_token_account.address));
+    let _decimals = account_balance.value.decimals;
+    return { decimals: _decimals, associated_token_account, balance: account_balance.value.amount };
+});
+/**
+ *
+ * ed SOL tokens for 9 candidates. Signature:  {
+  success: [
+    {
+      status: true,
+      signature: '5TqE4jg9uAUYjSD9qesaUTTetY2gyr3jTu2DVQmgLnV5S39v1NZtVqd6rkqBX2gCFWbA28oosJdTMw3s4zPW86c6',
+      requests: [Array]
+    },
+    {
+      status: true,
+      signature: '5SKz2R5tJ6s4SjCYpf6guEjup7AJsdXfmFrcDVj6g3E3bWChhaS2JbTek9iUmaogjRZgbriHtyEuhseHJMYfR9NZ',
+      requests: [Array]
+    },
+    {
+      status: true,
+      signature: 'Rv9fe8aALLg2JZRZPQnAChsVrYatP15Ujq4xDbyeqvcR5p8NMCwmLu6i3Sy5ZSQsL3ZbhSBTYAoTEkuw1RkHvQh',
+      requests: [Array]
+    },
+    {
+      status: true,
+      signature: '4US2GHvquPAYejYcqDkHEXqNZs2B3geYDs8sJL2NsDqyTAUboGyWTPo1Yt9547qBakpuuP2Zi4DRABbPEtoq3EDs',
+      requests: [Array]
+    },
+    {
+      status: true,
+      signature: '4b8o27d7jbqrTFzFjx9oq8RcrupnCZVsxwELHBLVN4kTW52Xp8ReShK8UbFpBtkc7PjQ1xVqWQLd6GxBxftcr2mz',
+      requests: [Array]
+    },
+    {
+      status: true,
+      signature: '4XMc7FyGHcW4ski7PNEtPGXh18GFGVC8syUi9zeXjtRMtu2MKbnyMUhgJBu7nNvo41MYXfenuYVmLftnndxBjzzE',
+      requests: [Array]
+    },
+    {
+      status: true,
+      signature: '47yUxggE2mCAJz2j4B36uU7yxQxn8ymwAotnybVAcx3uQ5m2QD2V9JhPwJXZ73yuP2bd6otFvPoTLqzho68nzGtB',
+      requests: [Array]
+    }
+  ],
+  failed: [
+    { status: false, signature: null, requests: [Array] },
+    { status: false, signature: null, requests: [Array] }
+  ]
+}
+Processing 1 ERC20 transfers for token 0xd36A20dB12953F0bf09C66B08c1771ae046D2152
+Sleeping 200ms
+====================================
+ */