hedge-web3 0.1.28 → 0.1.32

package/src/instructions/createVault.ts

@@ -1,10 +1,6 @@
-import { BN, Idl, Program, Provider } from "@project-serum/anchor";
-import { TokenInstructions } from "@project-serum/serum";
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ID,
-  TOKEN_PROGRAM_ID,
-  getOrCreateAssociatedTokenAccount,
-} from "@solana/spl-token";
+import { BN, Idl, Program, Provider } from '@project-serum/anchor'
+import { TokenInstructions } from '@project-serum/serum'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount } from '@solana/spl-token'
 import {
   Keypair,
   PublicKey,
@@ -14,7 +10,7 @@ import {
   SYSVAR_RENT_PUBKEY,
   Transaction,
   TransactionInstruction,
-} from "@solana/web3.js";
+} from '@solana/web3.js'
 import {
   findAssociatedTokenAddress,
   findVaultAddress,
@@ -23,65 +19,47 @@ import {
   getVaultSystemStatePublicKey,
   getPoolPublicKeyForMint,
   getHedgeMintPublicKey,
-} from "../Constants";
+} from '../Constants'
 
-import { v4 as uuidv4 } from "uuid";
-import { parseAnchorErrors } from "../utils/Errors";
+import { v4 as uuidv4 } from 'uuid'
+import { parseAnchorErrors } from '../utils/Errors'
+import { Vault } from 'idl/vault'
 
 export async function createVault(
-  program: Program,
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   collateralType: string,
   depositAmount: number,
   overrideTime?: number
 ): Promise<PublicKey> {
-  const ushMintPublickey = await getUshMintPublicKey();
+  const ushMintPublickey = await getUshMintPublicKey()
 
-  const salt = uuidv4().substring(0, 8);
-  const newVaultPublicKey = await findVaultAddress(salt);
-  const history = Keypair.generate();
+  const salt = uuidv4().substring(0, 8)
+  const newVaultPublicKey = await findVaultAddress(salt)
+  const history = Keypair.generate()
 
   // Prep the user to get USH back out at some point
-  await getOrCreateAssociatedTokenAccount(
-    provider.connection,
-    payer,
-    ushMintPublickey,
-    payer.publicKey
-  );
+  await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
 
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
-    collateralType
-  );
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
-    vaultTypeAccountPublicKey
-  );
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
 
-  const payerTokenAccount = await findAssociatedTokenAddress(
-    payer.publicKey,
-    vaultTypeAccountInfo.collateralMint
-  );
+  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, vaultTypeAccountInfo.collateralMint)
   const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
     newVaultPublicKey,
     vaultTypeAccountInfo.collateralMint
-  );
+  )
 
-  const wrappedSolAccount = Keypair.generate();
+  const wrappedSolAccount = Keypair.generate()
 
-  const transaction = new Transaction();
-  const signers = [payer, history];
+  const transaction = new Transaction()
+  const signers = [payer, history]
 
-  const isWrappedSol =
-    vaultTypeAccountInfo.collateralMint.toString() ===
-    TokenInstructions.WRAPPED_SOL_MINT.toString();
+  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === TokenInstructions.WRAPPED_SOL_MINT.toString()
 
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
-    await getHedgeMintPublicKey()
-  );
-  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
-    hedgeStakingPoolPublicKey,
-    ushMintPublickey
-  );
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, ushMintPublickey)
 
   if (isWrappedSol) {
     transaction.add(
@@ -97,8 +75,8 @@ export async function createVault(
         mint: TokenInstructions.WRAPPED_SOL_MINT,
         owner: payer.publicKey,
       })
-    );
-    signers.push(wrappedSolAccount);
+    )
+    signers.push(wrappedSolAccount)
   }
   transaction.add(
     await createVaultInstruction(
@@ -117,7 +95,7 @@ export async function createVault(
       depositAmount,
       overrideTime
     )
-  );
+  )
   if (isWrappedSol) {
     transaction.add(
       TokenInstructions.closeAccount({
@@ -125,74 +103,53 @@ export async function createVault(
         destination: payer.publicKey,
         owner: payer.publicKey,
       })
-    );
+    )
   }
 
