hedge-web3 0.1.29 → 0.1.31

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()
 }

package/src/instructions/depositVault.ts

@@ -1,9 +1,6 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { TokenInstructions } from '@project-serum/serum'
-import {
-  getOrCreateAssociatedTokenAccount,
-  TOKEN_PROGRAM_ID,
-} from '@solana/spl-token'
+import { getOrCreateAssociatedTokenAccount, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import {
   Keypair,
   PublicKey,
@@ -22,9 +19,10 @@ import {
   getPoolPublicKeyForMint,
   getHedgeMintPublicKey,
 } from '../Constants'
+import { Vault } from 'idl/vault'
 
 export async function depositVault(
-  program: Program,
+  program: Program<Vault>,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
@@ -34,67 +32,49 @@ export async function depositVault(
   const ushMintPublickey = await getUshMintPublicKey()
 
   // 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 vaultAccount = await program.account.vault.fetch(vaultPublicKey)
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
-    vaultAccount.collateralType
-  )
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
-    vaultTypeAccountPublicKey
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(vaultAccount.collateralType)
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const vaultTypeAssociatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    vaultTypeAccountInfo.collateralMint,
+    vaultTypeAccountPublicKey,
+    true
   )
-  const vaultTypeAssociatedTokenAccount =
-    await getOrCreateAssociatedTokenAccount(
-      provider.connection,
-      payer,
-      vaultTypeAccountInfo.collateralMint,
-      vaultTypeAccountPublicKey,
-      true
-    )
 
-  const payerTokenAccount = await findAssociatedTokenAddress(
-    payer.publicKey,
+  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, vaultTypeAccountInfo.collateralMint)
+  const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(
+    vaultPublicKey,
     vaultTypeAccountInfo.collateralMint
   )
-  const vaultAssociatedCollateralAccountPublicKey =
-    await findAssociatedTokenAddress(
-      vaultPublicKey,
-      vaultTypeAccountInfo.collateralMint
-    )
 
   const history = Keypair.generate()
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
 
   const wrappedSolAccount = Keypair.generate()
 
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
-    await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const hedgeStakingPoolAssociatedUshTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    ushMintPublickey
   )
-  const hedgeStakingPoolAssociatedUshTokenAccount =
-    await findAssociatedTokenAddress(
-      hedgeStakingPoolPublicKey,
-      ushMintPublickey
-    )
 
   const transaction = new Transaction()
   const signers = [payer, history]
 
-  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] =
-    await getLinkedListAccounts(
-      program,
-      provider,
-      vaultTypeAccountPublicKey,
-      vaultPublicKey,
-      depositAmount,
-      0,
-      false,
-      false
-    )
+  const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = await getLinkedListAccounts(
+    program,
+    provider,
+    vaultTypeAccountPublicKey,
+    vaultPublicKey,
+    depositAmount,
+    0,
+    false,
+    false
+  )
 
   if (vaultAccount.collateralType === 'SOL') {
     transaction.add(
@@ -118,9 +98,7 @@ export async function depositVault(
       program,
       vaultSystemStatePublicKey,
       payer.publicKey,
-      vaultAccount.collateralType === 'SOL'
-        ? wrappedSolAccount.publicKey
-        : payerTokenAccount,
+      vaultAccount.collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount,
       vaultPublicKey,
       vaultAssociatedCollateralAccountPublicKey,
       history.publicKey,
@@ -147,17 +125,12 @@ export async function depositVault(
     )
   }
 
-  await sendAndConfirmTransaction(
-    provider.connection,
-    transaction,
-    signers,
-    provider.opts
-  )
+  await sendAndConfirmTransaction(provider.connection, transaction, signers)
   return vaultPublicKey
 }
 
 export async function depositVaultInstruction(
-  program: Program,
+  program: Program<Vault>,
   vaultSystemStatePublicKey: PublicKey,
   vaultOwner: PublicKey,
   vaultOwnerTokenAccount: PublicKey,
@@ -176,31 +149,29 @@ export async function depositVaultInstruction(
   depositAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
-  return program.instruction.depositVault(
-    new BN(depositAmount),
-    new BN(overrideTime ?? Math.floor(Date.now() / 1000)), // override override time
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        vaultTypeAccount: vaultTypeAccountPublicKey,
-        vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
-        collateralTokenMint: collateralMint,
-        vault: vaultPublicKey,
-        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-        feePool: hedgeStakingPoolPublicKey,
-        feePoolAssociatedUshTokenAccount:
-          hedgeStakingPoolAssociatedUshTokenAccount,
-        history: historyPublicKey,
-        vaultOwner: vaultOwner,
-        vaultOwnerTokenAccount: vaultOwnerTokenAccount,
-        ushMint: ushMintPublickey,
-        oldSmallerVaultInfo: oldSmallerPublicKey,
-        newSmallerVaultInfo: newSmallerPublicKey,
-        newLargerVaultInfo: newLargerPublicKey,
-        systemProgram: SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-      },
-      signers: [],
-    }
-  )
+  return await program.methods
+    .depositVault(
+      new BN(depositAmount),
+      new BN(overrideTime ?? Math.floor(Date.now() / 1000)) // override override time
+    )
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      vaultTypeAccount: vaultTypeAccountPublicKey,
+      vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+      collateralTokenMint: collateralMint,
+      vault: vaultPublicKey,
+      vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+      feePool: hedgeStakingPoolPublicKey,
+      feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+      history: historyPublicKey,
+      vaultOwner: vaultOwner,
+      vaultOwnerTokenAccount: vaultOwnerTokenAccount,
+      ushMint: ushMintPublickey,
+      oldSmallerVaultInfo: oldSmallerPublicKey,
+      newSmallerVaultInfo: newSmallerPublicKey,
+      newLargerVaultInfo: newLargerPublicKey,
+      systemProgram: SystemProgram.programId,
+      tokenProgram: TOKEN_PROGRAM_ID,
+    })
+    .instruction()
 }

