@layerzerolabs/lz-solana-sdk-v2 3.0.104 → 3.0.105-mpt.0

package/dist/umi.mjs

@@ -1,5 +1,5 @@
-import { defaultPublicKey, deserializeAccount, publicKey, assertAccountExists, gpaBuilder, ProgramError, transactionBuilder, createNullRpc, some, createNoopSigner, isSome, isPublicKey, publicKeyBytes, isPda, isSigner } from '@metaplex-foundation/umi';
-import { mapSerializer, struct, bytes, bool, u8, u32, publicKey as publicKey$1, option, scalarEnum, u64, array, u16, dataEnum, tuple, u128, i64, base58, Endian } from '@metaplex-foundation/umi/serializers';
+import { defaultPublicKey, deserializeAccount, publicKey, assertAccountExists, gpaBuilder, ProgramError, transactionBuilder, createNullRpc, some, createNoopSigner, isSome, isPublicKey, generateSigner, publicKeyBytes, isPda, isSigner } from '@metaplex-foundation/umi';
+import { mapSerializer, struct, bytes, bool, u8, u32, publicKey as publicKey$1, option, scalarEnum, u64, array, u16, dataEnum, tuple, u128, i64, unit, base58, Endian } from '@metaplex-foundation/umi/serializers';
 import { createWeb3JsEddsa } from '@metaplex-foundation/umi-eddsa-web3js';
 import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository';
 import { toWeb3JsPublicKey, fromWeb3JsPublicKey, toWeb3JsInstruction } from '@metaplex-foundation/umi-web3js-adapters';
@@ -10,6 +10,7 @@ import { arrayify } from '@layerzerolabs/lz-utilities';
 import { addressToBytes32, PacketV1Codec } from '@layerzerolabs/lz-v2-utilities';
 import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from '@solana/spl-token';
 import invariant3 from 'tiny-invariant';
+import { fetchAllAddressLookupTable } from '@metaplex-foundation/mpl-toolbox';
 import { Environment } from '@layerzerolabs/lz-definitions';
 
 var __defProp = Object.defineProperty;
@@ -284,8 +285,16 @@ var _ExecutorPDA = class _ExecutorPDA {
   config() {
     return EDDSA.findPda(this.program, [Buffer.from(_ExecutorPDA.EXECUTOR_CONFIG_SEED, "utf8")]);
   }
+  context(executor, version4) {
+    return EDDSA.findPda(this.program, [
+      Buffer.from(_ExecutorPDA.EXECUTION_CONTEXT_SEED, "utf8"),
+      publicKeyBytes(executor),
+      u8().serialize(version4)
+    ]);
+  }
 };
 _ExecutorPDA.EXECUTOR_CONFIG_SEED = "ExecutorConfig";
