@wireio/stake 2.5.1 → 2.6.0

package/src/networks/solana/solana.ts

@@ -380,6 +380,66 @@ export class SolanaStakingClient implements IStakingClient {
         }
     }
 
+    /** Deposit SOL to liqSOL, then syndicate that liqSOL in one transaction. Requires enough SOL for the deposit fee. */
+    async depositAndStake(amountLamports: bigint): Promise<string> {
+        this.ensureUser();
+        if (!amountLamports || amountLamports <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
+
+        try {
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const depositIx = await this.convertClient.buildDepositTx(amountLamports, user);
+            const stakeIx = await this.outpostClient.buildStakeIx(amountLamports, user);
+
+            return !!this.squadsX
+                ? await this.sendSquadsIxs([depositIx, stakeIx])
+                : await this.buildAndSendIx([depositIx, stakeIx]);
+        } catch (err) {
+            console.log(`Failed to deposit and stake: ${err}`);
+            throw err;
+        }
+    }
+
+    /** Deposit SOL to liqSOL, then buy pretokens with that liqSOL in one transaction. Requires enough SOL for the deposit fee. */
+    async depositAndBuy(amountLamports: bigint): Promise<string> {
+        this.ensureUser();
+        if (!amountLamports || amountLamports <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
+
+        try {
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const depositIx = await this.convertClient.buildDepositTx(amountLamports, user);
+            const purchaseIx = await this.tokenClient.buildPurchaseIx(amountLamports, user);
+
+            return !!this.squadsX
+                ? await this.sendSquadsIxs([depositIx, purchaseIx])
+                : await this.buildAndSendIx([depositIx, purchaseIx]);
+        } catch (err) {
+            console.log(`Failed to deposit and buy: ${err}`);
+            throw err;
+        }
+    }
+
+    /** Desyndicate liqSOL, then request withdraw in one transaction. */
+    async unstakeAndWithdraw(amountLamports: bigint): Promise<string> {
+        this.ensureUser();
+        if (!amountLamports || amountLamports <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
+
+        try {
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const unstakeIx = await this.outpostClient.buildUnstakeIx(amountLamports, user);
+            const withdrawIx = await this.convertClient.buildWithdrawTx(amountLamports, user);
+
+            return !!this.squadsX
+                ? await this.sendSquadsIxs([unstakeIx, withdrawIx])
+                : await this.buildAndSendIx([unstakeIx, withdrawIx]);
+        } catch (err) {
+            console.log(`Failed to unstake and withdraw: ${err}`);
+            throw err;
+        }
+    }
+
     /**
      * Aggregate view of the user’s balances on Solana:
      *  - native: SOL wallet balance
@@ -567,9 +627,11 @@ export class SolanaStakingClient implements IStakingClient {
         return pda[0];
     }
 
-    private async sendSquadsIxs(ix: TransactionInstruction): Promise<string> {
+    /** Create a Squads vault transaction/proposal for one or more instructions. */
+    private async sendSquadsIxs(ix: TransactionInstruction | TransactionInstruction[]): Promise<string> {
         if (!this.squadsX) throw new Error('Attempting to wrap Squads instruction without SquadsX config');
 
+        const ixs = Array.isArray(ix) ? ix : [ix];
         const multisigPda = this.squadsMultisigPDA!;
         const vaultPda = this.squadsVaultPDA!;
         const vaultIndex = this.squadsX?.vaultIndex ?? 0;
@@ -579,19 +641,19 @@ export class SolanaStakingClient implements IStakingClient {
         const current = BigInt(ms.transactionIndex?.toString() ?? 0);
         const transactionIndex = current + BigInt(1);
 
-        const altAddress = this.program.PROGRAM_IDS.ALT_LOOKUP_TABLE;
+        const altAddress = this.program.PROGRAM_IDS.ALT;
         const altAccount = await this.connection.getAddressLookupTable(altAddress);
         if (!altAccount.value) throw new Error("ALT not found on-chain or not yet active.");
 
         const lookupTable: AddressLookupTableAccount = altAccount.value;
-        const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
+        const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 600_000 });
         const computePriceIx = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 2000 });
 
         const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
         const transactionMessage = new TransactionMessage({
             payerKey: vaultPda,
             recentBlockhash: blockhash,
-            instructions: [computeLimitIx, computePriceIx, ix],
+            instructions: [computeLimitIx, computePriceIx, ...ixs],
         });
 
         const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
@@ -640,10 +702,33 @@ export class SolanaStakingClient implements IStakingClient {
     // ---------------------------------------------------------------------
 
     async buildAndSendIx(ix: TransactionInstruction | TransactionInstruction[]): Promise<string> {
-        const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
         const ixs = Array.isArray(ix) ? ix : [ix];
-        const tx = new Transaction().add(cuIx, ...ixs);
-        const prepared = await this.prepareTx(tx);
+        const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 600_000 });
+        const computePriceIx = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 2000 });
+        const { blockhash, lastValidBlockHeight } =
+            await this.connection.getLatestBlockhash('confirmed');
+
+        const altAddress = this.program.PROGRAM_IDS.ALT;
+        const altAccount = await this.connection.getAddressLookupTable(altAddress);
+        const lookupTable = altAccount.value;
+
+        const instructions = [computeLimitIx, computePriceIx, ...ixs];
+
+        const tx = lookupTable
+            ? new VersionedTransaction(
+                new TransactionMessage({
+                    payerKey: this.feePayer,
+                    recentBlockhash: blockhash,
+                    instructions,
+                }).compileToV0Message([lookupTable]),
+            )
+            : new Transaction().add(...instructions);
+
+        const prepared =
+            tx instanceof Transaction
+                ? await this.prepareTx(tx)
+                : { tx, blockhash, lastValidBlockHeight };
+
         const signed = await this.signTransaction(prepared.tx);
 
         return this.sendAndConfirmHttp(signed, prepared);

package/src/networks/solana/types.ts

@@ -11,8 +11,8 @@ export type SolanaTransaction = Transaction | VersionedTransaction;
 
 export type WalletLike = {
     publicKey: PublicKey;
-    signTransaction: (tx: Transaction) => Promise<Transaction>;
-    signAllTransactions?: (txs: Transaction[]) => Promise<Transaction[]>;
+    signTransaction: <T extends SolanaTransaction>(tx: T) => Promise<T>;
+    signAllTransactions?: <T extends SolanaTransaction>(txs: T[]) => Promise<T[]>;
 };
 
 export type ParsedAccountInfo = {

package/src/types.ts

@@ -44,7 +44,16 @@ export interface IStakingClient {
     claimWithdraw(tokenId: bigint): Promise<string>
 
     /** Solana only: claim accrued liqSOL distribution rewards. */
-    claimLiqsolRewards?(): Promise<string>
+    // claimLiqsolRewards?(): Promise<string>
+
+    /** Atomically deposit native token to liq token, then stake that liq token. On Solana: amount in lamports. On Ethereum: amount in wei. */
+    depositAndStake(amount: bigint): Promise<string>
+
+    /** Atomically deposit native token to liq token, then buy pretokens with that liq token. On Solana: amount in lamports. On Ethereum: amount in wei. */
+    depositAndBuy(amount: bigint): Promise<string>
+
+    /** Atomically unstake liq token, then request withdrawal. On Solana: amount in lamports. On Ethereum: tokenId (ReceiptNFT ID). */
+    unstakeAndWithdraw(amount: bigint): Promise<string>
     
     /** Enumerate withdrawal receipt NFTs held by the user (queued/ready/claimed). */
     getPendingWithdraws(address?: string): Promise<WithdrawReceipt[]>