-  await sendAndConfirmTransaction(
-    provider.connection,
-    transaction,
-    signers,
-    provider?.opts
-  ).catch(parseAnchorErrors);
-  return newVaultPublicKey;
+  await sendAndConfirmTransaction(provider.connection, transaction, signers).catch(parseAnchorErrors)
+  return newVaultPublicKey
 }
 
 export async function buildCreateVaultTransaction(
-  program: Program,
+  program: Program<Vault>,
+  payerPublicKey: PublicKey,
   collateralType: string,
   depositAmount: number,
   overrideTime?: number
 ): Promise<[Transaction, Signer[], PublicKey]> {
-
-  console.log("HEDGE SDK: buildCreateVaultTransaction")
-  const ushMintPublickey = await getUshMintPublicKey();
-  const payerPublicKey = program.provider.wallet.publicKey;
-
-  const salt = uuidv4().substring(0, 8);
-  const newVaultPublicKey = await findVaultAddress(salt);
-  const history = Keypair.generate() as Signer;
+  console.log('HEDGE SDK: buildCreateVaultTransaction')
+  const ushMintPublickey = await getUshMintPublicKey()
+  const salt = uuidv4().substring(0, 8)
+  const newVaultPublicKey = await findVaultAddress(salt)
+  const history = Keypair.generate() as Signer
   const { blockhash } = await program.provider.connection.getLatestBlockhash()
   const transaction = new Transaction({
     feePayer: payerPublicKey,
     recentBlockhash: blockhash,
   })
-  const signers = [history];
-  const wrappedSolAccount = Keypair.generate();
+  const signers = [history]
+  const wrappedSolAccount = Keypair.generate()
 
   console.log('Lookup getVaultTypeAccountPublicKey', collateralType)
 
   // Lookup the vault type info
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
-    collateralType
-  );
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
 
   console.log('Lookup vaultTypeAccountPublicKey', vaultTypeAccountPublicKey.toString())
 
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
-    vaultTypeAccountPublicKey
-  );
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
   console.log('Lookup vaultTypeAccountInfo', vaultTypeAccountInfo)
 
-  const isWrappedSol =
-    vaultTypeAccountInfo.collateralMint.toString() ===
-    TokenInstructions.WRAPPED_SOL_MINT.toString();
+  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === TokenInstructions.WRAPPED_SOL_MINT.toString()
 
-  const payerTokenAccount = await findAssociatedTokenAddress(
-    payerPublicKey,
-    vaultTypeAccountInfo.collateralMint
-  );
+  const payerTokenAccount = await findAssociatedTokenAddress(payerPublicKey, vaultTypeAccountInfo.collateralMint)
   const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
     newVaultPublicKey,
     vaultTypeAccountInfo.collateralMint
-  );
+  )
 
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
-    await getHedgeMintPublicKey()
-  );
-  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
-    hedgeStakingPoolPublicKey,
-    ushMintPublickey
-  );
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const feePoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, ushMintPublickey)
 
   console.log('about to start building transaction')
 
@@ -211,10 +168,10 @@ export async function buildCreateVaultTransaction(
         mint: TokenInstructions.WRAPPED_SOL_MINT,
         owner: payerPublicKey,
       })
-    );
-    signers.push(wrappedSolAccount);
+    )
+    signers.push(wrappedSolAccount)
   }
-  console.log("hedgeStakingPoolPublicKey", hedgeStakingPoolPublicKey.toString())
+  console.log('hedgeStakingPoolPublicKey', hedgeStakingPoolPublicKey.toString())
   transaction.add(
     await createVaultInstruction(
       program,
@@ -232,7 +189,7 @@ export async function buildCreateVaultTransaction(
       depositAmount,
       overrideTime
     )
-  );
+  )
   if (isWrappedSol) {
     transaction.add(
       TokenInstructions.closeAccount({
@@ -240,18 +197,18 @@ export async function buildCreateVaultTransaction(
         destination: payerPublicKey,
         owner: payerPublicKey,
       })
-    );
+    )
     transaction.partialSign(wrappedSolAccount)
   }
-  
+
   transaction.partialSign(history)
-  console.log("transaction", transaction)
+  console.log('transaction', transaction)
 
-  return [transaction, signers, newVaultPublicKey];
+  return [transaction, signers, newVaultPublicKey]
 }
 
 export async function createVaultInstruction(
-  program: Program,
+  program: Program<Vault>,
   salt: string,
   payerPublicKey: PublicKey,
   payerTokenAccountPublicKey: PublicKey,
@@ -266,32 +223,31 @@ export async function createVaultInstruction(
   depositAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
-  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
 
-  const ix = program.instruction.createVault(
-    salt,
-    new BN(depositAmount),
-    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        vaultTypeAccount: vaultTypeAccount,
-        vault: vaultPublicKey,
-        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-        feePool: feePool,
-        feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccount,
-        history: historyPublicKey,
-        payer: payerPublicKey,
-        payerTokenAccount: payerTokenAccountPublicKey,
-        collateralMint: collateralMint,
-        ushMint: ushMintPublickey,
-        systemProgram: SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        rent: SYSVAR_RENT_PUBKEY,
-      },
-      signers: [],
-    }
-  );
-  return ix;
+  const ix = program.methods
+    .createVault(
+      salt,
+      new BN(depositAmount),
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccount,
+      vault: vaultPublicKey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      feePool: feePool,
+      feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccount,
+      history: historyPublicKey,
+      payer: payerPublicKey,
+      payerTokenAccount: payerTokenAccountPublicKey,
+      collateralMint: collateralMint,
+      ushMint: ushMintPublickey,
+      systemProgram: SystemProgram.programId,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      rent: SYSVAR_RENT_PUBKEY,
+    })
+    .instruction()
+  return ix
 }

