Sdk 331 account management should be moved to instruments

packages/js/src/plugins/instrumentModule/methods.ts

@@ -1,32 +1,12 @@
-import { Leg, QuoteAsset, legBeet } from '@convergence-rfq/rfq';
+import { QuoteAsset, legBeet } from '@convergence-rfq/rfq';
 
 import { AccountMeta } from '@solana/web3.js';
 import { createSerializerFromFixableBeetArgsStruct } from '../../types';
-import { addDecimals } from '../../utils/conversions';
-import { toSolitaLegSide } from '../rfqModule/models/LegSide';
-import { PsyoptionsEuropeanInstrument } from '../psyoptionsEuropeanInstrumentModule';
-import { PsyoptionsAmericanInstrument } from '../psyoptionsAmericanInstrumentModule';
-import { SpotLegInstrument } from '../spotInstrumentModule';
 import { LegInstrument, QuoteInstrument } from './types';
-import { Convergence } from '@/Convergence';
-
-export function toLeg(legInstrument: LegInstrument): Leg {
-  return {
-    instrumentProgram: legInstrument.getProgramId(),
-    baseAssetIndex: legInstrument.getBaseAssetIndex(),
-    instrumentData: legInstrument.serializeInstrumentData(),
-    instrumentAmount: addDecimals(
-      legInstrument.getAmount(),
-      legInstrument.getDecimals()
-    ),
-    instrumentDecimals: legInstrument.getDecimals(),
-    side: toSolitaLegSide(legInstrument.getSide()),
-  };
-}
 
 export function serializeAsLeg(legInstrument: LegInstrument) {
   const legSerializer = createSerializerFromFixableBeetArgsStruct(legBeet);
-  return legSerializer.serialize(toLeg(legInstrument));
+  return legSerializer.serialize(legInstrument.toLeg());
 }
 
 export function getSerializedLegLength(legInstrument: LegInstrument) {
@@ -41,46 +21,10 @@ export function getProgramAccount(legInstrument: LegInstrument): AccountMeta {
   };
 }
 
-export function getValidationAccounts(
-  legInstrument: LegInstrument
-): AccountMeta[] {
-  return [getProgramAccount(legInstrument)].concat(
-    legInstrument.getValidationAccounts()
-  );
-}
-
 export function toQuote(legInstrument: QuoteInstrument): QuoteAsset {
   return {
     instrumentProgram: legInstrument.getProgramId(),
     instrumentData: legInstrument.serializeInstrumentData(),
     instrumentDecimals: legInstrument.getDecimals(),
   };
 }
-
-//TODO: refactor this method to use instrument interface in the future
-export const legToBaseAssetMint = async (
-  convergence: Convergence,
-  leg: LegInstrument
-) => {
-  if (leg instanceof PsyoptionsEuropeanInstrument) {
-    const euroMetaOptionMint = await convergence.tokens().findMintByAddress({
-      address: leg.optionMint,
-    });
-
-    return euroMetaOptionMint;
-  } else if (leg instanceof PsyoptionsAmericanInstrument) {
-    const americanOptionMint = await convergence.tokens().findMintByAddress({
-      address: leg.optionMint,
-    });
-
-    return americanOptionMint;
-  } else if (leg instanceof SpotLegInstrument) {
-    const mint = await convergence.tokens().findMintByAddress({
-      address: leg.mintAddress,
-    });
-
-    return mint;
-  }
-
-  throw Error('Unsupported instrument!');
-};

packages/js/src/plugins/instrumentModule/plugin.ts

