privacycash 1.0.6

package/src/getUtxos.ts

@@ -0,0 +1,466 @@
+import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+import { Keypair as UtxoKeypair } from './models/keypair.js';
+import { Utxo } from './models/utxo.js';
+import { EncryptionService } from './utils/encryption.js';
+import { WasmFactory } from '@lightprotocol/hasher.rs';
+//@ts-ignore
+import * as ffjavascript from 'ffjavascript';
+import { FETCH_UTXOS_GROUP_SIZE, INDEXER_API_URL, LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, PROGRAM_ID } from './utils/constants.js';
+import { logger } from './utils/logger.js';
+
+// Use type assertion for the utility functions (same pattern as in get_verification_keys.ts)
+const utils = ffjavascript.utils as any;
+const { unstringifyBigInts, leInt2Buff } = utils;
+
+/**
+ * Interface for the UTXO data returned from the API
+ */
+interface ApiUtxo {
+    commitment: string;
+    encrypted_output: string; // Hex-encoded encrypted UTXO data
+    index: number;
+    nullifier?: string; // Optional, might not be present for all UTXOs
+}
+
+/**
+ * Interface for the API response format that includes count and encrypted_outputs
+ */
+interface ApiResponse {
+    count: number;
+    encrypted_outputs: string[];
+}
+
+function sleep(ms: number): Promise<string> {
+    return new Promise(resolve => setTimeout(() => {
+        resolve('ok')
+    }, ms))
+}
+
+export function localstorageKey(key: PublicKey) {
+    return PROGRAM_ID.toString().substring(0, 6) + key.toString()
+}
+
+let getMyUtxosPromise: Promise<Utxo[]> | null = null
+let roundStartIndex = 0
+let decryptionTaskFinished = 0;
+/**
+ * Fetch and decrypt all UTXOs for a user
+ * @param signed The user's signature 
+ * @param connection Solana connection to fetch on-chain commitment accounts
+ * @param setStatus A global state updator. Set live status message showing on webpage
+ * @returns Array of decrypted UTXOs that belong to the user
+ */
+
+export async function getUtxos({ publicKey, connection, encryptionService, storage }: {
+    publicKey: PublicKey,
+    connection: Connection,
+    encryptionService: EncryptionService,
+    storage: Storage
+}): Promise<Utxo[]> {
+    if (!getMyUtxosPromise) {
+        getMyUtxosPromise = (async () => {
+            let valid_utxos: Utxo[] = []
+            let valid_strings: string[] = []
+            try {
+                let offsetStr = storage.getItem(LSK_FETCH_OFFSET + localstorageKey(publicKey))
+                if (offsetStr) {
+                    roundStartIndex = Number(offsetStr)
+                } else {
+                    roundStartIndex = 0
+                }
+                decryptionTaskFinished = 0
+                while (true) {
+                    let offsetStr = storage.getItem(LSK_FETCH_OFFSET + localstorageKey(publicKey))
+                    let fetch_utxo_offset = offsetStr ? Number(offsetStr) : 0
+                    let fetch_utxo_end = fetch_utxo_offset + FETCH_UTXOS_GROUP_SIZE
+                    let fetch_utxo_url = `${INDEXER_API_URL}/utxos/range?start=${fetch_utxo_offset}&end=${fetch_utxo_end}`
+                    let fetched = await fetchUserUtxos({ publicKey, connection, url: fetch_utxo_url, encryptionService, storage })
+                    let am = 0
+
+                    const nonZeroUtxos: Utxo[] = [];
+                    const nonZeroEncrypted: any[] = [];
+                    for (let [k, utxo] of fetched.utxos.entries()) {
+                        if (utxo.amount.toNumber() > 0) {
+                            nonZeroUtxos.push(utxo);
+                            nonZeroEncrypted.push(fetched.encryptedOutputs[k]);
+                        }
+                    }
+                    if (nonZeroUtxos.length > 0) {
+                        const spentFlags = await areUtxosSpent(connection, nonZeroUtxos);
+                        for (let i = 0; i < nonZeroUtxos.length; i++) {
+                            if (!spentFlags[i]) {
+                                am += nonZeroUtxos[i].amount.toNumber();
+                                valid_utxos.push(nonZeroUtxos[i]);
+                                valid_strings.push(nonZeroEncrypted[i]);
+                            }
+                        }
+                    }
+                    storage.setItem(LSK_FETCH_OFFSET + localstorageKey(publicKey), (fetch_utxo_offset + fetched.len).toString())
+                    if (!fetched.hasMore) {
+                        break
+                    }
+                    await sleep(100)
+                }
+            } catch (e: any) {
+                throw e
+            } finally {
+                getMyUtxosPromise = null
+            }
+            // store valid strings
+            valid_strings = [...new Set(valid_strings)];
+            storage.setItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(publicKey), JSON.stringify(valid_strings))
+            return valid_utxos
+        })()
+    }
+    return getMyUtxosPromise
+}
+
+async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionService }: {
+    publicKey: PublicKey,
+    connection: Connection,
+    url: string,
+    encryptionService: EncryptionService,
+    storage: Storage
+}): Promise<{
+    encryptedOutputs: string[],
+    utxos: Utxo[],
+    hasMore: boolean,
+    len: number
+}> {
+    const lightWasm = await WasmFactory.getInstance();
+
+    // Derive the UTXO keypair from the wallet keypair
+    const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
+    const utxoKeypair = new UtxoKeypair(utxoPrivateKey, lightWasm);
+
+
+    // Fetch all UTXOs from the API
+    let encryptedOutputs: string[] = [];
+    logger.debug('fetching utxo data', url)
+    let res = await fetch(url)
+    if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
+    const data: any = await res.json()
+    logger.debug('got utxo data')
+    if (!data) {
+        throw new Error('API returned empty data')
+    } else if (Array.isArray(data)) {
+        // Handle the case where the API returns an array of UTXOs
+        const utxos: ApiUtxo[] = data;
+        // Extract encrypted outputs from the array of UTXOs
+        encryptedOutputs = utxos
+            .filter(utxo => utxo.encrypted_output)
+            .map(utxo => utxo.encrypted_output);
+    } else if (typeof data === 'object' && data.encrypted_outputs) {
+        // Handle the case where the API returns an object with encrypted_outputs array
+        const apiResponse = data as ApiResponse;
+        encryptedOutputs = apiResponse.encrypted_outputs;
+    } else {
+        throw new Error(`API returned unexpected data format: ${JSON.stringify(data).substring(0, 100)}...`);
+    }
+
+    // Try to decrypt each encrypted output
+    const myUtxos: Utxo[] = [];
+    const myEncryptedOutputs: string[] = [];
+    let decryptionAttempts = 0;
+    let successfulDecryptions = 0;
+
+    let cachedStringNum = 0
+    let cachedString = storage.getItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(publicKey))
+    if (cachedString) {
+        cachedStringNum = JSON.parse(cachedString).length
+    }
+
+
+    let decryptionTaskTotal = data.total + cachedStringNum - roundStartIndex;
+    let batchRes = await decrypt_outputs(encryptedOutputs, encryptionService, utxoKeypair, lightWasm)
+    decryptionTaskFinished += encryptedOutputs.length
+    logger.debug('batchReslen', batchRes.length)
+    for (let i = 0; i < batchRes.length; i++) {
+        let dres = batchRes[i]
+        if (dres.status == 'decrypted' && dres.utxo) {
+            myUtxos.push(dres.utxo)
+            myEncryptedOutputs.push(dres.encryptedOutput!)
+        }
+    }
+    logger.info(`(decrypting cached utxo: ${decryptionTaskFinished + 1}/${decryptionTaskTotal}...)`)
+    // check cached string when no more fetching tasks
+    if (!data.hasMore) {
+        if (cachedString) {
+            let cachedEncryptedOutputs = JSON.parse(cachedString)
+            for (let encryptedOutput of cachedEncryptedOutputs) {
+                if (decryptionTaskFinished % 100 == 0) {
+                    logger.info(`(decrypting cached utxo: ${decryptionTaskFinished + 1}/${decryptionTaskTotal}...)`)
+                }
+                let batchRes = await decrypt_outputs(cachedEncryptedOutputs, encryptionService, utxoKeypair, lightWasm)
+                decryptionTaskFinished += cachedEncryptedOutputs.length
+                logger.debug('cachedbatchReslen', batchRes.length, ' source', cachedEncryptedOutputs.length)
+                for (let i = 0; i < batchRes.length; i++) {
+                    let dres = batchRes[i]
+                    if (dres.status == 'decrypted' && dres.utxo) {
+                        myUtxos.push(dres.utxo)
+                        myEncryptedOutputs.push(dres.encryptedOutput!)
+                    }
+                }
+            }
+        }
+    }
+
+    return { encryptedOutputs: myEncryptedOutputs, utxos: myUtxos, hasMore: data.hasMore, len: encryptedOutputs.length };
+}
+
+/**
+ * Check if a UTXO has been spent
+ * @param connection Solana connection
+ * @param utxo The UTXO to check
+ * @returns Promise<boolean> true if spent, false if unspent
+ */
+export async function isUtxoSpent(connection: Connection, utxo: Utxo): Promise<boolean> {
+    try {
+        // Get the nullifier for this UTXO
+        const nullifier = await utxo.getNullifier();
+        logger.debug(`Checking if UTXO with nullifier ${nullifier} is spent`);
+
+        // Convert decimal nullifier string to byte array (same format as in proofs)
+        // This matches how commitments are handled and how the Rust code expects the seeds
+        const nullifierBytes = Array.from(
+            leInt2Buff(unstringifyBigInts(nullifier), 32)
+        ).reverse() as number[];
+
+        // Try nullifier0 seed
+        const [nullifier0PDA] = PublicKey.findProgramAddressSync(
+            [Buffer.from("nullifier0"), Buffer.from(nullifierBytes)],
+            PROGRAM_ID
+        );
+
+        logger.debug(`Derived nullifier0 PDA: ${nullifier0PDA.toBase58()}`);
+        const nullifier0Account = await connection.getAccountInfo(nullifier0PDA);
+        if (nullifier0Account !== null) {
+            logger.debug(`UTXO is spent (nullifier0 account exists)`);
+            return true;
+        }
+
+
+        const [nullifier1PDA] = PublicKey.findProgramAddressSync(
+            [Buffer.from("nullifier1"), Buffer.from(nullifierBytes)],
+            PROGRAM_ID
+        );
+
+        logger.debug(`Derived nullifier1 PDA: ${nullifier1PDA.toBase58()}`);
+        const nullifier1Account = await connection.getAccountInfo(nullifier1PDA);
+        if (nullifier1Account !== null) {
+            logger.debug(`UTXO is spent (nullifier1 account exists)`);
+            return true
+        }
+        return false;
+    } catch (error: any) {
+        console.error('Error checking if UTXO is spent:', error);
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        return await isUtxoSpent(connection, utxo)
+    }
+}
+
+async function areUtxosSpent(
+    connection: Connection,
+    utxos: Utxo[]
+): Promise<boolean[]> {
+    try {
+        const allPDAs: { utxoIndex: number; pda: PublicKey }[] = [];
+
+        for (let i = 0; i < utxos.length; i++) {
+            const utxo = utxos[i];
+            const nullifier = await utxo.getNullifier();
+
+            const nullifierBytes = Array.from(
+                leInt2Buff(unstringifyBigInts(nullifier), 32)
+            ).reverse() as number[];
+
+            const [nullifier0PDA] = PublicKey.findProgramAddressSync(
+                [Buffer.from("nullifier0"), Buffer.from(nullifierBytes)],
+                PROGRAM_ID
+            );
+            const [nullifier1PDA] = PublicKey.findProgramAddressSync(
+                [Buffer.from("nullifier1"), Buffer.from(nullifierBytes)],
+                PROGRAM_ID
+            );
+
+            allPDAs.push({ utxoIndex: i, pda: nullifier0PDA });
+            allPDAs.push({ utxoIndex: i, pda: nullifier1PDA });
+        }
+
+        const results: any[] =
+            await connection.getMultipleAccountsInfo(allPDAs.map((x) => x.pda));
+
+        const spentFlags = new Array(utxos.length).fill(false);
+        for (let i = 0; i < allPDAs.length; i++) {
+            if (results[i] !== null) {
+                spentFlags[allPDAs[i].utxoIndex] = true;
+            }
+        }
+
+        return spentFlags;
+    } catch (error: any) {
+        console.error("Error checking if UTXOs are spent:", error);
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+        return await areUtxosSpent(connection, utxos);
+    }
+}
+
+// Calculate total balance
+export function getBalanceFromUtxos(utxos: Utxo[]) {
+    const totalBalance = utxos.reduce((sum, utxo) => sum.add(utxo.amount), new BN(0));
+    // const LAMPORTS_PER_SOL = new BN(1_000_000_000);
+    // const balanceInSol = totalBalance.div(LAMPORTS_PER_SOL);
+    // const remainderLamports = totalBalance.mod(LAMPORTS_PER_SOL);
+    return { lamports: totalBalance.toNumber() }
+}
+
+// Decrypt single output to Utxo
+type DecryptRes = { status: 'decrypted' | 'skipped' | 'unDecrypted', utxo?: Utxo, encryptedOutput?: string }
+async function decrypt_output(
+    encryptedOutput: string,
+    encryptionService: EncryptionService,
+    utxoKeypair: UtxoKeypair,
+    lightWasm: any,
+    connection: Connection
+): Promise<DecryptRes> {
+    let res: DecryptRes = { status: 'unDecrypted' }
+    try {
+        if (!encryptedOutput) {
+            return { status: 'skipped' }
+        }
+
+        // Try to decrypt the UTXO
+        res.utxo = await encryptionService.decryptUtxo(
+            encryptedOutput,
+            lightWasm
+        );
+
+        // If we got here, decryption succeeded, so this UTXO belongs to the user
+        res.status = 'decrypted'
+
+        // Get the real index from the on-chain commitment account
+        try {
+            if (!res.utxo) {
+                throw new Error('res.utxo undefined')
+            }
+            const commitment = await res.utxo.getCommitment();
+            // Convert decimal commitment string to byte array (same format as in proofs)
+            const commitmentBytes = Array.from(
+                leInt2Buff(unstringifyBigInts(commitment), 32)
+            ).reverse() as number[];
+
+            // Derive the commitment PDA (could be either commitment0 or commitment1)
+            // We'll try both seeds since we don't know which one it is
+            let commitmentAccount = null;
+            let realIndex = null;
+            // Try commitment0 seed
+            try {
+                const [commitment0PDA] = PublicKey.findProgramAddressSync(
+                    [Buffer.from("commitment0"), Buffer.from(commitmentBytes)],
+                    PROGRAM_ID
+                );
+
+                const account0Info = await connection.getAccountInfo(commitment0PDA);
+                if (account0Info) {
+                    // Parse the index from the account data according to CommitmentAccount structure:
+                    // 0-8: Anchor discriminator
+                    // 8-40: commitment (32 bytes)  
+                    // 40-44: encrypted_output length (4 bytes)
+                    // 44-44+len: encrypted_output data
+                    // 44+len-52+len: index (8 bytes)
+                    const encryptedOutputLength = account0Info.data.readUInt32LE(40);
+                    const indexOffset = 44 + encryptedOutputLength;
+                    const indexBytes = account0Info.data.slice(indexOffset, indexOffset + 8);
+                    realIndex = new BN(indexBytes, 'le').toNumber();
+                }
+            } catch (e) {
+                // Try commitment1 seed if commitment0 fails
+                try {
+                    const [commitment1PDA] = PublicKey.findProgramAddressSync(
+                        [Buffer.from("commitment1"), Buffer.from(commitmentBytes)],
+                        PROGRAM_ID
+                    );
+
+                    const account1Info = await connection.getAccountInfo(commitment1PDA);
+                    if (account1Info) {
+                        // Parse the index from the account data according to CommitmentAccount structure
+                        const encryptedOutputLength = account1Info.data.readUInt32LE(40);
+                        const indexOffset = 44 + encryptedOutputLength;
+                        const indexBytes = account1Info.data.slice(indexOffset, indexOffset + 8);
+                        realIndex = new BN(indexBytes, 'le').toNumber();
+                        logger.debug(`Found commitment1 account with index: ${realIndex}`);
+                    }
+                } catch (e2) {
+                    logger.debug(`Could not find commitment account for ${commitment}, using encrypted index: ${res.utxo.index}`);
+                }
+            }
+
+            // Update the UTXO with the real index if we found it
+            if (realIndex !== null) {
+                const oldIndex = res.utxo.index;
+                res.utxo.index = realIndex;
+            }
+
+        } catch (error: any) {
+            logger.debug(`Failed to get real index for UTXO: ${error.message}`);
+        }
+    } catch (error: any) {
+        // this UTXO doesn't belong to the user
+    }
+    return res
+}
+
+async function decrypt_outputs(
+    encryptedOutputs: string[],
+    encryptionService: EncryptionService,
+    utxoKeypair: UtxoKeypair,
+    lightWasm: any,
+): Promise<DecryptRes[]> {
+    let results: DecryptRes[] = [];
+
+    // decript all UTXO
+    for (const encryptedOutput of encryptedOutputs) {
+        if (!encryptedOutput) {
+            results.push({ status: 'skipped' });
+            continue;
+        }
+        try {
+            const utxo = await encryptionService.decryptUtxo(
+                encryptedOutput,
+                lightWasm
+            );
+            results.push({ status: 'decrypted', utxo, encryptedOutput });
+        } catch {
+            results.push({ status: 'unDecrypted' });
+        }
+    }
+    results = results.filter(r => r.status == 'decrypted')
+    if (!results.length) {
+        return []
+    }
+
+    // update utxo index
+    if (results.length > 0) {
+        let encrypted_outputs = results.map(r => r.encryptedOutput)
+
+        let url = INDEXER_API_URL + `/utxos/indices`
+        let res = await fetch(url, {
+            method: 'POST', headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ encrypted_outputs })
+        })
+        let j = await res.json()
+        if (!j.indices || !Array.isArray(j.indices) || j.indices.length != encrypted_outputs.length) {
+            throw new Error('failed fetching /utxos/indices')
+        }
+        for (let i = 0; i < results.length; i++) {
+            let utxo = results[i].utxo
+            if (utxo!.index !== j.indices[i] && typeof j.indices[i] == 'number') {
+                logger.debug(`Updated UTXO index from ${utxo!.index} to ${j.indices[i]}`);
+                utxo!.index = j.indices[i]
+            }
+        }
+    }
+
+    return results;
+}

