privacycash 1.1.8 → 1.1.9

package/dist/deposit.d.ts

@@ -10,9 +10,10 @@ type DepositParams = {
     keyBasePath: string;
     lightWasm: hasher.LightWasm;
     referrer?: string;
+    signer?: PublicKey;
     transactionSigner: (tx: VersionedTransaction) => Promise<VersionedTransaction>;
 };
-export declare function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer }: DepositParams): Promise<{
+export declare function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer, signer }: DepositParams): Promise<{
     tx: string;
 }>;
 export {};

package/dist/deposit.js

@@ -44,20 +44,23 @@ async function relayDepositToIndexer(signedTransaction, publicKey, referrer) {
         throw error;
     }
 }
-export async function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer }) {
+export async function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer, signer }) {
     // check limit
     let limitAmount = await checkDepositLimit(connection);
     if (limitAmount && amount_in_lamports > limitAmount * LAMPORTS_PER_SOL) {
         throw new Error(`Don't deposit more than ${limitAmount} SOL`);
     }
+    if (!signer) {
+        signer = publicKey;
+    }
     // const amount_in_lamports = amount_in_sol * LAMPORTS_PER_SOL
     const fee_amount_in_lamports = 0;
     logger.debug('Encryption key generated from user keypair');
-    logger.debug(`User wallet: ${publicKey.toString()}`);
+    logger.debug(`User wallet: ${signer.toString()}`);
     logger.debug(`Deposit amount: ${amount_in_lamports} lamports (${amount_in_lamports / LAMPORTS_PER_SOL} SOL)`);
     logger.debug(`Calculated fee: ${fee_amount_in_lamports} lamports (${fee_amount_in_lamports / LAMPORTS_PER_SOL} SOL)`);
     // Check wallet balance
-    const balance = await connection.getBalance(publicKey);
+    const balance = await connection.getBalance(signer);
     logger.debug(`Wallet balance: ${balance / 1e9} SOL`);
     if (balance < amount_in_lamports + fee_amount_in_lamports) {
         throw new Error(`Insufficient balance: ${balance / 1e9} SOL. Need at least ${(amount_in_lamports + fee_amount_in_lamports) / LAMPORTS_PER_SOL} SOL.`);
@@ -303,7 +306,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
             // fee recipient
             { pubkey: FEE_RECIPIENT, isSigner: false, isWritable: true },
             // signer
-            { pubkey: publicKey, isSigner: true, isWritable: true },
+            { pubkey: signer, isSigner: true, isWritable: true },
             { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
         ],
         programId: PROGRAM_ID,
@@ -316,7 +319,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     // Create versioned transaction with Address Lookup Table
     const recentBlockhash = await connection.getLatestBlockhash();
     const messageV0 = new TransactionMessage({
-        payerKey: publicKey, // User pays for their own deposit
+        payerKey: signer, // User pays for their own deposit
         recentBlockhash: recentBlockhash.blockhash,
         instructions: [modifyComputeUnits, depositInstruction],
     }).compileToV0Message([lookupTableAccount.value]);
@@ -329,7 +332,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     logger.debug('Prepared signed transaction for relay to indexer backend');
     // Relay the pre-signed transaction to indexer backend
     logger.info('submitting transaction to relayer...');
-    const signature = await relayDepositToIndexer(serializedTransaction, publicKey, referrer);
+    const signature = await relayDepositToIndexer(serializedTransaction, signer, referrer);
     logger.debug('Transaction signature:', signature);
     logger.debug(`Transaction link: https://explorer.solana.com/tx/${signature}`);
     logger.info('Waiting for transaction confirmation...');

package/dist/depositSPL.d.ts

@@ -12,9 +12,10 @@ type DepositParams = {
     keyBasePath: string;
     lightWasm: hasher.LightWasm;
     referrer?: string;
+    signer?: PublicKey;
     transactionSigner: (tx: VersionedTransaction) => Promise<VersionedTransaction>;
 };
-export declare function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, mintAddress }: DepositParams): Promise<{
+export declare function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, mintAddress, signer }: DepositParams): Promise<{
     tx: string;
 }>;
 export {};

package/dist/depositSPL.js

@@ -53,7 +53,7 @@ async function relayDepositToIndexer({ signedTransaction, publicKey, referrer, m
         throw error;
     }
 }
