js

Author: 2501babe

clients/js-legacy/src/instructions.ts

@@ -86,4 +86,19 @@ export class SinglePoolInstruction {
     );
     return modernInstructionToLegacy(instruction);
   }
+
+  static async depositSol(
+    voteAccount: PublicKey,
+    userWallet: PublicKey,
+    userTokenAccount: PublicKey,
+    lamports: number | bigint,
+  ): Promise<TransactionInstruction> {
+    const instruction = await PoolInstructionModern.depositSol(
+      voteAccount.toBase58() as VoteAccountAddress,
+      userWallet.toBase58() as Address,
+      userTokenAccount.toBase58() as Address,
+      BigInt(lamports),
+    );
+    return modernInstructionToLegacy(instruction);
+  }
 }

clients/js-legacy/src/transactions.ts

@@ -27,6 +27,14 @@ interface WithdrawParams {
   userTokenAuthority?: PublicKey;
 }
 
+interface DepositSolParams {
+  connection: Connection;
+  voteAccount: PublicKey;
+  userWallet: PublicKey;
+  lamports: number | bigint;
+  userTokenAccount?: PublicKey;
+}
+
 export class SinglePoolProgram {
   static programId: PublicKey = new PublicKey(PoolProgramModern.programAddress);
   static space: number = Number(PoolProgramModern.space);
@@ -105,4 +113,11 @@ export class SinglePoolProgram {
 
     return modernTransactionToLegacy(modernTransaction);
   }
+
+  static async depositSol(params: DepositSolParams) {
+    const modernParams = paramsToModern(params);
+    const modernTransaction = await PoolProgramModern.depositSol(modernParams);
+
+    return modernTransactionToLegacy(modernTransaction);
+  }
 }

clients/js-legacy/tests/transactions.test.ts

@@ -448,3 +448,36 @@ test('get vote account address', async (t) => {
   const chainVoteAccount = await getVoteAccountAddressForPool(connection, poolAddress);
   t.true(chainVoteAccount.equals(voteAccountAddress), 'got correct vote account');
 });
+
+test('deposit sol', async (t) => {
+  const context = await startWithContext();
+  const svm = context.svm;
+  const payer = context.payer;
+  const connection = new LiteConnection(svm, payer);
+
+  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
+  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
+  const onrampAddress = await findPoolOnRampAddress(SinglePoolProgram.programId, poolAddress);
+
+  // initialize pool
+  let transaction = await SinglePoolProgram.initialize(
+    connection,
+    voteAccountAddress,
+    payer.publicKey,
+  );
+  await processTransaction(context, transaction);
+  context.advanceEpoch();
+
+  // deposit sol
+  transaction = await SinglePoolProgram.depositSol({
+    connection,
+    voteAccount: voteAccountAddress,
+    userWallet: payer.publicKey,
+    lamports: LAMPORTS_PER_SOL,
+  });
+  await processTransaction(context, transaction);
+
+  const stakeRent = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
+  const onrampAccount = svm.getAccount(onrampAddress);
+  t.is(onrampAccount.lamports, LAMPORTS_PER_SOL + stakeRent, 'sol has been deposited');
+});

clients/js/src/instructions.ts

@@ -157,6 +157,28 @@ type InitializeOnRampInstruction = Instruction<typeof SINGLE_POOL_PROGRAM_ID> &
   > &
   InstructionWithData<Uint8Array>;
 
