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

package/dist/umi.cjs

@@ -11,6 +11,7 @@ var lzUtilities = require('@layerzerolabs/lz-utilities');
 var lzV2Utilities = require('@layerzerolabs/lz-v2-utilities');
 var splToken = require('@solana/spl-token');
 var invariant3 = require('tiny-invariant');
+var mplToolbox = require('@metaplex-foundation/mpl-toolbox');
 var lzDefinitions = require('@layerzerolabs/lz-definitions');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -308,8 +309,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"),
+      umi.publicKeyBytes(executor),
+      serializers.u8().serialize(version4)
+    ]);
+  }
 };
 _ExecutorPDA.EXECUTOR_CONFIG_SEED = "ExecutorConfig";
+_ExecutorPDA.EXECUTION_CONTEXT_SEED = "ExecutionContext";
 var ExecutorPDA = _ExecutorPDA;
 var _PriceFeedPDA = class _PriceFeedPDA {
   constructor(program) {
@@ -431,17 +440,17 @@ function deserializeComposeMessageState(rawAccount) {
     getComposeMessageStateAccountDataSerializer()
   );
 }
-async function fetchComposeMessageState(context, publicKey14, options) {
+async function fetchComposeMessageState(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ComposeMessageState");
   return deserializeComposeMessageState(maybeAccount);
 }
-async function safeFetchComposeMessageState(context, publicKey14, options) {
+async function safeFetchComposeMessageState(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeComposeMessageState(maybeAccount) : null;
@@ -508,17 +517,17 @@ function deserializeEndpointSettings(rawAccount) {
     getEndpointSettingsAccountDataSerializer()
   );
 }
-async function fetchEndpointSettings(context, publicKey14, options) {
+async function fetchEndpointSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "EndpointSettings");
   return deserializeEndpointSettings(maybeAccount);
 }
-async function safeFetchEndpointSettings(context, publicKey14, options) {
+async function safeFetchEndpointSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeEndpointSettings(maybeAccount) : null;
@@ -634,17 +643,17 @@ function deserializeMessageLibInfo(rawAccount) {
     getMessageLibInfoAccountDataSerializer()
   );
 }
-async function fetchMessageLibInfo(context, publicKey14, options) {
+async function fetchMessageLibInfo(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "MessageLibInfo");
   return deserializeMessageLibInfo(maybeAccount);
 }
-async function safeFetchMessageLibInfo(context, publicKey14, options) {
+async function safeFetchMessageLibInfo(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLibInfo(maybeAccount) : null;
@@ -708,17 +717,17 @@ function getNonceAccountDataSerializer() {
 function deserializeNonce(rawAccount) {
   return umi.deserializeAccount(rawAccount, getNonceAccountDataSerializer());
 }
-async function fetchNonce(context, publicKey14, options) {
+async function fetchNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce(maybeAccount);
 }
-async function safeFetchNonce(context, publicKey14, options) {
+async function safeFetchNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce(maybeAccount) : null;
@@ -777,17 +786,17 @@ function getOAppRegistryAccountDataSerializer() {
 function deserializeOAppRegistry(rawAccount) {
   return umi.deserializeAccount(rawAccount, getOAppRegistryAccountDataSerializer());
 }
-async function fetchOAppRegistry(context, publicKey14, options) {
+async function fetchOAppRegistry(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "OAppRegistry");
   return deserializeOAppRegistry(maybeAccount);
 }
-async function safeFetchOAppRegistry(context, publicKey14, options) {
+async function safeFetchOAppRegistry(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeOAppRegistry(maybeAccount) : null;
@@ -847,17 +856,17 @@ function getPayloadHashAccountDataSerializer() {
 function deserializePayloadHash(rawAccount) {
   return umi.deserializeAccount(rawAccount, getPayloadHashAccountDataSerializer());
 }
-async function fetchPayloadHash(context, publicKey14, options) {
+async function fetchPayloadHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "PayloadHash");
   return deserializePayloadHash(maybeAccount);
 }
-async function safeFetchPayloadHash(context, publicKey14, options) {
+async function safeFetchPayloadHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializePayloadHash(maybeAccount) : null;
@@ -918,17 +927,17 @@ function deserializePendingInboundNonce(rawAccount) {
     getPendingInboundNonceAccountDataSerializer()
   );
 }
-async function fetchPendingInboundNonce(context, publicKey14, options) {
+async function fetchPendingInboundNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "PendingInboundNonce");
   return deserializePendingInboundNonce(maybeAccount);
 }
-async function safeFetchPendingInboundNonce(context, publicKey14, options) {
+async function safeFetchPendingInboundNonce(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializePendingInboundNonce(maybeAccount) : null;
@@ -991,17 +1000,17 @@ function deserializeReceiveLibraryConfig(rawAccount) {
     getReceiveLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveLibraryConfig(context, publicKey14, options) {
+async function fetchReceiveLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveLibraryConfig");
   return deserializeReceiveLibraryConfig(maybeAccount);
 }
-async function safeFetchReceiveLibraryConfig(context, publicKey14, options) {
+async function safeFetchReceiveLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveLibraryConfig(maybeAccount) : null;
@@ -1064,17 +1073,17 @@ function deserializeSendLibraryConfig(rawAccount) {
     getSendLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchSendLibraryConfig(context, publicKey14, options) {
+async function fetchSendLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "SendLibraryConfig");
   return deserializeSendLibraryConfig(maybeAccount);
 }
-async function safeFetchSendLibraryConfig(context, publicKey14, options) {
+async function safeFetchSendLibraryConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeSendLibraryConfig(maybeAccount) : null;
@@ -4011,17 +4020,17 @@ function getMessageLibAccountDataSerializer() {
 function deserializeMessageLib(rawAccount) {
   return umi.deserializeAccount(rawAccount, getMessageLibAccountDataSerializer());
 }
-async function fetchMessageLib(context, publicKey14, options) {
+async function fetchMessageLib(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "MessageLib");
   return deserializeMessageLib(maybeAccount);
 }
-async function safeFetchMessageLib(context, publicKey14, options) {
+async function safeFetchMessageLib(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLib(maybeAccount) : null;
@@ -4088,17 +4097,17 @@ function deserializeReceiveConfigStore(rawAccount) {
     getReceiveConfigStoreAccountDataSerializer()
   );
 }
-async function fetchReceiveConfigStore(context, publicKey14, options) {
+async function fetchReceiveConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveConfigStore");
   return deserializeReceiveConfigStore(maybeAccount);
 }
-async function safeFetchReceiveConfigStore(context, publicKey14, options) {
+async function safeFetchReceiveConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfigStore(maybeAccount) : null;
@@ -4160,17 +4169,17 @@ function deserializeSendConfigStore(rawAccount) {
     getSendConfigStoreAccountDataSerializer()
   );
 }
-async function fetchSendConfigStore(context, publicKey14, options) {
+async function fetchSendConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "SendConfigStore");
   return deserializeSendConfigStore(maybeAccount);
 }
-async function safeFetchSendConfigStore(context, publicKey14, options) {
+async function safeFetchSendConfigStore(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfigStore(maybeAccount) : null;
@@ -6988,17 +6997,17 @@ function getDvnConfigAccountDataSerializer() {
 function deserializeDvnConfig(rawAccount) {
   return umi.deserializeAccount(rawAccount, getDvnConfigAccountDataSerializer());
 }
-async function fetchDvnConfig(context, publicKey14, options) {
+async function fetchDvnConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "DvnConfig");
   return deserializeDvnConfig(maybeAccount);
 }
-async function safeFetchDvnConfig(context, publicKey14, options) {
+async function safeFetchDvnConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeDvnConfig(maybeAccount) : null;
@@ -7061,17 +7070,17 @@ function getExecuteHashAccountDataSerializer() {
 function deserializeExecuteHash(rawAccount) {
   return umi.deserializeAccount(rawAccount, getExecuteHashAccountDataSerializer());
 }
-async function fetchExecuteHash(context, publicKey14, options) {
+async function fetchExecuteHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ExecuteHash");
   return deserializeExecuteHash(maybeAccount);
 }
-async function safeFetchExecuteHash(context, publicKey14, options) {
+async function safeFetchExecuteHash(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeExecuteHash(maybeAccount) : null;
@@ -7132,17 +7141,17 @@ function deserializeReceiveConfig(rawAccount) {
     getReceiveConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveConfig(context, publicKey14, options) {
+async function fetchReceiveConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig(maybeAccount);
 }
-async function safeFetchReceiveConfig(context, publicKey14, options) {
+async function safeFetchReceiveConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig(maybeAccount) : null;
@@ -8389,22 +8398,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 serializers.mapSerializer(
+    serializers.struct(
+      [
+        ["discriminator", serializers.bytes({ size: 8 })],
+        ["initialPayerBalance", serializers.u64()],
+        ["feeLimit", serializers.u64()]
+      ],
+      { description: "ExecutionContextV1AccountData" }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([132, 92, 176, 59, 141, 186, 141, 137])
+    })
+  );
+}
+function deserializeExecutionContextV1(rawAccount) {
+  return umi.deserializeAccount(
+    rawAccount,
+    getExecutionContextV1AccountDataSerializer()
+  );
+}
+async function fetchExecutionContextV1(context, publicKey16, options) {
+  const maybeAccount = await context.rpc.getAccount(
+    umi.publicKey(publicKey16, false),
+    options
+  );
+  umi.assertAccountExists(maybeAccount, "ExecutionContextV1");
+  return deserializeExecutionContextV1(maybeAccount);
+}
+async function safeFetchExecutionContextV1(context, publicKey16, options) {
+  const maybeAccount = await context.rpc.getAccount(
+    umi.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) => umi.publicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    umi.assertAccountExists(maybeAccount, "ExecutionContextV1");
+    return deserializeExecutionContextV1(maybeAccount);
+  });
+}
+async function safeFetchAllExecutionContextV1(context, publicKeys, options) {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => umi.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 umi.gpaBuilder(context, programId).registerFields({
+    discriminator: [0, serializers.bytes({ size: 8 })],
+    initialPayerBalance: [8, serializers.u64()],
+    feeLimit: [16, serializers.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 = {};
@@ -8417,7 +8509,6 @@ __export(types_exports4, {
   getExecutionStateSerializer: () => getExecutionStateSerializer,
   getLzComposeParamsSerializer: () => getLzComposeParamsSerializer,
   getLzOptionSerializer: () => getLzOptionSerializer2,
-  getLzReceiveParamsSerializer: () => getLzReceiveParamsSerializer,
   getNativeDropRequestSerializer: () => getNativeDropRequestSerializer,
   getOwnerSetConfigParamsSerializer: () => getOwnerSetConfigParamsSerializer,
   isAdminSetConfigParams: () => isAdminSetConfigParams,
@@ -8509,19 +8600,6 @@ function getLzOptionSerializer2() {
     { description: "LzOption" }
   );
 }
-function getLzReceiveParamsSerializer() {
-  return serializers.struct(
-    [
-      ["srcEid", serializers.u32()],
-      ["sender", serializers.bytes({ size: 32 })],
-      ["nonce", serializers.u64()],
-      ["guid", serializers.bytes({ size: 32 })],
-      ["message", serializers.bytes({ size: serializers.u32() })],
-      ["extraData", serializers.bytes({ size: serializers.u32() })]
-    ],
-    { description: "LzReceiveParams" }
-  );
-}
 function getNativeDropRequestSerializer() {
   return serializers.struct(
     [
@@ -8618,17 +8696,17 @@ function deserializeExecutorConfig(rawAccount) {
     getExecutorConfigAccountDataSerializer()
   );
 }
-async function fetchExecutorConfig(context, publicKey14, options) {
+async function fetchExecutorConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ExecutorConfig");
   return deserializeExecutorConfig(maybeAccount);
 }
-async function safeFetchExecutorConfig(context, publicKey14, options) {
+async function safeFetchExecutorConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeExecutorConfig(maybeAccount) : null;
@@ -8696,17 +8774,17 @@ function getNonceAccountDataSerializer2() {
 function deserializeNonce2(rawAccount) {
   return umi.deserializeAccount(rawAccount, getNonceAccountDataSerializer2());
 }
-async function fetchNonce2(context, publicKey14, options) {
+async function fetchNonce2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce2(maybeAccount);
 }
-async function safeFetchNonce2(context, publicKey14, options) {
+async function safeFetchNonce2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce2(maybeAccount) : null;
@@ -8750,9 +8828,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,
@@ -8956,6 +9036,32 @@ var InvalidOwnerError = class extends umi.ProgramError {
 };
 codeToErrorMap4.set(6017, InvalidOwnerError);
 nameToErrorMap4.set("InvalidOwner", InvalidOwnerError);
+var InvalidInstructionSequenceError = class extends umi.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 umi.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;
@@ -8991,20 +9097,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) {
@@ -9200,78 +9308,6 @@ function executable(context, accounts, args) {
     { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
   ]);
 }
-function getExecuteInstructionDataSerializer() {
-  return serializers.mapSerializer(
-    serializers.struct(
-      [
-        ["discriminator", serializers.bytes({ size: 8 })],
-        ["receiver", serializers.publicKey()],
-        ["lzReceive", getLzReceiveParamsSerializer()],
-        ["value", serializers.u64()],
-        ["computeUnits", serializers.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 umi.transactionBuilder([
-    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
-  ]);
-}
 function getExtendExecutorConfigInstructionDataSerializer() {
   return serializers.mapSerializer(
     serializers.struct(
@@ -9520,6 +9556,137 @@ function ownerSetConfig(context, input) {
     { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
   ]);
 }
+function getPostExecuteInstructionDataSerializer() {
+  return serializers.mapSerializer(
+    serializers.struct(
+      [
+        ["discriminator", serializers.bytes({ size: 8 })],
+        ["contextVersion", serializers.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 = umi.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 umi.transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
+  ]);
+}
+function getPreExecuteInstructionDataSerializer() {
+  return serializers.mapSerializer(
+    serializers.struct(
+      [
+        ["discriminator", serializers.bytes({ size: 8 })],
+        ["contextVersion", serializers.u8()],
+        ["feeLimit", serializers.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 = umi.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 umi.transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain }
+  ]);
+}
 function getQuoteExecutorInstructionDataSerializer() {
   return serializers.mapSerializer(
     serializers.struct(
@@ -9585,9 +9752,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 serializers.struct(
     [
       ["srcEid", serializers.u32()],
@@ -9632,6 +9800,72 @@ var ExecutorOptionType = /* @__PURE__ */ ((ExecutorOptionType2) => {
   return ExecutorOptionType2;
 })(ExecutorOptionType || {});
 var MaxExecutorOptionTypeLength = 10;
+function getAddressLocatorSerializer() {
+  return serializers.dataEnum(
+    [
+      [
+        "Address",
+        serializers.struct([["fields", serializers.tuple([serializers.publicKey()])]])
+      ],
+      ["AltIndex", serializers.struct([["fields", serializers.tuple([serializers.u8(), serializers.u8()])]])],
+      ["Payer", serializers.unit()],
+      ["Signer", serializers.struct([["fields", serializers.tuple([serializers.u8()])]])],
+      ["Context", serializers.unit()]
+    ],
+    { description: "AddressLocator" }
+  );
+}
+function getLzReceiveTypesV2AccountsSerializer() {
+  return serializers.struct([["accounts", serializers.array(serializers.publicKey())]], {
+    description: "LzReceiveTypesV2Result"
+  });
+}
+function getAccountMetaRefSerializer() {
+  return serializers.struct(
+    [
+      ["pubkey", getAddressLocatorSerializer()],
+      ["isWritable", serializers.bool()]
+    ],
+    { description: "AccountMetaRef" }
+  );
+}
+function getInstructionSerializer() {
+  return serializers.dataEnum(
+    [
+      [
+        "LzReceive",
+        serializers.struct([
+          ["accounts", serializers.array(getAccountMetaRefSerializer())]
+        ])
+      ],
+      [
+        "Standard",
+        serializers.struct([
+          ["programId", serializers.publicKey()],
+          ["accounts", serializers.array(getAccountMetaRefSerializer())],
+          ["data", serializers.bytes({ size: serializers.u32() })]
+        ])
+      ]
+    ],
+    { description: "Instruction" }
+  );
+}
+function getLzReceiveTypesV2ResultSerializer() {
+  return serializers.struct(
+    [
+      ["contextVersion", serializers.u8()],
+      ["alts", serializers.array(serializers.publicKey())],
+      ["instructions", serializers.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 = {};
@@ -10150,29 +10384,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] = serializers.publicKey().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(),
+    [umiWeb3jsAdapters.toWeb3JsInstruction(lzReceiveTypesIx)],
+    umiWeb3jsAdapters.toWeb3JsPublicKey(receiverProgram),
+    umiWeb3jsAdapters.toWeb3JsPublicKey(payer),
+    serializers.array(getLzReceiveAccountSerializer()),
+    commitment
+  );
+  return updateAccountFromSimulatedResp(keys, payer);
+}
+function updateAccountFromSimulatedResp(accounts, payer) {
+  return accounts.map((r) => {
+    if (r.pubkey == umi.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(),
+    [umiWeb3jsAdapters.toWeb3JsInstruction(lzReceiveTypesIx)],
+    umiWeb3jsAdapters.toWeb3JsPublicKey(receiverProgram),
+    umiWeb3jsAdapters.toWeb3JsPublicKey(payer),
+    getLzReceiveTypesV2ResultSerializer(),
+    commitment
+  );
+  const tables = await mplToolbox.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(),
+    [umiWeb3jsAdapters.toWeb3JsInstruction(lzReceiveTypesIx)],
+    umiWeb3jsAdapters.toWeb3JsPublicKey(receiverProgram),
+    umiWeb3jsAdapters.toWeb3JsPublicKey(payer),
+    serializers.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$1, 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 = umi.generateSigner(umi$1);
+      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 = umi.publicKey(lzV2Utilities.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 = lzUtilities.arrayify(sender_);
+  const receiverBytes = lzV2Utilities.addressToBytes32(receiver_);
   const message = lzUtilities.arrayify(message_);
   const params = {
     srcEid,
-    sender: lzUtilities.arrayify(sender),
+    sender,
     guid: lzUtilities.arrayify(guid),
     message,
     callerParams,
-    nonce: BigInt(packet.nonce)
+    nonce: BigInt(nonce)
   };
-  const receiverInfo = await rpc.getAccount(receiver, { commitment });
-  invariant3__default.default(receiverInfo.exists, `Receiver account not found: ${receiver}`);
+  const receiverPubkey = umi.publicKey(receiverBytes);
+  const receiverInfo = await rpc.getAccount(receiverPubkey, { commitment });
+  invariant3__default.default(receiverInfo.exists, `Receiver account not found: ${receiverPubkey}`);
   const receiverProgram = umi.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;
@@ -10197,47 +10671,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] = serializers.publicKey().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(),
-    [umiWeb3jsAdapters.toWeb3JsInstruction(lzReceiveTypesIx)],
-    umiWeb3jsAdapters.toWeb3JsPublicKey(receiverProgram),
-    umiWeb3jsAdapters.toWeb3JsPublicKey(payer),
-    serializers.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);
@@ -10277,9 +10710,9 @@ async function getLzComposeAccountMeta(rpc, payer, to, composerProgram, params,
     serializers.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 == umi.defaultPublicKey() && r.isSigner) {
       if (!payer) throw new Error("payer is required");
@@ -10539,61 +10972,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 = umi.publicKey(lzV2Utilities.addressToBytes32(receiver_));
-    const receiverInfo = await rpc.getAccount(receiver, { commitment });
-    invariant3__default.default(receiverInfo.exists, `Receiver account not found: ${receiver}`);
-    const receiverProgram = umi.publicKey(receiverInfo.owner);
-    const message = lzUtilities.arrayify(message_);
-    const accounts = await getLzReceiveAccounts(
-      rpc,
-      executor.publicKey,
-      receiver,
-      receiverProgram,
-      {
-        srcEid,
-        sender: lzUtilities.arrayify(sender),
-        guid: lzUtilities.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: lzUtilities.arrayify(sender),
-          nonce: parseInt(nonce),
-          guid: lzUtilities.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;
@@ -10649,6 +11041,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
@@ -10705,17 +11108,17 @@ function deserializeConfirmations(rawAccount) {
     getConfirmationsAccountDataSerializer()
   );
 }
-async function fetchConfirmations(context, publicKey14, options) {
+async function fetchConfirmations(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "Confirmations");
   return deserializeConfirmations(maybeAccount);
 }
-async function safeFetchConfirmations(context, publicKey14, options) {
+async function safeFetchConfirmations(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeConfirmations(maybeAccount) : null;
@@ -10777,17 +11180,17 @@ function deserializeReceiveConfig2(rawAccount) {
     getReceiveConfigAccountDataSerializer2()
   );
 }
-async function fetchReceiveConfig2(context, publicKey14, options) {
+async function fetchReceiveConfig2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig2(maybeAccount);
 }
-async function safeFetchReceiveConfig2(context, publicKey14, options) {
+async function safeFetchReceiveConfig2(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig2(maybeAccount) : null;
@@ -10847,17 +11250,17 @@ function getSendConfigAccountDataSerializer() {
 function deserializeSendConfig(rawAccount) {
   return umi.deserializeAccount(rawAccount, getSendConfigAccountDataSerializer());
 }
-async function fetchSendConfig(context, publicKey14, options) {
+async function fetchSendConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "SendConfig");
   return deserializeSendConfig(maybeAccount);
 }
-async function safeFetchSendConfig(context, publicKey14, options) {
+async function safeFetchSendConfig(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfig(maybeAccount) : null;
@@ -10917,17 +11320,17 @@ function getUlnSettingsAccountDataSerializer() {
 function deserializeUlnSettings(rawAccount) {
   return umi.deserializeAccount(rawAccount, getUlnSettingsAccountDataSerializer());
 }
-async function fetchUlnSettings(context, publicKey14, options) {
+async function fetchUlnSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "UlnSettings");
   return deserializeUlnSettings(maybeAccount);
 }
-async function safeFetchUlnSettings(context, publicKey14, options) {
+async function safeFetchUlnSettings(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializeUlnSettings(maybeAccount) : null;
@@ -13337,17 +13740,17 @@ function getPriceFeedAccountDataSerializer() {
 function deserializePriceFeed(rawAccount) {
   return umi.deserializeAccount(rawAccount, getPriceFeedAccountDataSerializer());
 }
-async function fetchPriceFeed(context, publicKey14, options) {
+async function fetchPriceFeed(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "PriceFeed");
   return deserializePriceFeed(maybeAccount);
 }
-async function safeFetchPriceFeed(context, publicKey14, options) {
+async function safeFetchPriceFeed(context, publicKey16, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey14, false),
+    umi.publicKey(publicKey16, false),
     options
   );
   return maybeAccount.exists ? deserializePriceFeed(maybeAccount) : null;
@@ -14676,6 +15079,8 @@ exports.SetConfigType = SetConfigType2;
 exports.SimpleMessageLibProgram = simple_message_lib_exports;
 exports.UlnPDA = UlnPDA;
 exports.UlnProgram = uln_exports;
+exports.addressLocator = addressLocator;
+exports.buildLzReceiveExecutionPlan = buildLzReceiveExecutionPlan;
 exports.buildMessageV0 = buildMessageV0;
 exports.buildVersionedTransaction = buildVersionedTransaction;
 exports.closeLookupTable = closeLookupTable;
@@ -14689,15 +15094,21 @@ exports.extractReceivedPacketEventByTxHash = extractReceivedPacketEventByTxHash;
 exports.extractVerifiedPacketEventByTxHash = extractVerifiedPacketEventByTxHash;
 exports.extractWorkerFeePaidEventByTxHash = extractWorkerFeePaidEventByTxHash;
 exports.generateAddressLookupTable = generateAddressLookupTable;
+exports.getAccountMetaRefSerializer = getAccountMetaRefSerializer;
+exports.getAddressLocatorSerializer = getAddressLocatorSerializer;
 exports.getBlockedMessageLibProgramId = getBlockedMessageLibProgramId;
 exports.getDVNProgramId = getDVNProgramId;
 exports.getEndpointProgramId = getEndpointProgramId;
 exports.getExecutorProgramId = getExecutorProgramId;
+exports.getInstructionSerializer = getInstructionSerializer;
 exports.getLzComposeAccountMeta = getLzComposeAccountMeta;
 exports.getLzComposeParamsSerializer = getLzComposeParamsSerializer2;
 exports.getLzReceiveAccountSerializer = getLzReceiveAccountSerializer;
-exports.getLzReceiveAccounts = getLzReceiveAccounts;
-exports.getLzReceiveParamsSerializer = getLzReceiveParamsSerializer2;
+exports.getLzReceiveAccountsFromTypesV1 = getLzReceiveAccountsFromTypesV1;
+exports.getLzReceiveParamsSerializer = getLzReceiveParamsSerializer;
+exports.getLzReceiveTypesInfo = getLzReceiveTypesInfo;
+exports.getLzReceiveTypesV2AccountsSerializer = getLzReceiveTypesV2AccountsSerializer;
+exports.getLzReceiveTypesV2ResultSerializer = getLzReceiveTypesV2ResultSerializer;
 exports.getNextNonceInstructionDataSerializer = getNextNonceInstructionDataSerializer;
 exports.getPricefeedProgramId = getPricefeedProgramId;
 exports.getProgramKeypair = getProgramKeypair;
@@ -14706,6 +15117,7 @@ exports.getULNProgramId = getULNProgramId;
 exports.idlTypes = idlTypes;
 exports.instructionDiscriminator = instructionDiscriminator;
 exports.isAccountInitialized = isAccountInitialized;
+exports.isAddressLocator = isAddressLocator;
 exports.lzCompose = lzCompose;
 exports.lzReceive = lzReceive;
 exports.messageLibs = messageLibs;