-export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, mintAddress }) {
+export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, mintAddress, signer }) {
     if (typeof mintAddress == 'string') {
         mintAddress = new PublicKey(mintAddress);
     }
@@ -67,12 +67,15 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     if (!base_units) {
         throw new Error('You must input at least one of "base_units" or "amount"');
     }
+    if (!signer) {
+        signer = publicKey;
+    }
     // let mintInfo = await getMint(connection, token.pubkey)
     // let units_per_token = 10 ** mintInfo.decimals
     let recipient = new PublicKey('AWexibGxNFKTa1b5R5MN4PJr9HWnWRwf8EW9g8cLx3dM');
     let recipient_ata = getAssociatedTokenAddressSync(token.pubkey, recipient, true);
     let feeRecipientTokenAccount = getAssociatedTokenAddressSync(token.pubkey, FEE_RECIPIENT, true);
-    let signerTokenAccount = getAssociatedTokenAddressSync(token.pubkey, publicKey);
+    let signerTokenAccount = getAssociatedTokenAddressSync(token.pubkey, signer);
     // Derive tree account PDA with mint address for SPL
     const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree'), token.pubkey.toBuffer()], PROGRAM_ID);
     let limitAmount = await checkDepositLimit(connection, treeAccount, token);
@@ -82,7 +85,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     // const base_units = amount_in_sol * units_per_token
     const fee_base_units = 0;
     logger.debug('Encryption key generated from user keypair');
-    logger.debug(`User wallet: ${publicKey.toString()}`);
+    logger.debug(`User wallet: ${signer.toString()}`);
     logger.debug(`Deposit amount: ${base_units} base_units (${base_units / token.units_per_token}  ${token.name.toUpperCase()})`);
     logger.debug(`Calculated fee: ${fee_base_units} base_units (${fee_base_units / token.units_per_token}  ${token.name.toUpperCase()})`);
     // Check SPL balance
@@ -95,7 +98,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         throw new Error(`Insufficient balance. Need at least ${(base_units + fee_base_units) / token.units_per_token}  ${token.name.toUpperCase()}.`);
     }
     // Check SOL balance
-    const solBalance = await connection.getBalance(publicKey);
+    const solBalance = await connection.getBalance(signer);
     logger.debug(`SOL Wallet balance: ${solBalance / 1e9} SOL`);
     if (solBalance / 1e9 < 0.002) {
         throw new Error(`Need at least 0.002 SOL for Solana fees.`);
@@ -339,7 +342,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
             { pubkey: nullifier3PDA, isSigner: false, isWritable: false },
             { pubkey: globalConfigAccount, isSigner: false, isWritable: false },
             // signer
-            { pubkey: publicKey, isSigner: true, isWritable: true },
+            { pubkey: signer, isSigner: true, isWritable: true },
             // SPL token mint
             { pubkey: token.pubkey, isSigner: false, isWritable: false },
             // signer's token account
@@ -369,7 +372,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     // Create versioned transaction with Address Lookup Table
     const recentBlockhash = await connection.getLatestBlockhash();
     const messageV0 = new TransactionMessage({
-        payerKey: publicKey, // User pays for their own deposit
+        payerKey: signer, // User pays for their own deposit
         recentBlockhash: recentBlockhash.blockhash,
         instructions: [modifyComputeUnits, depositInstruction],
     }).compileToV0Message([lookupTableAccount.value]);
@@ -384,7 +387,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     logger.info('submitting transaction to relayer...');
     const signature = await relayDepositToIndexer({
         mintAddress: token.pubkey.toString(),
-        publicKey,
+        publicKey: signer,
         signedTransaction: serializedTransaction,
         referrer
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privacycash",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "",
   "main": "dist/index.js",
   "repository": "https://github.com/Privacy-Cash/privacy-cash-sdk",

package/src/deposit.ts

@@ -62,9 +62,10 @@ type DepositParams = {
     keyBasePath: string,
     lightWasm: hasher.LightWasm,
     referrer?: string,
+    signer?: PublicKey,
     transactionSigner: (tx: VersionedTransaction) => Promise<VersionedTransaction>
 }
-export async function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer }: DepositParams) {
+export async function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer, signer }: DepositParams) {
     // check limit
     let limitAmount = await checkDepositLimit(connection)
 
@@ -72,15 +73,19 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
         throw new Error(`Don't deposit more than ${limitAmount} SOL`)
     }
 
+    if (!signer) {
+        signer = publicKey
+    }
+
     // const amount_in_lamports = amount_in_sol * LAMPORTS_PER_SOL
     const fee_amount_in_lamports = 0
     logger.debug('Encryption key generated from user keypair');
-    logger.debug(`User wallet: ${publicKey.toString()}`);
+    logger.debug(`User wallet: ${signer.toString()}`);
     logger.debug(`Deposit amount: ${amount_in_lamports} lamports (${amount_in_lamports / LAMPORTS_PER_SOL} SOL)`);
     logger.debug(`Calculated fee: ${fee_amount_in_lamports} lamports (${fee_amount_in_lamports / LAMPORTS_PER_SOL} SOL)`);
 
     // Check wallet balance
