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

package/src/receive.ts

@@ -1,33 +1,24 @@
-import {
-    AccountMeta,
-    Commitment,
-    Instruction,
-    PublicKey,
-    RpcInterface,
-    defaultPublicKey,
-    publicKey,
-} from '@metaplex-foundation/umi'
-import { array, publicKey as publicKeySerializer } from '@metaplex-foundation/umi/serializers'
-import { toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import { Commitment, Instruction, PublicKey, RpcInterface, publicKey } from '@metaplex-foundation/umi'
 import invariant from 'tiny-invariant'
 
 import { arrayify } from '@layerzerolabs/lz-utilities'
 import { Packet, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
 
-import { OmniAppPDA } from '.'
+import { getLzComposeAccountsFromTypesV1 } from './compose-types-v1'
+import { buildLzComposeExecutionPlan, getLzComposeTypesInfo } from './compose-types-v2'
 import { ComposeSentEvent } from './generated/kinobi/endpoint/events'
 import { EXECUTOR_PROGRAM_ID } from './generated/kinobi/executor/programs'
 import { getLzReceiveAccountsFromTypesV1 } from './receive-types-v1'
 import { buildLzReceiveExecutionPlan, getLzReceiveTypesInfo } from './receive-types-v2'
 import {
     LzComposeParams,
+    LzComposeTypesV2Accounts,
     LzReceiveParams,
     LzReceiveTypesV2Accounts,
     getLzComposeParamsSerializer,
-    getLzReceiveAccountSerializer,
     getLzReceiveParamsSerializer,
 } from './types'
-import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
+import { instructionDiscriminator } from './utility'
 
 /**
  * Unified entry point for receiving a LayerZero message on Solana.
@@ -114,23 +105,20 @@ export async function lzReceive(
 }
 
 /**
- * Composes a LayerZero message.
- *
- * @param {Connection} connection - The Solana connection object.
- * @param {PublicKey} payer - The public key of the payer.
- * @param {ComposeSentEvent} event - The event containing the message details.
- * @param {Uint8Array} [extraData] - Optional extra data.
- * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
+ * Unified entry point for composing a LayerZero message on Solana.
+ * This function automatically detects the lz_compose_types version and dispatches to the correct logic.
  *
- * @returns {Promise<TransactionInstruction>} The transaction instruction.
+ * For V1: returns a single Instruction (legacy behavior).
+ * For V2: returns { signers, instructions } for multi-instruction atomic execution.
  */
 export async function lzCompose(
     rpc: RpcInterface,
     payer: PublicKey,
     event: ComposeSentEvent,
     extraData: Uint8Array = Uint8Array.from([0, 0]),
+    executorProgram: PublicKey = EXECUTOR_PROGRAM_ID,
     commitment: Commitment = 'confirmed'
-): Promise<Instruction> {
+): Promise<{ instruction: Instruction; contextVersion: number } | ReturnType<typeof buildLzComposeExecutionPlan>> {
     const { to, from, guid, index, message } = event
     const params: LzComposeParams = {
         from,
@@ -144,97 +132,42 @@ export async function lzCompose(
     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 composerProgram = accountInfo.owner
 
-    const data = getLzComposeParamsSerializer().serialize(params)
-    return {
-        programId,
-        keys: accounts,
-        data: Buffer.concat([instructionDiscriminator('lz_compose'), data]),
+    // Try to detect version by calling lz_compose_types_info
+    let version = 1
+    let composeTypesAccounts: LzComposeTypesV2Accounts | undefined
+    try {
+        // V2: lz_compose_types_info returns version 2
+        composeTypesAccounts = await getLzComposeTypesInfo(rpc, payer, to, composerProgram, params, commitment)
+        version = 2
+    } catch (e) {
+        // If info call fails or version !== 2, fallback to V1
+        version = 1
     }
-}
 
-/**
- * Retrieves the accounts required for the LzCompose instruction.
- *
- * @param {Connection} connection - The Solana connection object.
- * @param {PublicKey} payer - The public key of the payer.
- * @param {PublicKey} to - The public key of the recipient.
- * @param {PublicKey} composerProgram - The public key of the composer program.
- * @param {LzComposeParams} params - The parameters for the LzCompose instruction.
- * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
- *
- * @returns {Promise<AccountMeta[]>} The list of account metadata.
- */
-export async function getLzComposeAccountMeta(
-    rpc: RpcInterface,
-    payer: PublicKey,
-    to: PublicKey,
-    composerProgram: PublicKey,
-    params: LzComposeParams,
-    commitment: Commitment = 'confirmed'
-): Promise<AccountMeta[]> {
-    const lzComposeTypesAccounts = await (async (): Promise<AccountMeta[]> => {
-        const oappPDA = new OmniAppPDA(composerProgram)
-        const [lzComposeTypesAccountsPDA] = oappPDA.lzComposeTypesAccounts(to)
-        // const [lzComposeTypesAccountsPDA] = deriveLzComposeTypesAccountsPDA(composerProgram, to)
-        // Get the lzReceiveTypesAccounts. Deserialize the AccountInfo.data to get the lzComposeTypesAccounts.
-        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] = publicKeySerializer().deserialize(buffer, i)
-                accounts.push({
-                    pubkey: address,
-                    isSigner: false,
-                    isWritable: false,
-                })
-            }
+    if (version === 2) {
+        return buildLzComposeExecutionPlan(
+            rpc,
+            executorProgram,
+            payer,
+            to,
+            composerProgram,
+            params,
+            composeTypesAccounts,
+            commitment
+        )
+    } else {
+        // V1: return a single Instruction (legacy behavior)
+        const accounts = await getLzComposeAccountsFromTypesV1(rpc, payer, to, composerProgram, params, commitment)
+        const data = getLzComposeParamsSerializer().serialize(params)
+        return {
+            instruction: {
+                programId: composerProgram,
+                keys: accounts,
+                data: Buffer.concat([instructionDiscriminator('lz_compose'), data]),
+            },
+            contextVersion: 1,
         }
-        return accounts
-    })()
-
-    const data = getLzComposeParamsSerializer().serialize(params)
-    const lzComposeTypesIx: Instruction = {
-        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 updateAccountFromSimulatedResp(keys, payer)
-}
-
-function updateAccountFromSimulatedResp(accounts: AccountMeta[], payer?: PublicKey): AccountMeta[] {
-    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,
-            } satisfies AccountMeta
-        } else {
-            return {
-                pubkey: r.pubkey,
-                isSigner: r.isSigner,
-                isWritable: r.isWritable,
-            } satisfies AccountMeta
-        }
-    })
 }

package/src/types.ts

@@ -231,6 +231,10 @@ export interface LzReceiveTypesV2Accounts {
     accounts: PublicKey[]
 }
 
+export interface LzComposeTypesV2Accounts {
+    accounts: PublicKey[]
+}
+
 export type AddressLocator =
     | { __kind: 'Address'; fields: [PublicKey] }
     | { __kind: 'AltIndex'; fields: [number, number] }
@@ -243,14 +247,24 @@ export interface AccountMetaRef {
     isWritable: boolean
 }
 
-export type Instruction =
+export type InstructionForLzReceive =
     | { __kind: 'LzReceive'; accounts: AccountMetaRef[] }
     | { __kind: 'Standard'; programId: PublicKey; accounts: AccountMetaRef[]; data: Uint8Array }
 
+export type InstructionForLzCompose =
+    | { __kind: 'LzCompose'; accounts: AccountMetaRef[] }
+    | { __kind: 'Standard'; programId: PublicKey; accounts: AccountMetaRef[]; data: Uint8Array }
+
 export interface LzReceiveTypesV2Result {
     contextVersion: number
     alts: PublicKey[]
-    instructions: Instruction[]
+    instructions: InstructionForLzReceive[]
+}
+
+export interface LzComposeTypesV2Result {
+    contextVersion: number
+    alts: PublicKey[]
+    instructions: InstructionForLzCompose[]
 }
 
 export function getAddressLocatorSerializer(): Serializer<AddressLocator, AddressLocator> {
@@ -278,6 +292,15 @@ export function getLzReceiveTypesV2AccountsSerializer(): Serializer<
     })
 }
 
