pctestupgrade2 1.1.8

package/dist/index.js

@@ -0,0 +1,305 @@
+import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
+import { deposit } from './deposit.js';
+import { getBalanceFromUtxos, getUtxos, localstorageKey } from './getUtxos.js';
+import { getBalanceFromUtxosSPL, getUtxosSPL } from './getUtxosSPL.js';
+import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, tokens, USDC_MINT } from './utils/constants.js';
+import { logger, 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';
+import { depositSPL } from './depositSPL.js';
+import { withdrawSPL } from './withdrawSPL.js';
+import { getAssociatedTokenAddress } from '@solana/spl-token';
+let storage = new LocalStorage(path.join(process.cwd(), "cache"));
+export class PrivacyCash {
+    connection;
+    publicKey;
+    encryptionService;
+    keypair;
+    isRuning = false;
+    status = '';
+    constructor({ RPC_url, owner, enableDebug }) {
+        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) {
+        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));
+        // spl
+        for (let token of tokens) {
+            let ata = await getAssociatedTokenAddress(token.pubkey, this.publicKey);
+            storage.removeItem(LSK_FETCH_OFFSET + localstorageKey(ata));
+            storage.removeItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(ata));
+        }
+        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 }) {
+        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) => {
+                tx.sign([this.keypair]);
+                return tx;
+            },
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage
+        });
+        this.isRuning = false;
+        return res;
+    }
+    /**
+    * Deposit USDC to the Privacy Cash.
+    */
+    async depositUSDC({ base_units }) {
+        this.isRuning = true;
+        logger.info('start depositting');
+        let lightWasm = await WasmFactory.getInstance();
+        let res = await depositSPL({
+            mintAddress: USDC_MINT,
+            lightWasm,
+            base_units: base_units,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            transactionSigner: async (tx) => {
+                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, referrer }) {
+        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,
+            referrer
+        });
+        logger.debug(`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;
+    }
+    /**
+      * Withdraw USDC from the Privacy Cash.
+      *
+      * base_units is the amount of USDC in base unit. e.g. if you want to withdraw 1 USDC (1,000,000 base unit), call withdraw({ base_units: 1000000, recipientAddress: 'some_address' })
+      */
+    async withdrawUSDC({ base_units, recipientAddress, referrer }) {
+        this.isRuning = true;
+        logger.info('start withdrawing');
+        let lightWasm = await WasmFactory.getInstance();
+        let recipient = recipientAddress ? new PublicKey(recipientAddress) : this.publicKey;
+        let res = await withdrawSPL({
+            mintAddress: USDC_MINT,
+            lightWasm,
+            base_units,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            recipient,
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage,
+            referrer
+        });
+        logger.debug(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`);
+        this.isRuning = false;
+        return res;
+    }
+    /**
+     * Returns the amount of lamports current wallet has in Privacy Cash.
+     */
+    async getPrivateBalance(abortSignal) {
+        logger.info('getting private balance');
+        this.isRuning = true;
+        let utxos = await getUtxos({ publicKey: this.publicKey, connection: this.connection, encryptionService: this.encryptionService, storage, abortSignal });
+        this.isRuning = false;
+        return getBalanceFromUtxos(utxos);
+    }
+    /**
+    * Returns the amount of base unites current wallet has in Privacy Cash.
+    */
+    async getPrivateBalanceUSDC() {
+        logger.info('getting private balance');
+        this.isRuning = true;
+        let utxos = await getUtxosSPL({ publicKey: this.publicKey, connection: this.connection, encryptionService: this.encryptionService, storage, mintAddress: USDC_MINT });
+        this.isRuning = false;
+        return getBalanceFromUtxosSPL(utxos);
+    }
+    /**
+    * Returns the amount of base unites current wallet has in Privacy Cash.
+    */
+    async getPrivateBalanceSpl(mintAddress) {
+        this.isRuning = true;
+        let utxos = await getUtxosSPL({
+            publicKey: this.publicKey,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            storage,
+            mintAddress
+        });
+        this.isRuning = false;
+        return getBalanceFromUtxosSPL(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));
+        }
+    }
+    /**
+   * Deposit SPL to the Privacy Cash.
+   */
+    async depositSPL({ base_units, mintAddress, amount }) {
+        this.isRuning = true;
+        logger.info('start depositting');
+        let lightWasm = await WasmFactory.getInstance();
+        let res = await depositSPL({
+            lightWasm,
+            base_units,
+            amount,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            transactionSigner: async (tx) => {
+                tx.sign([this.keypair]);
+                return tx;
+            },
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage,
+            mintAddress
+        });
+        this.isRuning = false;
+        return res;
+    }
+    /**
+      * Withdraw SPL from the Privacy Cash.
+      */
+    async withdrawSPL({ base_units, mintAddress, recipientAddress, amount, referrer }) {
+        this.isRuning = true;
+        logger.info('start withdrawing');
+        let lightWasm = await WasmFactory.getInstance();
+        let recipient = recipientAddress ? new PublicKey(recipientAddress) : this.publicKey;
+        let res = await withdrawSPL({
+            lightWasm,
+            base_units,
+            amount,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            recipient,
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage,
+            mintAddress,
+            referrer
+        });
+        logger.debug(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`);
+        this.isRuning = false;
+        return res;
+    }
+}
+function getSolanaKeypair(secret) {
+    try {
+        if (secret instanceof Keypair) {
+            return secret;
+        }
+        let keyArray;
+        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, frame) {
+    let blue = "\x1b[34m";
+    let reset = "\x1b[0m";
+    process.stdout.write(`${frame}status: ${blue}${status}${reset}\r`);
+}

package/dist/models/keypair.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Keypair module for ZK Cash
+ *
+ * Provides cryptographic keypair functionality for the ZK Cash system
+ * Based on: https://github.com/tornadocash/tornado-nova
+ */
+import BN from 'bn.js';
+import * as hasher from '@lightprotocol/hasher.rs';
+/**
+ * Simplified version of Keypair
+ */
+export declare class Keypair {
+    privkey: BN;
+    pubkey: BN;
+    private lightWasm;
+    constructor(privkeyHex: string, lightWasm: hasher.LightWasm);
+    /**
+    * Sign a message using keypair private key
+    *
+    * @param {string|number|BigNumber} commitment a hex string with commitment
+    * @param {string|number|BigNumber} merklePath a hex string with merkle path
+    * @returns {BigNumber} a hex string with signature
+    */
+    sign(commitment: string, merklePath: string): string;
+    static generateNew(lightWasm: hasher.LightWasm): Promise<Keypair>;
+}

package/dist/models/keypair.js

@@ -0,0 +1,43 @@
+/**
+ * Keypair module for ZK Cash
+ *
+ * Provides cryptographic keypair functionality for the ZK Cash system
+ * Based on: https://github.com/tornadocash/tornado-nova
+ */
+import BN from 'bn.js';
+import { ethers } from 'ethers';
+// Field size constant
+const FIELD_SIZE = new BN('21888242871839275222246405745257275088548364400416034343698204186575808495617');
+/**
+ * Simplified version of Keypair
+ */
+export class Keypair {
+    privkey;
+    pubkey;
+    lightWasm;
+    constructor(privkeyHex, lightWasm) {
+        const rawDecimal = BigInt(privkeyHex);
+        this.privkey = new BN((rawDecimal % BigInt(FIELD_SIZE.toString())).toString());
+        this.lightWasm = lightWasm;
+        // TODO: lazily compute pubkey
+        this.pubkey = new BN(this.lightWasm.poseidonHashString([this.privkey.toString()]));
+    }
+    /**
+    * Sign a message using keypair private key
+    *
+    * @param {string|number|BigNumber} commitment a hex string with commitment
+    * @param {string|number|BigNumber} merklePath a hex string with merkle path
+    * @returns {BigNumber} a hex string with signature
+    */
+    sign(commitment, merklePath) {
+        return this.lightWasm.poseidonHashString([this.privkey.toString(), commitment, merklePath]);
+    }
+    static async generateNew(lightWasm) {
+        // Tornado Cash Nova uses ethers.js to generate a random private key
+        // We can't generate Solana keypairs because it won't fit in the field size
+        // It's OK to use ethereum secret keys, because the secret key is only used for the proof generation.
+        // Namely, it's used to guarantee the uniqueness of the nullifier.
+        const wallet = ethers.Wallet.createRandom();
+        return new Keypair(wallet.privateKey, lightWasm);
+    }
+}

package/dist/models/utxo.d.ts

@@ -0,0 +1,49 @@
+/**
+ * UTXO (Unspent Transaction Output) module for ZK Cash
+ *
+ * Provides UTXO functionality for the ZK Cash system
+ * Based on: https://github.com/tornadocash/tornado-nova
+ */
+import BN from 'bn.js';
+import { Keypair } from './keypair.js';
+import * as hasher from '@lightprotocol/hasher.rs';
+/**
+ * Simplified Utxo class inspired by Tornado Cash Nova
+ * Based on: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/utxo.js
+ */
+export declare class Utxo {
+    amount: BN;
+    blinding: BN;
+    keypair: Keypair;
+    index: number;
+    mintAddress: string;
+    version: 'v1' | 'v2';
+    private lightWasm;
+    constructor({ lightWasm, amount, 
+    /**
+     * Tornado nova doesn't use solana eddsa with curve 25519 but their own "keypair"
+     * which is:
+     * - private key: random [31;u8]
+     * - public key: PoseidonHash(privateKey)
+     *
+     * Generate a new keypair for each UTXO
+     */
+    keypair, blinding, // Use fixed value for consistency instead of randomBN()
+    index, mintAddress, // Default to Solana native SOL mint address,
+    version }: {
+        lightWasm: hasher.LightWasm;
+        amount?: BN | number | string;
+        keypair?: Keypair;
+        blinding?: BN | number | string;
+        index?: number;
+        mintAddress?: string;
+        version?: 'v1' | 'v2';
+    });
+    getCommitment(): Promise<string>;
+    getNullifier(): Promise<string>;
+    /**
+     * Log all the UTXO's public properties and derived values in JSON format
+     * @returns Promise that resolves once all logging is complete
+     */
+    log(): Promise<void>;
+}

package/dist/models/utxo.js

@@ -0,0 +1,85 @@
+/**
+ * UTXO (Unspent Transaction Output) module for ZK Cash
+ *
+ * Provides UTXO functionality for the ZK Cash system
+ * Based on: https://github.com/tornadocash/tornado-nova
+ */
+import BN from 'bn.js';
+import { Keypair } from './keypair.js';
+import { ethers } from 'ethers';
+import { getMintAddressField } from '../utils/utils.js';
+import { PublicKey } from '@solana/web3.js';
+/**
+ * Simplified Utxo class inspired by Tornado Cash Nova
+ * Based on: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/utxo.js
+ */
+export class Utxo {
+    amount;
+    blinding;
+    keypair;
+    index;
+    mintAddress;
+    version;
+    lightWasm;
+    constructor({ lightWasm, amount = new BN(0), 
+    /**
+     * Tornado nova doesn't use solana eddsa with curve 25519 but their own "keypair"
+     * which is:
+     * - private key: random [31;u8]
+     * - public key: PoseidonHash(privateKey)
+     *
+     * Generate a new keypair for each UTXO
+     */
+    keypair, blinding = new BN(Math.floor(Math.random() * 1000000000)), // Use fixed value for consistency instead of randomBN()
+    index = 0, mintAddress = '11111111111111111111111111111112', // Default to Solana native SOL mint address,
+    version = 'v2' }) {
+        this.amount = new BN(amount.toString());
+        this.blinding = new BN(blinding.toString());
+        this.lightWasm = lightWasm;
+        this.keypair = keypair || new Keypair(ethers.Wallet.createRandom().privateKey, lightWasm);
+        this.index = index;
+        this.mintAddress = mintAddress;
+        this.version = version;
+    }
+    async getCommitment() {
+        // return this.lightWasm.poseidonHashString([this.amount.toString(), this.keypair.pubkey.toString(), this.blinding.toString(), this.mintAddress]);
+        const mintAddressField = getMintAddressField(new PublicKey(this.mintAddress));
+        return this.lightWasm.poseidonHashString([
+            this.amount.toString(),
+            this.keypair.pubkey.toString(),
+            this.blinding.toString(),
+            mintAddressField
+        ]);
+    }
+    async getNullifier() {
+        const commitmentValue = await this.getCommitment();
+        const signature = this.keypair.sign(commitmentValue, new BN(this.index).toString());
+        return this.lightWasm.poseidonHashString([commitmentValue, new BN(this.index).toString(), signature]);
+    }
+    /**
+     * Log all the UTXO's public properties and derived values in JSON format
+     * @returns Promise that resolves once all logging is complete
+     */
+    async log() {
+        // Prepare the UTXO data object
+        const utxoData = {
+            amount: this.amount.toString(),
+            blinding: this.blinding.toString(),
+            index: this.index,
+            mintAddress: this.mintAddress,
+            keypair: {
+                pubkey: this.keypair.pubkey.toString()
+            }
+        };
+        // Add derived values
+        try {
+            utxoData.commitment = await this.getCommitment();
+            utxoData.nullifier = await this.getNullifier();
+        }
+        catch (error) {
+            utxoData.error = error.message;
+        }
+        // Output as formatted JSON
+        console.log(JSON.stringify(utxoData, null, 2));
+    }
+}

package/dist/utils/address_lookup_table.d.ts

@@ -0,0 +1,9 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+/**
+ * Helper function to use an existing ALT (recommended for production)
+ * Use create_alt.ts to create the ALT once, then hardcode the address and use this function
+ */
+export declare function useExistingALT(connection: Connection, altAddress: PublicKey): Promise<{
+    value: any;
+} | null>;
+export declare function getProtocolAddressesWithMint(programId: PublicKey, authority: PublicKey, treeAta: PublicKey, feeRecipient: PublicKey, feeRecipientAta: PublicKey): PublicKey[];

package/dist/utils/address_lookup_table.js

@@ -0,0 +1,45 @@
+import { PublicKey, SystemProgram, ComputeBudgetProgram } from '@solana/web3.js';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { logger } from './logger.js';
+/**
+ * Helper function to use an existing ALT (recommended for production)
+ * Use create_alt.ts to create the ALT once, then hardcode the address and use this function
+ */
+export async function useExistingALT(connection, altAddress) {
+    try {
+        logger.debug(`Using existing ALT: ${altAddress.toString()}`);
+        const altAccount = await connection.getAddressLookupTable(altAddress);
+        if (altAccount.value) {
+            logger.debug(`✅ ALT found with ${altAccount.value.state.addresses.length} addresses`);
+        }
+        else {
+            logger.error('❌ ALT not found');
+        }
+        return altAccount;
+    }
+    catch (error) {
+        console.error('Error getting existing ALT:', error);
+        return null;
+    }
+}
+export function getProtocolAddressesWithMint(programId, authority, treeAta, feeRecipient, feeRecipientAta) {
+    // Derive global config PDA
+    const [globalConfigAccount] = PublicKey.findProgramAddressSync([Buffer.from('global_config')], programId);
+    // Derive tree accounts
+    const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree')], programId);
+    return [
+        // Core program accounts (constant)
+        programId,
+        treeAccount,
+        treeAta,
+        globalConfigAccount,
+        authority,
+        feeRecipient,
+        feeRecipientAta,
+        // System programs (constant)
+        SystemProgram.programId,
+        ComputeBudgetProgram.programId,
+        ASSOCIATED_TOKEN_PROGRAM_ID,
+        TOKEN_PROGRAM_ID,
+    ];
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,27 @@
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+export declare const FIELD_SIZE: BN;
+export declare const PROGRAM_ID: PublicKey;
+export declare const FEE_RECIPIENT: PublicKey;
+export declare const FETCH_UTXOS_GROUP_SIZE = 20000;
+export declare const TRANSACT_IX_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const TRANSACT_SPL_IX_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const MERKLE_TREE_DEPTH = 26;
+export declare const ALT_ADDRESS: PublicKey;
+export declare const RELAYER_API_URL: string;
+export declare const SIGN_MESSAGE = "Privacy Money account sign in";
+export declare const LSK_FETCH_OFFSET = "fetch_offset";
+export declare const LSK_ENCRYPTED_OUTPUTS = "encrypted_outputs";
+export declare const USDC_MINT: PublicKey;
+declare const tokenList: readonly ["sol", "usdc", "usdt", "zec", "ore", "store"];
+export type TokenList = typeof tokenList[number];
+declare const splList: readonly ["usdc", "usdt", "zec", "ore", "store"];
+export type SplList = typeof splList[number];
+export type Token = {
+    name: TokenList;
+    prefix: string;
+    units_per_token: number;
+    pubkey: PublicKey;
+};
+export declare const tokens: Token[];
+export {};

package/dist/utils/constants.js

@@ -0,0 +1,56 @@
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+export const FIELD_SIZE = new BN('21888242871839275222246405745257275088548364400416034343698204186575808495617');
+export const PROGRAM_ID = process.env.NEXT_PUBLIC_PROGRAM_ID ? new PublicKey(process.env.NEXT_PUBLIC_PROGRAM_ID) : new PublicKey('9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD');
+export const FEE_RECIPIENT = new PublicKey('AWexibGxNFKTa1b5R5MN4PJr9HWnWRwf8EW9g8cLx3dM');
+export const FETCH_UTXOS_GROUP_SIZE = 20_000;
+export const TRANSACT_IX_DISCRIMINATOR = Buffer.from([217, 149, 130, 143, 221, 52, 252, 119]);
+export const TRANSACT_SPL_IX_DISCRIMINATOR = Buffer.from([154, 66, 244, 204, 78, 225, 163, 151]);
+export const MERKLE_TREE_DEPTH = 26;
+export const ALT_ADDRESS = process.env.NEXT_PUBLIC_ALT_ADDRESS ? new PublicKey(process.env.NEXT_PUBLIC_ALT_ADDRESS) : new PublicKey('HEN49U2ySJ85Vc78qprSW9y6mFDhs1NczRxyppNHjofe');
+export const RELAYER_API_URL = process.env.NEXT_PUBLIC_RELAYER_API_URL ?? 'https://api3.privacycash.org';
+export const SIGN_MESSAGE = `Privacy Money account sign in`;
+// localStorage cache keys
+export const LSK_FETCH_OFFSET = 'fetch_offset';
+export const LSK_ENCRYPTED_OUTPUTS = 'encrypted_outputs';
+export const USDC_MINT = process.env.NEXT_PUBLIC_USDC_MINT ? new PublicKey(process.env.NEXT_PUBLIC_USDC_MINT) : new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+const tokenList = ['sol', 'usdc', 'usdt', 'zec', 'ore', 'store'];
+const splList = ['usdc', 'usdt', 'zec', 'ore', 'store'];
+export const tokens = [
+    {
+        name: 'sol',
+        pubkey: new PublicKey('So11111111111111111111111111111111111111112'),
+        prefix: '',
+        units_per_token: 1e9
+    },
+    {
+        name: 'usdc',
+        pubkey: process.env.NEXT_PUBLIC_USDC_MINT ? new PublicKey(process.env.NEXT_PUBLIC_USDC_MINT) : new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
+        prefix: 'usdc_',
+        units_per_token: 1e6
+    },
+    {
+        name: 'usdt',
+        pubkey: process.env.NEXT_PUBLIC_USDT_MINT ? new PublicKey(process.env.NEXT_PUBLIC_USDT_MINT) : new PublicKey('Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB'),
+        prefix: 'usdt_',
+        units_per_token: 1e6
+    },
+    {
+        name: 'zec',
+        pubkey: process.env.NEXT_PUBLIC_ZEC_MINT ? new PublicKey(process.env.NEXT_PUBLIC_ZEC_MINT) : new PublicKey('A7bdiYdS5GjqGFtxf17ppRHtDKPkkRqbKtR27dxvQXaS'),
+        prefix: 'zec_',
+        units_per_token: 1e8
+    },
+    {
+        name: 'ore',
+        pubkey: process.env.NEXT_PUBLIC_ORE_MINT ? new PublicKey(process.env.NEXT_PUBLIC_ORE_MINT) : new PublicKey('oreoU2P8bN6jkk3jbaiVxYnG1dCXcYxwhwyK9jSybcp'),
+        prefix: 'ore_',
+        units_per_token: 1e11
+    },
+    {
+        name: 'store',
+        pubkey: process.env.NEXT_PUBLIC_STORE_MINT ? new PublicKey(process.env.NEXT_PUBLIC_STORE_MINT) : new PublicKey('sTorERYB6xAZ1SSbwpK3zoK2EEwbBrc7TZAzg1uCGiH'),
+        prefix: 'store_',
+        units_per_token: 1e11
+    },
+];