package/src/index.ts

@@ -0,0 +1,191 @@
+import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, VersionedTransaction } from '@solana/web3.js';
+import { deposit } from './deposit.js';
+import { getBalanceFromUtxos, getUtxos, localstorageKey } from './getUtxos.js';
+
+import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET } from './utils/constants.js';
+import { logger, type LoggerFn, setLogger } from './utils/logger.js';
+import { EncryptionService } from './utils/encryption.js';
+import { WasmFactory } from '@lightprotocol/hasher.rs';
+import bs58 from 'bs58'
+import { withdraw } from './withdraw.js';
+import { LocalStorage } from "node-localstorage";
+import path from 'node:path'
+
+let storage = new LocalStorage(path.join(process.cwd(), "cache"));
+
+export class PrivacyCash {
+    private connection: Connection
+    public publicKey: PublicKey
+    private encryptionService: EncryptionService
+    private keypair: Keypair
+    private isRuning?: boolean = false
+    private status: string = ''
+    constructor({ RPC_url, owner, enableDebug }: {
+        RPC_url: string,
+        owner: string | number[] | Uint8Array | Keypair,
+        enableDebug?: boolean
+    }) {
+        let keypair = getSolanaKeypair(owner)
+        if (!keypair) {
+            throw new Error('param "owner" is not a valid Private Key or Keypair')
+        }
+        this.keypair = keypair
+        this.connection = new Connection(RPC_url, 'confirmed')
+        this.publicKey = keypair.publicKey
+        this.encryptionService = new EncryptionService();
+        this.encryptionService.deriveEncryptionKeyFromWallet(this.keypair);
+        if (!enableDebug) {
+            this.startStatusRender()
+            this.setLogger((level, message) => {
+                if (level == 'info') {
+                    this.status = message
+                } else if (level == 'error') {
+                    console.log('error message: ', message)
+                }
+            })
+        }
+    }
+
+    setLogger(loger: LoggerFn) {
+        setLogger(loger)
+        return this
+    }
+
+    /**
+     * Clears the cache of utxos.
+     * 
+     * By default, downloaded utxos will be cached in the local storage. Thus the next time when you makes another
+     * deposit or withdraw or getPrivateBalance, the SDK only fetches the utxos that are not in the cache.
+     * 
+     * This method clears the cache of utxos.
+     */
+    async clearCache() {
+        if (!this.publicKey) {
+            return this
+        }
+        storage.removeItem(LSK_FETCH_OFFSET + localstorageKey(this.publicKey))
+        storage.removeItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(this.publicKey))
+        return this
+    }
+
+    /**
+     * Deposit SOL to the Privacy Cash.
+     * 
+     * Lamports is the amount of SOL in lamports. e.g. if you want to deposit 0.01 SOL (10000000 lamports), call deposit({ lamports: 10000000 })
+     */
+    async deposit({ lamports }: {
+        lamports: number
+    }) {
+        this.isRuning = true
+        logger.info('start depositting')
+        let lightWasm = await WasmFactory.getInstance()
+        let res = await deposit({
+            lightWasm,
+            amount_in_lamports: lamports,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            transactionSigner: async (tx: VersionedTransaction) => {
+                tx.sign([this.keypair])
+                return tx
+            },
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage
+        })
+        this.isRuning = false
+        return res
+    }
+
+    /**
+     * Withdraw SOL from the Privacy Cash.
+     * 
+     * Lamports is the amount of SOL in lamports. e.g. if you want to withdraw 0.01 SOL (10000000 lamports), call withdraw({ lamports: 10000000 })
+     */
+    async withdraw({ lamports, recipientAddress }: {
+        lamports: number,
+        recipientAddress?: string
+    }) {
+        this.isRuning = true
+        logger.info('start withdrawing')
+        let lightWasm = await WasmFactory.getInstance()
+        let recipient = recipientAddress ? new PublicKey(recipientAddress) : this.publicKey
+        let res = await withdraw({
+            lightWasm,
+            amount_in_lamports: lamports,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            recipient,
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage
+        })
+        console.log(`Withdraw successful. Recipient ${recipient} received ${res.amount_in_lamports / LAMPORTS_PER_SOL} SOL, with ${res.fee_in_lamports / LAMPORTS_PER_SOL} SOL relayers fees`)
+        this.isRuning = false
+        return res
+    }
+
+    /**
+     * Returns the amount of lamports current wallet has in Privacy Cash.
+     */
+    async getPrivateBalance() {
+        logger.info('getting private balance')
+        this.isRuning = true
+        let utxos = await getUtxos({ publicKey: this.publicKey, connection: this.connection, encryptionService: this.encryptionService, storage })
+        this.isRuning = false
+        return getBalanceFromUtxos(utxos)
+    }
+
+    /**
+     * Returns true if the code is running in a browser.
+     */
+    isBrowser() {
+        return typeof window !== "undefined"
+    }
+
+    async startStatusRender() {
+        let frames = ['-', '\\', '|', '/'];
+        let i = 0
+        while (true) {
+            if (this.isRuning) {
+                let k = i % frames.length
+                i++
+                stdWrite(this.status, frames[k])
+            }
+            await new Promise(r => setTimeout(r, 250));
+        }
+    }
+}
+
+function getSolanaKeypair(
+    secret: string | number[] | Uint8Array | Keypair
+): Keypair | null {
+    try {
+        if (secret instanceof Keypair) {
+            return secret;
+        }
+
+        let keyArray: Uint8Array;
+
+        if (typeof secret === "string") {
+            keyArray = bs58.decode(secret);
+        } else if (secret instanceof Uint8Array) {
+            keyArray = secret;
+        } else {
+            // number[]
+            keyArray = Uint8Array.from(secret);
+        }
+
+        if (keyArray.length !== 32 && keyArray.length !== 64) {
+            return null;
+        }
+        return Keypair.fromSecretKey(keyArray);
+    } catch {
+        return null;
+    }
+}
+
+function stdWrite(status: string, frame: string) {
+    let blue = "\x1b[34m";
+    let reset = "\x1b[0m";
+    process.stdout.write(`${frame}status: ${blue}${status}${reset}\r`);
+}