+export function getLzComposeTypesV2AccountsSerializer(): Serializer<
+    LzComposeTypesV2Accounts,
+    LzComposeTypesV2Accounts
+> {
+    return struct<LzComposeTypesV2Accounts>([['accounts', array(publicKeySerializer())]], {
+        description: 'LzComposeTypesV2Accounts',
+    })
+}
+
 export function getAccountMetaRefSerializer(): Serializer<AccountMetaRef, AccountMetaRef> {
     return struct<AccountMetaRef>(
         [
@@ -288,18 +311,18 @@ export function getAccountMetaRefSerializer(): Serializer<AccountMetaRef, Accoun
     )
 }
 
-export function getInstructionSerializer(): Serializer<Instruction, Instruction> {
-    return dataEnum<Instruction>(
+export function getInstructionForLzReceiveSerializer(): Serializer<InstructionForLzReceive, InstructionForLzReceive> {
+    return dataEnum<InstructionForLzReceive>(
         [
             [
                 'LzReceive',
-                struct<GetDataEnumKindContent<Instruction, 'LzReceive'>>([
+                struct<GetDataEnumKindContent<InstructionForLzReceive, 'LzReceive'>>([
                     ['accounts', array(getAccountMetaRefSerializer())],
                 ]),
             ],
             [
                 'Standard',
-                struct<GetDataEnumKindContent<Instruction, 'Standard'>>([
+                struct<GetDataEnumKindContent<InstructionForLzReceive, 'Standard'>>([
                     ['programId', publicKeySerializer()],
                     ['accounts', array(getAccountMetaRefSerializer())],
                     ['data', bytes({ size: u32() })],
@@ -310,17 +333,49 @@ export function getInstructionSerializer(): Serializer<Instruction, Instruction>
     )
 }
 
+export function getInstructionForLzComposeSerializer(): Serializer<InstructionForLzCompose, InstructionForLzCompose> {
+    return dataEnum<InstructionForLzCompose>(
+        [
+            [
+                'LzCompose',
+                struct<GetDataEnumKindContent<InstructionForLzCompose, 'LzCompose'>>([
+                    ['accounts', array(getAccountMetaRefSerializer())],
+                ]),
+            ],
+            [
+                'Standard',
+                struct<GetDataEnumKindContent<InstructionForLzCompose, 'Standard'>>([
+                    ['programId', publicKeySerializer()],
+                    ['accounts', array(getAccountMetaRefSerializer())],
+                    ['data', bytes({ size: u32() })],
+                ]),
+            ],
+        ],
+        { description: 'Instruction' }
+    )
+}
 export function getLzReceiveTypesV2ResultSerializer(): Serializer<LzReceiveTypesV2Result, LzReceiveTypesV2Result> {
     return struct<LzReceiveTypesV2Result>(
         [
             ['contextVersion', u8()],
             ['alts', array(publicKeySerializer())],
-            ['instructions', array(getInstructionSerializer())],
+            ['instructions', array(getInstructionForLzReceiveSerializer())],
         ],
         { description: 'LzReceiveTypesV2Result' }
     )
 }
 
+export function getLzComposeTypesV2ResultSerializer(): Serializer<LzComposeTypesV2Result, LzComposeTypesV2Result> {
+    return struct<LzComposeTypesV2Result>(
+        [
+            ['contextVersion', u8()],
+            ['alts', array(publicKeySerializer())],
+            ['instructions', array(getInstructionForLzComposeSerializer())],
+        ],
+        { description: 'LzComposeTypesV2Result' }
+    )
+}
+
 // Data Enum Helpers.
 export function addressLocator(kind: 'Payer'): GetDataEnumKind<AddressLocator, 'Payer'>