-    const balance = await connection.getBalance(publicKey);
+    const balance = await connection.getBalance(signer);
     logger.debug(`Wallet balance: ${balance / 1e9} SOL`);
 
     if (balance < amount_in_lamports + fee_amount_in_lamports) {
@@ -374,7 +379,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
             // fee recipient
             { pubkey: FEE_RECIPIENT, isSigner: false, isWritable: true },
             // signer
-            { pubkey: publicKey, isSigner: true, isWritable: true },
+            { pubkey: signer, isSigner: true, isWritable: true },
             { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
         ],
         programId: PROGRAM_ID,
@@ -390,7 +395,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     const recentBlockhash = await connection.getLatestBlockhash();
 
     const messageV0 = new TransactionMessage({
-        payerKey: publicKey, // User pays for their own deposit
+        payerKey: signer, // User pays for their own deposit
         recentBlockhash: recentBlockhash.blockhash,
         instructions: [modifyComputeUnits, depositInstruction],
     }).compileToV0Message([lookupTableAccount.value]);
@@ -409,7 +414,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
 
     // Relay the pre-signed transaction to indexer backend
     logger.info('submitting transaction to relayer...')
-    const signature = await relayDepositToIndexer(serializedTransaction, publicKey, referrer);
+    const signature = await relayDepositToIndexer(serializedTransaction, signer, referrer);
     logger.debug('Transaction signature:', signature);
     logger.debug(`Transaction link: https://explorer.solana.com/tx/${signature}`);
 

package/src/depositSPL.ts

@@ -77,9 +77,10 @@ type DepositParams = {
     keyBasePath: string,
     lightWasm: hasher.LightWasm,
     referrer?: string,
+    signer?: PublicKey,
     transactionSigner: (tx: VersionedTransaction) => Promise<VersionedTransaction>
 }
-export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, mintAddress }: DepositParams) {
+export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, mintAddress, signer }: DepositParams) {
     if (typeof mintAddress == 'string') {
         mintAddress = new PublicKey(mintAddress)
     }
@@ -96,6 +97,9 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         throw new Error('You must input at least one of "base_units" or "amount"')
     }
 
+    if (!signer) {
+        signer = publicKey
+    }
 
     // let mintInfo = await getMint(connection, token.pubkey)
     // let units_per_token = 10 ** mintInfo.decimals
@@ -113,7 +117,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     );
     let signerTokenAccount = getAssociatedTokenAddressSync(
         token.pubkey,
-        publicKey
+        signer
     );
 
     // Derive tree account PDA with mint address for SPL
@@ -130,7 +134,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     // const base_units = amount_in_sol * units_per_token
     const fee_base_units = 0
     logger.debug('Encryption key generated from user keypair');
-    logger.debug(`User wallet: ${publicKey.toString()}`);
+    logger.debug(`User wallet: ${signer.toString()}`);
     logger.debug(`Deposit amount: ${base_units} base_units (${base_units / token.units_per_token}  ${token.name.toUpperCase()})`);
     logger.debug(`Calculated fee: ${fee_base_units} base_units (${fee_base_units / token.units_per_token}  ${token.name.toUpperCase()})`);
 
@@ -146,7 +150,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     }
 
     // Check SOL balance
-    const solBalance = await connection.getBalance(publicKey);
+    const solBalance = await connection.getBalance(signer);
     logger.debug(`SOL Wallet balance: ${solBalance / 1e9} SOL`);
 
     if (solBalance / 1e9 < 0.002) {
@@ -440,7 +444,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
 
             { pubkey: globalConfigAccount, isSigner: false, isWritable: false },
             // signer
-            { pubkey: publicKey, isSigner: true, isWritable: true },
+            { pubkey: signer, isSigner: true, isWritable: true },
             // SPL token mint
             { pubkey: token.pubkey, isSigner: false, isWritable: false },
             // signer's token account
@@ -475,7 +479,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     const recentBlockhash = await connection.getLatestBlockhash();
 
     const messageV0 = new TransactionMessage({
-        payerKey: publicKey, // User pays for their own deposit
+        payerKey: signer, // User pays for their own deposit
         recentBlockhash: recentBlockhash.blockhash,
         instructions: [modifyComputeUnits, depositInstruction],
     }).compileToV0Message([lookupTableAccount.value]);
@@ -497,7 +501,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     logger.info('submitting transaction to relayer...')
     const signature = await relayDepositToIndexer({
         mintAddress: token.pubkey.toString(),
-        publicKey,
+        publicKey: signer,
         signedTransaction: serializedTransaction,
         referrer
     });