+_ExecutorPDA.EXECUTION_CONTEXT_SEED = "ExecutionContext";
 var ExecutorPDA = _ExecutorPDA;
 var _PriceFeedPDA = class _PriceFeedPDA {
   constructor(program) {
@@ -407,17 +416,17 @@ function deserializeComposeMessageState(rawAccount) {
     getComposeMessageStateAccountDataSerializer()
   );
 }
-async function fetchComposeMessageState(context, publicKey14, options) {
+async function fetchComposeMessageState(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "ComposeMessageState");
   return deserializeComposeMessageState(maybeAccount);
 }
-async function safeFetchComposeMessageState(context, publicKey14, options) {
+async function safeFetchComposeMessageState(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeComposeMessageState(maybeAccount) : null;
@@ -484,17 +493,17 @@ function deserializeEndpointSettings(rawAccount) {
     getEndpointSettingsAccountDataSerializer()
   );
 }
-async function fetchEndpointSettings(context, publicKey14, options) {
+async function fetchEndpointSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "EndpointSettings");
   return deserializeEndpointSettings(maybeAccount);
 }
-async function safeFetchEndpointSettings(context, publicKey14, options) {
+async function safeFetchEndpointSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeEndpointSettings(maybeAccount) : null;
@@ -610,17 +619,17 @@ function deserializeMessageLibInfo(rawAccount) {
     getMessageLibInfoAccountDataSerializer()
   );
 }
-async function fetchMessageLibInfo(context, publicKey14, options) {
+async function fetchMessageLibInfo(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "MessageLibInfo");
   return deserializeMessageLibInfo(maybeAccount);
 }
-async function safeFetchMessageLibInfo(context, publicKey14, options) {
+async function safeFetchMessageLibInfo(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLibInfo(maybeAccount) : null;
@@ -684,17 +693,17 @@ function getNonceAccountDataSerializer() {
 function deserializeNonce(rawAccount) {
   return deserializeAccount(rawAccount, getNonceAccountDataSerializer());
 }
-async function fetchNonce(context, publicKey14, options) {
+async function fetchNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce(maybeAccount);
 }
-async function safeFetchNonce(context, publicKey14, options) {
+async function safeFetchNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce(maybeAccount) : null;
@@ -753,17 +762,17 @@ function getOAppRegistryAccountDataSerializer() {
 function deserializeOAppRegistry(rawAccount) {
   return deserializeAccount(rawAccount, getOAppRegistryAccountDataSerializer());
 }
-async function fetchOAppRegistry(context, publicKey14, options) {
+async function fetchOAppRegistry(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "OAppRegistry");
   return deserializeOAppRegistry(maybeAccount);
 }
-async function safeFetchOAppRegistry(context, publicKey14, options) {
+async function safeFetchOAppRegistry(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeOAppRegistry(maybeAccount) : null;
@@ -823,17 +832,17 @@ function getPayloadHashAccountDataSerializer() {
 function deserializePayloadHash(rawAccount) {
   return deserializeAccount(rawAccount, getPayloadHashAccountDataSerializer());
 }
-async function fetchPayloadHash(context, publicKey14, options) {
+async function fetchPayloadHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "PayloadHash");
   return deserializePayloadHash(maybeAccount);
 }
-async function safeFetchPayloadHash(context, publicKey14, options) {
+async function safeFetchPayloadHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializePayloadHash(maybeAccount) : null;
@@ -894,17 +903,17 @@ function deserializePendingInboundNonce(rawAccount) {
     getPendingInboundNonceAccountDataSerializer()
   );
 }
-async function fetchPendingInboundNonce(context, publicKey14, options) {
+async function fetchPendingInboundNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "PendingInboundNonce");
   return deserializePendingInboundNonce(maybeAccount);
 }
-async function safeFetchPendingInboundNonce(context, publicKey14, options) {
+async function safeFetchPendingInboundNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializePendingInboundNonce(maybeAccount) : null;
@@ -967,17 +976,17 @@ function deserializeReceiveLibraryConfig(rawAccount) {
     getReceiveLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveLibraryConfig(context, publicKey14, options) {
+async function fetchReceiveLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveLibraryConfig");
   return deserializeReceiveLibraryConfig(maybeAccount);
 }
-async function safeFetchReceiveLibraryConfig(context, publicKey14, options) {
+async function safeFetchReceiveLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveLibraryConfig(maybeAccount) : null;
@@ -1040,17 +1049,17 @@ function deserializeSendLibraryConfig(rawAccount) {
     getSendLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchSendLibraryConfig(context, publicKey14, options) {
+async function fetchSendLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "SendLibraryConfig");
   return deserializeSendLibraryConfig(maybeAccount);
 }
-async function safeFetchSendLibraryConfig(context, publicKey14, options) {
+async function safeFetchSendLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeSendLibraryConfig(maybeAccount) : null;
@@ -3987,17 +3996,17 @@ function getMessageLibAccountDataSerializer() {
 function deserializeMessageLib(rawAccount) {
   return deserializeAccount(rawAccount, getMessageLibAccountDataSerializer());
 }
-async function fetchMessageLib(context, publicKey14, options) {
+async function fetchMessageLib(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "MessageLib");
   return deserializeMessageLib(maybeAccount);
 }
-async function safeFetchMessageLib(context, publicKey14, options) {
+async function safeFetchMessageLib(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLib(maybeAccount) : null;
@@ -4064,17 +4073,17 @@ function deserializeReceiveConfigStore(rawAccount) {
     getReceiveConfigStoreAccountDataSerializer()
   );
 }
-async function fetchReceiveConfigStore(context, publicKey14, options) {
+async function fetchReceiveConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveConfigStore");
   return deserializeReceiveConfigStore(maybeAccount);
 }
-async function safeFetchReceiveConfigStore(context, publicKey14, options) {
+async function safeFetchReceiveConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfigStore(maybeAccount) : null;
@@ -4136,17 +4145,17 @@ function deserializeSendConfigStore(rawAccount) {
     getSendConfigStoreAccountDataSerializer()
   );
 }
-async function fetchSendConfigStore(context, publicKey14, options) {
+async function fetchSendConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "SendConfigStore");
   return deserializeSendConfigStore(maybeAccount);
 }
-async function safeFetchSendConfigStore(context, publicKey14, options) {
+async function safeFetchSendConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfigStore(maybeAccount) : null;
@@ -6964,17 +6973,17 @@ function getDvnConfigAccountDataSerializer() {
 function deserializeDvnConfig(rawAccount) {
   return deserializeAccount(rawAccount, getDvnConfigAccountDataSerializer());
 }
-async function fetchDvnConfig(context, publicKey14, options) {
+async function fetchDvnConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "DvnConfig");
   return deserializeDvnConfig(maybeAccount);
 }
-async function safeFetchDvnConfig(context, publicKey14, options) {
+async function safeFetchDvnConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeDvnConfig(maybeAccount) : null;
@@ -7037,17 +7046,17 @@ function getExecuteHashAccountDataSerializer() {
 function deserializeExecuteHash(rawAccount) {
   return deserializeAccount(rawAccount, getExecuteHashAccountDataSerializer());
 }
-async function fetchExecuteHash(context, publicKey14, options) {
+async function fetchExecuteHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "ExecuteHash");
   return deserializeExecuteHash(maybeAccount);
 }
-async function safeFetchExecuteHash(context, publicKey14, options) {
+async function safeFetchExecuteHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeExecuteHash(maybeAccount) : null;
@@ -7108,17 +7117,17 @@ function deserializeReceiveConfig(rawAccount) {
     getReceiveConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveConfig(context, publicKey14, options) {
+async function fetchReceiveConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig(maybeAccount);
 }
-async function safeFetchReceiveConfig(context, publicKey14, options) {
+async function safeFetchReceiveConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig(maybeAccount) : null;
@@ -8365,22 +8374,105 @@ __export(executor_exports, {
 // src/generated/kinobi/executor/accounts/index.ts
 var accounts_exports4 = {};
 __export(accounts_exports4, {
+  deserializeExecutionContextV1: () => deserializeExecutionContextV1,
   deserializeExecutorConfig: () => deserializeExecutorConfig,
   deserializeNonce: () => deserializeNonce2,
+  fetchAllExecutionContextV1: () => fetchAllExecutionContextV1,
   fetchAllExecutorConfig: () => fetchAllExecutorConfig,
   fetchAllNonce: () => fetchAllNonce2,
+  fetchExecutionContextV1: () => fetchExecutionContextV1,
   fetchExecutorConfig: () => fetchExecutorConfig,
   fetchNonce: () => fetchNonce2,
+  getExecutionContextV1AccountDataSerializer: () => getExecutionContextV1AccountDataSerializer,
+  getExecutionContextV1GpaBuilder: () => getExecutionContextV1GpaBuilder,
+  getExecutionContextV1Size: () => getExecutionContextV1Size,
   getExecutorConfigAccountDataSerializer: () => getExecutorConfigAccountDataSerializer,
   getExecutorConfigGpaBuilder: () => getExecutorConfigGpaBuilder,
   getNonceAccountDataSerializer: () => getNonceAccountDataSerializer2,
   getNonceGpaBuilder: () => getNonceGpaBuilder2,
   getNonceSize: () => getNonceSize2,
+  safeFetchAllExecutionContextV1: () => safeFetchAllExecutionContextV1,
   safeFetchAllExecutorConfig: () => safeFetchAllExecutorConfig,
   safeFetchAllNonce: () => safeFetchAllNonce2,
+  safeFetchExecutionContextV1: () => safeFetchExecutionContextV1,
   safeFetchExecutorConfig: () => safeFetchExecutorConfig,
   safeFetchNonce: () => safeFetchNonce2
 });
+function getExecutionContextV1AccountDataSerializer() {
+  return mapSerializer(
+    struct(
+      [
+        ["discriminator", bytes({ size: 8 })],
+        ["initialPayerBalance", u64()],
+        ["feeLimit", u64()]
+      ],
+      { description: "ExecutionContextV1AccountData" }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([132, 92, 176, 59, 141, 186, 141, 137])
+    })
+  );
+}
+function deserializeExecutionContextV1(rawAccount) {
+  return deserializeAccount(
+    rawAccount,
+    getExecutionContextV1AccountDataSerializer()
+  );
+}
+async function fetchExecutionContextV1(context, publicKey16, options) {
+  const maybeAccount = await context.rpc.getAccount(
+    publicKey(publicKey16, false),
+    options
+  );
+  assertAccountExists(maybeAccount, "ExecutionContextV1");
+  return deserializeExecutionContextV1(maybeAccount);
+}
+async function safeFetchExecutionContextV1(context, publicKey16, options) {
+  const maybeAccount = await context.rpc.getAccount(
+    publicKey(publicKey16, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeExecutionContextV1(maybeAccount) : null;
+}
+async function fetchAllExecutionContextV1(context, publicKeys, options) {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => publicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, "ExecutionContextV1");
+    return deserializeExecutionContextV1(maybeAccount);
+  });
+}
+async function safeFetchAllExecutionContextV1(context, publicKeys, options) {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => publicKey(key, false)),
+    options
+  );
+  return maybeAccounts.filter((maybeAccount) => maybeAccount.exists).map(
+    (maybeAccount) => deserializeExecutionContextV1(maybeAccount)
+  );
+}
+function getExecutionContextV1GpaBuilder(context) {
+  const programId = context.programs.getPublicKey(
+    "executor",
+    "6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn"
+  );
+  return gpaBuilder(context, programId).registerFields({
+    discriminator: [0, bytes({ size: 8 })],
+    initialPayerBalance: [8, u64()],
+    feeLimit: [16, u64()]
+  }).deserializeUsing(
+    (account) => deserializeExecutionContextV1(account)
+  ).whereField(
+    "discriminator",
+    new Uint8Array([132, 92, 176, 59, 141, 186, 141, 137])
+  );
+}
+function getExecutionContextV1Size() {
+  return 24;
+}
 
 // src/generated/kinobi/executor/types/index.ts
 var types_exports4 = {};
@@ -8393,7 +8485,6 @@ __export(types_exports4, {
   getExecutionStateSerializer: () => getExecutionStateSerializer,
   getLzComposeParamsSerializer: () => getLzComposeParamsSerializer,
   getLzOptionSerializer: () => getLzOptionSerializer2,
-  getLzReceiveParamsSerializer: () => getLzReceiveParamsSerializer,
   getNativeDropRequestSerializer: () => getNativeDropRequestSerializer,
   getOwnerSetConfigParamsSerializer: () => getOwnerSetConfigParamsSerializer,
   isAdminSetConfigParams: () => isAdminSetConfigParams,
@@ -8485,19 +8576,6 @@ function getLzOptionSerializer2() {
     { description: "LzOption" }
   );
 }
-function getLzReceiveParamsSerializer() {
-  return struct(
-    [
-      ["srcEid", u32()],
-      ["sender", bytes({ size: 32 })],
-      ["nonce", u64()],
-      ["guid", bytes({ size: 32 })],
-      ["message", bytes({ size: u32() })],
-      ["extraData", bytes({ size: u32() })]
-    ],
-    { description: "LzReceiveParams" }
-  );
-}
 function getNativeDropRequestSerializer() {
   return struct(
     [
@@ -8594,17 +8672,17 @@ function deserializeExecutorConfig(rawAccount) {
     getExecutorConfigAccountDataSerializer()
   );
 }
-async function fetchExecutorConfig(context, publicKey14, options) {
+async function fetchExecutorConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "ExecutorConfig");
   return deserializeExecutorConfig(maybeAccount);
 }
-async function safeFetchExecutorConfig(context, publicKey14, options) {
+async function safeFetchExecutorConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeExecutorConfig(maybeAccount) : null;
@@ -8672,17 +8750,17 @@ function getNonceAccountDataSerializer2() {
 function deserializeNonce2(rawAccount) {
   return deserializeAccount(rawAccount, getNonceAccountDataSerializer2());
 }
-async function fetchNonce2(context, publicKey14, options) {
+async function fetchNonce2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce2(maybeAccount);
 }
-async function safeFetchNonce2(context, publicKey14, options) {
+async function safeFetchNonce2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce2(maybeAccount) : null;
@@ -8726,9 +8804,11 @@ function getNonceSize2() {
 // src/generated/kinobi/executor/errors/index.ts
 var errors_exports4 = {};
 __export(errors_exports4, {
+  ContextAccountAlreadyInitializedError: () => ContextAccountAlreadyInitializedError,
   EidNotSupportedError: () => EidNotSupportedError2,
   ExecutorIsAdminError: () => ExecutorIsAdminError,
   InsufficientBalanceError: () => InsufficientBalanceError,
+  InvalidInstructionSequenceError: () => InvalidInstructionSequenceError,
   InvalidNativeDropReceiverError: () => InvalidNativeDropReceiverError,
   InvalidNativeDropRequestsLengthError: () => InvalidNativeDropRequestsLengthError,
   InvalidOwnerError: () => InvalidOwnerError,
@@ -8932,6 +9012,32 @@ var InvalidOwnerError = class extends ProgramError {
 };
 codeToErrorMap4.set(6017, InvalidOwnerError);
 nameToErrorMap4.set("InvalidOwner", InvalidOwnerError);
+var InvalidInstructionSequenceError = class extends ProgramError {
+  // 6018
+  constructor(program, cause) {
+    super("", program, cause);
+    this.name = "InvalidInstructionSequence";
+    this.code = 6018;
+  }
+};
+codeToErrorMap4.set(6018, InvalidInstructionSequenceError);
+nameToErrorMap4.set(
+  "InvalidInstructionSequence",
+  InvalidInstructionSequenceError
+);
+var ContextAccountAlreadyInitializedError = class extends ProgramError {
+  // 6019
+  constructor(program, cause) {
+    super("", program, cause);
+    this.name = "ContextAccountAlreadyInitialized";
+    this.code = 6019;
+  }
+};
+codeToErrorMap4.set(6019, ContextAccountAlreadyInitializedError);
+nameToErrorMap4.set(
+  "ContextAccountAlreadyInitialized",
+  ContextAccountAlreadyInitializedError
+);
 function getExecutorErrorFromCode(code, program, cause) {
   const constructor = codeToErrorMap4.get(code);
   return constructor ? new constructor(program, cause) : null;
@@ -8967,20 +9073,22 @@ __export(instructions_exports4, {
   adminSetConfig: () => adminSetConfig,
   compose: () => compose,
   executable: () => executable,
-  execute: () => execute,
   extendExecutorConfig: () => extendExecutorConfig,
   getAdminSetConfigInstructionDataSerializer: () => getAdminSetConfigInstructionDataSerializer,
   getComposeInstructionDataSerializer: () => getComposeInstructionDataSerializer,
   getExecutableInstructionDataSerializer: () => getExecutableInstructionDataSerializer,
-  getExecuteInstructionDataSerializer: () => getExecuteInstructionDataSerializer,
   getExtendExecutorConfigInstructionDataSerializer: () => getExtendExecutorConfigInstructionDataSerializer,
   getInitExecutorInstructionDataSerializer: () => getInitExecutorInstructionDataSerializer,
   getNativeDropInstructionDataSerializer: () => getNativeDropInstructionDataSerializer,
   getOwnerSetConfigInstructionDataSerializer: () => getOwnerSetConfigInstructionDataSerializer,
+  getPostExecuteInstructionDataSerializer: () => getPostExecuteInstructionDataSerializer,
+  getPreExecuteInstructionDataSerializer: () => getPreExecuteInstructionDataSerializer,
   getQuoteExecutorInstructionDataSerializer: () => getQuoteExecutorInstructionDataSerializer,
   initExecutor: () => initExecutor,
   nativeDrop: () => nativeDrop,
   ownerSetConfig: () => ownerSetConfig,
+  postExecute: () => postExecute,
+  preExecute: () => preExecute,
   quoteExecutor: () => quoteExecutor
 });
 function getAccountMetasAndSigners4(accounts, optionalAccountStrategy, programId) {
@@ -9176,78 +9284,6 @@ function executable(context, accounts, args) {
     { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
   ]);
 }
-function getExecuteInstructionDataSerializer() {
-  return mapSerializer(
-    struct(
-      [
-        ["discriminator", bytes({ size: 8 })],
-        ["receiver", publicKey$1()],
-        ["lzReceive", getLzReceiveParamsSerializer()],
-        ["value", u64()],
-        ["computeUnits", u64()]
-      ],
-      { description: "ExecuteInstructionData" }
-    ),
-    (value) => ({
-      ...value,
-      discriminator: new Uint8Array([130, 221, 242, 154, 13, 193, 189, 29])
-    })
-  );
-}
-function execute(context, input) {
-  const programId = context.programs.getPublicKey(
-    "executor",
-    "6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn"
-  );
-  const resolvedAccounts = {
-    executor: {
-      index: 0,
-      isWritable: true,
-      value: input.executor ?? null
-    },
-    config: {
-      index: 1,
-      isWritable: false,
-      value: input.config ?? null
-    },
-    endpointProgram: {
-      index: 2,
-      isWritable: false,
-      value: input.endpointProgram ?? null
-    },
-    endpointEventAuthority: {
-      index: 3,
-      isWritable: false,
-      value: input.endpointEventAuthority ?? null
-    },
-    eventAuthority: {
-      index: 4,
-      isWritable: false,
-      value: input.eventAuthority ?? null
-    },
-    program: {
-      index: 5,
-      isWritable: false,
-      value: input.program ?? null
-    }
-  };
-  const resolvedArgs = { ...input };
-  const orderedAccounts = Object.values(
-    resolvedAccounts
-  ).sort((a, b) => a.index - b.index);
-  const [keys, signers] = getAccountMetasAndSigners4(
-    orderedAccounts,
-    "programId",
-    programId
-  );
-  const data = getExecuteInstructionDataSerializer().serialize(
-    resolvedArgs
-  );
-  const bytesCreatedOnChain = 0;
-  return transactionBuilder([
-    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
-  ]);
-}
 function getExtendExecutorConfigInstructionDataSerializer() {
   return mapSerializer(
     struct(
@@ -9496,6 +9532,137 @@ function ownerSetConfig(context, input) {
     { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
   ]);
 }
+function getPostExecuteInstructionDataSerializer() {
+  return mapSerializer(
+    struct(
+      [
+        ["discriminator", bytes({ size: 8 })],
+        ["contextVersion", u8()]
+      ],
+      { description: "PostExecuteInstructionData" }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([74, 168, 167, 167, 76, 220, 95, 56])
+    })
+  );
+}
+function postExecute(context, input) {
+  const programId = context.programs.getPublicKey(
+    "executor",
+    "6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn"
+  );
+  const resolvedAccounts = {
+    executor: {
+      index: 0,
+      isWritable: false,
+      value: input.executor ?? null
+    },
+    context: {
+      index: 1,
+      isWritable: true,
+      value: input.context ?? null
+    },
+    instructionSysvar: {
+      index: 2,
+      isWritable: false,
+      value: input.instructionSysvar ?? null
+    }
+  };
+  const resolvedArgs = { ...input };
+  if (!resolvedAccounts.instructionSysvar.value) {
+    resolvedAccounts.instructionSysvar.value = publicKey(
+      "Sysvar1nstructions1111111111111111111111111"
+    );
+  }
+  const orderedAccounts = Object.values(
+    resolvedAccounts
+  ).sort((a, b) => a.index - b.index);
+  const [keys, signers] = getAccountMetasAndSigners4(
+    orderedAccounts,
+    "programId",
+    programId
+  );
+  const data = getPostExecuteInstructionDataSerializer().serialize(
+    resolvedArgs
+  );
+  const bytesCreatedOnChain = 0;
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
+  ]);
+}
+function getPreExecuteInstructionDataSerializer() {
+  return mapSerializer(
+    struct(
+      [
+        ["discriminator", bytes({ size: 8 })],
+        ["contextVersion", u8()],
+        ["feeLimit", u64()]
+      ],
+      { description: "PreExecuteInstructionData" }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([207, 125, 18, 148, 72, 192, 198, 83])
+    })
+  );
+}
+function preExecute(context, input) {
+  const programId = context.programs.getPublicKey(
+    "executor",
+    "6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn"
+  );
+  const resolvedAccounts = {
+    executor: {
+      index: 0,
+      isWritable: true,
+      value: input.executor ?? null
+    },
+    context: {
+      index: 1,
+      isWritable: true,
+      value: input.context ?? null
+    },
+    systemProgram: {
+      index: 2,
+      isWritable: false,
+      value: input.systemProgram ?? null
+    },
+    instructionSysvar: {
+      index: 3,
+      isWritable: false,
+      value: input.instructionSysvar ?? null
+    }
+  };
+  const resolvedArgs = { ...input };
+  if (!resolvedAccounts.systemProgram.value) {
+    resolvedAccounts.systemProgram.value = context.programs.getPublicKey(
+      "splSystem",
+      "11111111111111111111111111111111"
+    );
+    resolvedAccounts.systemProgram.isWritable = false;
+  }
+  if (!resolvedAccounts.instructionSysvar.value) {
+    resolvedAccounts.instructionSysvar.value = publicKey(
+      "Sysvar1nstructions1111111111111111111111111"
+    );
+  }
+  const orderedAccounts = Object.values(
+    resolvedAccounts
+  ).sort((a, b) => a.index - b.index);
+  const [keys, signers] = getAccountMetasAndSigners4(
+    orderedAccounts,
+    "programId",
+    programId
+  );
+  const data = getPreExecuteInstructionDataSerializer().serialize(
+    resolvedArgs
+  );
+  const bytesCreatedOnChain = 0;
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
+  ]);
+}
 function getQuoteExecutorInstructionDataSerializer() {
   return mapSerializer(
     struct(
@@ -9561,9 +9728,10 @@ var MSG_TYPE_OFFSET = 0;
 var MessageType = /* @__PURE__ */ ((MessageType2) => {
   MessageType2[MessageType2["VANILLA"] = 1] = "VANILLA";
   MessageType2[MessageType2["COMPOSED_TYPE"] = 2] = "COMPOSED_TYPE";
+  MessageType2[MessageType2["ABA"] = 3] = "ABA";
   return MessageType2;
 })(MessageType || {});
-function getLzReceiveParamsSerializer2() {
+function getLzReceiveParamsSerializer() {
   return struct(
     [
       ["srcEid", u32()],
@@ -9608,6 +9776,72 @@ var ExecutorOptionType = /* @__PURE__ */ ((ExecutorOptionType2) => {
   return ExecutorOptionType2;
 })(ExecutorOptionType || {});
 var MaxExecutorOptionTypeLength = 10;
+function getAddressLocatorSerializer() {
+  return dataEnum(
+    [
+      [
+        "Address",
+        struct([["fields", tuple([publicKey$1()])]])
+      ],
+      ["AltIndex", struct([["fields", tuple([u8(), u8()])]])],
+      ["Payer", unit()],
+      ["Signer", struct([["fields", tuple([u8()])]])],
+      ["Context", unit()]
+    ],
+    { description: "AddressLocator" }
+  );
+}
+function getLzReceiveTypesV2AccountsSerializer() {
+  return struct([["accounts", array(publicKey$1())]], {
+    description: "LzReceiveTypesV2Result"
+  });
+}
+function getAccountMetaRefSerializer() {
+  return struct(
+    [
+      ["pubkey", getAddressLocatorSerializer()],
+      ["isWritable", bool()]
+    ],
+    { description: "AccountMetaRef" }
+  );
+}
+function getInstructionSerializer() {
+  return dataEnum(
+    [
+      [
+        "LzReceive",
+        struct([
+          ["accounts", array(getAccountMetaRefSerializer())]
+        ])
+      ],
+      [
+        "Standard",
+        struct([
+          ["programId", publicKey$1()],
+          ["accounts", array(getAccountMetaRefSerializer())],
+          ["data", bytes({ size: u32() })]
+        ])
+      ]
+    ],
+    { description: "Instruction" }
+  );
+}
+function getLzReceiveTypesV2ResultSerializer() {
+  return struct(
+    [
+      ["contextVersion", u8()],
+      ["alts", array(publicKey$1())],
+      ["instructions", array(getInstructionSerializer())]
+    ],
+    { description: "LzReceiveTypesV2Result" }
+  );
+}
+function addressLocator(kind, data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
+}
+function isAddressLocator(kind, value) {
+  return value.__kind === kind;
+}
 
 // src/generated/kinobi/uln/events/index.ts
 var events_exports4 = {};
@@ -10126,29 +10360,269 @@ function toWeb3Connection(rpc) {
   }
 }
 
+// src/receive-types-v1.ts
+async function getLzReceiveAccountsFromTypesV1(rpc, payer, receiver, receiverProgram, params, commitment = "confirmed") {
+  const oappPDA = new OmniAppPDA(receiverProgram);
+  const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver);
+  const info = await rpc.getAccount(lzReceiveTypesAccountsPDA, { commitment });
+  const accounts = [];
+  if (info.exists) {
+    const buffer = Buffer.from(info.data);
+    const len = buffer.length - 8;
+    if (len % 32 !== 0) {
+      throw new Error(
+        `Invalid length of AccountInfo.data. The length must be a multiple of 32 plus 8.(n*32+8). Current length is ${buffer.length}`
+      );
+    }
+    for (let i = 8; i < len; i += 32) {
+      const [address] = publicKey$1().deserialize(buffer, i);
+      accounts.push({
+        pubkey: address,
+        isSigner: false,
+        isWritable: false
+      });
+    }
+  }
+  const data = getLzReceiveParamsSerializer().serialize(params);
+  const lzReceiveTypesIx = {
+    programId: receiverProgram,
+    keys: accounts,
+    data: Buffer.concat([instructionDiscriminator("lz_receive_types"), data])
+  };
+  const keys = await simulateWeb3JsTransaction(
+    rpc.getEndpoint(),
+    [toWeb3JsInstruction(lzReceiveTypesIx)],
+    toWeb3JsPublicKey(receiverProgram),
+    toWeb3JsPublicKey(payer),
+    array(getLzReceiveAccountSerializer()),
+    commitment
+  );
+  return updateAccountFromSimulatedResp(keys, payer);
+}
+function updateAccountFromSimulatedResp(accounts, payer) {
+  return accounts.map((r) => {
+    if (r.pubkey == defaultPublicKey() && r.isSigner) {
+      if (!payer) throw new Error("payer is required");
+      return {
+        pubkey: payer,
+        isSigner: true,
+        isWritable: r.isWritable
+      };
+    } else {
+      return {
+        pubkey: r.pubkey,
+        isSigner: r.isSigner,
+        isWritable: r.isWritable
+      };
+    }
+  });
+}
+async function buildLzReceiveExecutionPlan(rpc, executorProgram, payer, receiver, receiverProgram, params, receiveTypesAccounts, commitment = "confirmed") {
+  receiveTypesAccounts = receiveTypesAccounts ?? await getLzReceiveTypesInfo(rpc, payer, receiver, receiverProgram, params, commitment);
+  const data = getLzReceiveParamsSerializer().serialize(params);
+  const lzReceiveTypesIx = {
+    programId: receiverProgram,
+    keys: receiveTypesAccounts.accounts.map((pubkey) => {
+      return {
+        pubkey,
+        isSigner: false,
+        isWritable: false
+      };
+    }),
+    data: Buffer.concat([instructionDiscriminator("lz_receive_types_v2"), data])
+  };
+  const resp = await simulateWeb3JsTransaction(
+    rpc.getEndpoint(),
+    [toWeb3JsInstruction(lzReceiveTypesIx)],
+    toWeb3JsPublicKey(receiverProgram),
+    toWeb3JsPublicKey(payer),
+    getLzReceiveTypesV2ResultSerializer(),
+    commitment
+  );
+  const tables = await fetchAllAddressLookupTable({ rpc }, resp.alts);
+  const signers = {};
+  const lzReceiveDiscriminator = instructionDiscriminator("lz_receive").toString("hex");
+  const instructionTracker = {};
+  for (const ix of resp.instructions) {
+    let programId = receiverProgram;
+    let instructionType = "lz_receive";
+    if (ix.__kind === "Standard") {
+      const { programId: stdProgramId, data: data2 } = ix;
+      programId = stdProgramId;
+      const discriminator = Buffer.from(data2.slice(0, 8)).toString("hex");
+      instructionType = discriminator === lzReceiveDiscriminator ? "lz_receive" : discriminator;
+    }
+    const key = `${programId}-${instructionType}`;
+    if (instructionTracker[key]) {
+      throw new Error(`Duplicate instruction found: ${instructionType} for program ${programId}`);
+    }
+    instructionTracker[key] = true;
+  }
+  const { contextVersion } = resp;
+  const instructions = resp.instructions.map((ix) => {
+    if (ix.__kind === "LzReceive") {
+      return {
+        programId: receiverProgram,
+        keys: ix.accounts.map(
+          (account) => accountMetaRefToAccountMeta(
+            { eddsa: EDDSA },
+            executorProgram,
+            tables,
+            signers,
+            account,
+            payer,
+            contextVersion
+          )
+        ),
+        data: Buffer.concat([instructionDiscriminator("lz_receive"), data])
+      };
+    } else {
+      return {
+        programId: ix.programId,
+        keys: ix.accounts.map(
+          (account) => accountMetaRefToAccountMeta(
+            { eddsa: EDDSA },
+            executorProgram,
+            tables,
+            signers,
+            account,
+            payer,
+            contextVersion
+          )
+        ),
+        data: ix.data
+      };
+    }
+  });
+  return {
+    contextVersion,
+    signers: Object.values(signers).filter((signer) => signer !== void 0),
+    instructions
+  };
+}
+async function getLzReceiveTypesInfo(rpc, payer, receiver, receiverProgram, params, commitment = "confirmed") {
+  const oappPDA = new OmniAppPDA(receiverProgram);
+  const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver);
+  const lzReceiveTypesIx = {
+    programId: receiverProgram,
+    keys: [
+      {
+        pubkey: receiver,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: lzReceiveTypesAccountsPDA,
+        isSigner: false,
+        isWritable: false
+      }
+    ],
+    data: Buffer.concat([instructionDiscriminator("lz_receive_types_info")])
+  };
+  const resp = await simulateWeb3JsTransaction(
+    rpc.getEndpoint(),
+    [toWeb3JsInstruction(lzReceiveTypesIx)],
+    toWeb3JsPublicKey(receiverProgram),
+    toWeb3JsPublicKey(payer),
+    bytes(),
+    commitment
+  );
+  const version4 = resp.at(0);
+  if (version4 !== 2) {
+    throw new Error(`Invalid version ${version4}. Expected version 2.`);
+  }
+  return getLzReceiveTypesV2AccountsSerializer().deserialize(resp, 1)[0];
+}
+function accountMetaRefToAccountMeta(umi, executorProgram, tables, signers, accountMetaRef, payer, contextVersion) {
+  const { isWritable, pubkey: locator } = accountMetaRef;
+  const pubkey = addressLocatorToPublicKey(umi, executorProgram, tables, signers, locator, payer, contextVersion);
+  return { pubkey, isSigner: locator.__kind === "Signer" || locator.__kind === "Payer", isWritable };
+}
+function addressLocatorToPublicKey(umi, executorProgram, tables, signers, locator, payer, contextVersion) {
+  if (locator.__kind === "Payer") {
+    return payer;
+  } else if (locator.__kind === "Signer") {
+    const index = locator.fields[0];
+    let signer = signers[index];
+    if (signer === void 0) {
+      signer = generateSigner(umi);
+      signers[index] = signer;
+    }
+    return signer.publicKey;
+  } else if (locator.__kind === "Address") {
+    return locator.fields[0];
+  } else if (locator.__kind === "Context") {
+    const pda = new ExecutorPDA(executorProgram);
+    return pda.context(payer, contextVersion)[0];
+  } else {
+    const table = tables[locator.fields[0]];
+    return table.addresses[locator.fields[1]];
+  }
+}
+
 // src/receive.ts
-async function lzReceive(rpc, payer, packet, callerParams = Uint8Array.from([0, 0]), commitment = "confirmed") {
-  const { message: message_, sender, srcEid, guid, receiver: receiver_ } = packet;
-  const receiver = publicKey(addressToBytes32(receiver_));
+async function lzReceive(rpc, payer, packet, callerParams = Uint8Array.from([0, 0]), executorProgram = EXECUTOR_PROGRAM_ID, commitment = "confirmed") {
+  const { message: message_, sender: sender_, srcEid, guid, receiver: receiver_, nonce } = packet;
+  const sender = arrayify(sender_);
+  const receiverBytes = addressToBytes32(receiver_);
   const message = arrayify(message_);
   const params = {
     srcEid,
-    sender: arrayify(sender),
+    sender,
     guid: arrayify(guid),
     message,
     callerParams,
-    nonce: BigInt(packet.nonce)
+    nonce: BigInt(nonce)
   };
-  const receiverInfo = await rpc.getAccount(receiver, { commitment });
-  invariant3(receiverInfo.exists, `Receiver account not found: ${receiver}`);
+  const receiverPubkey = publicKey(receiverBytes);
+  const receiverInfo = await rpc.getAccount(receiverPubkey, { commitment });
+  invariant3(receiverInfo.exists, `Receiver account not found: ${receiverPubkey}`);
   const receiverProgram = publicKey(receiverInfo.owner);
-  const accounts = await getLzReceiveAccounts(rpc, payer, receiver, receiverProgram, params, commitment);
-  const data = getLzReceiveParamsSerializer2().serialize(params);
-  return {
-    programId: receiverProgram,
-    keys: accounts,
-    data: Buffer.concat([instructionDiscriminator("lz_receive"), data])
-  };
+  let version4 = 1;
+  let receiveTypesAccounts;
+  try {
+    receiveTypesAccounts = await getLzReceiveTypesInfo(
+      rpc,
+      payer,
+      receiverPubkey,
+      receiverProgram,
+      params,
+      commitment
+    );
+    version4 = 2;
+  } catch (e) {
+    version4 = 1;
+  }
+  if (version4 === 2) {
+    return buildLzReceiveExecutionPlan(
+      rpc,
+      executorProgram,
+      payer,
+      receiverPubkey,
+      receiverProgram,
+      params,
+      receiveTypesAccounts,
+      commitment
+    );
+  } else {
+    const accounts = await getLzReceiveAccountsFromTypesV1(
+      rpc,
+      payer,
+      receiverPubkey,
+      receiverProgram,
+      params,
+      commitment
+    );
+    const data = getLzReceiveParamsSerializer().serialize(params);
+    return {
+      instruction: {
+        programId: receiverProgram,
+        keys: accounts,
+        data: Buffer.concat([instructionDiscriminator("lz_receive"), data])
+      },
+      contextVersion: 1
+    };
+  }
 }
 async function lzCompose(rpc, payer, event, extraData = Uint8Array.from([0, 0]), commitment = "confirmed") {
   const { to, from, guid, index, message } = event;
@@ -10173,47 +10647,6 @@ async function lzCompose(rpc, payer, event, extraData = Uint8Array.from([0, 0]),
     data: Buffer.concat([instructionDiscriminator("lz_compose"), data])
   };
 }
-async function getLzReceiveAccounts(rpc, payer, receiver, receiverProgram, params, commitment = "confirmed") {
-  const lzReceiveTypesAccounts = await (async () => {
-    const oappPDA = new OmniAppPDA(receiverProgram);
-    const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver);
-    const info = await rpc.getAccount(lzReceiveTypesAccountsPDA, { commitment });
-    const accounts = [];
-    if (info.exists) {
-      const buffer = Buffer.from(info.data);
-      const len = buffer.length - 8;
-      if (len % 32 !== 0) {
-        throw new Error(
-          `Invalid length of AccountInfo.data. The length must be a multiple of 32 plus 8.(n*32+8). Current length is ${buffer.length}`
-        );
-      }
-      for (let i = 8; i < len; i += 32) {
-        const [address] = publicKey$1().deserialize(buffer, i);
-        accounts.push({
-          pubkey: address,
-          isSigner: false,
-          isWritable: false
-        });
-      }
-    }
-    return accounts;
-  })();
-  const data = getLzReceiveParamsSerializer2().serialize(params);
-  const lzReceiveTypesIx = {
-    programId: receiverProgram,
-    keys: lzReceiveTypesAccounts,
-    data: Buffer.concat([instructionDiscriminator("lz_receive_types"), data])
-  };
-  const keys = await simulateWeb3JsTransaction(
-    rpc.getEndpoint(),
-    [toWeb3JsInstruction(lzReceiveTypesIx)],
-    toWeb3JsPublicKey(receiverProgram),
-    toWeb3JsPublicKey(payer),
-    array(getLzReceiveAccountSerializer()),
-    "confirmed"
-  );
-  return updateAccountFromSimulatedResp(keys, payer);
-}
 async function getLzComposeAccountMeta(rpc, payer, to, composerProgram, params, commitment = "confirmed") {
   const lzComposeTypesAccounts = await (async () => {
     const oappPDA = new OmniAppPDA(composerProgram);
@@ -10253,9 +10686,9 @@ async function getLzComposeAccountMeta(rpc, payer, to, composerProgram, params,
     array(getLzReceiveAccountSerializer()),
     "confirmed"
   );
-  return updateAccountFromSimulatedResp(keys, payer);
+  return updateAccountFromSimulatedResp2(keys, payer);
 }
-function updateAccountFromSimulatedResp(accounts, payer) {
+function updateAccountFromSimulatedResp2(accounts, payer) {
   return accounts.map((r) => {
     if (r.pubkey == defaultPublicKey() && r.isSigner) {
       if (!payer) throw new Error("payer is required");
@@ -10515,61 +10948,20 @@ var Executor = class {
     ].concat(ixAccounts);
   }
   async execute(rpc, executor, param, commitment = "confirmed") {
-    const { packet, extraData, value = 0n, computeUnits = 2e5, endpointProgram = ENDPOINT_PROGRAM_ID } = param;
-    const endpointEventPDA = new EventPDA(endpointProgram);
-    const executorEventPDA = new EventPDA(this.programId);
-    const { message: message_, sender, srcEid, guid, receiver: receiver_, nonce } = packet;
-    const receiver = publicKey(addressToBytes32(receiver_));
-    const receiverInfo = await rpc.getAccount(receiver, { commitment });
-    invariant3(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,
-        sender: arrayify(sender),
-        guid: arrayify(guid),
-        message,
-        callerParams: extraData,
-        nonce: BigInt(packet.nonce)
-      },
-      commitment
-    );
-    const txBuilder = execute(
-      { programs: this.programRepo },
-      {
-        executor,
-        config: this.pda.config(),
-        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];
+    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 = [this.preExecute(executor, contextVersion, value).instruction];
+    const signers = [];
+    if ("instruction" in lzReceiveResult) {
+      instructions.push(lzReceiveResult.instruction);
+    } else {
+      instructions.push(...lzReceiveResult.instructions);
+      signers.push(...lzReceiveResult.signers);
+    }
+    instructions.push(this.postExecute(executor, contextVersion).instruction);
+    return { signers, instructions };
   }
   async compose(rpc, executor, param, commitment = "confirmed") {
     const { event, extraData, value = 0n, computeUnits = 4e5, endpointProgram = ENDPOINT_PROGRAM_ID } = param;
@@ -10625,6 +11017,17 @@ var Executor = class {
       ...accounts
     ]).items[0];
   }
+  preExecute(executor, version4, feeLimit) {
+    const context = this.pda.context(executor.publicKey, version4);
+    return preExecute(
+      { programs: this.programRepo },
+      { executor, context, feeLimit, contextVersion: version4 }
+    ).items[0];
+  }
+  postExecute(executor, version4) {
+    const context = this.pda.context(executor.publicKey, version4);
+    return postExecute({ programs: this.programRepo }, { context, executor, contextVersion: version4 }).items[0];
+  }
 };
 
 // src/generated/kinobi/uln/accounts/index.ts
@@ -10681,17 +11084,17 @@ function deserializeConfirmations(rawAccount) {
     getConfirmationsAccountDataSerializer()
   );
 }
-async function fetchConfirmations(context, publicKey14, options) {
+async function fetchConfirmations(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "Confirmations");
   return deserializeConfirmations(maybeAccount);
 }
-async function safeFetchConfirmations(context, publicKey14, options) {
+async function safeFetchConfirmations(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeConfirmations(maybeAccount) : null;
@@ -10753,17 +11156,17 @@ function deserializeReceiveConfig2(rawAccount) {
     getReceiveConfigAccountDataSerializer2()
   );
 }
-async function fetchReceiveConfig2(context, publicKey14, options) {
+async function fetchReceiveConfig2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig2(maybeAccount);
 }
-async function safeFetchReceiveConfig2(context, publicKey14, options) {
+async function safeFetchReceiveConfig2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig2(maybeAccount) : null;
@@ -10823,17 +11226,17 @@ function getSendConfigAccountDataSerializer() {
 function deserializeSendConfig(rawAccount) {
   return deserializeAccount(rawAccount, getSendConfigAccountDataSerializer());
 }
-async function fetchSendConfig(context, publicKey14, options) {
+async function fetchSendConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "SendConfig");
   return deserializeSendConfig(maybeAccount);
 }
-async function safeFetchSendConfig(context, publicKey14, options) {
+async function safeFetchSendConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfig(maybeAccount) : null;
@@ -10893,17 +11296,17 @@ function getUlnSettingsAccountDataSerializer() {
 function deserializeUlnSettings(rawAccount) {
   return deserializeAccount(rawAccount, getUlnSettingsAccountDataSerializer());
 }
-async function fetchUlnSettings(context, publicKey14, options) {
+async function fetchUlnSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "UlnSettings");
   return deserializeUlnSettings(maybeAccount);
 }
-async function safeFetchUlnSettings(context, publicKey14, options) {
+async function safeFetchUlnSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeUlnSettings(maybeAccount) : null;
@@ -13313,17 +13716,17 @@ function getPriceFeedAccountDataSerializer() {
 function deserializePriceFeed(rawAccount) {
   return deserializeAccount(rawAccount, getPriceFeedAccountDataSerializer());
 }
-async function fetchPriceFeed(context, publicKey14, options) {
+async function fetchPriceFeed(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   assertAccountExists(maybeAccount, "PriceFeed");
   return deserializePriceFeed(maybeAccount);
 }
-async function safeFetchPriceFeed(context, publicKey14, options) {
+async function safeFetchPriceFeed(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey14, false),
+    publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializePriceFeed(maybeAccount) : null;
@@ -14625,6 +15028,6 @@ var SetConfigType2 = /* @__PURE__ */ ((SetConfigType3) => {
   return SetConfigType3;
 })(SetConfigType2 || {});
 
-export { blocked_messagelib_exports as BlockedMessageLibProgram, dvn_exports2 as DVNProgram, DvnPDA, dvn_exports as DvnProgram, EDDSA, ENFORCED_OPTIONS_SEED, EndpointPDA, endpoint_exports as EndpointProgram, EventPDA, ExecutorOptionType, ExecutorPDA, executor_exports as ExecutorProgram, FAUCET_URL, MINT_SEED, MSG_TYPE_OFFSET, MaxExecutorOptionTypeLength, MessageLibPDA, MessageType, OmniAppPDA, PEER_SEED, PriceFeedPDA, pricefeed_exports as PriceFeedProgram, SendHelper, SetConfigType2 as SetConfigType, simple_message_lib_exports as SimpleMessageLibProgram, UlnPDA, uln_exports as UlnProgram, buildMessageV0, buildVersionedTransaction, closeLookupTable, createNonceAccountTX, deactivateLookupTable, extractComposeDeliveredEventByTxHash, extractComposeSentEventByTxHash, extractEventFromTransactionSignature, extractPacketSentEventByTxHash, extractReceivedPacketEventByTxHash, extractVerifiedPacketEventByTxHash, extractWorkerFeePaidEventByTxHash, generateAddressLookupTable, getBlockedMessageLibProgramId, getDVNProgramId, getEndpointProgramId, getExecutorProgramId, getLzComposeAccountMeta, getLzComposeParamsSerializer2 as getLzComposeParamsSerializer, getLzReceiveAccountSerializer, getLzReceiveAccounts, getLzReceiveParamsSerializer2 as getLzReceiveParamsSerializer, getNextNonceInstructionDataSerializer, getPricefeedProgramId, getProgramKeypair, getSimpleMessageLibProgramId, getULNProgramId, idlTypes, instructionDiscriminator, isAccountInitialized, lzCompose, lzReceive, messageLibs, nextNonce, simulateWeb3JsTransaction, toWeb3Connection, txWithAddressLookupTable, txWithNonce };
+export { blocked_messagelib_exports as BlockedMessageLibProgram, dvn_exports2 as DVNProgram, DvnPDA, dvn_exports as DvnProgram, EDDSA, ENFORCED_OPTIONS_SEED, EndpointPDA, endpoint_exports as EndpointProgram, EventPDA, ExecutorOptionType, ExecutorPDA, executor_exports as ExecutorProgram, FAUCET_URL, MINT_SEED, MSG_TYPE_OFFSET, MaxExecutorOptionTypeLength, MessageLibPDA, MessageType, OmniAppPDA, PEER_SEED, PriceFeedPDA, pricefeed_exports as PriceFeedProgram, SendHelper, SetConfigType2 as SetConfigType, simple_message_lib_exports as SimpleMessageLibProgram, UlnPDA, uln_exports as UlnProgram, addressLocator, buildLzReceiveExecutionPlan, buildMessageV0, buildVersionedTransaction, closeLookupTable, createNonceAccountTX, deactivateLookupTable, extractComposeDeliveredEventByTxHash, extractComposeSentEventByTxHash, extractEventFromTransactionSignature, extractPacketSentEventByTxHash, extractReceivedPacketEventByTxHash, extractVerifiedPacketEventByTxHash, extractWorkerFeePaidEventByTxHash, generateAddressLookupTable, getAccountMetaRefSerializer, getAddressLocatorSerializer, getBlockedMessageLibProgramId, getDVNProgramId, getEndpointProgramId, getExecutorProgramId, getInstructionSerializer, getLzComposeAccountMeta, getLzComposeParamsSerializer2 as getLzComposeParamsSerializer, getLzReceiveAccountSerializer, getLzReceiveAccountsFromTypesV1, getLzReceiveParamsSerializer, getLzReceiveTypesInfo, getLzReceiveTypesV2AccountsSerializer, getLzReceiveTypesV2ResultSerializer, getNextNonceInstructionDataSerializer, getPricefeedProgramId, getProgramKeypair, getSimpleMessageLibProgramId, getULNProgramId, idlTypes, instructionDiscriminator, isAccountInitialized, isAddressLocator, lzCompose, lzReceive, messageLibs, nextNonce, simulateWeb3JsTransaction, toWeb3Connection, txWithAddressLookupTable, txWithNonce };
 //# sourceMappingURL=umi.mjs.map
 //# sourceMappingURL=umi.mjs.map