Instruction Plan prototype

clients/js/src/createMetadata.ts

@@ -1,173 +1,128 @@
 import { getTransferSolInstruction } from '@solana-program/system';
 import {
-  CompilableTransactionMessage,
   GetMinimumBalanceForRentExemptionApi,
   Lamports,
+  ReadonlyUint8Array,
   Rpc,
+  TransactionSigner,
 } from '@solana/kit';
 import {
   getAllocateInstruction,
   getInitializeInstruction,
+  InitializeInput,
   PROGRAM_METADATA_PROGRAM_ADDRESS,
 } from './generated';
 import {
-  getTransactionMessageFromPlan,
-  InstructionPlan,
-  MessageInstructionPlan,
+  createDefaultTransactionPlanExecutor,
+  createDefaultTransactionPlanner,
+  parallelInstructionPlan,
+  sequentialInstructionPlan,
 } from './instructionPlans';
 import {
-  calculateMaxChunkSize,
-  getComputeUnitInstructions,
-  getExtendedMetadataInput,
   getExtendInstructionPlan,
-  getMetadataInstructionPlanExecutor,
+  getPdaDetails,
   getWriteInstructionPlan,
-  messageFitsInOneTransaction,
-  PdaDetails,
   REALLOC_LIMIT,
 } from './internals';
 import { getAccountSize, MetadataInput, MetadataResponse } from './utils';
 
 export async function createMetadata(
-  input: MetadataInput
-): Promise<MetadataResponse> {
-  const extendedInput = await getExtendedMetadataInput(input);
-  const executor = getMetadataInstructionPlanExecutor(extendedInput);
-  const plan = await getCreateMetadataInstructionPlan(extendedInput);
-  return await executor(plan);
-}
-
-export async function getCreateMetadataInstructionPlan(
-  input: Omit<MetadataInput, 'rpc' | 'rpcSubscriptions'> &
-    PdaDetails & {
-      rpc: Rpc<GetMinimumBalanceForRentExemptionApi>;
-      defaultMessage: CompilableTransactionMessage;
-    }
-): Promise<InstructionPlan> {
-  const rent = await input.rpc
-    .getMinimumBalanceForRentExemption(getAccountSize(input.data.length))
-    .send();
-  const planUsingInstructionData =
-    getCreateMetadataInstructionPlanUsingInstructionData({ ...input, rent });
-  const messageUsingInstructionData = getTransactionMessageFromPlan(
-    input.defaultMessage,
-    planUsingInstructionData
-  );
-  const useBuffer =
-    input.buffer === undefined
-      ? !messageFitsInOneTransaction(messageUsingInstructionData)
-      : !!input.buffer;
-
-  if (!useBuffer) {
-    return planUsingInstructionData;
+  input: MetadataInput & {
+    rpc: Rpc<GetMinimumBalanceForRentExemptionApi> &
+      Parameters<typeof createDefaultTransactionPlanExecutor>[0]['rpc'];
+    rpcSubscriptions: Parameters<
+      typeof createDefaultTransactionPlanExecutor
+    >[0]['rpcSubscriptions'];
   }
-
-  const chunkSize = calculateMaxChunkSize(input.defaultMessage, {
-    ...input,
-    buffer: input.metadata,
+): Promise<MetadataResponse> {
+  const planner = createDefaultTransactionPlanner({
+    feePayer: input.payer,
+    computeUnitPrice: input.priorityFees,
+  });
+  const executor = createDefaultTransactionPlanExecutor({
+    rpc: input.rpc,
+    rpcSubscriptions: input.rpcSubscriptions,
+    parallelChunkSize: 5,
   });
-  return getCreateMetadataInstructionPlanUsingBuffer({
+
+  const [{ programData, isCanonical, metadata }, rent] = await Promise.all([
+    getPdaDetails(input),
+    input.rpc
+      .getMinimumBalanceForRentExemption(getAccountSize(input.data.length))
+      .send(),
+  ]);
+  const extendedInput = {
     ...input,
-    chunkSize,
+    programData: isCanonical ? programData : undefined,
+    metadata,
     rent,
-  });
+  };
+
+  const transactionPlan = await planner(
+    getCreateMetadataInstructionPlanUsingInstructionData(extendedInput)
+  ).catch(() =>
+    planner(getCreateMetadataInstructionPlanUsingBuffer(extendedInput))
+  );
+
+  const result = await executor(transactionPlan);
+  return { metadata, result };
 }
 
 export function getCreateMetadataInstructionPlanUsingInstructionData(
-  input: Omit<MetadataInput, 'rpc' | 'rpcSubscriptions'> &
-    PdaDetails & { rent: Lamports }
-): MessageInstructionPlan {
-  return {
-    kind: 'message',
-    instructions: [
-      ...getComputeUnitInstructions({
-        computeUnitPrice: input.priorityFees,
-        computeUnitLimit: 'simulated',
-      }),
-      getTransferSolInstruction({
-        source: input.payer,
-        destination: input.metadata,
-        amount: input.rent,
-      }),
-      getInitializeInstruction({
-        ...input,
-        programData: input.isCanonical ? input.programData : undefined,
-      }),
-    ],
-  };
+  input: InitializeInput & { payer: TransactionSigner; rent: Lamports }
+) {
+  return sequentialInstructionPlan([
+    getTransferSolInstruction({
+      source: input.payer,
+      destination: input.metadata,
+      amount: input.rent,
+    }),
+    getInitializeInstruction(input),
+  ]);
 }
 
 export function getCreateMetadataInstructionPlanUsingBuffer(
-  input: Omit<MetadataInput, 'rpc' | 'rpcSubscriptions'> &
-    PdaDetails & { rent: Lamports; chunkSize: number }
-): InstructionPlan {
-  const mainPlan: InstructionPlan = { kind: 'sequential', plans: [] };
-
-  mainPlan.plans.push({
-    kind: 'message',
-    instructions: [
-      ...getComputeUnitInstructions({
-        computeUnitPrice: input.priorityFees,
-        computeUnitLimit: 'simulated',
-      }),
-      getTransferSolInstruction({
-        source: input.payer,
-        destination: input.metadata,
-        amount: input.rent,
-      }),
-      getAllocateInstruction({
-        buffer: input.metadata,
-        authority: input.authority,
-        program: input.program,
-        programData: input.isCanonical ? input.programData : undefined,
-        seed: input.seed,
-      }),
-    ],
-  });
-
-  if (input.data.length > REALLOC_LIMIT) {
-    mainPlan.plans.push(
-      getExtendInstructionPlan({
-        account: input.metadata,
-        authority: input.authority,
-        extraLength: input.data.length,
-        program: input.program,
-        programData: input.isCanonical ? input.programData : undefined,
-      })
-    );
+  input: Omit<InitializeInput, 'data'> & {
+    data: ReadonlyUint8Array;
+    payer: TransactionSigner;
+    rent: Lamports;
   }
-
-  let offset = 0;
-  const writePlan: InstructionPlan = { kind: 'parallel', plans: [] };
-  while (offset < input.data.length) {
-    writePlan.plans.push(
+) {
+  return sequentialInstructionPlan([
+    getTransferSolInstruction({
+      source: input.payer,
+      destination: input.metadata,
+      amount: input.rent,
+    }),
+    getAllocateInstruction({
+      buffer: input.metadata,
+      authority: input.authority,
+      program: input.program,
+      programData: input.programData,
+      seed: input.seed,
+    }),
+    ...(input.data.length > REALLOC_LIMIT
+      ? [
+          getExtendInstructionPlan({
+            account: input.metadata,
+            authority: input.authority,
+            extraLength: input.data.length,
+            program: input.program,
+            programData: input.programData,
+          }),
+        ]
+      : []),
+    parallelInstructionPlan([
       getWriteInstructionPlan({
         buffer: input.metadata,
         authority: input.authority,
-        offset,
-        data: input.data.slice(offset, offset + input.chunkSize),
-        priorityFees: input.priorityFees,
-      })
-    );
-    offset += input.chunkSize;
-  }
-  mainPlan.plans.push(writePlan);
-
-  mainPlan.plans.push({
-    kind: 'message',
-    instructions: [
-      ...getComputeUnitInstructions({
-        computeUnitPrice: input.priorityFees,
-        computeUnitLimit: 'simulated',
-      }),
-      getInitializeInstruction({
-        ...input,
-        programData: input.isCanonical ? input.programData : undefined,
-        system: PROGRAM_METADATA_PROGRAM_ADDRESS,
-        data: undefined,
+        data: input.data,
       }),
-    ],
-  });
-
-  return mainPlan;
+    ]),
+    getInitializeInstruction({
+      ...input,
+      system: PROGRAM_METADATA_PROGRAM_ADDRESS,
+      data: undefined,
+    }),
+  ]);
 }

clients/js/src/index.ts

@@ -1,4 +1,5 @@
 export * from './generated';
+export * from './instructionPlans';
 
 export * from './createMetadata';
 export * from './downloadMetadata';