Sdk 372 preparesettlement should calculate needed atas create atas

packages/js/src/plugins/psyoptionsAmericanInstrumentModule/helpers.ts

@@ -1,25 +1,31 @@
 import * as psyoptionsAmerican from '@mithraic-labs/psy-american';
 
 import { BN } from 'bn.js';
-import { PublicKey } from '@solana/web3.js';
+import {
+  PublicKey,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js';
 import { Convergence } from '../../Convergence';
 
-import { ATAExistence, getOrCreateATA } from '../../utils/ata';
+import {
+  ATAExistence,
+  getOrCreateATA,
+  getOrCreateATAtxBuilder,
+} from '../../utils/ata';
 import { Mint } from '../tokenModule/models';
+import { TransactionBuilder } from '../../utils/TransactionBuilder';
 import { CvgWallet } from '../../utils/Wallets';
-import {
-  InstructionWithSigners,
-  TransactionBuilder,
-} from '../../utils/TransactionBuilder';
 import { PsyoptionsAmericanInstrument } from './types';
 import { createAmericanProgram } from './instrument';
 
 export const mintAmericanOptions = async (
   convergence: Convergence,
   responseAddress: PublicKey,
-  caller: PublicKey,
-  americanProgram: any
+  caller: PublicKey
 ) => {
+  const cvgWallet = new CvgWallet(convergence);
+  const americanProgram = createAmericanProgram(convergence, cvgWallet);
   const response = await convergence
     .rfqs()
     .findResponseByAddress({ address: responseAddress });
@@ -28,46 +34,51 @@ export const mintAmericanOptions = async (
     .findRfqByAddress({ address: response.rfq });
 
   const callerSide = caller.equals(rfq.taker) ? 'taker' : 'maker';
-  const instructionWithSigners: InstructionWithSigners[] = [];
-  const { legs } = await convergence.rfqs().getSettlementResult({
+
+  const { legs } = convergence.rfqs().getSettlementResult({
     response,
     rfq,
   });
+
+  const ataTxBuilderArray: TransactionBuilder[] = [];
+  const mintTxBuilderArray: TransactionBuilder[] = [];
   for (const [index, leg] of rfq.legs.entries()) {
+    const mintInstructions: TransactionInstruction[] = [];
     if (leg instanceof PsyoptionsAmericanInstrument) {
-      const { receiver } = legs[index];
+      const { receiver, amount } = legs[index];
       if (receiver !== callerSide) {
-        const { amount } = legs[index];
-
-        const optionMarket = await psyoptionsAmerican.getOptionByKey(
-          americanProgram,
-          leg.optionMetaPubKey
-        );
+        const optionMarket = await leg.getOptionMeta();
         if (optionMarket) {
-          const optionToken = await getOrCreateATA(
+          const optionToken = await getOrCreateATAtxBuilder(
             convergence,
             optionMarket.optionMint,
             caller
           );
-
-          const writerToken = await getOrCreateATA(
+          if (optionToken.txBuilder) {
+            ataTxBuilderArray.push(optionToken.txBuilder);
+          }
+          const writerToken = await getOrCreateATAtxBuilder(
             convergence,
             optionMarket!.writerTokenMint,
             caller
           );
-
-          const underlyingToken = await getOrCreateATA(
+          if (writerToken.txBuilder) {
+            ataTxBuilderArray.push(writerToken.txBuilder);
+          }
+          const underlyingToken = await getOrCreateATAtxBuilder(
             convergence,
             optionMarket!.underlyingAssetMint,
             caller
           );
-
+          if (underlyingToken.txBuilder) {
+            ataTxBuilderArray.push(underlyingToken.txBuilder);
+          }
           const ixWithSigners =
             await psyoptionsAmerican.instructions.mintOptionV2Instruction(
               americanProgram,
-              optionToken,
-              writerToken,
-              underlyingToken,
+              optionToken.ataPubKey,
+              writerToken.ataPubKey,
+              underlyingToken.ataPubKey,
               new BN(amount!),
               optionMarket as psyoptionsAmerican.OptionMarketWithKey
             );
@@ -76,23 +87,55 @@ export const mintAmericanOptions = async (
             isSigner: true,
             isWritable: false,
           };
-          instructionWithSigners.push({
-            instruction: ixWithSigners.ix,
-            signers: ixWithSigners.signers,
-          });
+          mintInstructions.push(ixWithSigners.ix);
         }
       }
     }
+    if (mintInstructions.length > 0) {
+      const txBuilder = TransactionBuilder.make().setFeePayer(
+        convergence.rpc().getDefaultFeePayer()
+      );
+      mintInstructions.forEach((ins) => {
+        txBuilder.add({
+          instruction: ins,
+          signers: [convergence.identity()],
+        });
+      });
+      mintTxBuilderArray.push(txBuilder);
+    }
+  }
+  let signedTxs: Transaction[] = [];
+  if (ataTxBuilderArray.length > 0 || mintTxBuilderArray.length > 0) {
+    const mergedTxBuilderArray = ataTxBuilderArray.concat(mintTxBuilderArray);
+    const lastValidBlockHeight = await convergence.rpc().getLatestBlockhash();
+    signedTxs = await convergence
+      .identity()
+      .signAllTransactions(
+        mergedTxBuilderArray.map((b) => b.toTransaction(lastValidBlockHeight))
+      );
   }
-  if (instructionWithSigners.length > 0) {
-    const payer = convergence.rpc().getDefaultFeePayer();
-    const txBuilder = TransactionBuilder.make().setFeePayer(payer);
 
-    txBuilder.add(...instructionWithSigners);
-    const sig = await txBuilder.sendAndConfirm(convergence);
-    return sig;
+  const ataSignedTx = signedTxs.slice(0, ataTxBuilderArray.length);
+  const mintSignedTx = signedTxs.slice(ataTxBuilderArray.length);
+
+  if (ataSignedTx.length > 0) {
+    const lastValidBlockHeight = await convergence.rpc().getLatestBlockhash();
+    ataSignedTx.map(
+      async (signedTx) =>
+        await convergence
+          .rpc()
+          .serializeAndSendTransaction(signedTx, lastValidBlockHeight)
+    );
+  }
+  if (mintSignedTx.length > 0) {
+    const lastValidBlockHeight = await convergence.rpc().getLatestBlockhash();
+    mintSignedTx.map(
+      async (signedTx) =>
+        await convergence
+          .rpc()
+          .serializeAndSendTransaction(signedTx, lastValidBlockHeight)
+    );
   }
-  return null;
 };
 
 export const initializeNewAmericanOption = async (
@@ -112,10 +155,8 @@ export const initializeNewAmericanOption = async (
     Number(underlyingAmountPerContract) * Math.pow(10, underlyingMint.decimals)
   );
 
-  const americanProgram = createAmericanProgram(
-    convergence,
-    new CvgWallet(convergence)
-  );
+  const cvgWallet = new CvgWallet(convergence);
+  const americanProgram = createAmericanProgram(convergence, cvgWallet);
 
   const { optionMarketKey, optionMintKey, writerMintKey } =
     await psyoptionsAmerican.instructions.initializeMarket(americanProgram, {

packages/js/src/plugins/psyoptionsAmericanInstrumentModule/instrument.ts

@@ -113,7 +113,8 @@ export class PsyoptionsAmericanInstrument implements LegInstrument {
     convergence: Convergence,
     metaKey: PublicKey
   ): Promise<OptionMarketWithKey> {
-    const americanProgram = createAmericanProgram(convergence);
+    const cvgWallet = new CvgWallet(convergence);
+    const americanProgram = createAmericanProgram(convergence, cvgWallet);
     const optionMarket = (await psyoptionsAmerican.getOptionByKey(
       americanProgram,
       metaKey

packages/js/src/plugins/psyoptionsEuropeanInstrumentModule/classes.ts

@@ -0,0 +1,49 @@
+import { AccountMeta, TransactionInstruction } from '@solana/web3.js';
+
+export class InstructionUniquenessTracker {
+  constructor(public readonly IxArray: TransactionInstruction[]) {
+    this.IxArray = IxArray;
+  }
+
+  private matchKeys = (
+    keys: AccountMeta[],
+    keysToMatch: AccountMeta[]
+  ): boolean => {
+    let matching = true;
+    if (keys.length !== keysToMatch.length) {
+      return false;
+    }
+    for (let i = 0; i < keys.length; i++) {
+      if (
+        keys[i].isSigner !== keysToMatch[i].isSigner ||
+        keys[i].isWritable !== keysToMatch[i].isWritable ||
+        !keys[i].pubkey.equals(keysToMatch[i].pubkey)
+      ) {
+        matching = false;
+        break;
+      }
+    }
+    return matching;
+  };
+  private matchInstruction = (ixToBeAdded: TransactionInstruction): boolean => {
+    let match = false;
+    this.IxArray.forEach((ix) => {
+      if (
+        this.matchKeys(ix.keys, ixToBeAdded.keys) &&
+        ix.programId.equals(ixToBeAdded.programId) &&
+        ix.data.equals(ixToBeAdded.data)
+      ) {
+        match = true;
+        return match;
+      }
+    });
+    return match;
+  };
+  checkedAdd(ix: TransactionInstruction): boolean {
+    if (!this.matchInstruction(ix)) {
+      this.IxArray.push(ix);
+      return true;
+    }
+    return false;
+  }
+}