@@ -26,7 +26,7 @@ export const instrumentModule = (): ConvergencePlugin => ({
       legInstrumentParsers.push([programAddress, factory]);
     };
 
-    convergence.parseLegInstrument = function (leg: SolitaLeg) {
+    convergence.parseLegInstrument = async function (leg: SolitaLeg) {
       const factory = legInstrumentParsers.find(([key]) =>
         leg.instrumentProgram.equals(key)
       )?.[1];
@@ -48,7 +48,7 @@ declare module '../../Convergence' {
       programAddress: PublicKey,
       factory: LegInstrumentParser
     ): void;
-    parseLegInstrument(leg: SolitaLeg): LegInstrument;
+    parseLegInstrument(leg: SolitaLeg): Promise<LegInstrument>;
   }
 }
 

packages/js/src/plugins/instrumentModule/types.ts

@@ -18,8 +18,13 @@ export interface LegInstrument {
   getDecimals: () => number;
   getSide: () => LegSide;
   serializeInstrumentData: () => Buffer;
+  getBaseAssetMint(): PublicKey;
+  getBaseAssetAccount(): AccountMeta;
+  getOracleAccount(): Promise<AccountMeta>;
   getValidationAccounts(): AccountMeta[];
   getPreparationsBeforeRfqCreation(): Promise<CreateOptionInstrumentsResult>;
+  getUnderlyingBaseAssetMint(): PublicKey;
+  toLeg(): Leg;
 }
 
 // TODO add registration of quote instruments

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

@@ -72,13 +72,20 @@ export const prepareAmericanOptions = async (
     ) {
       ataTxBuilderArray.push(underlyingToken.txBuilder);
     }
+    const { tokenBalance } = await convergence.tokens().getTokenBalance({
+      mintAddress: optionMarket.optionMint,
+      owner: caller,
+      mintDecimals: PsyoptionsAmericanInstrument.decimals,
+    });
+
+    const tokensToMint = amount - tokenBalance;
     const ixWithSigners =
       await psyoptionsAmerican.instructions.mintOptionInstruction(
         americanProgram,
         optionToken.ataPubKey,
         writerToken.ataPubKey,
         underlyingToken.ataPubKey,
-        new BN(amount!),
+        new BN(tokensToMint!),
         optionMarket as psyoptionsAmerican.OptionMarketWithKey
       );
     ixWithSigners.ix.keys[0] = {

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

@@ -1,4 +1,9 @@
-import { Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import {
+  AccountMeta,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+} from '@solana/web3.js';
 import { Leg, BaseAssetIndex } from '@convergence-rfq/rfq';
 import { OptionMarketWithKey } from '@mithraic-labs/psy-american';
 import { OptionType } from '@mithraic-labs/tokenized-euros';
@@ -15,7 +20,11 @@ import {
 import { addDecimals, removeDecimals } from '../../utils/conversions';
 import { Convergence } from '../../Convergence';
 import { createSerializerFromFixableBeetArgsStruct } from '../../types';
-import { LegSide, fromSolitaLegSide } from '../rfqModule/models/LegSide';
+import {
+  LegSide,
+  fromSolitaLegSide,
+  toSolitaLegSide,
+} from '../rfqModule/models/LegSide';
 import { CvgWallet, NoopWallet } from '../../utils/Wallets';
 import {
   GetOrCreateATAtxBuilderReturnType,
@@ -66,14 +75,25 @@ export class PsyoptionsAmericanInstrument implements LegInstrument {
     readonly baseAssetIndex: BaseAssetIndex,
     readonly amount: number,
     readonly side: LegSide,
-    readonly underlyingAssetMint?: PublicKey,
-    readonly stableAssetMint?: PublicKey
+    readonly underlyingAssetMint: PublicKey,
+    readonly stableAssetMint: PublicKey
   ) {}
 
-  getBaseAssetIndex = () => this.baseAssetIndex;
   getAmount = () => this.amount;
+  getBaseAssetIndex = () => this.baseAssetIndex;
   getDecimals = () => PsyoptionsAmericanInstrument.decimals;
   getSide = () => this.side;
+  toLeg(): Leg {
+    return {
+      instrumentProgram: this.getProgramId(),
+      baseAssetIndex: this.getBaseAssetIndex(),
+      instrumentData: this.serializeInstrumentData(),
+      instrumentAmount: addDecimals(this.getAmount(), this.getDecimals()),
+      instrumentDecimals: this.getDecimals(),
+      side: toSolitaLegSide(this.getSide()),
+    };
+  }
+
   async getPreparationsBeforeRfqCreation(): Promise<CreateOptionInstrumentsResult> {
     if (!this.underlyingAssetMint) {
       throw new Error('Missing underlying asset mint');
@@ -94,6 +114,48 @@ export class PsyoptionsAmericanInstrument implements LegInstrument {
     );
     return optionMarketIxs;
   }
+  getBaseAssetAccount(): AccountMeta {
+    const baseAsset = this.convergence
+      .protocol()
+      .pdas()
+      .baseAsset({ index: this.baseAssetIndex.value });
+
+    const baseAssetAccount: AccountMeta = {
+      pubkey: baseAsset,
+      isSigner: false,
+      isWritable: false,
+    };
+
+    return baseAssetAccount;
+  }
+  getBaseAssetMint(): PublicKey {
+    return this.optionMint;
+  }
+
+  getUnderlyingBaseAssetMint(): PublicKey {
+    return this.underlyingAssetMint;
+  }
+
+  async getOracleAccount(): Promise<AccountMeta> {
+    const baseAsset = this.convergence
+      .protocol()
+      .pdas()
+      .baseAsset({ index: this.baseAssetIndex.value });
+
+    const baseAssetModel = await this.convergence
+      .protocol()
+      .findBaseAssetByAddress({ address: baseAsset });
+
+    if (!baseAssetModel.priceOracle.address) {
+      throw Error('Base asset does not have a price oracle!');
+    }
+    const oracleAccount = {
+      pubkey: baseAssetModel.priceOracle.address,
+      isSigner: false,
+      isWritable: false,
+    };
+    return oracleAccount;
+  }
 
   static async create(
     convergence: Convergence,
@@ -186,6 +248,11 @@ export class PsyoptionsAmericanInstrument implements LegInstrument {
       .pdas()
       .mintInfo({ mint: this.stableAssetMint });
     return [
+      {
+        pubkey: this.getProgramId(),
+        isSigner: false,
+        isWritable: false,
+      },
       { pubkey: this.optionMetaPubKey, isSigner: false, isWritable: false },
       {
         pubkey: mintInfoPda,
@@ -237,10 +304,10 @@ export class PsyoptionsAmericanInstrument implements LegInstrument {
 }
 
 export const psyoptionsAmericanInstrumentParser = {
-  parseFromLeg(
+  async parseFromLeg(
     convergence: Convergence,
     leg: Leg
-  ): PsyoptionsAmericanInstrument {
+  ): Promise<PsyoptionsAmericanInstrument> {
     const { side, instrumentAmount, instrumentData, baseAssetIndex } = leg;
     const [
       {
@@ -257,6 +324,11 @@ export const psyoptionsAmericanInstrumentParser = {
       Buffer.from(instrumentData)
     );
 
+    const optionMeta = await PsyoptionsAmericanInstrument.fetchMeta(
+      convergence,
+      metaKey
+    );
+
     return new PsyoptionsAmericanInstrument(
       convergence,
       optionType,
@@ -272,7 +344,9 @@ export const psyoptionsAmericanInstrumentParser = {
       metaKey,
       baseAssetIndex,
       removeDecimals(instrumentAmount, PsyoptionsAmericanInstrument.decimals),
-      fromSolitaLegSide(side)
+      fromSolitaLegSide(side),
+      optionMeta.underlyingAssetMint,
+      optionMeta.quoteAssetMint
     );
   },
 };

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

@@ -86,14 +86,26 @@ export const prepareEuropeanOptions = async (
     ) {
       ataTxBuilderArray.push(writerDestination.txBuilder);
     }
+
+    const { tokenBalance } = await convergence.tokens().getTokenBalance({
+      mintAddress:
+        leg.optionType == psyoptionsEuropean.OptionType.PUT
+          ? euroMeta.putOptionMint
+          : euroMeta.callOptionMint,
+      owner: caller,
+      mintDecimals: PsyoptionsEuropeanInstrument.decimals,
+    });
+
+    const tokensToMint = amount - tokenBalance;
+
     const { instruction: ix } = psyoptionsEuropean.instructions.mintOptions(
       europeanProgram,
       leg.optionMetaPubKey,
       euroMeta as psyoptionsEuropean.EuroMeta,
       minterCollateralKey,
       optionDestination.ataPubKey,
       writerDestination.ataPubKey,
-      addDecimals(amount, PsyoptionsEuropeanInstrument.decimals),
+      addDecimals(tokensToMint, PsyoptionsEuropeanInstrument.decimals),
       leg.optionType
     );