+type DepositSolInstruction = Instruction<typeof SINGLE_POOL_PROGRAM_ID> &
+  InstructionWithAccounts<
+    [
+      ReadonlyAccount<VoteAccountAddress>,
+      ReadonlyAccount<PoolAddress>,
+      WritableAccount<PoolStakeAddress>,
+      WritableAccount<PoolOnRampAddress>,
+      WritableAccount<PoolMintAddress>,
+      ReadonlyAccount<PoolStakeAuthorityAddress>,
+      ReadonlyAccount<PoolMintAuthorityAddress>,
+      WritableSignerAccount<Address>, // user lamport
+      WritableAccount<Address>, // user token
+      ReadonlyAccount<typeof SYSVAR_CLOCK_ID>,
+      ReadonlyAccount<typeof SYSVAR_STAKE_HISTORY_ID>,
+      ReadonlyAccount<typeof STAKE_CONFIG_ID>,
+      ReadonlyAccount<typeof SYSTEM_PROGRAM_ID>,
+      ReadonlyAccount<typeof TOKEN_PROGRAM_ID>,
+      ReadonlyAccount<typeof STAKE_PROGRAM_ID>,
+    ]
+  > &
+  InstructionWithData<Uint8Array>;
+
 const enum SinglePoolInstructionType {
   InitializePool = 0,
   ReplenishPool,
@@ -165,6 +187,7 @@ const enum SinglePoolInstructionType {
   CreateTokenMetadata,
   UpdateTokenMetadata,
   InitializeOnRamp,
+  DepositSol,
 }
 
 export const SinglePoolInstruction = {
@@ -175,6 +198,7 @@ export const SinglePoolInstruction = {
   createTokenMetadata: createTokenMetadataInstruction,
   updateTokenMetadata: updateTokenMetadataInstruction,
   initializeOnRamp: initializeOnRampInstruction,
+  depositSol: depositSolInstruction,
 };
 
 export async function initializePoolInstruction(
@@ -430,3 +454,44 @@ export async function initializeOnRampInstruction(
     programAddress,
   };
 }
+
+export async function depositSolInstruction(
+  voteAccount: VoteAccountAddress,
+  userLamportAccount: Address,
+  userTokenAccount: Address,
+  lamports: bigint,
+): Promise<DepositSolInstruction> {
+  const programAddress = SINGLE_POOL_PROGRAM_ID;
+  const pool = await findPoolAddress(programAddress, voteAccount);
+  const [stake, onramp, mint, stakeAuthority, mintAuthority] = await Promise.all([
+    findPoolStakeAddress(programAddress, pool),
+    findPoolOnRampAddress(programAddress, pool),
+    findPoolMintAddress(programAddress, pool),
+    findPoolStakeAuthorityAddress(programAddress, pool),
+    findPoolMintAuthorityAddress(programAddress, pool),
+  ]);
+
+  const data = new Uint8Array([SinglePoolInstructionType.DepositSol, ...u64(lamports)]);
+
+  return {
+    data,
+    accounts: [
+      { address: voteAccount, role: AccountRole.READONLY },
+      { address: pool, role: AccountRole.READONLY },
+      { address: stake, role: AccountRole.WRITABLE },
+      { address: onramp, role: AccountRole.WRITABLE },
+      { address: mint, role: AccountRole.WRITABLE },
+      { address: stakeAuthority, role: AccountRole.READONLY },
+      { address: mintAuthority, role: AccountRole.READONLY },
+      { address: userLamportAccount, role: AccountRole.WRITABLE_SIGNER },
+      { address: userTokenAccount, role: AccountRole.WRITABLE },
+      { address: SYSVAR_CLOCK_ID, role: AccountRole.READONLY },
+      { address: SYSVAR_STAKE_HISTORY_ID, role: AccountRole.READONLY },
+      { address: STAKE_CONFIG_ID, role: AccountRole.READONLY },
+      { address: SYSTEM_PROGRAM_ID, role: AccountRole.READONLY },
+      { address: TOKEN_PROGRAM_ID, role: AccountRole.READONLY },
+      { address: STAKE_PROGRAM_ID, role: AccountRole.READONLY },
+    ],
+    programAddress,
+  };
+}

clients/js/src/transactions.ts

@@ -40,6 +40,7 @@ import {
   createTokenMetadataInstruction,
   updateTokenMetadataInstruction,
   initializeOnRampInstruction,
+  depositSolInstruction,
 } from './instructions.js';
 import {
   STAKE_PROGRAM_ID,
@@ -74,6 +75,14 @@ interface WithdrawParams {
   userTokenAuthority?: Address;
 }
 
+interface DepositSolParams {
+  rpc: Rpc<GetAccountInfoApi & GetMinimumBalanceForRentExemptionApi & GetStakeMinimumDelegationApi>;
+  voteAccount: VoteAccountAddress;
+  userWallet: Address;
+  lamports: bigint;
+  userTokenAccount?: Address;
+}
+
 export const SINGLE_POOL_ACCOUNT_SIZE = 33n;
 
 export const SinglePoolProgram = {
@@ -86,6 +95,7 @@ export const SinglePoolProgram = {
   createTokenMetadata: createTokenMetadataTransaction,
   updateTokenMetadata: updateTokenMetadataTransaction,
   initializeOnRamp: initializeOnRampTransaction,
+  depositSol: depositSolTransaction,
 };
 
 async function getInitializeInstructionPlan(
@@ -336,3 +346,43 @@ export async function initializeOnRampTransaction(
 
   return transaction;
 }
+
+export async function depositSolTransaction(params: DepositSolParams) {
+  const { rpc, voteAccount, userWallet, lamports } = params;
+
+  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
+
+  const pool = await findPoolAddress(SINGLE_POOL_PROGRAM_ID, voteAccount);
+  const mint = await findPoolMintAddress(SINGLE_POOL_PROGRAM_ID, pool);
+
+  const userAssociatedTokenAccount = await getAssociatedTokenAddress(mint, userWallet);
+  const userTokenAccount = params.userTokenAccount || userAssociatedTokenAccount;
+
+  if (
+    userTokenAccount == userAssociatedTokenAccount &&
+    (await rpc.getAccountInfo(userAssociatedTokenAccount).send()) == null
+  ) {
+    transaction = appendTransactionMessageInstruction(
+      TokenInstruction.createAssociatedTokenAccount({
+        payer: userWallet,
+        associatedAccount: userAssociatedTokenAccount,
+        owner: userWallet,
+        mint,
+      }),
+      transaction,
+    );
+  }
+
+  // NOTE in our rust instruction builder, we transfer lamports to an escrow account.
+  // this allows us to give greater assurance to the end user that their signing
+  // authority cannot be misused by our benevolent, yet untrusted, program.
+  // unfortunately this is not possible in js middleware but dapps may wish to consider
+  // doing similar by injecting a system transfer between these two instructions
+
+  transaction = appendTransactionMessageInstruction(
+    await depositSolInstruction(voteAccount, userWallet, userTokenAccount, lamports),
+    transaction,
+  );
+
+  return transaction;
+}