@velumdotcash/sdk 2.0.0

package/dist/utils/utils.js

@@ -0,0 +1,165 @@
+/**
+ * Utility functions for ZK Cash
+ *
+ * Provides common utility functions for the ZK Cash system
+ * Based on: https://github.com/tornadocash/tornado-nova
+ */
+import BN from 'bn.js';
+import * as borsh from 'borsh';
+import { sha256 } from '@ethersproject/sha2';
+import { PublicKey } from '@solana/web3.js';
+import { RELAYER_API_URL, PROGRAM_ID } from './constants.js';
+import { logger } from './logger.js';
+import { getConfig } from '../config.js';
+/**
+ * Calculate deposit fee based on deposit amount and fee rate
+ * @param depositAmount Amount being deposited in lamports
+ * @returns Fee amount in lamports
+ */
+export async function calculateDepositFee(depositAmount) {
+    return Math.floor(depositAmount * (await getConfig('deposit_fee_rate')) / 10000);
+}
+/**
+ * Calculate withdrawal fee based on withdrawal amount and fee rate
+ * @param withdrawalAmount Amount being withdrawn in lamports
+ * @returns Fee amount in lamports
+ */
+export async function calculateWithdrawalFee(withdrawalAmount) {
+    return Math.floor(withdrawalAmount * (await getConfig('withdraw_fee_rate')) / 10000);
+}
+/**
+ * Mock encryption function - in real implementation this would be proper encryption
+ * For testing, we just return a fixed prefix to ensure consistent extDataHash
+ * @param value Value to encrypt
+ * @returns Encrypted string representation
+ */
+export function mockEncrypt(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Calculates the hash of ext data using Borsh serialization
+ * @param extData External data object containing recipient, amount, encrypted outputs, fee, fee recipient, and mint address
+ * @returns The hash as a Uint8Array (32 bytes)
+ */
+export function getExtDataHash(extData) {
+    // Convert all inputs to their appropriate types
+    const recipient = extData.recipient instanceof PublicKey
+        ? extData.recipient
+        : new PublicKey(extData.recipient);
+    const feeRecipient = extData.feeRecipient instanceof PublicKey
+        ? extData.feeRecipient
+        : new PublicKey(extData.feeRecipient);
+    const mintAddress = extData.mintAddress instanceof PublicKey
+        ? extData.mintAddress
+        : new PublicKey(extData.mintAddress);
+    // Convert to BN for proper i64/u64 handling
+    const extAmount = new BN(extData.extAmount.toString());
+    const fee = new BN(extData.fee.toString());
+    // Handle encrypted outputs - they might not be present in Account Data Separation approach
+    const encryptedOutput1 = extData.encryptedOutput1
+        ? Buffer.from(extData.encryptedOutput1)
+        : Buffer.alloc(0); // Empty buffer if not provided
+    const encryptedOutput2 = extData.encryptedOutput2
+        ? Buffer.from(extData.encryptedOutput2)
+        : Buffer.alloc(0); // Empty buffer if not provided
+    // Define the borsh schema matching the Rust struct
+    const schema = {
+        struct: {
+            recipient: { array: { type: 'u8', len: 32 } },
+            extAmount: 'i64',
+            encryptedOutput1: { array: { type: 'u8' } },
+            encryptedOutput2: { array: { type: 'u8' } },
+            fee: 'u64',
+            feeRecipient: { array: { type: 'u8', len: 32 } },
+            mintAddress: { array: { type: 'u8', len: 32 } },
+        }
+    };
+    const value = {
+        recipient: recipient.toBytes(),
+        extAmount: extAmount, // BN instance - Borsh handles it correctly with i64 type
+        encryptedOutput1: encryptedOutput1,
+        encryptedOutput2: encryptedOutput2,
+        fee: fee, // BN instance - Borsh handles it correctly with u64 type
+        feeRecipient: feeRecipient.toBytes(),
+        mintAddress: mintAddress.toBytes(),
+    };
+    // Serialize with Borsh
+    const serializedData = borsh.serialize(schema, value);
+    // Calculate the SHA-256 hash
+    const hashHex = sha256(serializedData);
+    // Convert from hex string to Uint8Array
+    return Buffer.from(hashHex.slice(2), 'hex');
+}
+// Function to fetch Merkle proof from API for a given commitment
+export async function fetchMerkleProof(commitment, tokenName) {
+    try {
+        logger.debug(`Fetching Merkle proof for commitment: ${commitment}`);
+        let url = `${RELAYER_API_URL}/merkle/proof/${commitment}`;
+        if (tokenName) {
+            url += '?token=' + tokenName;
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch Merkle proof: ${url}`);
+        }
+        const data = await response.json();
+        logger.debug(`✓ Fetched Merkle proof with ${data.pathElements.length} elements`);
+        return data;
+    }
+    catch (error) {
+        console.error(`Failed to fetch Merkle proof for commitment ${commitment}:`, error);
+        throw error;
+    }
+}
+// Find nullifier PDAs for the given proof
+export function findNullifierPDAs(proof) {
+    const [nullifier0PDA] = PublicKey.findProgramAddressSync([Buffer.from("nullifier0"), Buffer.from(proof.inputNullifiers[0])], PROGRAM_ID);
+    const [nullifier1PDA] = PublicKey.findProgramAddressSync([Buffer.from("nullifier1"), Buffer.from(proof.inputNullifiers[1])], PROGRAM_ID);
+    return { nullifier0PDA, nullifier1PDA };
+}
+// Function to query remote tree state from indexer API
+export async function queryRemoteTreeState(tokenName) {
+    try {
+        logger.debug('Fetching Merkle root and nextIndex from API...');
+        let url = `${RELAYER_API_URL}/merkle/root`;
+        if (tokenName) {
+            url += '?token=' + tokenName;
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch Merkle root and nextIndex: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.debug(`Fetched root from API: ${data.root}`);
+        logger.debug(`Fetched nextIndex from API: ${data.nextIndex}`);
+        return data;
+    }
+    catch (error) {
+        console.error('Failed to fetch root and nextIndex from API:', error);
+        throw error;
+    }
+}
+export function getProgramAccounts() {
+    // Derive PDA (Program Derived Addresses) for the tree account and other required accounts
+    const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree')], PROGRAM_ID);
+    const [treeTokenAccount] = PublicKey.findProgramAddressSync([Buffer.from('tree_token')], PROGRAM_ID);
+    const [globalConfigAccount] = PublicKey.findProgramAddressSync([Buffer.from('global_config')], PROGRAM_ID);
+    return { treeAccount, treeTokenAccount, globalConfigAccount };
+}
+export function findCrossCheckNullifierPDAs(proof) {
+    const [nullifier2PDA] = PublicKey.findProgramAddressSync([Buffer.from("nullifier0"), Buffer.from(proof.inputNullifiers[1])], PROGRAM_ID);
+    const [nullifier3PDA] = PublicKey.findProgramAddressSync([Buffer.from("nullifier1"), Buffer.from(proof.inputNullifiers[0])], PROGRAM_ID);
+    return { nullifier2PDA, nullifier3PDA };
+}
+export function getMintAddressField(mint) {
+    const mintStr = mint.toString();
+    // Special case for SOL (system program)
+    if (mintStr === '11111111111111111111111111111112') {
+        return mintStr;
+    }
+    // For SPL tokens (USDC, USDT, etc): use first 31 bytes (248 bits)
+    // This provides better collision resistance than 8 bytes while still fitting in the field
+    // We will only suppport private SOL, USDC and USDT send, so there won't be any collision.
+    const mintBytes = mint.toBytes();
+    return new BN(mintBytes.slice(0, 31), 'be').toString();
+}

package/dist/withdraw.d.ts

@@ -0,0 +1,22 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import * as hasher from "@lightprotocol/hasher.rs";
+import { EncryptionService } from "./utils/encryption.js";
+type WithdrawParams = {
+    publicKey: PublicKey;
+    connection: Connection;
+    amount_in_lamports: number;
+    keyBasePath: string;
+    encryptionService: EncryptionService;
+    lightWasm: hasher.LightWasm;
+    recipient: PublicKey;
+    storage: Storage;
+    referrer?: string;
+};
+export declare function withdraw({ recipient, lightWasm, storage, publicKey, connection, amount_in_lamports, encryptionService, keyBasePath, referrer, }: WithdrawParams): Promise<{
+    isPartial: boolean;
+    tx: string;
+    recipient: string;
+    amount_in_lamports: number;
+    fee_in_lamports: number;
+}>;
+export {};

package/dist/withdraw.js

@@ -0,0 +1,290 @@
+import { LAMPORTS_PER_SOL, } from "@solana/web3.js";
+import BN from "bn.js";
+import { Buffer } from "buffer";
+import { Keypair as UtxoKeypair } from "./models/keypair.js";
+import { Utxo } from "./models/utxo.js";
+import { parseProofToBytesArray, parseToBytesArray, prove, } from "./utils/prover.js";
+import { InsufficientBalanceError, NetworkError, TransactionTimeoutError, } from "./errors.js";
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH, } from "./utils/constants.js";
+import { serializeProofAndExtData, } from "./utils/encryption.js";
+import { fetchMerkleProof, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, } from "./utils/utils.js";
+import { getUtxos } from "./getUtxos.js";
+import { logger } from "./utils/logger.js";
+import { getConfig } from "./config.js";
+// Indexer API endpoint
+// Function to submit withdraw request to indexer backend
+async function submitWithdrawToIndexer(params) {
+    try {
+        const response = await fetch(`${RELAYER_API_URL}/withdraw`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(params),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json());
+            throw new NetworkError(errorData.error || "Relayer request failed");
+        }
+        const result = (await response.json());
+        logger.debug("Withdraw request submitted successfully!");
+        logger.debug("Response:", result);
+        return result.signature;
+    }
+    catch (error) {
+        logger.debug("Failed to submit withdraw request to indexer:", typeof error, error);
+        throw error;
+    }
+}
+export async function withdraw({ recipient, lightWasm, storage, publicKey, connection, amount_in_lamports, encryptionService, keyBasePath, referrer, }) {
+    let fee_in_lamports = Math.floor(amount_in_lamports * (await getConfig("withdraw_fee_rate")) +
+        LAMPORTS_PER_SOL * (await getConfig("withdraw_rent_fee")));
+    amount_in_lamports = Math.floor(amount_in_lamports - fee_in_lamports);
+    let isPartial = false;
+    logger.debug("Encryption key generated from user keypair");
+    const { treeAccount, treeTokenAccount, globalConfigAccount } = getProgramAccounts();
+    // Get current tree state
+    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState();
+    logger.debug(`Using tree root: ${root}`);
+    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
+    // Generate a deterministic private key derived from the wallet keypair
+    const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
+    // Create a UTXO keypair that will be used for all inputs and outputs
+    const utxoKeypair = new UtxoKeypair(utxoPrivateKey, lightWasm);
+    logger.debug("Using wallet-derived UTXO keypair for withdrawal");
+    // Generate a deterministic private key derived from the wallet keypair (V2)
+    const utxoPrivateKeyV2 = encryptionService.getUtxoPrivateKeyV2();
+    const utxoKeypairV2 = new UtxoKeypair(utxoPrivateKeyV2, lightWasm);
+    // Fetch existing UTXOs for this user
+    logger.debug("\nFetching existing UTXOs...");
+    const unspentUtxos = await getUtxos({
+        connection,
+        publicKey,
+        encryptionService,
+        storage,
+    });
+    logger.debug(`Found ${unspentUtxos.length} total UTXOs`);
+    // Calculate and log total unspent UTXO balance
+    const totalUnspentBalance = unspentUtxos.reduce((sum, utxo) => sum.add(utxo.amount), new BN(0));
+    logger.debug(`Total unspent UTXO balance before: ${totalUnspentBalance.toString()} lamports (${totalUnspentBalance.toNumber() / 1e9} SOL)`);
+    if (unspentUtxos.length < 1) {
+        throw new Error("Need at least 1 unspent UTXO to perform a withdrawal");
+    }
+    // Sort UTXOs by amount in descending order to use the largest ones first
+    unspentUtxos.sort((a, b) => b.amount.cmp(a.amount));
+    // Use the largest UTXO as first input, and either second largest UTXO or dummy UTXO as second input
+    const firstInput = unspentUtxos[0];
+    const secondInput = unspentUtxos.length > 1
+        ? unspentUtxos[1]
+        : new Utxo({
+            lightWasm,
+            keypair: utxoKeypair,
+            amount: "0",
+        });
+    const inputs = [firstInput, secondInput];
+    logger.debug(`firstInput index: ${firstInput.index}, commitment: ${firstInput.getCommitment()}`);
+    logger.debug(`secondInput index: ${secondInput.index}, commitment: ${secondInput.getCommitment()}`);
+    const totalInputAmount = firstInput.amount.add(secondInput.amount);
+    logger.debug(`Using UTXO with amount: ${firstInput.amount.toString()} and ${secondInput.amount.gt(new BN(0)) ? "second UTXO with amount: " + secondInput.amount.toString() : "dummy UTXO"}`);
+    if (totalInputAmount.toNumber() === 0) {
+        throw new InsufficientBalanceError(1, 0, "SOL");
+    }
+    if (totalInputAmount.lt(new BN(amount_in_lamports + fee_in_lamports))) {
+        isPartial = true;
+        amount_in_lamports = totalInputAmount.toNumber();
+        amount_in_lamports -= fee_in_lamports;
+    }
+    // Calculate the change amount (what's left after withdrawal and fee)
+    const changeAmount = totalInputAmount
+        .sub(new BN(amount_in_lamports))
+        .sub(new BN(fee_in_lamports));
+    logger.debug(`Withdrawing ${amount_in_lamports} lamports with ${fee_in_lamports} fee, ${changeAmount.toString()} as change`);
+    // Get Merkle proofs for both input UTXOs
+    const inputMerkleProofs = await Promise.all(inputs.map(async (utxo, index) => {
+        // For dummy UTXO (amount is 0), use a zero-filled proof
+        if (utxo.amount.eq(new BN(0))) {
+            return {
+                pathElements: [...new Array(MERKLE_TREE_DEPTH).fill("0")],
+                pathIndices: Array(MERKLE_TREE_DEPTH).fill(0),
+            };
+        }
+        // For real UTXOs, fetch the proof from API
+        const commitment = await utxo.getCommitment();
+        return fetchMerkleProof(commitment);
+    }));
+    // Extract path elements and indices
+    const inputMerklePathElements = inputMerkleProofs.map((proof) => proof.pathElements);
+    const inputMerklePathIndices = inputs.map((utxo) => utxo.index || 0);
+    // Create outputs: first output is change, second is dummy (required by protocol)
+    const outputs = [
+        new Utxo({
+            lightWasm,
+            amount: changeAmount.toString(),
+            keypair: utxoKeypairV2,
+            index: currentNextIndex,
+        }), // Change output
+        new Utxo({
+            lightWasm,
+            amount: "0",
+            keypair: utxoKeypairV2,
+            index: currentNextIndex + 1,
+        }), // Empty UTXO
+    ];
+    // For withdrawals, extAmount is negative (funds leaving the system)
+    const extAmount = -amount_in_lamports;
+    const publicAmountForCircuit = new BN(extAmount)
+        .sub(new BN(fee_in_lamports))
+        .add(FIELD_SIZE)
+        .mod(FIELD_SIZE);
+    logger.debug(`Public amount calculation: (${extAmount} - ${fee_in_lamports} + FIELD_SIZE) % FIELD_SIZE = ${publicAmountForCircuit.toString()}`);
+    // Verify this matches the circuit balance equation: sumIns + publicAmount = sumOuts
+    const sumIns = inputs.reduce((sum, input) => sum.add(input.amount), new BN(0));
+    const sumOuts = outputs.reduce((sum, output) => sum.add(output.amount), new BN(0));
+    logger.debug(`Circuit balance check: sumIns(${sumIns.toString()}) + publicAmount(${publicAmountForCircuit.toString()}) should equal sumOuts(${sumOuts.toString()})`);
+    // Convert to circuit-compatible format
+    const publicAmountCircuitResult = sumIns
+        .add(publicAmountForCircuit)
+        .mod(FIELD_SIZE);
+    logger.debug(`Balance verification: ${sumIns.toString()} + ${publicAmountForCircuit.toString()} (mod FIELD_SIZE) = ${publicAmountCircuitResult.toString()}`);
+    logger.debug(`Expected sum of outputs: ${sumOuts.toString()}`);
+    logger.debug(`Balance equation satisfied: ${publicAmountCircuitResult.eq(sumOuts)}`);
+    // Generate nullifiers and commitments
+    const inputNullifiers = await Promise.all(inputs.map((x) => x.getNullifier()));
+    const outputCommitments = await Promise.all(outputs.map((x) => x.getCommitment()));
+    // Save original commitment and nullifier values for verification
+    logger.debug("\n=== UTXO VALIDATION ===");
+    logger.debug("Output 0 Commitment:", outputCommitments[0]);
+    logger.debug("Output 1 Commitment:", outputCommitments[1]);
+    // Encrypt the UTXO data using a compact format that includes the keypair
+    logger.debug("\nEncrypting UTXOs with keypair data...");
+    const encryptedOutput1 = encryptionService.encryptUtxo(outputs[0]);
+    const encryptedOutput2 = encryptionService.encryptUtxo(outputs[1]);
+    logger.debug(`\nOutput[0] (change):`);
+    await outputs[0].log();
+    logger.debug(`\nOutput[1] (empty):`);
+    await outputs[1].log();
+    logger.debug(`Encrypted output 1: ${encryptedOutput1.toString("hex")}`);
+    logger.debug(`Encrypted output 2: ${encryptedOutput2.toString("hex")}`);
+    logger.debug(`\nEncrypted output 1 size: ${encryptedOutput1.length} bytes`);
+    logger.debug(`Encrypted output 2 size: ${encryptedOutput2.length} bytes`);
+    logger.debug(`Total encrypted outputs size: ${encryptedOutput1.length + encryptedOutput2.length} bytes`);
+    // Test decryption to verify commitment values match
+    logger.debug("\n=== TESTING DECRYPTION ===");
+    logger.debug("Decrypting output 1 to verify commitment matches...");
+    const decryptedUtxo1 = await encryptionService.decryptUtxo(encryptedOutput1, lightWasm);
+    if (decryptedUtxo1) {
+        const decryptedCommitment1 = await decryptedUtxo1.getCommitment();
+        logger.debug("Original commitment:", outputCommitments[0]);
+        logger.debug("Decrypted commitment:", decryptedCommitment1);
+        logger.debug("Commitment matches:", outputCommitments[0] === decryptedCommitment1);
+    }
+    // Create the withdrawal ExtData with real encrypted outputs
+    const extData = {
+        // it can be any address
+        recipient,
+        extAmount: new BN(extAmount),
+        encryptedOutput1: encryptedOutput1,
+        encryptedOutput2: encryptedOutput2,
+        fee: new BN(fee_in_lamports),
+        feeRecipient: FEE_RECIPIENT,
+        mintAddress: inputs[0].mintAddress,
+    };
+    // Calculate the extDataHash with the encrypted outputs
+    const calculatedExtDataHash = getExtDataHash(extData);
+    // Create the input for the proof generation
+    const input = {
+        // Common transaction data
+        root: root,
+        inputNullifier: inputNullifiers,
+        outputCommitment: outputCommitments,
+        publicAmount: publicAmountForCircuit.toString(),
+        extDataHash: calculatedExtDataHash,
+        // Input UTXO data (UTXOs being spent)
+        inAmount: inputs.map((x) => x.amount.toString(10)),
+        inPrivateKey: inputs.map((x) => x.keypair.privkey),
+        inBlinding: inputs.map((x) => x.blinding.toString(10)),
+        inPathIndices: inputMerklePathIndices,
+        inPathElements: inputMerklePathElements,
+        // Output UTXO data (UTXOs being created)
+        outAmount: outputs.map((x) => x.amount.toString(10)),
+        outBlinding: outputs.map((x) => x.blinding.toString(10)),
+        outPubkey: outputs.map((x) => x.pubkey),
+        // new mint address
+        mintAddress: inputs[0].mintAddress,
+    };
+    logger.info("generating ZK proof...");
+    // Generate the zero-knowledge proof
+    const { proof, publicSignals } = await prove(input, keyBasePath);
+    // Parse the proof and public signals into byte arrays
+    const proofInBytes = parseProofToBytesArray(proof);
+    const inputsInBytes = parseToBytesArray(publicSignals);
+    // Create the proof object to submit to the program
+    const proofToSubmit = {
+        proofA: proofInBytes.proofA,
+        proofB: proofInBytes.proofB.flat(),
+        proofC: proofInBytes.proofC,
+        root: inputsInBytes[0],
+        publicAmount: inputsInBytes[1],
+        extDataHash: inputsInBytes[2],
+        inputNullifiers: [inputsInBytes[3], inputsInBytes[4]],
+        outputCommitments: [inputsInBytes[5], inputsInBytes[6]],
+    };
+    // Find PDAs for nullifiers and commitments
+    const { nullifier0PDA, nullifier1PDA } = findNullifierPDAs(proofToSubmit);
+    const { nullifier2PDA, nullifier3PDA } = findCrossCheckNullifierPDAs(proofToSubmit);
+    // Serialize the proof and extData
+    const serializedProof = serializeProofAndExtData(proofToSubmit, extData);
+    logger.debug(`Total instruction data size: ${serializedProof.length} bytes`);
+    // Prepare withdraw parameters for indexer backend
+    const withdrawParams = {
+        serializedProof: serializedProof.toString("base64"),
+        treeAccount: treeAccount.toString(),
+        nullifier0PDA: nullifier0PDA.toString(),
+        nullifier1PDA: nullifier1PDA.toString(),
+        nullifier2PDA: nullifier2PDA.toString(),
+        nullifier3PDA: nullifier3PDA.toString(),
+        treeTokenAccount: treeTokenAccount.toString(),
+        globalConfigAccount: globalConfigAccount.toString(),
+        recipient: recipient.toString(),
+        feeRecipientAccount: FEE_RECIPIENT.toString(),
+        extAmount: extAmount,
+        encryptedOutput1: encryptedOutput1.toString("base64"),
+        encryptedOutput2: encryptedOutput2.toString("base64"),
+        fee: fee_in_lamports,
+        lookupTableAddress: ALT_ADDRESS.toString(),
+        senderAddress: publicKey.toString(),
+        referralWalletAddress: referrer,
+    };
+    logger.debug("Prepared withdraw parameters for indexer backend");
+    // Submit to indexer backend instead of directly to Solana
+    logger.info("submitting transaction to relayer...");
+    const signature = await submitWithdrawToIndexer(withdrawParams);
+    // Wait a moment for the transaction to be confirmed
+    logger.info("waiting for transaction confirmation...");
+    let retryTimes = 0;
+    let itv = 2;
+    const encryptedOutputStr = Buffer.from(encryptedOutput1).toString("hex");
+    let start = Date.now();
+    while (true) {
+        logger.info("Confirming transaction..");
+        logger.debug(`retryTimes: ${retryTimes}`);
+        await new Promise((resolve) => setTimeout(resolve, itv * 1000));
+        logger.info("Fetching updated tree state...");
+        let res = await fetch(RELAYER_API_URL + "/utxos/check/" + encryptedOutputStr);
+        let resJson = await res.json();
+        logger.debug("resJson:", resJson);
+        if (resJson.exists) {
+            return {
+                isPartial,
+                tx: signature,
+                recipient: recipient.toString(),
+                amount_in_lamports,
+                fee_in_lamports,
+            };
+        }
+        if (retryTimes >= 10) {
+            throw new TransactionTimeoutError(`Transaction confirmation timeout after ${retryTimes * 3} seconds`, signature);
+        }
+        retryTimes++;
+    }
+}

package/dist/withdrawSPL.d.ts

@@ -0,0 +1,24 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import * as hasher from "@lightprotocol/hasher.rs";
+import { EncryptionService } from "./utils/encryption.js";
+type WithdrawParams = {
+    publicKey: PublicKey;
+    connection: Connection;
+    base_units?: number;
+    amount?: number;
+    keyBasePath: string;
+    encryptionService: EncryptionService;
+    lightWasm: hasher.LightWasm;
+    recipient: PublicKey;
+    mintAddress: PublicKey | string;
+    storage: Storage;
+    referrer?: string;
+};
+export declare function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, amount, encryptionService, keyBasePath, mintAddress, referrer, }: WithdrawParams): Promise<{
+    isPartial: boolean;
+    tx: string;
+    recipient: string;
+    base_units: number;
+    fee_base_units: number;
+}>;
+export {};