@layerzerolabs/lz-solana-sdk-v2 3.0.104 → 3.0.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/lz-solana-sdk-v2",
-  "version": "3.0.104",
+  "version": "3.0.105",
   "license": "BUSL-1.1",
   "exports": {
     ".": {
@@ -39,14 +39,15 @@
     "test-uln": "TEST_SCOPES=uln anchor test --skip-build"
   },
   "dependencies": {
-    "@layerzerolabs/lz-corekit-solana": "^3.0.104",
-    "@layerzerolabs/lz-definitions": "^3.0.104",
-    "@layerzerolabs/lz-foundation": "^3.0.104",
-    "@layerzerolabs/lz-serdes": "^3.0.104",
-    "@layerzerolabs/lz-utilities": "^3.0.104",
-    "@layerzerolabs/lz-v2-utilities": "^3.0.104",
+    "@layerzerolabs/lz-corekit-solana": "^3.0.105",
+    "@layerzerolabs/lz-definitions": "^3.0.105",
+    "@layerzerolabs/lz-foundation": "^3.0.105",
+    "@layerzerolabs/lz-serdes": "^3.0.105",
+    "@layerzerolabs/lz-utilities": "^3.0.105",
+    "@layerzerolabs/lz-v2-utilities": "^3.0.105",
     "@metaplex-foundation/beet": "^0.7.1",
     "@metaplex-foundation/beet-solana": "^0.4.0",
+    "@metaplex-foundation/mpl-toolbox": "^0.9.2",
     "@metaplex-foundation/umi": "^0.9.2",
     "@metaplex-foundation/umi-eddsa-web3js": "^0.9.2",
     "@metaplex-foundation/umi-program-repository": "^0.9.2",
@@ -66,8 +67,8 @@
     "@kinobi-so/renderers": "^0.21.3",
     "@kinobi-so/renderers-js-umi": "^0.21.6",
     "@layerzerolabs/layerzero-v2-solana": "^0.0.0",
-    "@layerzerolabs/tsup-config-next": "^3.0.104",
-    "@layerzerolabs/typescript-config-next": "^3.0.104",
+    "@layerzerolabs/tsup-config-next": "^3.0.105",
+    "@layerzerolabs/typescript-config-next": "^3.0.105",
     "@metaplex-foundation/umi-bundle-defaults": "^0.9.2",
     "@types/bn.js": "^5.1.5",
     "@types/chai": "^4.3.11",

package/src/executor.ts

@@ -3,6 +3,7 @@ import {
     Cluster,
     ClusterFilter,
     Commitment,
+    Instruction,
     Program,
     ProgramError,
     ProgramRepositoryInterface,
@@ -17,8 +18,7 @@ import {
 import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
 import invariant from 'tiny-invariant'
 
-import { arrayify } from '@layerzerolabs/lz-utilities'
-import { Packet, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
+import { Packet } from '@layerzerolabs/lz-v2-utilities'
 
 import { ENDPOINT_PROGRAM_ID } from './endpoint'
 import { ComposeSentEvent } from './generated/kinobi/endpoint/events'
@@ -30,7 +30,7 @@ import { NativeDropInstructionDataArgs, QuoteExecutorInstructionArgs } from './g
 import { EXECUTOR_PROGRAM_ID } from './generated/kinobi/executor/programs'
 import * as types from './generated/kinobi/executor/types'
 import { EventPDA, ExecutorPDA, MessageLibPDA, PriceFeedPDA } from './pda'
-import { getLzComposeAccountMeta, getLzReceiveAccounts } from './receive'
+import { getLzComposeAccountMeta, lzReceive } from './receive'
 
 export { EXECUTOR_PROGRAM_ID } from './generated/kinobi/executor/programs'
 export { accounts, instructions, types, events, errors }
@@ -320,63 +320,25 @@ export class Executor {
             endpointProgram?: PublicKey
         },
         commitment: Commitment = 'confirmed'
-    ): Promise<WrappedInstruction> {
-        const { packet, extraData, value = 0n, computeUnits = 200000, endpointProgram = ENDPOINT_PROGRAM_ID } = param
-        const endpointEventPDA = new EventPDA(endpointProgram)
-        const executorEventPDA = new EventPDA(this.programId)
-        const { message: message_, sender: sender, srcEid, guid, receiver: receiver_, nonce } = packet
-        const receiver = publicKey(addressToBytes32(receiver_))
-        const receiverInfo = await rpc.getAccount(receiver, { commitment })
-        invariant(receiverInfo.exists, `Receiver account not found: ${receiver}`)
-        const receiverProgram = publicKey(receiverInfo.owner)
-        const message = arrayify(message_)
-        const accounts = await getLzReceiveAccounts(
-            rpc,
-            executor.publicKey,
-            receiver,
-            receiverProgram,
-            {
-                srcEid: srcEid,
-                sender: arrayify(sender),
-                guid: arrayify(guid),
-                message,
-                callerParams: extraData,
-                nonce: BigInt(packet.nonce),
-            },
-            commitment
-        )
+    ): Promise<{ signers: Signer[]; instructions: Instruction[] }> {
+        const { packet, extraData, value = 0n } = param
+        const payer = executor.publicKey
+        const lzReceiveResult = await lzReceive(rpc, payer, packet, extraData, this.programId, commitment)
+        const { contextVersion } = lzReceiveResult
+        const instructions: Instruction[] = [this.preExecute(executor, contextVersion, value).instruction]
+        const signers: Signer[] = []
 
-        const txBuilder = instructions.execute(
-            { programs: this.programRepo },
-            {
-                executor,
-                config: this.pda.config(),
-                endpointProgram: endpointProgram,
-                endpointEventAuthority: endpointEventPDA.eventAuthority()[0],
-                program: this.programId,
-                eventAuthority: executorEventPDA.eventAuthority()[0],
-                // param
-                receiver,
-                lzReceive: {
-                    srcEid,
-                    sender: arrayify(sender),
-                    nonce: parseInt(nonce),
-                    guid: arrayify(guid),
-                    message,
-                    extraData,
-                },
-                value,
-                computeUnits,
-            }
-        )
-        return txBuilder.addRemainingAccounts([
-            {
-                pubkey: receiverProgram,
-                isWritable: false,
-                isSigner: false,
-            },
-            ...accounts,
-        ]).items[0]
+        // Handle both V1 (Instruction) and V2 ({signers, instructions})
+        if ('instruction' in lzReceiveResult) {
+            // V1: single instruction
+            instructions.push(lzReceiveResult.instruction)
+        } else {
+            // V2: multi-instruction
+            instructions.push(...lzReceiveResult.instructions)
+            signers.push(...lzReceiveResult.signers)
+        }
+        instructions.push(this.postExecute(executor, contextVersion).instruction)
+        return { signers, instructions }
     }
 
     async compose(
@@ -447,4 +409,18 @@ export class Executor {
             ...accounts,
         ]).items[0]
     }
+
+    preExecute(executor: Signer, version: number, feeLimit: bigint): WrappedInstruction {
+        const context = this.pda.context(executor.publicKey, version)
+        return instructions.preExecute(
+            { programs: this.programRepo },
+            { executor, context, feeLimit, contextVersion: version }
+        ).items[0]
+    }
+
+    postExecute(executor: Signer, version: number): WrappedInstruction {
+        const context = this.pda.context(executor.publicKey, version)
+        return instructions.postExecute({ programs: this.programRepo }, { context, executor, contextVersion: version })
+            .items[0]
+    }
 }

package/src/generated/kinobi/executor/accounts/executionContextV1.ts

@@ -0,0 +1,173 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/kinobi-so/kinobi
+ */
+
+import {
+  Account,
+  Context,
+  Pda,
+  PublicKey,
+  RpcAccount,
+  RpcGetAccountOptions,
+  RpcGetAccountsOptions,
+  assertAccountExists,
+  deserializeAccount,
+  gpaBuilder,
+  publicKey as toPublicKey,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u64,
+} from '@metaplex-foundation/umi/serializers';
+
+export type ExecutionContextV1 = Account<ExecutionContextV1AccountData>;
+
+export type ExecutionContextV1AccountData = {
+  discriminator: Uint8Array;
+  initialPayerBalance: bigint;
+  /**
+   * The maximum total lamports allowed to be used by all instructions in this execution.
+   * This is a hard cap for the sum of lamports consumed by all instructions in the execution batch.
+   */
+  feeLimit: bigint;
+};
+
+export type ExecutionContextV1AccountDataArgs = {
+  initialPayerBalance: number | bigint;
+  /**
+   * The maximum total lamports allowed to be used by all instructions in this execution.
+   * This is a hard cap for the sum of lamports consumed by all instructions in the execution batch.
+   */
+  feeLimit: number | bigint;
+};
+
+export function getExecutionContextV1AccountDataSerializer(): Serializer<
+  ExecutionContextV1AccountDataArgs,
+  ExecutionContextV1AccountData
+> {
+  return mapSerializer<
+    ExecutionContextV1AccountDataArgs,
+    any,
+    ExecutionContextV1AccountData
+  >(
+    struct<ExecutionContextV1AccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['initialPayerBalance', u64()],
+        ['feeLimit', u64()],
+      ],
+      { description: 'ExecutionContextV1AccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([132, 92, 176, 59, 141, 186, 141, 137]),
+    })
+  ) as Serializer<
+    ExecutionContextV1AccountDataArgs,
+    ExecutionContextV1AccountData
+  >;
+}
+
+export function deserializeExecutionContextV1(
+  rawAccount: RpcAccount
+): ExecutionContextV1 {
+  return deserializeAccount(
+    rawAccount,
+    getExecutionContextV1AccountDataSerializer()
+  );
+}
+
+export async function fetchExecutionContextV1(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ExecutionContextV1> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'ExecutionContextV1');
+  return deserializeExecutionContextV1(maybeAccount);
+}
+
+export async function safeFetchExecutionContextV1(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ExecutionContextV1 | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists
+    ? deserializeExecutionContextV1(maybeAccount)
+    : null;
+}
+
+export async function fetchAllExecutionContextV1(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ExecutionContextV1[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'ExecutionContextV1');
+    return deserializeExecutionContextV1(maybeAccount);
+  });
+}
+
+export async function safeFetchAllExecutionContextV1(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ExecutionContextV1[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeExecutionContextV1(maybeAccount as RpcAccount)
+    );
+}
+
+export function getExecutionContextV1GpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'executor',
+    '6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      initialPayerBalance: number | bigint;
+      feeLimit: number | bigint;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      initialPayerBalance: [8, u64()],
+      feeLimit: [16, u64()],
+    })
+    .deserializeUsing<ExecutionContextV1>((account) =>
+      deserializeExecutionContextV1(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([132, 92, 176, 59, 141, 186, 141, 137])
+    );
+}
+
+export function getExecutionContextV1Size(): number {
+  return 24;
+}