package/src/instructions/initHedgeFoundation.ts

@@ -1,64 +1,63 @@
 import { 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, getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUshAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
-
-export async function initHedgeFoundation(
-  program: Program,
-  provider: Provider,
-  payer: Signer
-): Promise<PublicKey> {
+import {
+  findAssociatedTokenAddress,
+  getHedgeMintPublicKey,
+  getLiquidationPoolStatePublicKey,
+  getLiquidationPoolUshAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
+import { Vault } from 'idl/vault'
 
+export async function initHedgeFoundation(program: Program<Vault>, provider: Provider, payer: Signer): Promise<PublicKey> {
   const poolEra = Keypair.generate()
   const transaction = new Transaction().add(
-    await initHedgeFoundationInstruction(
-      program,
-      poolEra.publicKey,
-      payer.publicKey,
-    )
+    await initHedgeFoundationInstruction(program, poolEra.publicKey, payer.publicKey)
   )
 
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolEra], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, poolEra]).catch(parseAnchorErrors)
   return payer.publicKey
 }
 
-export async function initHedgeFoundationInstruction (
-  program: Program,
+export async function initHedgeFoundationInstruction(
+  program: Program<Vault>,
   poolEraPublicKey: PublicKey,
-  payerPublicKey: PublicKey,
+  payerPublicKey: PublicKey
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const poolStatePublickey = await getLiquidationPoolStatePublicKey()
   const poolUshTokenAccount = await getLiquidationPoolUshAccountPublicKey()
   const ushMintPublickey = await getUshMintPublicKey()
   const hedgeMintPublickey = await getHedgeMintPublicKey()
-  const founderHedgeTokenAccount = await findAssociatedTokenAddress(
-    payerPublicKey,
-    hedgeMintPublickey
-  )
-  const communityHedgeTokenAccount = await findAssociatedTokenAddress(
-    vaultSystemStatePublicKey,
-    hedgeMintPublickey
-  )
+  const founderHedgeTokenAccount = await findAssociatedTokenAddress(payerPublicKey, hedgeMintPublickey)
+  const communityHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMintPublickey)
 
-  return program.instruction.initHedgeFoundation(
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        poolState: poolStatePublickey,
-        poolEra: poolEraPublicKey,
-        poolUshAccount: poolUshTokenAccount,
-        founder: payerPublicKey,
-        ushMint: ushMintPublickey,
-        hedgeMint: hedgeMintPublickey,
-        founderAssociatedHedgeTokenAccount: founderHedgeTokenAccount,
-        communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
-        rent: SYSVAR_RENT_PUBKEY,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .initHedgeFoundation()
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      poolState: poolStatePublickey,
+      poolEra: poolEraPublicKey,
+      poolUshAccount: poolUshTokenAccount,
+      founder: payerPublicKey,
+      ushMint: ushMintPublickey,
+      hedgeMint: hedgeMintPublickey,
+      rent: SYSVAR_RENT_PUBKEY,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }

package/src/instructions/initHedgeFoundationTokens.ts

@@ -1,55 +1,54 @@
 import { 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, getHedgeMintPublicKey, getLiquidationPoolStatePublicKey, getLiquidationPoolUshAccountPublicKey, getUshMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
-
-export async function initHedgeFoundationTokens(
-  program: Program,
-  provider: Provider,
-  payer: Signer
-): Promise<PublicKey> {
+import {
+  findAssociatedTokenAddress,
+  getHedgeMintPublicKey,
+  getLiquidationPoolStatePublicKey,
+  getLiquidationPoolUshAccountPublicKey,
+  getUshMintPublicKey,
+  getVaultSystemStatePublicKey,
+} from '../Constants'
 
+export async function initHedgeFoundationTokens(program: Program, provider: Provider, payer: Signer): Promise<PublicKey> {
   const poolEra = Keypair.generate()
-  const transaction = new Transaction().add(
-    await initHedgeFoundationTokensInstruction(
-      program,
-      payer.publicKey,
-    )
-  )
+  const transaction = new Transaction().add(await initHedgeFoundationTokensInstruction(program, payer.publicKey))
 
-  await sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors)
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer]).catch(parseAnchorErrors)
   return payer.publicKey
 }
 
