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

package/dist/umi.mjs

@@ -9,7 +9,7 @@ import { keccak_256, sha2_256 } from '@layerzerolabs/lz-foundation';
 import { arrayify } from '@layerzerolabs/lz-utilities';
 import { addressToBytes32, PacketV1Codec } from '@layerzerolabs/lz-v2-utilities';
 import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from '@solana/spl-token';
-import invariant3 from 'tiny-invariant';
+import invariant2 from 'tiny-invariant';
 import { fetchAllAddressLookupTable } from '@metaplex-foundation/mpl-toolbox';
 import { Environment } from '@layerzerolabs/lz-definitions';
 
@@ -416,17 +416,17 @@ function deserializeComposeMessageState(rawAccount) {
     getComposeMessageStateAccountDataSerializer()
   );
 }
-async function fetchComposeMessageState(context, publicKey16, options) {
+async function fetchComposeMessageState(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ComposeMessageState");
   return deserializeComposeMessageState(maybeAccount);
 }
-async function safeFetchComposeMessageState(context, publicKey16, options) {
+async function safeFetchComposeMessageState(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeComposeMessageState(maybeAccount) : null;
@@ -493,17 +493,17 @@ function deserializeEndpointSettings(rawAccount) {
     getEndpointSettingsAccountDataSerializer()
   );
 }
-async function fetchEndpointSettings(context, publicKey16, options) {
+async function fetchEndpointSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "EndpointSettings");
   return deserializeEndpointSettings(maybeAccount);
 }
-async function safeFetchEndpointSettings(context, publicKey16, options) {
+async function safeFetchEndpointSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeEndpointSettings(maybeAccount) : null;
@@ -619,17 +619,17 @@ function deserializeMessageLibInfo(rawAccount) {
     getMessageLibInfoAccountDataSerializer()
   );
 }
-async function fetchMessageLibInfo(context, publicKey16, options) {
+async function fetchMessageLibInfo(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "MessageLibInfo");
   return deserializeMessageLibInfo(maybeAccount);
 }
-async function safeFetchMessageLibInfo(context, publicKey16, options) {
+async function safeFetchMessageLibInfo(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLibInfo(maybeAccount) : null;
@@ -693,17 +693,17 @@ function getNonceAccountDataSerializer() {
 function deserializeNonce(rawAccount) {
   return deserializeAccount(rawAccount, getNonceAccountDataSerializer());
 }
-async function fetchNonce(context, publicKey16, options) {
+async function fetchNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce(maybeAccount);
 }
-async function safeFetchNonce(context, publicKey16, options) {
+async function safeFetchNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce(maybeAccount) : null;
@@ -762,17 +762,17 @@ function getOAppRegistryAccountDataSerializer() {
 function deserializeOAppRegistry(rawAccount) {
   return deserializeAccount(rawAccount, getOAppRegistryAccountDataSerializer());
 }
-async function fetchOAppRegistry(context, publicKey16, options) {
+async function fetchOAppRegistry(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "OAppRegistry");
   return deserializeOAppRegistry(maybeAccount);
 }
-async function safeFetchOAppRegistry(context, publicKey16, options) {
+async function safeFetchOAppRegistry(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeOAppRegistry(maybeAccount) : null;
@@ -832,17 +832,17 @@ function getPayloadHashAccountDataSerializer() {
 function deserializePayloadHash(rawAccount) {
   return deserializeAccount(rawAccount, getPayloadHashAccountDataSerializer());
 }
-async function fetchPayloadHash(context, publicKey16, options) {
+async function fetchPayloadHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "PayloadHash");
   return deserializePayloadHash(maybeAccount);
 }
-async function safeFetchPayloadHash(context, publicKey16, options) {
+async function safeFetchPayloadHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializePayloadHash(maybeAccount) : null;
@@ -903,17 +903,17 @@ function deserializePendingInboundNonce(rawAccount) {
     getPendingInboundNonceAccountDataSerializer()
   );
 }
-async function fetchPendingInboundNonce(context, publicKey16, options) {
+async function fetchPendingInboundNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "PendingInboundNonce");
   return deserializePendingInboundNonce(maybeAccount);
 }
-async function safeFetchPendingInboundNonce(context, publicKey16, options) {
+async function safeFetchPendingInboundNonce(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializePendingInboundNonce(maybeAccount) : null;
@@ -976,17 +976,17 @@ function deserializeReceiveLibraryConfig(rawAccount) {
     getReceiveLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveLibraryConfig(context, publicKey16, options) {
+async function fetchReceiveLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveLibraryConfig");
   return deserializeReceiveLibraryConfig(maybeAccount);
 }
-async function safeFetchReceiveLibraryConfig(context, publicKey16, options) {
+async function safeFetchReceiveLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveLibraryConfig(maybeAccount) : null;
@@ -1049,17 +1049,17 @@ function deserializeSendLibraryConfig(rawAccount) {
     getSendLibraryConfigAccountDataSerializer()
   );
 }
-async function fetchSendLibraryConfig(context, publicKey16, options) {
+async function fetchSendLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "SendLibraryConfig");
   return deserializeSendLibraryConfig(maybeAccount);
 }
-async function safeFetchSendLibraryConfig(context, publicKey16, options) {
+async function safeFetchSendLibraryConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeSendLibraryConfig(maybeAccount) : null;
@@ -3996,17 +3996,17 @@ function getMessageLibAccountDataSerializer() {
 function deserializeMessageLib(rawAccount) {
   return deserializeAccount(rawAccount, getMessageLibAccountDataSerializer());
 }
-async function fetchMessageLib(context, publicKey16, options) {
+async function fetchMessageLib(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "MessageLib");
   return deserializeMessageLib(maybeAccount);
 }
-async function safeFetchMessageLib(context, publicKey16, options) {
+async function safeFetchMessageLib(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeMessageLib(maybeAccount) : null;
@@ -4073,17 +4073,17 @@ function deserializeReceiveConfigStore(rawAccount) {
     getReceiveConfigStoreAccountDataSerializer()
   );
 }
-async function fetchReceiveConfigStore(context, publicKey16, options) {
+async function fetchReceiveConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveConfigStore");
   return deserializeReceiveConfigStore(maybeAccount);
 }
-async function safeFetchReceiveConfigStore(context, publicKey16, options) {
+async function safeFetchReceiveConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfigStore(maybeAccount) : null;
@@ -4145,17 +4145,17 @@ function deserializeSendConfigStore(rawAccount) {
     getSendConfigStoreAccountDataSerializer()
   );
 }
-async function fetchSendConfigStore(context, publicKey16, options) {
+async function fetchSendConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "SendConfigStore");
   return deserializeSendConfigStore(maybeAccount);
 }
-async function safeFetchSendConfigStore(context, publicKey16, options) {
+async function safeFetchSendConfigStore(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfigStore(maybeAccount) : null;
@@ -6973,17 +6973,17 @@ function getDvnConfigAccountDataSerializer() {
 function deserializeDvnConfig(rawAccount) {
   return deserializeAccount(rawAccount, getDvnConfigAccountDataSerializer());
 }
-async function fetchDvnConfig(context, publicKey16, options) {
+async function fetchDvnConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "DvnConfig");
   return deserializeDvnConfig(maybeAccount);
 }
-async function safeFetchDvnConfig(context, publicKey16, options) {
+async function safeFetchDvnConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeDvnConfig(maybeAccount) : null;
@@ -7046,17 +7046,17 @@ function getExecuteHashAccountDataSerializer() {
 function deserializeExecuteHash(rawAccount) {
   return deserializeAccount(rawAccount, getExecuteHashAccountDataSerializer());
 }
-async function fetchExecuteHash(context, publicKey16, options) {
+async function fetchExecuteHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ExecuteHash");
   return deserializeExecuteHash(maybeAccount);
 }
-async function safeFetchExecuteHash(context, publicKey16, options) {
+async function safeFetchExecuteHash(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeExecuteHash(maybeAccount) : null;
@@ -7117,17 +7117,17 @@ function deserializeReceiveConfig(rawAccount) {
     getReceiveConfigAccountDataSerializer()
   );
 }
-async function fetchReceiveConfig(context, publicKey16, options) {
+async function fetchReceiveConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig(maybeAccount);
 }
-async function safeFetchReceiveConfig(context, publicKey16, options) {
+async function safeFetchReceiveConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig(maybeAccount) : null;
@@ -8420,17 +8420,17 @@ function deserializeExecutionContextV1(rawAccount) {
     getExecutionContextV1AccountDataSerializer()
   );
 }
-async function fetchExecutionContextV1(context, publicKey16, options) {
+async function fetchExecutionContextV1(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ExecutionContextV1");
   return deserializeExecutionContextV1(maybeAccount);
 }
-async function safeFetchExecutionContextV1(context, publicKey16, options) {
+async function safeFetchExecutionContextV1(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeExecutionContextV1(maybeAccount) : null;
@@ -8672,17 +8672,17 @@ function deserializeExecutorConfig(rawAccount) {
     getExecutorConfigAccountDataSerializer()
   );
 }
-async function fetchExecutorConfig(context, publicKey16, options) {
+async function fetchExecutorConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ExecutorConfig");
   return deserializeExecutorConfig(maybeAccount);
 }
-async function safeFetchExecutorConfig(context, publicKey16, options) {
+async function safeFetchExecutorConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeExecutorConfig(maybeAccount) : null;
@@ -8750,17 +8750,17 @@ function getNonceAccountDataSerializer2() {
 function deserializeNonce2(rawAccount) {
   return deserializeAccount(rawAccount, getNonceAccountDataSerializer2());
 }
-async function fetchNonce2(context, publicKey16, options) {
+async function fetchNonce2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "Nonce");
   return deserializeNonce2(maybeAccount);
 }
-async function safeFetchNonce2(context, publicKey16, options) {
+async function safeFetchNonce2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeNonce2(maybeAccount) : null;
@@ -9796,6 +9796,11 @@ function getLzReceiveTypesV2AccountsSerializer() {
     description: "LzReceiveTypesV2Result"
   });
 }
+function getLzComposeTypesV2AccountsSerializer() {
+  return struct([["accounts", array(publicKey$1())]], {
+    description: "LzComposeTypesV2Accounts"
+  });
+}
 function getAccountMetaRefSerializer() {
   return struct(
     [
@@ -9805,7 +9810,7 @@ function getAccountMetaRefSerializer() {
     { description: "AccountMetaRef" }
   );
 }
-function getInstructionSerializer() {
+function getInstructionForLzReceiveSerializer() {
   return dataEnum(
     [
       [
@@ -9826,16 +9831,47 @@ function getInstructionSerializer() {
     { description: "Instruction" }
   );
 }
+function getInstructionForLzComposeSerializer() {
+  return dataEnum(
+    [
+      [
+        "LzCompose",
+        struct([
+          ["accounts", array(getAccountMetaRefSerializer())]
+        ])
+      ],
+      [
+        "Standard",
+        struct([
+          ["programId", publicKey$1()],
+          ["accounts", array(getAccountMetaRefSerializer())],
+          ["data", bytes({ size: u32() })]
+        ])
+      ]
+    ],
+    { description: "Instruction" }
+  );
+}
 function getLzReceiveTypesV2ResultSerializer() {
   return struct(
     [
       ["contextVersion", u8()],
       ["alts", array(publicKey$1())],
-      ["instructions", array(getInstructionSerializer())]
+      ["instructions", array(getInstructionForLzReceiveSerializer())]
     ],
     { description: "LzReceiveTypesV2Result" }
   );
 }
+function getLzComposeTypesV2ResultSerializer() {
+  return struct(
+    [
+      ["contextVersion", u8()],
+      ["alts", array(publicKey$1())],
+      ["instructions", array(getInstructionForLzComposeSerializer())]
+    ],
+    { description: "LzComposeTypesV2Result" }
+  );
+}
 function addressLocator(kind, data) {
   return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
 }
@@ -10360,7 +10396,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] = publicKey$1().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(),
+    [toWeb3JsInstruction(lzComposeTypesIx)],
+    toWeb3JsPublicKey(composerProgram),
+    toWeb3JsPublicKey(payer),
+    array(getLzReceiveAccountSerializer()),
+    commitment
+  );
+  return updateAccountFromSimulatedResp(keys, payer);
+}
+function updateAccountFromSimulatedResp(accounts, payer) {
+  return accounts.map((r) => {
+    if (r.pubkey == defaultPublicKey() && r.isSigner) {
+      if (!payer) throw new Error("payer is required");
+      return {
+        pubkey: payer,
+        isSigner: true,
+        isWritable: r.isWritable
+      };
+    } else {
+      return {
+        pubkey: r.pubkey,
+        isSigner: r.isSigner,
+        isWritable: r.isWritable
+      };
+    }
+  });
+}
+async function 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(),
+    [toWeb3JsInstruction(lzComposeTypesIx)],
+    toWeb3JsPublicKey(composerProgram),
+    toWeb3JsPublicKey(payer),
+    getLzComposeTypesV2ResultSerializer(),
+    commitment
+  );
+  const tables = await 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(),
+    [toWeb3JsInstruction(lzComposeTypesIx)],
+    toWeb3JsPublicKey(composerProgram),
+    toWeb3JsPublicKey(payer),
+    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, executorProgram, tables, signers, locator, payer, contextVersion) {
+  if (locator.__kind === "Payer") {
+    return payer;
+  } else if (locator.__kind === "Signer") {
+    const index = locator.fields[0];
+    let signer = signers[index];
+    if (signer === void 0) {
+      signer = generateSigner(umi);
+      signers[index] = signer;
+    }
+    return signer.publicKey;
+  } else if (locator.__kind === "Address") {
+    return locator.fields[0];
+  } else if (locator.__kind === "Context") {
+    const pda = new ExecutorPDA(executorProgram);
+    return pda.context(payer, contextVersion)[0];
+  } else {
+    const table = tables[locator.fields[0]];
+    return table.addresses[locator.fields[1]];
+  }
+}
 async function getLzReceiveAccountsFromTypesV1(rpc, payer, receiver, receiverProgram, params, commitment = "confirmed") {
   const oappPDA = new OmniAppPDA(receiverProgram);
   const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver);
@@ -10397,9 +10632,9 @@ async function getLzReceiveAccountsFromTypesV1(rpc, payer, receiver, receiverPro
     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 == defaultPublicKey() && r.isSigner) {
       if (!payer) throw new Error("payer is required");
@@ -10464,7 +10699,7 @@ async function buildLzReceiveExecutionPlan(rpc, executorProgram, payer, receiver
       return {
         programId: receiverProgram,
         keys: ix.accounts.map(
-          (account) => accountMetaRefToAccountMeta(
+          (account) => accountMetaRefToAccountMeta2(
             { eddsa: EDDSA },
             executorProgram,
             tables,
@@ -10480,7 +10715,7 @@ async function buildLzReceiveExecutionPlan(rpc, executorProgram, payer, receiver
       return {
         programId: ix.programId,
         keys: ix.accounts.map(
-          (account) => accountMetaRefToAccountMeta(
+          (account) => accountMetaRefToAccountMeta2(
             { eddsa: EDDSA },
             executorProgram,
             tables,
@@ -10497,7 +10732,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") {
@@ -10533,12 +10769,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, executorProgram, tables, signers, locator, payer, contextVersion) {
+function addressLocatorToPublicKey2(umi, executorProgram, tables, signers, locator, payer, contextVersion) {
   if (locator.__kind === "Payer") {
     return payer;
   } else if (locator.__kind === "Signer") {
@@ -10576,7 +10812,7 @@ async function lzReceive(rpc, payer, packet, callerParams = Uint8Array.from([0,
   };
   const receiverPubkey = publicKey(receiverBytes);
   const receiverInfo = await rpc.getAccount(receiverPubkey, { commitment });
-  invariant3(receiverInfo.exists, `Receiver account not found: ${receiverPubkey}`);
+  invariant2(receiverInfo.exists, `Receiver account not found: ${receiverPubkey}`);
   const receiverProgram = publicKey(receiverInfo.owner);
   let version4 = 1;
   let receiveTypesAccounts;
@@ -10624,7 +10860,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,
@@ -10638,73 +10874,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] = publicKey$1().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(),
-    [toWeb3JsInstruction(lzComposeTypesIx)],
-    toWeb3JsPublicKey(composerProgram),
-    toWeb3JsPublicKey(payer),
-    array(getLzReceiveAccountSerializer()),
-    "confirmed"
-  );
-  return updateAccountFromSimulatedResp2(keys, payer);
-}
-function updateAccountFromSimulatedResp2(accounts, payer) {
-  return accounts.map((r) => {
-    if (r.pubkey == defaultPublicKey() && r.isSigner) {
-      if (!payer) throw new Error("payer is required");
-      return {
-        pubkey: payer,
-        isSigner: true,
-        isWritable: r.isWritable
-      };
-    } else {
-      return {
-        pubkey: r.pubkey,
-        isSigner: r.isSigner,
-        isWritable: r.isWritable
-      };
-    }
-  });
+  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
@@ -10954,68 +11155,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(receiverInfo.exists, `Receiver account not found: ${to}`);
-    const receiverProgram = 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);
@@ -11084,17 +11251,17 @@ function deserializeConfirmations(rawAccount) {
     getConfirmationsAccountDataSerializer()
   );
 }
-async function fetchConfirmations(context, publicKey16, options) {
+async function fetchConfirmations(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "Confirmations");
   return deserializeConfirmations(maybeAccount);
 }
-async function safeFetchConfirmations(context, publicKey16, options) {
+async function safeFetchConfirmations(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeConfirmations(maybeAccount) : null;
@@ -11156,17 +11323,17 @@ function deserializeReceiveConfig2(rawAccount) {
     getReceiveConfigAccountDataSerializer2()
   );
 }
-async function fetchReceiveConfig2(context, publicKey16, options) {
+async function fetchReceiveConfig2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "ReceiveConfig");
   return deserializeReceiveConfig2(maybeAccount);
 }
-async function safeFetchReceiveConfig2(context, publicKey16, options) {
+async function safeFetchReceiveConfig2(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeReceiveConfig2(maybeAccount) : null;
@@ -11226,17 +11393,17 @@ function getSendConfigAccountDataSerializer() {
 function deserializeSendConfig(rawAccount) {
   return deserializeAccount(rawAccount, getSendConfigAccountDataSerializer());
 }
-async function fetchSendConfig(context, publicKey16, options) {
+async function fetchSendConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "SendConfig");
   return deserializeSendConfig(maybeAccount);
 }
-async function safeFetchSendConfig(context, publicKey16, options) {
+async function safeFetchSendConfig(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeSendConfig(maybeAccount) : null;
@@ -11296,17 +11463,17 @@ function getUlnSettingsAccountDataSerializer() {
 function deserializeUlnSettings(rawAccount) {
   return deserializeAccount(rawAccount, getUlnSettingsAccountDataSerializer());
 }
-async function fetchUlnSettings(context, publicKey16, options) {
+async function fetchUlnSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "UlnSettings");
   return deserializeUlnSettings(maybeAccount);
 }
-async function safeFetchUlnSettings(context, publicKey16, options) {
+async function safeFetchUlnSettings(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializeUlnSettings(maybeAccount) : null;
@@ -12943,9 +13110,9 @@ var Uln = class {
         }
       ).items[0];
     } else {
-      invariant3(isSome(sendUlnConfig), "sendUlnConfig is required");
-      invariant3(isSome(receiveUlnConfig), "receiveUlnConfig is required");
-      invariant3(isSome(executorConfig), "executorConfig is required");
+      invariant2(isSome(sendUlnConfig), "sendUlnConfig is required");
+      invariant2(isSome(receiveUlnConfig), "receiveUlnConfig is required");
+      invariant2(isSome(executorConfig), "executorConfig is required");
       return initDefaultConfig2(
         { programs: this.programRepo },
         {
@@ -13099,9 +13266,9 @@ var Uln = class {
     const { payer, tokenMint, tokenSource } = accounts;
     const { sender, dstEid } = path;
     const ulnState = await this.getSetting(rpc, commitment);
-    invariant3(ulnState !== null, "ULN not initialized");
-    invariant3(isSome(ulnState.treasury), "treasury not set");
-    invariant3(isSome(ulnState.treasury.value.lzToken), "lzToken treasury not set");
+    invariant2(ulnState !== null, "ULN not initialized");
+    invariant2(isSome(ulnState.treasury), "treasury not set");
+    invariant2(isSome(ulnState.treasury.value.lzToken), "lzToken treasury not set");
     const lzTokenTreasury = ulnState.treasury.value.lzToken.value.receiver;
     let txBuilder = sendWithLzToken2(
       { payer: createNoopSigner(payer), programs: this.programRepo },
@@ -13169,7 +13336,7 @@ var Uln = class {
     });
     const priceFeedInfos = await rpc.getAccounts(priceFeeds, { commitment });
     const priceFeedDict = priceFeedInfos.reduce((acc, info, i) => {
-      invariant3(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
+      invariant2(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
       acc.set(priceFeeds[i], info.owner);
       return acc;
     }, /* @__PURE__ */ new Map());
@@ -13205,7 +13372,7 @@ var Uln = class {
     const [defaultSendConfigBuf, sendConfigBuf] = await rpc.getAccounts([defaultSendConfig, sendConfig], {
       commitment
     });
-    invariant3(defaultSendConfigBuf.exists, "defaultSendConfig not initialized");
+    invariant2(defaultSendConfigBuf.exists, "defaultSendConfig not initialized");
     const defaultSendConfigState = deserializeSendConfig(defaultSendConfigBuf);
     let {
       executor,
@@ -13229,14 +13396,14 @@ var Uln = class {
     const [executorBuf, ...dvnBuf] = await rpc.getAccounts([executor.executor, ...dvns], {
       commitment
     });
-    invariant3(executorBuf.exists, `executor:${executor.executor} not initialized`);
+    invariant2(executorBuf.exists, `executor:${executor.executor} not initialized`);
     return {
       executor: {
         config: accounts_exports4.deserializeExecutorConfig(executorBuf),
         owner: executorBuf.owner
       },
       dvns: dvnBuf.map((dvn, i) => {
-        invariant3(dvn.exists, `dvn:${dvns[i]} not initialized`);
+        invariant2(dvn.exists, `dvn:${dvns[i]} not initialized`);
         return {
           config: accounts_exports3.deserializeDvnConfig(dvn),
           owner: dvn.owner
@@ -13716,17 +13883,17 @@ function getPriceFeedAccountDataSerializer() {
 function deserializePriceFeed(rawAccount) {
   return deserializeAccount(rawAccount, getPriceFeedAccountDataSerializer());
 }
-async function fetchPriceFeed(context, publicKey16, options) {
+async function fetchPriceFeed(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   assertAccountExists(maybeAccount, "PriceFeed");
   return deserializePriceFeed(maybeAccount);
 }
-async function safeFetchPriceFeed(context, publicKey16, options) {
+async function safeFetchPriceFeed(context, publicKey15, options) {
   const maybeAccount = await context.rpc.getAccount(
-    publicKey(publicKey16, false),
+    publicKey(publicKey15, false),
     options
   );
   return maybeAccount.exists ? deserializePriceFeed(maybeAccount) : null;
@@ -14634,7 +14801,7 @@ var SendHelper = class {
       [sendLibConfig, defaultSendLibConfig, simpleMsgLib, uln, ulnDefaultSendConfig, ulnSendConfig],
       commitment
     );
-    invariant3(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, "endpoint send library not initialized");
+    invariant2(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;
@@ -14700,7 +14867,7 @@ var SendHelper = class {
       [sendLibConfig, defaultSendLibConfig, simpleMsgLib, uln, ulnDefaultSendConfig, ulnSendConfig],
       commitment
     );
-    invariant3(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, "endpoint send library not initialized");
+    invariant2(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;
@@ -14883,7 +15050,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(
+    invariant2(
       ulnInfo.accountInfo.exists && ulnDefaultSendConfigInfo.accountInfo.exists,
       "uln send library not initialized"
     );
@@ -14913,7 +15080,7 @@ var SendHelper = class {
       [executor.executor, ...dvnsKey],
       commitment
     );
-    invariant3(executorBuf.exists, `executor:${executor.executor} not initialized`);
+    invariant2(executorBuf.exists, `executor:${executor.executor} not initialized`);
     let executorAccounts, dvnAccounts;
     {
       const executor2 = {
@@ -14921,7 +15088,7 @@ var SendHelper = class {
         owner: executorBuf.owner
       };
       const dvns = dvnBuf.map((dvn, i) => {
-        invariant3(dvn.exists, `dvn:${dvnsKey[i]} not initialized`);
+        invariant2(dvn.exists, `dvn:${dvnsKey[i]} not initialized`);
         return {
           config: accounts_exports3.deserializeDvnConfig(dvn),
           owner: dvn.owner
@@ -14933,10 +15100,10 @@ var SendHelper = class {
       });
       const priceFeedInfos = await this.getMultipleAccountsInfo(rpc, priceFeeds, commitment);
       priceFeedInfos.forEach((info, i) => {
-        invariant3(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
+        invariant2(info.exists, `priceFeed:${priceFeeds[i]} not initialized`);
       });
       const executorPriceFeed = await this.getMultipleAccountsInfo(rpc, [executor2.config.priceFeed], commitment);
-      invariant3(executorPriceFeed[0].exists, `executor priceFeed:${executor2.config.priceFeed} not initialized`);
+      invariant2(executorPriceFeed[0].exists, `executor priceFeed:${executor2.config.priceFeed} not initialized`);
       executorAccounts = new Executor(executor2.owner).getQuoteIXAccountMetaForCPI(
         executor2.config.priceFeed,
         executorPriceFeed[0].owner,
@@ -14945,7 +15112,7 @@ var SendHelper = class {
       dvnAccounts = (await Promise.all(
         dvns.map(async (p, i) => {
           const dvnPriceFeed = await this.getMultipleAccountsInfo(rpc, [p.config.priceFeed], commitment);
-          invariant3(dvnPriceFeed[0].exists, `dvn priceFeed:${p.config.priceFeed} not initialized`);
+          invariant2(dvnPriceFeed[0].exists, `dvn priceFeed:${p.config.priceFeed} not initialized`);
           return new DVN(p.owner).getQuoteIXAccountMetaForCPI(
             p.config.priceFeed,
             dvnPriceFeed[0].owner,
@@ -15028,6 +15195,6 @@ var SetConfigType2 = /* @__PURE__ */ ((SetConfigType3) => {
   return SetConfigType3;
 })(SetConfigType2 || {});
 
-export { blocked_messagelib_exports as BlockedMessageLibProgram, dvn_exports2 as DVNProgram, DvnPDA, dvn_exports as DvnProgram, EDDSA, ENFORCED_OPTIONS_SEED, EndpointPDA, endpoint_exports as EndpointProgram, EventPDA, ExecutorOptionType, ExecutorPDA, executor_exports as ExecutorProgram, FAUCET_URL, MINT_SEED, MSG_TYPE_OFFSET, MaxExecutorOptionTypeLength, MessageLibPDA, MessageType, OmniAppPDA, PEER_SEED, PriceFeedPDA, pricefeed_exports as PriceFeedProgram, SendHelper, SetConfigType2 as SetConfigType, simple_message_lib_exports as SimpleMessageLibProgram, UlnPDA, uln_exports as UlnProgram, addressLocator, buildLzReceiveExecutionPlan, buildMessageV0, buildVersionedTransaction, closeLookupTable, createNonceAccountTX, deactivateLookupTable, extractComposeDeliveredEventByTxHash, extractComposeSentEventByTxHash, extractEventFromTransactionSignature, extractPacketSentEventByTxHash, extractReceivedPacketEventByTxHash, extractVerifiedPacketEventByTxHash, extractWorkerFeePaidEventByTxHash, generateAddressLookupTable, getAccountMetaRefSerializer, getAddressLocatorSerializer, getBlockedMessageLibProgramId, getDVNProgramId, getEndpointProgramId, getExecutorProgramId, getInstructionSerializer, getLzComposeAccountMeta, getLzComposeParamsSerializer2 as getLzComposeParamsSerializer, getLzReceiveAccountSerializer, getLzReceiveAccountsFromTypesV1, getLzReceiveParamsSerializer, getLzReceiveTypesInfo, getLzReceiveTypesV2AccountsSerializer, getLzReceiveTypesV2ResultSerializer, getNextNonceInstructionDataSerializer, getPricefeedProgramId, getProgramKeypair, getSimpleMessageLibProgramId, getULNProgramId, idlTypes, instructionDiscriminator, isAccountInitialized, isAddressLocator, lzCompose, lzReceive, messageLibs, nextNonce, simulateWeb3JsTransaction, toWeb3Connection, txWithAddressLookupTable, txWithNonce };
+export { blocked_messagelib_exports as BlockedMessageLibProgram, dvn_exports2 as DVNProgram, DvnPDA, dvn_exports as DvnProgram, EDDSA, ENFORCED_OPTIONS_SEED, EndpointPDA, endpoint_exports as EndpointProgram, EventPDA, ExecutorOptionType, ExecutorPDA, executor_exports as ExecutorProgram, FAUCET_URL, MINT_SEED, MSG_TYPE_OFFSET, MaxExecutorOptionTypeLength, MessageLibPDA, MessageType, OmniAppPDA, PEER_SEED, PriceFeedPDA, pricefeed_exports as PriceFeedProgram, SendHelper, SetConfigType2 as SetConfigType, simple_message_lib_exports as SimpleMessageLibProgram, UlnPDA, uln_exports as UlnProgram, addressLocator, buildLzComposeExecutionPlan, buildLzReceiveExecutionPlan, buildMessageV0, buildVersionedTransaction, closeLookupTable, createNonceAccountTX, deactivateLookupTable, extractComposeDeliveredEventByTxHash, extractComposeSentEventByTxHash, extractEventFromTransactionSignature, extractPacketSentEventByTxHash, extractReceivedPacketEventByTxHash, extractVerifiedPacketEventByTxHash, extractWorkerFeePaidEventByTxHash, generateAddressLookupTable, getAccountMetaRefSerializer, getAddressLocatorSerializer, getBlockedMessageLibProgramId, getDVNProgramId, getEndpointProgramId, getExecutorProgramId, getInstructionForLzComposeSerializer, getInstructionForLzReceiveSerializer, getLzComposeAccountsFromTypesV1, getLzComposeParamsSerializer2 as getLzComposeParamsSerializer, getLzComposeTypesInfo, getLzComposeTypesV2AccountsSerializer, getLzComposeTypesV2ResultSerializer, getLzReceiveAccountSerializer, getLzReceiveAccountsFromTypesV1, getLzReceiveParamsSerializer, getLzReceiveTypesInfo, getLzReceiveTypesV2AccountsSerializer, getLzReceiveTypesV2ResultSerializer, getNextNonceInstructionDataSerializer, getPricefeedProgramId, getProgramKeypair, getSimpleMessageLibProgramId, getULNProgramId, idlTypes, instructionDiscriminator, isAccountInitialized, isAddressLocator, lzCompose, lzReceive, messageLibs, nextNonce, simulateWeb3JsTransaction, toWeb3Connection, txWithAddressLookupTable, txWithNonce };
 //# sourceMappingURL=umi.mjs.map
 //# sourceMappingURL=umi.mjs.map