package/src/generated/kinobi/executor/accounts/index.ts

@@ -6,5 +6,6 @@
  * @see https://github.com/kinobi-so/kinobi
  */
 
+export * from './executionContextV1';
 export * from './executorConfig';
 export * from './nonce';

package/src/generated/kinobi/executor/errors/executor.ts

@@ -252,6 +252,38 @@ export class InvalidOwnerError extends ProgramError {
 codeToErrorMap.set(0x1781, InvalidOwnerError);
 nameToErrorMap.set('InvalidOwner', InvalidOwnerError);
 
+/** InvalidInstructionSequence */
+export class InvalidInstructionSequenceError extends ProgramError {
+  override readonly name: string = 'InvalidInstructionSequence';
+
+  readonly code: number = 0x1782; // 6018
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1782, InvalidInstructionSequenceError);
+nameToErrorMap.set(
+  'InvalidInstructionSequence',
+  InvalidInstructionSequenceError
+);
+
+/** ContextAccountAlreadyInitialized */
+export class ContextAccountAlreadyInitializedError extends ProgramError {
+  override readonly name: string = 'ContextAccountAlreadyInitialized';
+
+  readonly code: number = 0x1783; // 6019
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1783, ContextAccountAlreadyInitializedError);
+nameToErrorMap.set(
+  'ContextAccountAlreadyInitialized',
+  ContextAccountAlreadyInitializedError
+);
+
 /**
  * Attempts to resolve a custom program error from the provided error code.
  * @category Errors

package/src/generated/kinobi/executor/instructions/index.ts

@@ -9,9 +9,10 @@
 export * from './adminSetConfig';
 export * from './compose';
 export * from './executable';
-export * from './execute';
 export * from './extendExecutorConfig';
 export * from './initExecutor';
 export * from './nativeDrop';
 export * from './ownerSetConfig';
+export * from './postExecute';
+export * from './preExecute';
 export * from './quoteExecutor';

package/src/generated/kinobi/executor/instructions/postExecute.ts

@@ -0,0 +1,141 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/kinobi-so/kinobi
+ */
+
+import {
+  Context,
+  Pda,
+  PublicKey,
+  Signer,
+  TransactionBuilder,
+  publicKey,
+  transactionBuilder,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ResolvedAccount,
+  ResolvedAccountsWithIndices,
+  getAccountMetasAndSigners,
+} from '../shared';
+
+// Accounts.
+export type PostExecuteInstructionAccounts = {
+  executor: Signer;
+  /** Execution context account containing state from pre-execution */
+  context: PublicKey | Pda;
+  /** Instruction sysvar account for introspection */
+  instructionSysvar?: PublicKey | Pda;
+};
+
+// Data.
+export type PostExecuteInstructionData = {
+  discriminator: Uint8Array;
+  /** Version of the execution context to use */
+  contextVersion: number;
+};
+
+export type PostExecuteInstructionDataArgs = {
+  /** Version of the execution context to use */
+  contextVersion: number;
+};
+
+export function getPostExecuteInstructionDataSerializer(): Serializer<
+  PostExecuteInstructionDataArgs,
+  PostExecuteInstructionData
+> {
+  return mapSerializer<
+    PostExecuteInstructionDataArgs,
+    any,
+    PostExecuteInstructionData
+  >(
+    struct<PostExecuteInstructionData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['contextVersion', u8()],
+      ],
+      { description: 'PostExecuteInstructionData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([74, 168, 167, 167, 76, 220, 95, 56]),
+    })
+  ) as Serializer<PostExecuteInstructionDataArgs, PostExecuteInstructionData>;
+}
+
+// Args.
+export type PostExecuteInstructionArgs = PostExecuteInstructionDataArgs;
+
+// Instruction.
+export function postExecute(
+  context: Pick<Context, 'programs'>,
+  input: PostExecuteInstructionAccounts & PostExecuteInstructionArgs
+): TransactionBuilder {
+  // Program ID.
+  const programId = context.programs.getPublicKey(
+    'executor',
+    '6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn'
+  );
+
+  // Accounts.
+  const resolvedAccounts = {
+    executor: {
+      index: 0,
+      isWritable: false as boolean,
+      value: input.executor ?? null,
+    },
+    context: {
+      index: 1,
+      isWritable: true as boolean,
+      value: input.context ?? null,
+    },
+    instructionSysvar: {
+      index: 2,
+      isWritable: false as boolean,
+      value: input.instructionSysvar ?? null,
+    },
+  } satisfies ResolvedAccountsWithIndices;
+
+  // Arguments.
+  const resolvedArgs: PostExecuteInstructionArgs = { ...input };
+
+  // Default values.
+  if (!resolvedAccounts.instructionSysvar.value) {
+    resolvedAccounts.instructionSysvar.value = publicKey(
+      'Sysvar1nstructions1111111111111111111111111'
+    );
+  }
+
+  // Accounts in order.
+  const orderedAccounts: ResolvedAccount[] = Object.values(
+    resolvedAccounts
+  ).sort((a, b) => a.index - b.index);
+
+  // Keys and Signers.
+  const [keys, signers] = getAccountMetasAndSigners(
+    orderedAccounts,
+    'programId',
+    programId
+  );
+
+  // Data.
+  const data = getPostExecuteInstructionDataSerializer().serialize(
+    resolvedArgs as PostExecuteInstructionDataArgs
+  );
+
+  // Bytes Created On Chain.
+  const bytesCreatedOnChain = 0;
+
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
+  ]);
+}