-export async function initHedgeFoundationTokensInstruction (
+export async function initHedgeFoundationTokensInstruction(
   program: Program,
-  payerPublicKey: PublicKey,
+  payerPublicKey: PublicKey
 ): Promise<TransactionInstruction> {
   const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
   const hedgeMintPublickey = await getHedgeMintPublicKey()
-  const founderHedgeTokenAccount = await findAssociatedTokenAddress(
-    payerPublicKey,
-    hedgeMintPublickey
-  )
-  const communityHedgeTokenAccount = await findAssociatedTokenAddress(
-    vaultSystemStatePublicKey,
-    hedgeMintPublickey
-  )
+  const founderHedgeTokenAccount = await findAssociatedTokenAddress(payerPublicKey, hedgeMintPublickey)
+  const communityHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMintPublickey)
 
-  return program.instruction.initHedgeFoundationTokens(
-    {
-      accounts: {
-        vaultSystemState: vaultSystemStatePublicKey,
-        founder: payerPublicKey,
-        hedgeMint: hedgeMintPublickey,
-        founderAssociatedHedgeTokenAccount: founderHedgeTokenAccount,
-        communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
-        rent: SYSVAR_RENT_PUBKEY,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId
-      },
-      signers: []
+  return await program.methods
+    .initHedgeFoundationTokens()
+    .accounts({
+      vaultSystemState: vaultSystemStatePublicKey,
+      founder: payerPublicKey,
+      hedgeMint: hedgeMintPublickey,
+      founderAssociatedHedgeTokenAccount: founderHedgeTokenAccount,
+      communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
+      rent: SYSVAR_RENT_PUBKEY,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
     })
+    .instruction()
 }