Sdk 331 account management should be moved to instruments

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

@@ -1,86 +1,21 @@
-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) {
   return serializeAsLeg(legInstrument).length;
 }
 
-export function getProgramAccount(legInstrument: LegInstrument): AccountMeta {
-  return {
-    pubkey: legInstrument.getProgramId(),
-    isSigner: false,
-    isWritable: false,
-  };
-}
-
-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

@@ -6,7 +6,7 @@ import { Convergence } from '../../Convergence';
 import { LegSide } from '../rfqModule/models/LegSide';
 
 export interface LegInstrumentParser {
-  parseFromLeg(convergence: Convergence, leg: Leg): LegInstrument;
+  parseFromLeg(convergence: Convergence, leg: Leg): Promise<LegInstrument>;
 }
 
 export type CreateOptionInstrumentsResult = TransactionInstruction[];
@@ -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/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
     );
   },
 };