package/src/instructions/depositLiquidationPool.ts

@@ -1,18 +1,38 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
-import { getLiquidationPoolStatePublicKey, getLiquidationPoolUshAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import {
+  getLiquidationPoolStatePublicKey,
+  getLiquidationPoolUshAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function depositLiquidationPool (
-  program: Program,
+export async function depositLiquidationPool(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   depositAmount: number,
   overrideStartTime?: number
 ): Promise<PublicKey> {
   const ushMintPublickey = await getUshMintPublicKey()
-  const payerUshAccount = await getOrCreateAssociatedTokenAccount(provider.connection, payer, ushMintPublickey, payer.publicKey)
+  const payerUshAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    ushMintPublickey,
+    payer.publicKey
+  )
 
   const poolPosition = Keypair.generate()
   const transaction = new Transaction().add(
@@ -25,12 +45,12 @@ export async function depositLiquidationPool (
       overrideStartTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition]).catch(parseAnchorErrors)
   return poolPosition.publicKey
 }
 
-export async function depositLiquidationPoolInstruction (
-  program: Program,
+export async function depositLiquidationPoolInstruction(
+  program: Program<Vault>,
   payerPublicKey: PublicKey,
   payerUshAccount: PublicKey,
   poolPositionPublicKey: PublicKey,
@@ -45,23 +65,22 @@ export async function depositLiquidationPoolInstruction (
 
   const vaultSystemState = await getVaultSystemStatePublicKey()
 
-  return program.instruction.depositLiquidationPool(
-    new BN(depositAmount),
-    new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)), // override current time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemState,
-        poolState: liquidationPoolStatePublicKey,
-        poolEra: liquidationPoolState.currentEra,
-        poolPosition: poolPositionPublicKey,
-        poolUshAccount: poolUSHAccount,
-        ushMint: ushMint,
-        payer: payerPublicKey,
-        ownerUshAccount: payerUshAccount,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId,
-        rent: SYSVAR_RENT_PUBKEY
-      },
-      signers: []
+  return await program.methods
+    .depositLiquidationPool(
+      new BN(depositAmount),
+      new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemState,
+      poolState: liquidationPoolStatePublicKey,
+      poolUshAccount: poolUSHAccount,
+      poolEra: liquidationPoolState.currentEra,
+      poolPosition: poolPositionPublicKey,
+      ushMint: ushMint,
+      payer: payerPublicKey,
+      ownerUshAccount: payerUshAccount,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/instructions/depositStakingPool.ts

@@ -1,11 +1,21 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js'
 import { parseAnchorErrors } from '../utils/Errors'
 import { findAssociatedTokenAddress, getPoolPublicKeyForMint, getVaultSystemStatePublicKey } from '../Constants'
+import { Vault } from 'idl/vault'
 
-export async function depositStakingPool (
-  program: Program,
+export async function depositStakingPool(
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   mintPublicKey: PublicKey,
@@ -23,12 +33,12 @@ export async function depositStakingPool (
       overrideStartTime
     )
   )
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition]).catch(parseAnchorErrors)
   return poolPosition.publicKey
 }
 
-export async function depositStakingPoolInstruction (
-  program: Program,
+export async function depositStakingPoolInstruction(
+  program: Program<Vault>,
   payerPublicKey: PublicKey,
   poolPositionPublicKey: PublicKey,
   stakedTokenMintPublicKey: PublicKey,
@@ -40,23 +50,21 @@ export async function depositStakingPoolInstruction (
   const payersArbitraryTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey)
   const vaultSystemState = await getVaultSystemStatePublicKey()
 
-  return program.instruction.depositStakingPool(
-    new BN(depositAmount),
-    new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)), // override current time
-    {
-      accounts: {
-        payer: payerPublicKey,
-        vaultSystemState: vaultSystemState,
-        pool: poolPublickey,
-        poolPosition: poolPositionPublicKey,
-        stakedTokenMintInfo: stakedTokenMintPublicKey,
-        poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
-        payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
-        rent: SYSVAR_RENT_PUBKEY,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .depositStakingPool(
+      new BN(depositAmount),
+      new BN(overrideStartTime ?? Math.floor(Date.now() / 1000)) // override current time
+    )
+    .accounts({
+      payer: payerPublicKey,
+      vaultSystemState: vaultSystemState,
+      pool: poolPublickey,
+      poolPosition: poolPositionPublicKey,
+      stakedTokenMintInfo: stakedTokenMintPublicKey,
+      poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+      payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }