nova-privacy-sdk 1.0.0

package/src/index.ts

@@ -0,0 +1,350 @@
+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 { getBalanceFromUtxosSPL, getUtxosSPL } from './getUtxosSPL.js';
+
+import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, SplList, TokenList, tokens, USDC_MINT } 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'
+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 {
+    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))
+        // 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 }: {
+        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
+    }
+
+    /**
+    * Deposit USDC to the Privacy Cash.
+    */
+    async depositUSDC({ base_units }: {
+        base_units: number
+    }) {
+        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: 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
+        })
+        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 }: {
+        base_units: 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 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
+        })
+        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?: 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: PublicKey | string) {
+        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 }: {
+        base_units?: number,
+        amount?: number,
+        mintAddress: PublicKey | string
+    }) {
+        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: VersionedTransaction) => {
+                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 }: {
+        base_units?: number,
+        amount?: number,
+        mintAddress: PublicKey | string,
+        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 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
+        })
+        logger.debug(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`)
+        this.isRuning = false
+        return res
+    }
+
+
+}
+
+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`);
+}

package/src/models/keypair.ts

@@ -0,0 +1,52 @@
+/**
+ * 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';
+import * as hasher from '@lightprotocol/hasher.rs';
+
+// Field size constant
+const FIELD_SIZE = new BN(
+    '21888242871839275222246405745257275088548364400416034343698204186575808495617'
+);
+
+/**
+ * Simplified version of Keypair
+ */
+export class Keypair {
+    public privkey: BN;
+    public pubkey: BN;
+    private lightWasm: hasher.LightWasm;
+
+    constructor(privkeyHex: string, lightWasm: hasher.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: string, merklePath: string): string {
+        return this.lightWasm.poseidonHashString([this.privkey.toString(), commitment, merklePath]);
+    }
+
+    static async generateNew(lightWasm: hasher.LightWasm): Promise<Keypair> {
+        // 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/src/models/utxo.ts

@@ -0,0 +1,106 @@
+/**
+ * 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';
+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: BN;
+    blinding: BN;
+    keypair: Keypair;
+    index: number;
+    mintAddress: string;
+    version: 'v1' | 'v2';
+    private lightWasm: hasher.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'
+    }: {
+        lightWasm: hasher.LightWasm,
+        amount?: BN | number | string,
+        keypair?: Keypair,
+        blinding?: BN | number | string,
+        index?: number,
+        mintAddress?: string,
+        version?: 'v1' | '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(): Promise<string> {
+        // 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(): Promise<string> {
+        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(): Promise<void> {
+        // Prepare the UTXO data object
+        const utxoData: any = {
+            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: any) {
+            utxoData.error = error.message;
+        }
+
+        // Output as formatted JSON
+        console.log(JSON.stringify(utxoData, null, 2));
+    }
+} 

package/src/utils/address_lookup_table.ts

@@ -0,0 +1,78 @@
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  SystemProgram,
+  AddressLookupTableProgram,
+  Transaction,
+  sendAndConfirmTransaction,
+  ComputeBudgetProgram,
+  VersionedTransaction,
+  TransactionMessage
+} 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: Connection,
+  altAddress: PublicKey
+): Promise<{ value: any } | null> {
+  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: PublicKey,
+  authority: PublicKey,
+  treeAta: PublicKey,
+  feeRecipient: PublicKey,
+  feeRecipientAta: PublicKey
+): PublicKey[] {
+  // 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/src/utils/constants.ts

@@ -0,0 +1,84 @@
+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('SHLD11qQaY6h2N3ozXUWJEJitk1zGm9tvvAC7rjxpsp');
+
+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')
+
+// Tree addresses for SOL (NOVASOL), NOVA, and legacy SOL
+export const SOL_TREE_ADDRESS = process.env.NEXT_PUBLIC_SOL_TREE ? new PublicKey(process.env.NEXT_PUBLIC_SOL_TREE) : new PublicKey('DUnk81NBY7gUYRekT7GAwTU7jvabiVVwcMKZkRDs3dW9')
+export const NOVA_TREE_ADDRESS = process.env.NEXT_PUBLIC_NOVA_TREE ? new PublicKey(process.env.NEXT_PUBLIC_NOVA_TREE) : new PublicKey('9CJ8jwAXJ7GrYtrMmD4gXBpTC59DMX7a91yMVpz25enZ')
+// NOVASOL is the SOL tree used in Nova Privacy program
+export const NOVASOL_TREE_ADDRESS = process.env.NEXT_PUBLIC_NOVASOL_TREE ? new PublicKey(process.env.NEXT_PUBLIC_NOVASOL_TREE) : new PublicKey('FZfbN2fY3aj7hTwh87dKMfuVwpaEipY3TuGpmYJnsWcG')
+export const NOVA_MINT = process.env.NEXT_PUBLIC_NOVA_MINT ? new PublicKey(process.env.NEXT_PUBLIC_NOVA_MINT) : new PublicKey('3SkFJRqMPTKZLqKK1MmY2mvAm711FGAtJ9ZbL6r1coin')
+
+const tokenList = ['sol', 'usdc', 'usdt', 'zec', 'ore', 'nova'] as const;
+export type TokenList = typeof tokenList[number];
+const splList = ['usdc', 'usdt', 'zec', 'ore', 'nova'] as const;
+export type SplList = typeof splList[number];
+export type Token = {
+    name: TokenList
+    prefix: string
+    units_per_token: number
+    pubkey: PublicKey
+}
+export const tokens: Token[] = [
+    {
+        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: 'nova',
+        pubkey: NOVA_MINT,
+        prefix: 'nova_',
+        units_per_token: 1e9
+    },
+]