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

package/dist/umi.cjs

@@ -10,7 +10,7 @@ var lzFoundation = require('@layerzerolabs/lz-foundation');
 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 invariant2 = require('tiny-invariant');
 var mplToolbox = require('@metaplex-foundation/mpl-toolbox');
 var lzDefinitions = require('@layerzerolabs/lz-definitions');
 
@@ -35,7 +35,7 @@ function _interopNamespace(e) {
 }
 
 var web3__namespace = /*#__PURE__*/_interopNamespace(web3);
-var invariant3__default = /*#__PURE__*/_interopDefault(invariant3);
+var invariant2__default = /*#__PURE__*/_interopDefault(invariant2);
 
 var __defProp = Object.defineProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -440,17 +440,17 @@ function deserializeComposeMessageState(rawAccount) {
     getComposeMessageStateAccountDataSerializer()
   );
 }
-async function fetchComposeMessageState(context, publicKey16, options) {
+async function fetchComposeMessageState(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ComposeMessageState");
   return deserializeComposeMessageState(maybeAccount);
 }
-async function safeFetchComposeMessageState(context, publicKey16, options) {
+async function safeFetchComposeMessageState(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeComposeMessageState(maybeAccount) : null;
@@ -517,17 +517,17 @@ function deserializeEndpointSettings(rawAccount) {
     getEndpointSettingsAccountDataSerializer()
   );
 }
-async function fetchEndpointSettings(context, publicKey16, options) {
+async function fetchEndpointSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "EndpointSettings");
   return deserializeEndpointSettings(maybeAccount);
 }
-async function safeFetchEndpointSettings(context, publicKey16, options) {
+async function safeFetchEndpointSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeEndpointSettings(maybeAccount) : null;
@@ -643,17 +643,17 @@ function deserializeMessageLibInfo(rawAccount) {
     getMessageLibInfoAccountDataSerializer()
   );
 }
-async function fetchMessageLibInfo(context, publicKey16, options) {
+async function fetchMessageLibInfo(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "MessageLibInfo");
   return deserializeMessageLibInfo(maybeAccount);
 }
-async function safeFetchMessageLibInfo(context, publicKey16, options) {
+async function safeFetchMessageLibInfo(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLibInfo(maybeAccount) : null;
@@ -717,17 +717,17 @@ function getNonceAccountDataSerializer() {
 function deserializeNonce(rawAccount) {
   return umi.deserializeAccount(rawAccount, getNonceAccountDataSerializer());
 }
-async function fetchNonce(context, publicKey16, options) {
+async function fetchNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce(maybeAccount);
 }
-async function safeFetchNonce(context, publicKey16, options) {
+async function safeFetchNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce(maybeAccount) : null;
@@ -786,17 +786,17 @@ function getOAppRegistryAccountDataSerializer() {
 function deserializeOAppRegistry(rawAccount) {
   return umi.deserializeAccount(rawAccount, getOAppRegistryAccountDataSerializer());
 }
-async function fetchOAppRegistry(context, publicKey16, options) {
+async function fetchOAppRegistry(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "OAppRegistry");
   return deserializeOAppRegistry(maybeAccount);
 }
-async function safeFetchOAppRegistry(context, publicKey16, options) {
+async function safeFetchOAppRegistry(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeOAppRegistry(maybeAccount) : null;
@@ -856,17 +856,17 @@ function getPayloadHashAccountDataSerializer() {
 function deserializePayloadHash(rawAccount) {
   return umi.deserializeAccount(rawAccount, getPayloadHashAccountDataSerializer());
 }
-async function fetchPayloadHash(context, publicKey16, options) {
+async function fetchPayloadHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "PayloadHash");
   return deserializePayloadHash(maybeAccount);
 }
-async function safeFetchPayloadHash(context, publicKey16, options) {
+async function safeFetchPayloadHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializePayloadHash(maybeAccount) : null;
@@ -927,17 +927,17 @@ function deserializePendingInboundNonce(rawAccount) {
     getPendingInboundNonceAccountDataSerializer()
   );
 }
-async function fetchPendingInboundNonce(context, publicKey16, options) {
+async function fetchPendingInboundNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "PendingInboundNonce");
   return deserializePendingInboundNonce(maybeAccount);
 }
-async function safeFetchPendingInboundNonce(context, publicKey16, options) {
+async function safeFetchPendingInboundNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializePendingInboundNonce(maybeAccount) : null;
@@ -1000,17 +1000,17 @@ function deserializeReceiveLibraryConfig(rawAccount) {
     getReceiveLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveLibraryConfig(context, publicKey16, options) {
+async function fetchReceiveLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveLibraryConfig");
   return deserializeReceiveLibraryConfig(maybeAccount);
 }
-async function safeFetchReceiveLibraryConfig(context, publicKey16, options) {
+async function safeFetchReceiveLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveLibraryConfig(maybeAccount) : null;
@@ -1073,17 +1073,17 @@ function deserializeSendLibraryConfig(rawAccount) {
     getSendLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchSendLibraryConfig(context, publicKey16, options) {
+async function fetchSendLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "SendLibraryConfig");
   return deserializeSendLibraryConfig(maybeAccount);
 }
-async function safeFetchSendLibraryConfig(context, publicKey16, options) {
+async function safeFetchSendLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeSendLibraryConfig(maybeAccount) : null;
@@ -4020,17 +4020,17 @@ function getMessageLibAccountDataSerializer() {
 function deserializeMessageLib(rawAccount) {
   return umi.deserializeAccount(rawAccount, getMessageLibAccountDataSerializer());
 }
-async function fetchMessageLib(context, publicKey16, options) {
+async function fetchMessageLib(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "MessageLib");
   return deserializeMessageLib(maybeAccount);
 }
-async function safeFetchMessageLib(context, publicKey16, options) {
+async function safeFetchMessageLib(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLib(maybeAccount) : null;
@@ -4097,17 +4097,17 @@ function deserializeReceiveConfigStore(rawAccount) {
     getReceiveConfigStoreAccountDataSerializer()
   );
 }
-async function fetchReceiveConfigStore(context, publicKey16, options) {
+async function fetchReceiveConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveConfigStore");
   return deserializeReceiveConfigStore(maybeAccount);
 }
-async function safeFetchReceiveConfigStore(context, publicKey16, options) {
+async function safeFetchReceiveConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfigStore(maybeAccount) : null;
@@ -4169,17 +4169,17 @@ function deserializeSendConfigStore(rawAccount) {
     getSendConfigStoreAccountDataSerializer()
   );
 }
-async function fetchSendConfigStore(context, publicKey16, options) {
+async function fetchSendConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "SendConfigStore");
   return deserializeSendConfigStore(maybeAccount);
 }
-async function safeFetchSendConfigStore(context, publicKey16, options) {
+async function safeFetchSendConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfigStore(maybeAccount) : null;
@@ -6997,17 +6997,17 @@ function getDvnConfigAccountDataSerializer() {
 function deserializeDvnConfig(rawAccount) {
   return umi.deserializeAccount(rawAccount, getDvnConfigAccountDataSerializer());
 }
-async function fetchDvnConfig(context, publicKey16, options) {
+async function fetchDvnConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "DvnConfig");
   return deserializeDvnConfig(maybeAccount);
 }
-async function safeFetchDvnConfig(context, publicKey16, options) {
+async function safeFetchDvnConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeDvnConfig(maybeAccount) : null;
@@ -7070,17 +7070,17 @@ function getExecuteHashAccountDataSerializer() {
 function deserializeExecuteHash(rawAccount) {
   return umi.deserializeAccount(rawAccount, getExecuteHashAccountDataSerializer());
 }
-async function fetchExecuteHash(context, publicKey16, options) {
+async function fetchExecuteHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ExecuteHash");
   return deserializeExecuteHash(maybeAccount);
 }
-async function safeFetchExecuteHash(context, publicKey16, options) {
+async function safeFetchExecuteHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeExecuteHash(maybeAccount) : null;
@@ -7141,17 +7141,17 @@ function deserializeReceiveConfig(rawAccount) {
     getReceiveConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveConfig(context, publicKey16, options) {
+async function fetchReceiveConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig(maybeAccount);
 }
-async function safeFetchReceiveConfig(context, publicKey16, options) {
+async function safeFetchReceiveConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig(maybeAccount) : null;
@@ -8444,17 +8444,17 @@ function deserializeExecutionContextV1(rawAccount) {
     getExecutionContextV1AccountDataSerializer()
   );
 }
-async function fetchExecutionContextV1(context, publicKey16, options) {
+async function fetchExecutionContextV1(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ExecutionContextV1");
   return deserializeExecutionContextV1(maybeAccount);
 }
-async function safeFetchExecutionContextV1(context, publicKey16, options) {
+async function safeFetchExecutionContextV1(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeExecutionContextV1(maybeAccount) : null;
@@ -8696,17 +8696,17 @@ function deserializeExecutorConfig(rawAccount) {
     getExecutorConfigAccountDataSerializer()
   );
 }
-async function fetchExecutorConfig(context, publicKey16, options) {
+async function fetchExecutorConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ExecutorConfig");
   return deserializeExecutorConfig(maybeAccount);
 }
-async function safeFetchExecutorConfig(context, publicKey16, options) {
+async function safeFetchExecutorConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeExecutorConfig(maybeAccount) : null;
@@ -8774,17 +8774,17 @@ function getNonceAccountDataSerializer2() {
 function deserializeNonce2(rawAccount) {
   return umi.deserializeAccount(rawAccount, getNonceAccountDataSerializer2());
 }
-async function fetchNonce2(context, publicKey16, options) {
+async function fetchNonce2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce2(maybeAccount);
 }
-async function safeFetchNonce2(context, publicKey16, options) {
+async function safeFetchNonce2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce2(maybeAccount) : null;
@@ -9820,6 +9820,11 @@ function getLzReceiveTypesV2AccountsSerializer() {
     description: "LzReceiveTypesV2Result"
   });
 }
+function getLzComposeTypesV2AccountsSerializer() {
+  return serializers.struct([["accounts", serializers.array(serializers.publicKey())]], {
+    description: "LzComposeTypesV2Accounts"
+  });
+}
 function getAccountMetaRefSerializer() {
   return serializers.struct(
     [
@@ -9829,7 +9834,7 @@ function getAccountMetaRefSerializer() {
     { description: "AccountMetaRef" }
   );
 }
-function getInstructionSerializer() {
+function getInstructionForLzReceiveSerializer() {
   return serializers.dataEnum(
     [
       [
@@ -9850,16 +9855,47 @@ function getInstructionSerializer() {
     { description: "Instruction" }
   );
 }
+function getInstructionForLzComposeSerializer() {
+  return serializers.dataEnum(
+    [
+      [
+        "LzCompose",
+        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())]
+      ["instructions", serializers.array(getInstructionForLzReceiveSerializer())]
     ],
     { description: "LzReceiveTypesV2Result" }
   );
 }
+function getLzComposeTypesV2ResultSerializer() {
+  return serializers.struct(
+    [
+      ["contextVersion", serializers.u8()],
+      ["alts", serializers.array(serializers.publicKey())],
+      ["instructions", serializers.array(getInstructionForLzComposeSerializer())]
+    ],
+    { description: "LzComposeTypesV2Result" }
+  );
+}
 function addressLocator(kind, data) {
   return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
 }
@@ -10384,7 +10420,206 @@ function toWeb3Connection(rpc) {
   }
 }
 
-// src/receive-types-v1.ts
+// src/compose-types-v1.ts
+async function getLzComposeAccountsFromTypesV1(rpc, payer, to, composerProgram, params, commitment = "confirmed") {
+  const oappPDA = new OmniAppPDA(composerProgram);
+  const [lzComposeTypesAccountsPDA] = oappPDA.lzComposeTypesAccounts(to);
+  const info = await rpc.getAccount(lzComposeTypesAccountsPDA, { 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 = getLzComposeParamsSerializer2().serialize(params);
+  const lzComposeTypesIx = {
+    programId: composerProgram,
+    keys: accounts,
+    data: Buffer.concat([instructionDiscriminator("lz_compose_types"), data])
+  };
+  const keys = await simulateWeb3JsTransaction(
+    rpc.getEndpoint(),
+    [umiWeb3jsAdapters.toWeb3JsInstruction(lzComposeTypesIx)],
+    umiWeb3jsAdapters.toWeb3JsPublicKey(composerProgram),
+    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 buildLzComposeExecutionPlan(rpc, executorProgram, payer, to, composerProgram, params, composeTypesAccounts, commitment = "confirmed") {
+  composeTypesAccounts = composeTypesAccounts ?? await getLzComposeTypesInfo(rpc, payer, to, composerProgram, params, commitment);
+  const data = getLzComposeParamsSerializer2().serialize(params);
+  const lzComposeTypesIx = {
+    programId: composerProgram,
+    keys: composeTypesAccounts.accounts.map((pubkey) => {
+      return {
+        pubkey,
+        isSigner: false,
+        isWritable: false
+      };
+    }),
+    data: Buffer.concat([instructionDiscriminator("lz_compose_types_v2"), data])
+  };
+  const resp = await simulateWeb3JsTransaction(
+    rpc.getEndpoint(),
+    [umiWeb3jsAdapters.toWeb3JsInstruction(lzComposeTypesIx)],
+    umiWeb3jsAdapters.toWeb3JsPublicKey(composerProgram),
+    umiWeb3jsAdapters.toWeb3JsPublicKey(payer),
+    getLzComposeTypesV2ResultSerializer(),
+    commitment
+  );
+  const tables = await mplToolbox.fetchAllAddressLookupTable({ rpc }, resp.alts);
+  const signers = {};
+  const lzComposeDiscriminator = instructionDiscriminator("lz_compose").toString("hex");
+  const instructionTracker = {};
+  for (const ix of resp.instructions) {
+    let programId = composerProgram;
+    let instructionType = "lz_compose";
+    if (ix.__kind === "Standard") {
+      const { programId: stdProgramId, data: data2 } = ix;
+      programId = stdProgramId;
+      const discriminator = Buffer.from(data2.slice(0, 8)).toString("hex");
+      instructionType = discriminator === lzComposeDiscriminator ? "lz_compose" : 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 === "LzCompose") {
+      return {
+        programId: composerProgram,
+        keys: ix.accounts.map(
+          (account) => accountMetaRefToAccountMeta(
+            { eddsa: EDDSA },
+            executorProgram,
+            tables,
+            signers,
+            account,
+            payer,
+            contextVersion
+          )
+        ),
+        data: Buffer.concat([instructionDiscriminator("lz_compose"), 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,
+    addressLookupTables: tables
+  };
+}
+async function getLzComposeTypesInfo(rpc, payer, to, composerProgram, params, commitment = "confirmed") {
+  const oappPDA = new OmniAppPDA(composerProgram);
+  const [lzComposeTypesAccountsPDA] = oappPDA.lzComposeTypesAccounts(to);
+  const lzComposeTypesIx = {
+    programId: composerProgram,
+    keys: [
+      {
+        pubkey: to,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: lzComposeTypesAccountsPDA,
+        isSigner: false,
+        isWritable: false
+      }
+    ],
+    data: Buffer.concat([instructionDiscriminator("lz_compose_types_info")])
+  };
+  const resp = await simulateWeb3JsTransaction(
+    rpc.getEndpoint(),
+    [umiWeb3jsAdapters.toWeb3JsInstruction(lzComposeTypesIx)],
+    umiWeb3jsAdapters.toWeb3JsPublicKey(composerProgram),
+    umiWeb3jsAdapters.toWeb3JsPublicKey(payer),
+    serializers.bytes(),
+    commitment
+  );
+  const version4 = resp.at(0);
+  if (version4 !== 2) {
+    throw new Error(`Invalid version ${version4}. Expected version 2.`);
+  }
+  return getLzComposeTypesV2AccountsSerializer().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]];
+  }
+}
 async function getLzReceiveAccountsFromTypesV1(rpc, payer, receiver, receiverProgram, params, commitment = "confirmed") {
   const oappPDA = new OmniAppPDA(receiverProgram);
   const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver);
@@ -10421,9 +10656,9 @@ async function getLzReceiveAccountsFromTypesV1(rpc, payer, receiver, receiverPro
     serializers.array(getLzReceiveAccountSerializer()),
     commitment
   );
-  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");
@@ -10488,7 +10723,7 @@ async function buildLzReceiveExecutionPlan(rpc, executorProgram, payer, receiver
       return {
         programId: receiverProgram,
         keys: ix.accounts.map(
-          (account) => accountMetaRefToAccountMeta(
+          (account) => accountMetaRefToAccountMeta2(
             { eddsa: EDDSA },
             executorProgram,
             tables,
@@ -10504,7 +10739,7 @@ async function buildLzReceiveExecutionPlan(rpc, executorProgram, payer, receiver
       return {
         programId: ix.programId,
         keys: ix.accounts.map(
-          (account) => accountMetaRefToAccountMeta(
+          (account) => accountMetaRefToAccountMeta2(
             { eddsa: EDDSA },
             executorProgram,
             tables,
@@ -10521,7 +10756,8 @@ async function buildLzReceiveExecutionPlan(rpc, executorProgram, payer, receiver
   return {
     contextVersion,
     signers: Object.values(signers).filter((signer) => signer !== void 0),
-    instructions
+    instructions,
+    addressLookupTables: tables
   };
 }
 async function getLzReceiveTypesInfo(rpc, payer, receiver, receiverProgram, params, commitment = "confirmed") {
@@ -10557,12 +10793,12 @@ async function getLzReceiveTypesInfo(rpc, payer, receiver, receiverProgram, para
   }
   return getLzReceiveTypesV2AccountsSerializer().deserialize(resp, 1)[0];
 }
-function accountMetaRefToAccountMeta(umi, executorProgram, tables, signers, accountMetaRef, payer, contextVersion) {
+function accountMetaRefToAccountMeta2(umi, executorProgram, tables, signers, accountMetaRef, payer, contextVersion) {
   const { isWritable, pubkey: locator } = accountMetaRef;
-  const pubkey = addressLocatorToPublicKey(umi, executorProgram, tables, signers, locator, payer, contextVersion);
+  const pubkey = addressLocatorToPublicKey2(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) {
+function addressLocatorToPublicKey2(umi$1, executorProgram, tables, signers, locator, payer, contextVersion) {
   if (locator.__kind === "Payer") {
     return payer;
   } else if (locator.__kind === "Signer") {
@@ -10600,7 +10836,7 @@ async function lzReceive(rpc, payer, packet, callerParams = Uint8Array.from([0,
   };
   const receiverPubkey = umi.publicKey(receiverBytes);
   const receiverInfo = await rpc.getAccount(receiverPubkey, { commitment });
-  invariant3__default.default(receiverInfo.exists, `Receiver account not found: ${receiverPubkey}`);
+  invariant2__default.default(receiverInfo.exists, `Receiver account not found: ${receiverPubkey}`);
   const receiverProgram = umi.publicKey(receiverInfo.owner);
   let version4 = 1;
   let receiveTypesAccounts;
@@ -10648,7 +10884,7 @@ async function lzReceive(rpc, payer, packet, callerParams = Uint8Array.from([0,
     };
   }
 }
-async function lzCompose(rpc, payer, event, extraData = Uint8Array.from([0, 0]), commitment = "confirmed") {
+async function lzCompose(rpc, payer, event, extraData = Uint8Array.from([0, 0]), executorProgram = EXECUTOR_PROGRAM_ID, commitment = "confirmed") {
   const { to, from, guid, index, message } = event;
   const params = {
     from,
@@ -10662,73 +10898,38 @@ async function lzCompose(rpc, payer, event, extraData = Uint8Array.from([0, 0]),
   if (!accountInfo.exists) {
     throw new Error(`Account not found: ${to}`);
   }
-  const programId = accountInfo.owner;
-  const accounts = await getLzComposeAccountMeta(rpc, payer, to, programId, params, commitment);
-  const data = getLzComposeParamsSerializer2().serialize(params);
-  return {
-    programId,
-    keys: accounts,
-    data: Buffer.concat([instructionDiscriminator("lz_compose"), data])
-  };
-}
-async function getLzComposeAccountMeta(rpc, payer, to, composerProgram, params, commitment = "confirmed") {
-  const lzComposeTypesAccounts = await (async () => {
-    const oappPDA = new OmniAppPDA(composerProgram);
-    const [lzComposeTypesAccountsPDA] = oappPDA.lzComposeTypesAccounts(to);
-    const info = await rpc.getAccount(lzComposeTypesAccountsPDA, { 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 = getLzComposeParamsSerializer2().serialize(params);
-  const lzComposeTypesIx = {
-    programId: composerProgram,
-    keys: lzComposeTypesAccounts,
-    data: Buffer.concat([instructionDiscriminator("lz_compose_types"), data])
-  };
-  const keys = await simulateWeb3JsTransaction(
-    rpc.getEndpoint(),
-    [umiWeb3jsAdapters.toWeb3JsInstruction(lzComposeTypesIx)],
-    umiWeb3jsAdapters.toWeb3JsPublicKey(composerProgram),
-    umiWeb3jsAdapters.toWeb3JsPublicKey(payer),
-    serializers.array(getLzReceiveAccountSerializer()),
-    "confirmed"
-  );
-  return updateAccountFromSimulatedResp2(keys, payer);
-}
-function updateAccountFromSimulatedResp2(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
-      };
-    }
-  });
+  const composerProgram = accountInfo.owner;
+  let version4 = 1;
+  let composeTypesAccounts;
+  try {
+    composeTypesAccounts = await getLzComposeTypesInfo(rpc, payer, to, composerProgram, params, commitment);
+    version4 = 2;
+  } catch (e) {
+    version4 = 1;
+  }
+  if (version4 === 2) {
+    return buildLzComposeExecutionPlan(
+      rpc,
+      executorProgram,
+      payer,
+      to,
+      composerProgram,
+      params,
+      composeTypesAccounts,
+      commitment
+    );
+  } else {
+    const accounts = await getLzComposeAccountsFromTypesV1(rpc, payer, to, composerProgram, params, commitment);
+    const data = getLzComposeParamsSerializer2().serialize(params);
+    return {
+      instruction: {
+        programId: composerProgram,
+        keys: accounts,
+        data: Buffer.concat([instructionDiscriminator("lz_compose"), data])
+      },
+      contextVersion: 1
+    };
+  }
 }
 
 // src/executor.ts
@@ -10978,68 +11179,34 @@ var Executor = class {
     const { contextVersion } = lzReceiveResult;
     const instructions = [this.preExecute(executor, contextVersion, value).instruction];
     const signers = [];
+    const addressLookupTables = [];
     if ("instruction" in lzReceiveResult) {
       instructions.push(lzReceiveResult.instruction);
     } else {
       instructions.push(...lzReceiveResult.instructions);
       signers.push(...lzReceiveResult.signers);
+      addressLookupTables.push(...lzReceiveResult.addressLookupTables);
     }
     instructions.push(this.postExecute(executor, contextVersion).instruction);
-    return { signers, instructions };
+    return { signers, instructions, addressLookupTables };
   }
   async compose(rpc, executor, param, commitment = "confirmed") {
-    const { event, extraData, value = 0n, computeUnits = 4e5, endpointProgram = ENDPOINT_PROGRAM_ID } = param;
-    const endpointEventDeriver = new EventPDA(endpointProgram);
-    const executorEventDeriver = new EventPDA(this.programId);
-    const { to, from, guid, index, message } = event;
-    const receiverInfo = await rpc.getAccount(to, { commitment });
-    invariant3__default.default(receiverInfo.exists, `Receiver account not found: ${to}`);
-    const receiverProgram = umi.publicKey(receiverInfo.owner);
-    const accounts = await getLzComposeAccountMeta(
-      rpc,
-      executor.publicKey,
-      to,
-      receiverProgram,
-      {
-        from,
-        to,
-        guid,
-        index,
-        message,
-        extraData
-      },
-      commitment
-    );
-    const txBuilder = compose(
-      { programs: this.programRepo },
-      {
-        executor,
-        config: this.pda.config(),
-        endpointProgram,
-        endpointEventAuthority: endpointEventDeriver.eventAuthority()[0],
-        program: this.programId,
-        eventAuthority: executorEventDeriver.eventAuthority()[0],
-        // param
-        lzCompose: {
-          to,
-          from,
-          guid,
-          index,
-          message,
-          extraData
-        },
-        computeUnits,
-        value
-      }
-    );
-    return txBuilder.addRemainingAccounts([
-      {
-        pubkey: receiverProgram,
-        isWritable: false,
-        isSigner: false
-      },
-      ...accounts
-    ]).items[0];
+    const { event, extraData, value = 0n } = param;
+    const payer = executor.publicKey;
+    const lzComposeResult = await lzCompose(rpc, payer, event, extraData, this.programId, commitment);
+    const { contextVersion } = lzComposeResult;
+    const instructions = [this.preExecute(executor, contextVersion, value).instruction];
+    const signers = [];
+    const addressLookupTables = [];
+    if ("instruction" in lzComposeResult) {
+      instructions.push(lzComposeResult.instruction);
+    } else {
+      instructions.push(...lzComposeResult.instructions);
+      signers.push(...lzComposeResult.signers);
+      addressLookupTables.push(...lzComposeResult.addressLookupTables);
+    }
+    instructions.push(this.postExecute(executor, contextVersion).instruction);
+    return { signers, instructions, addressLookupTables };
   }
   preExecute(executor, version4, feeLimit) {
     const context = this.pda.context(executor.publicKey, version4);
@@ -11108,17 +11275,17 @@ function deserializeConfirmations(rawAccount) {
     getConfirmationsAccountDataSerializer()
   );
 }
-async function fetchConfirmations(context, publicKey16, options) {
+async function fetchConfirmations(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "Confirmations");
   return deserializeConfirmations(maybeAccount);
 }
-async function safeFetchConfirmations(context, publicKey16, options) {
+async function safeFetchConfirmations(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeConfirmations(maybeAccount) : null;
@@ -11180,17 +11347,17 @@ function deserializeReceiveConfig2(rawAccount) {
     getReceiveConfigAccountDataSerializer2()
   );
 }
-async function fetchReceiveConfig2(context, publicKey16, options) {
+async function fetchReceiveConfig2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig2(maybeAccount);
 }
-async function safeFetchReceiveConfig2(context, publicKey16, options) {
+async function safeFetchReceiveConfig2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig2(maybeAccount) : null;
@@ -11250,17 +11417,17 @@ function getSendConfigAccountDataSerializer() {
 function deserializeSendConfig(rawAccount) {
   return umi.deserializeAccount(rawAccount, getSendConfigAccountDataSerializer());
 }
-async function fetchSendConfig(context, publicKey16, options) {
+async function fetchSendConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "SendConfig");
   return deserializeSendConfig(maybeAccount);
 }
-async function safeFetchSendConfig(context, publicKey16, options) {
+async function safeFetchSendConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfig(maybeAccount) : null;
@@ -11320,17 +11487,17 @@ function getUlnSettingsAccountDataSerializer() {
 function deserializeUlnSettings(rawAccount) {
   return umi.deserializeAccount(rawAccount, getUlnSettingsAccountDataSerializer());
 }
-async function fetchUlnSettings(context, publicKey16, options) {
+async function fetchUlnSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "UlnSettings");
   return deserializeUlnSettings(maybeAccount);
 }
-async function safeFetchUlnSettings(context, publicKey16, options) {
+async function safeFetchUlnSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeUlnSettings(maybeAccount) : null;
@@ -12967,9 +13134,9 @@ var Uln = class {
         }
       ).items[0];
     } else {
-      invariant3__default.default(umi.isSome(sendUlnConfig), "sendUlnConfig is required");
-      invariant3__default.default(umi.isSome(receiveUlnConfig), "receiveUlnConfig is required");
-      invariant3__default.default(umi.isSome(executorConfig), "executorConfig is required");
+      invariant2__default.default(umi.isSome(sendUlnConfig), "sendUlnConfig is required");
+      invariant2__default.default(umi.isSome(receiveUlnConfig), "receiveUlnConfig is required");
+      invariant2__default.default(umi.isSome(executorConfig), "executorConfig is required");
       return initDefaultConfig2(
         { programs: this.programRepo },
         {
@@ -13123,9 +13290,9 @@ var Uln = class {
     const { payer, tokenMint, tokenSource } = accounts;
     const { sender, dstEid } = path;
     const ulnState = await this.getSetting(rpc, commitment);
-    invariant3__default.default(ulnState !== null, "ULN not initialized");
-    invariant3__default.default(umi.isSome(ulnState.treasury), "treasury not set");
-    invariant3__default.default(umi.isSome(ulnState.treasury.value.lzToken), "lzToken treasury not set");
+    invariant2__default.default(ulnState !== null, "ULN not initialized");
+    invariant2__default.default(umi.isSome(ulnState.treasury), "treasury not set");
+    invariant2__default.default(umi.isSome(ulnState.treasury.value.lzToken), "lzToken treasury not set");
     const lzTokenTreasury = ulnState.treasury.value.lzToken.value.receiver;
     let txBuilder = sendWithLzToken2(
       { payer: umi.createNoopSigner(payer), programs: this.programRepo },
@@ -13193,7 +13360,7 @@ var Uln = class {
     });
     const priceFeedInfos = await rpc.getAccounts(priceFeeds, { commitment });
     const priceFeedDict = priceFeedInfos.reduce((acc, info, i) => {
-      invariant3__default.default(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
+      invariant2__default.default(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
       acc.set(priceFeeds[i], info.owner);
       return acc;
     }, /* @__PURE__ */ new Map());
@@ -13229,7 +13396,7 @@ var Uln = class {
     const [defaultSendConfigBuf, sendConfigBuf] = await rpc.getAccounts([defaultSendConfig, sendConfig], {
       commitment
     });
-    invariant3__default.default(defaultSendConfigBuf.exists, "defaultSendConfig not initialized");
+    invariant2__default.default(defaultSendConfigBuf.exists, "defaultSendConfig not initialized");
     const defaultSendConfigState = deserializeSendConfig(defaultSendConfigBuf);
     let {
       executor,
@@ -13253,14 +13420,14 @@ var Uln = class {
     const [executorBuf, ...dvnBuf] = await rpc.getAccounts([executor.executor, ...dvns], {
       commitment
     });
-    invariant3__default.default(executorBuf.exists, `executor:${executor.executor} not initialized`);
+    invariant2__default.default(executorBuf.exists, `executor:${executor.executor} not initialized`);
     return {
       executor: {
         config: accounts_exports4.deserializeExecutorConfig(executorBuf),
         owner: executorBuf.owner
       },
       dvns: dvnBuf.map((dvn, i) => {
-        invariant3__default.default(dvn.exists, `dvn:${dvns[i]} not initialized`);
+        invariant2__default.default(dvn.exists, `dvn:${dvns[i]} not initialized`);
         return {
           config: accounts_exports3.deserializeDvnConfig(dvn),
           owner: dvn.owner
@@ -13740,17 +13907,17 @@ function getPriceFeedAccountDataSerializer() {
 function deserializePriceFeed(rawAccount) {
   return umi.deserializeAccount(rawAccount, getPriceFeedAccountDataSerializer());
 }
-async function fetchPriceFeed(context, publicKey16, options) {
+async function fetchPriceFeed(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   umi.assertAccountExists(maybeAccount, "PriceFeed");
   return deserializePriceFeed(maybeAccount);
 }
-async function safeFetchPriceFeed(context, publicKey16, options) {
+async function safeFetchPriceFeed(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    umi.publicKey(publicKey16, false),
+    umi.publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializePriceFeed(maybeAccount) : null;
@@ -14658,7 +14825,7 @@ var SendHelper = class {
       [sendLibConfig, defaultSendLibConfig, simpleMsgLib, uln, ulnDefaultSendConfig, ulnSendConfig],
       commitment
     );
-    invariant3__default.default(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, "endpoint send library not initialized");
+    invariant2__default.default(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, "endpoint send library not initialized");
     const sendLibConfigInfo = endpoint_exports.accounts.deserializeSendLibraryConfig(sendLibConfigBuf);
     const defaultSendLibConfigInfo = endpoint_exports.accounts.deserializeSendLibraryConfig(defaultSendLibConfigBuf);
     const msgLib = sendLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString() ? defaultSendLibConfigInfo.messageLib : sendLibConfigInfo.messageLib;
@@ -14724,7 +14891,7 @@ var SendHelper = class {
       [sendLibConfig, defaultSendLibConfig, simpleMsgLib, uln, ulnDefaultSendConfig, ulnSendConfig],
       commitment
     );
-    invariant3__default.default(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, "endpoint send library not initialized");
+    invariant2__default.default(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, "endpoint send library not initialized");
     const sendLibConfigInfo = endpoint_exports.accounts.deserializeSendLibraryConfig(sendLibConfigBuf);
     const defaultSendLibConfigInfo = endpoint_exports.accounts.deserializeSendLibraryConfig(defaultSendLibConfigBuf);
     const msgLib = sendLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString() ? defaultSendLibConfigInfo.messageLib : sendLibConfigInfo.messageLib;
@@ -14907,7 +15074,7 @@ var SendHelper = class {
    * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
    */
   async getUlnAccounts(rpc, payer, ulnInfo, ulnDefaultSendConfigInfo, ulnSendConfigInfo, quoteOrSend, commitment = "confirmed") {
-    invariant3__default.default(
+    invariant2__default.default(
       ulnInfo.accountInfo.exists && ulnDefaultSendConfigInfo.accountInfo.exists,
       "uln send library not initialized"
     );
@@ -14937,7 +15104,7 @@ var SendHelper = class {
       [executor.executor, ...dvnsKey],
       commitment
     );
-    invariant3__default.default(executorBuf.exists, `executor:${executor.executor} not initialized`);
+    invariant2__default.default(executorBuf.exists, `executor:${executor.executor} not initialized`);
     let executorAccounts, dvnAccounts;
     {
       const executor2 = {
@@ -14945,7 +15112,7 @@ var SendHelper = class {
         owner: executorBuf.owner
       };
       const dvns = dvnBuf.map((dvn, i) => {
-        invariant3__default.default(dvn.exists, `dvn:${dvnsKey[i]} not initialized`);
+        invariant2__default.default(dvn.exists, `dvn:${dvnsKey[i]} not initialized`);
         return {
           config: accounts_exports3.deserializeDvnConfig(dvn),
           owner: dvn.owner
@@ -14957,10 +15124,10 @@ var SendHelper = class {
       });
       const priceFeedInfos = await this.getMultipleAccountsInfo(rpc, priceFeeds, commitment);
       priceFeedInfos.forEach((info, i) => {
-        invariant3__default.default(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
+        invariant2__default.default(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
       });
       const executorPriceFeed = await this.getMultipleAccountsInfo(rpc, [executor2.config.priceFeed], commitment);
-      invariant3__default.default(executorPriceFeed[0].exists, `executor priceFeed:${executor2.config.priceFeed} not initialized`);
+      invariant2__default.default(executorPriceFeed[0].exists, `executor priceFeed:${executor2.config.priceFeed} not initialized`);
       executorAccounts = new Executor(executor2.owner).getQuoteIXAccountMetaForCPI(
         executor2.config.priceFeed,
         executorPriceFeed[0].owner,
@@ -14969,7 +15136,7 @@ var SendHelper = class {
       dvnAccounts = (await Promise.all(
         dvns.map(async (p, i) => {
           const dvnPriceFeed = await this.getMultipleAccountsInfo(rpc, [p.config.priceFeed], commitment);
-          invariant3__default.default(dvnPriceFeed[0].exists, `dvn priceFeed:${p.config.priceFeed} not initialized`);
+          invariant2__default.default(dvnPriceFeed[0].exists, `dvn priceFeed:${p.config.priceFeed} not initialized`);
           return new DVN(p.owner).getQuoteIXAccountMetaForCPI(
             p.config.priceFeed,
             dvnPriceFeed[0].owner,
@@ -15080,6 +15247,7 @@ exports.SimpleMessageLibProgram = simple_message_lib_exports;
 exports.UlnPDA = UlnPDA;
 exports.UlnProgram = uln_exports;
 exports.addressLocator = addressLocator;
+exports.buildLzComposeExecutionPlan = buildLzComposeExecutionPlan;
 exports.buildLzReceiveExecutionPlan = buildLzReceiveExecutionPlan;
 exports.buildMessageV0 = buildMessageV0;
 exports.buildVersionedTransaction = buildVersionedTransaction;
@@ -15100,9 +15268,13 @@ exports.getBlockedMessageLibProgramId = getBlockedMessageLibProgramId;
 exports.getDVNProgramId = getDVNProgramId;
 exports.getEndpointProgramId = getEndpointProgramId;
 exports.getExecutorProgramId = getExecutorProgramId;
-exports.getInstructionSerializer = getInstructionSerializer;
-exports.getLzComposeAccountMeta = getLzComposeAccountMeta;
+exports.getInstructionForLzComposeSerializer = getInstructionForLzComposeSerializer;
+exports.getInstructionForLzReceiveSerializer = getInstructionForLzReceiveSerializer;
+exports.getLzComposeAccountsFromTypesV1 = getLzComposeAccountsFromTypesV1;
 exports.getLzComposeParamsSerializer = getLzComposeParamsSerializer2;
+exports.getLzComposeTypesInfo = getLzComposeTypesInfo;
+exports.getLzComposeTypesV2AccountsSerializer = getLzComposeTypesV2AccountsSerializer;
+exports.getLzComposeTypesV2ResultSerializer = getLzComposeTypesV2ResultSerializer;
 exports.getLzReceiveAccountSerializer = getLzReceiveAccountSerializer;
 exports.getLzReceiveAccountsFromTypesV1 = getLzReceiveAccountsFromTypesV1;
 exports.getLzReceiveParamsSerializer = getLzReceiveParamsSerializer;