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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/lz-solana-sdk-v2",
-  "version": "3.0.105-mpt.0",
+  "version": "3.0.106-snapshots.0",
   "license": "BUSL-1.1",
   "exports": {
     ".": {
@@ -39,12 +39,12 @@
     "test-uln": "TEST_SCOPES=uln anchor test --skip-build"
   },
   "dependencies": {
-    "@layerzerolabs/lz-corekit-solana": "^3.0.105-mpt.0",
-    "@layerzerolabs/lz-definitions": "^3.0.105-mpt.0",
-    "@layerzerolabs/lz-foundation": "^3.0.105-mpt.0",
-    "@layerzerolabs/lz-serdes": "^3.0.105-mpt.0",
-    "@layerzerolabs/lz-utilities": "^3.0.105-mpt.0",
-    "@layerzerolabs/lz-v2-utilities": "^3.0.105-mpt.0",
+    "@layerzerolabs/lz-corekit-solana": "^3.0.106-snapshots.0",
+    "@layerzerolabs/lz-definitions": "^3.0.106-snapshots.0",
+    "@layerzerolabs/lz-foundation": "^3.0.106-snapshots.0",
+    "@layerzerolabs/lz-serdes": "^3.0.106-snapshots.0",
+    "@layerzerolabs/lz-utilities": "^3.0.106-snapshots.0",
+    "@layerzerolabs/lz-v2-utilities": "^3.0.106-snapshots.0",
     "@metaplex-foundation/beet": "^0.7.1",
     "@metaplex-foundation/beet-solana": "^0.4.0",
     "@metaplex-foundation/mpl-toolbox": "^0.9.2",
@@ -67,8 +67,8 @@
     "@kinobi-so/renderers": "^0.21.3",
     "@kinobi-so/renderers-js-umi": "^0.21.6",
     "@layerzerolabs/layerzero-v2-solana": "^0.0.0",
-    "@layerzerolabs/tsup-config-next": "^3.0.105-mpt.0",
-    "@layerzerolabs/typescript-config-next": "^3.0.105-mpt.0",
+    "@layerzerolabs/tsup-config-next": "^3.0.106-snapshots.0",
+    "@layerzerolabs/typescript-config-next": "^3.0.106-snapshots.0",
     "@metaplex-foundation/umi-bundle-defaults": "^0.9.2",
     "@types/bn.js": "^5.1.5",
     "@types/chai": "^4.3.11",

package/src/compose-types-v1.ts

@@ -0,0 +1,85 @@
+import {
+    AccountMeta,
+    Commitment,
+    Instruction,
+    PublicKey,
+    RpcInterface,
+    defaultPublicKey,
+} from '@metaplex-foundation/umi'
+import { array, publicKey as publicKeySerializer } from '@metaplex-foundation/umi/serializers'
+import { toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+
+import { OmniAppPDA } from '.'
+import { LzComposeParams, getLzComposeParamsSerializer, getLzReceiveAccountSerializer } from './types'
+import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
+
+/**
+ * Get the accounts required for lz_compose by querying lz_compose_types_v1.
+ */
+export async function getLzComposeAccountsFromTypesV1(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    to: PublicKey,
+    composerProgram: PublicKey,
+    params: LzComposeParams,
+    commitment: Commitment = 'confirmed'
+): Promise<AccountMeta[]> {
+    // Derive the PDA for the lz_compose_types_accounts
+    const oappPDA = new OmniAppPDA(composerProgram)
+    const [lzComposeTypesAccountsPDA] = oappPDA.lzComposeTypesAccounts(to)
+    // Fetch the PDA account and parse the static account list
+    const info = await rpc.getAccount(lzComposeTypesAccountsPDA, { commitment })
+    const accounts: AccountMeta[] = []
+    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,
+            })
+        }
+    }
+    // Simulate the lz_compose_types instruction to get the dynamic account metas
+    const data = getLzComposeParamsSerializer().serialize(params)
+    const lzComposeTypesIx: Instruction = {
+        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: 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/compose-types-v2.ts

@@ -0,0 +1,224 @@
+import { AddressLookupTable, fetchAllAddressLookupTable } from '@metaplex-foundation/mpl-toolbox'
+import {
+    AccountMeta,
+    AddressLookupTableInput,
+    Commitment,
+    Context,
+    Instruction,
+    KeypairSigner,
+    PublicKey,
+    RpcInterface,
+    generateSigner,
+} from '@metaplex-foundation/umi'
+import { bytes as bytesSerializer } from '@metaplex-foundation/umi/serializers'
+import { toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+
+import { EDDSA, ExecutorPDA, OmniAppPDA } from '.'
+import {
+    AccountMetaRef,
+    AddressLocator,
+    LzComposeParams,
+    LzComposeTypesV2Accounts,
+    getLzComposeParamsSerializer,
+    getLzComposeTypesV2AccountsSerializer,
+    getLzComposeTypesV2ResultSerializer,
+} from './types'
+import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
+
+/**
+ * Retrieves the instructions and signers required for the LzCompose instruction (V2).
+ * This is used for lz_compose_types version 2.
+ */
+export async function buildLzComposeExecutionPlan(
+    rpc: RpcInterface,
+    executorProgram: PublicKey,
+    payer: PublicKey,
+    to: PublicKey,
+    composerProgram: PublicKey,
+    params: LzComposeParams,
+    composeTypesAccounts?: LzComposeTypesV2Accounts,
+    commitment: Commitment = 'confirmed'
+): Promise<{
+    contextVersion: number
+    signers: KeypairSigner[]
+    instructions: Instruction[]
+    addressLookupTables: AddressLookupTableInput[]
+}> {
+    composeTypesAccounts =
+        composeTypesAccounts ?? (await getLzComposeTypesInfo(rpc, payer, to, composerProgram, params, commitment))
+
+    const data = getLzComposeParamsSerializer().serialize(params)
+    const lzComposeTypesIx: Instruction = {
+        programId: composerProgram,
+        keys: composeTypesAccounts.accounts.map((pubkey) => {
+            return {
+                pubkey,
+                isSigner: false,
+                isWritable: false,
+            }
+        }),
+        data: Buffer.concat([instructionDiscriminator('lz_compose_types_v2'), data]),
+    }
+    // Simulate the V2 instruction to get the result (instructions, ALTs, etc)
+    const resp = await simulateWeb3JsTransaction(
+        rpc.getEndpoint(),
+        [toWeb3JsInstruction(lzComposeTypesIx)],
+        toWeb3JsPublicKey(composerProgram),
+        toWeb3JsPublicKey(payer),
+        getLzComposeTypesV2ResultSerializer(),
+        commitment
+    )
+    const tables = await fetchAllAddressLookupTable({ rpc }, resp.alts)
+    const signers: { [key: number]: KeypairSigner | undefined } = {}
+
+    const lzComposeDiscriminator = instructionDiscriminator('lz_compose').toString('hex')
+    const instructionTracker: { [key: string]: boolean } = {}
+
+    for (const ix of resp.instructions) {
+        let programId = composerProgram
+        let instructionType = 'lz_compose'
+        if (ix.__kind === 'Standard') {
+            const { programId: stdProgramId, data } = ix
+            programId = stdProgramId
+            const discriminator = Buffer.from(data.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: Instruction[] = 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 !== undefined) as KeypairSigner[],
+        instructions,
+        addressLookupTables: tables,
+    }
+}
+
+/**
+ * Fetches the metadata for lz_compose_types (versioned, V2).
+ * This reads the PDA account and deserializes the version, alts, and accounts.
+ */
+export async function getLzComposeTypesInfo(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    to: PublicKey,
+    composerProgram: PublicKey,
+    params: LzComposeParams,
+    commitment: Commitment = 'confirmed'
+): Promise<LzComposeTypesV2Accounts> {
+    const oappPDA = new OmniAppPDA(composerProgram)
+    const [lzComposeTypesAccountsPDA] = oappPDA.lzComposeTypesAccounts(to)
+    const lzComposeTypesIx: Instruction = {
+        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),
+        bytesSerializer(),
+        commitment
+    )
+    const version = resp.at(0)
+    if (version !== 2) {
+        throw new Error(`Invalid version ${version}. Expected version 2.`)
+    }
+    return getLzComposeTypesV2AccountsSerializer().deserialize(resp, 1)[0]
+}
+
+function accountMetaRefToAccountMeta(
+    umi: Pick<Context, 'eddsa'>,
+    executorProgram: PublicKey,
+    tables: AddressLookupTable[],
+    signers: { [key: number]: KeypairSigner | undefined },
+    accountMetaRef: AccountMetaRef,
+    payer: PublicKey,
+    contextVersion: number
+): AccountMeta {
+    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: Pick<Context, 'eddsa'>,
+    executorProgram: PublicKey,
+    tables: AddressLookupTable[],
+    signers: { [key: number]: KeypairSigner | undefined },
+    locator: AddressLocator,
+    payer: PublicKey,
+    contextVersion: number
+): PublicKey {
+    if (locator.__kind === 'Payer') {
+        return payer
+    } else if (locator.__kind === 'Signer') {
+        const index = locator.fields[0]
+        let signer = signers[index]
+        if (signer === undefined) {
+            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]]
+    }
+}

package/src/executor.ts

@@ -1,5 +1,6 @@
 import {
     AccountMeta,
+    AddressLookupTableInput,
     Cluster,
     ClusterFilter,
     Commitment,
@@ -13,14 +14,11 @@ import {
     WrappedInstruction,
     createNullRpc,
     defaultPublicKey,
-    publicKey,
 } from '@metaplex-foundation/umi'
 import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
-import invariant from 'tiny-invariant'
 
 import { Packet } from '@layerzerolabs/lz-v2-utilities'
 
-import { ENDPOINT_PROGRAM_ID } from './endpoint'
 import { ComposeSentEvent } from './generated/kinobi/endpoint/events'
 import * as accounts from './generated/kinobi/executor/accounts'
 import * as errors from './generated/kinobi/executor/errors'
@@ -30,7 +28,7 @@ import { NativeDropInstructionDataArgs, QuoteExecutorInstructionArgs } from './g
 import { EXECUTOR_PROGRAM_ID } from './generated/kinobi/executor/programs'
 import * as types from './generated/kinobi/executor/types'
 import { EventPDA, ExecutorPDA, MessageLibPDA, PriceFeedPDA } from './pda'
-import { getLzComposeAccountMeta, lzReceive } from './receive'
+import { lzCompose, lzReceive } from './receive'
 
 export { EXECUTOR_PROGRAM_ID } from './generated/kinobi/executor/programs'
 export { accounts, instructions, types, events, errors }
@@ -320,14 +318,14 @@ export class Executor {
             endpointProgram?: PublicKey
         },
         commitment: Commitment = 'confirmed'
-    ): Promise<{ signers: Signer[]; instructions: Instruction[] }> {
+    ): Promise<{ signers: Signer[]; instructions: Instruction[]; addressLookupTables: AddressLookupTableInput[] }> {
         const { packet, extraData, value = 0n } = param
         const payer = executor.publicKey
         const lzReceiveResult = await lzReceive(rpc, payer, packet, extraData, this.programId, commitment)
         const { contextVersion } = lzReceiveResult
         const instructions: Instruction[] = [this.preExecute(executor, contextVersion, value).instruction]
         const signers: Signer[] = []
-
+        const addressLookupTables: AddressLookupTableInput[] = []
         // Handle both V1 (Instruction) and V2 ({signers, instructions})
         if ('instruction' in lzReceiveResult) {
             // V1: single instruction
@@ -336,9 +334,10 @@ export class Executor {
             // V2: multi-instruction
             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(
@@ -348,66 +347,29 @@ export class Executor {
             event: ComposeSentEvent
             extraData: Uint8Array
             value?: bigint
-            computeUnits?: number
             endpointProgram?: PublicKey
         },
         commitment: Commitment = 'confirmed'
-    ): Promise<WrappedInstruction> {
-        const { event, extraData, value = 0n, computeUnits = 400000, 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 })
-        invariant(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 = instructions.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]
+    ): Promise<{ signers: Signer[]; instructions: Instruction[]; addressLookupTables: AddressLookupTableInput[] }> {
+        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: Instruction[] = [this.preExecute(executor, contextVersion, value).instruction]
+        const signers: Signer[] = []
+        const addressLookupTables: AddressLookupTableInput[] = []
+        // Handle both V1 (Instruction) and V2 ({signers, instructions})
+        if ('instruction' in lzComposeResult) {
+            // V1: single instruction
+            instructions.push(lzComposeResult.instruction)
+        } else {
+            // V2: multi-instruction
+            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: Signer, version: number, feeLimit: bigint): WrappedInstruction {

package/src/index.ts

@@ -13,6 +13,8 @@ export * from './config'
 export * from './receive'
 export * from './receive-types-v1'
 export * from './receive-types-v2'
+export * from './compose-types-v1'
+export * from './compose-types-v2'
 export * from './types'
 export * from './deployment'
 export * from './next_nonce'

package/src/receive-types-v2.ts

@@ -1,6 +1,7 @@
 import { AddressLookupTable, fetchAllAddressLookupTable } from '@metaplex-foundation/mpl-toolbox'
 import {
     AccountMeta,
+    AddressLookupTableInput,
     Commitment,
     Context,
     Instruction,
@@ -37,7 +38,12 @@ export async function buildLzReceiveExecutionPlan(
     params: LzReceiveParams,
     receiveTypesAccounts?: LzReceiveTypesV2Accounts,
     commitment: Commitment = 'confirmed'
-): Promise<{ contextVersion: number; signers: KeypairSigner[]; instructions: Instruction[] }> {
+): Promise<{
+    contextVersion: number
+    signers: KeypairSigner[]
+    instructions: Instruction[]
+    addressLookupTables: AddressLookupTableInput[]
+}> {
     receiveTypesAccounts =
         receiveTypesAccounts ?? (await getLzReceiveTypesInfo(rpc, payer, receiver, receiverProgram, params, commitment))
 
@@ -123,6 +129,7 @@ export async function buildLzReceiveExecutionPlan(
         contextVersion,
         signers: Object.values(signers).filter((signer) => signer !== undefined) as KeypairSigner[],
         instructions,
+        addressLookupTables: tables,
     }
 }