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

package/src/receive.ts

@@ -16,9 +16,13 @@ import { Packet, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
 
 import { OmniAppPDA } from '.'
 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,
     LzReceiveParams,
+    LzReceiveTypesV2Accounts,
     getLzComposeParamsSerializer,
     getLzReceiveAccountSerializer,
     getLzReceiveParamsSerializer,
@@ -26,50 +30,86 @@ import {
 import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
 
 /**
- * Receives a LayerZero message.
+ * Unified entry point for receiving a LayerZero message on Solana.
+ * This function automatically detects the lz_receive_types version and dispatches to the correct logic.
  *
- * @param {Connection} connection - The Solana connection object.
- * @param {PublicKey} payer - The public key of the payer.
- * @param {Packet} packet - The packet containing the message.
- * @param {Uint8Array} [callerParams] - Optional caller parameters.
- * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
- *
- * @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 lzReceive(
     rpc: RpcInterface,
     payer: PublicKey,
     packet: Pick<Packet, 'message' | 'sender' | 'srcEid' | 'guid' | 'receiver' | 'nonce'>,
     callerParams: Uint8Array = Uint8Array.from([0, 0]),
+    executorProgram: PublicKey = EXECUTOR_PROGRAM_ID,
     commitment: Commitment = 'confirmed'
-): Promise<Instruction> {
-    const { message: message_, sender: sender, srcEid, guid, receiver: receiver_ } = packet
-    const receiver = publicKey(addressToBytes32(receiver_))
+): Promise<{ instruction: Instruction; contextVersion: number } | ReturnType<typeof buildLzReceiveExecutionPlan>> {
+    const { message: message_, sender: sender_, srcEid, guid, receiver: receiver_, nonce } = packet
+    const sender = arrayify(sender_)
+    const receiverBytes = addressToBytes32(receiver_)
     const message = arrayify(message_)
     const params: LzReceiveParams = {
         srcEid: srcEid,
-        sender: arrayify(sender),
+        sender,
         guid: arrayify(guid),
         message,
         callerParams,
-        nonce: BigInt(packet.nonce),
+        nonce: BigInt(nonce),
     }
-    const receiverInfo = await rpc.getAccount(receiver, { commitment })
-    invariant(receiverInfo.exists, `Receiver account not found: ${receiver}`)
+    const receiverPubkey = publicKey(receiverBytes)
+    const receiverInfo = await rpc.getAccount(receiverPubkey, { commitment })
+    invariant(receiverInfo.exists, `Receiver account not found: ${receiverPubkey}`)
     const receiverProgram = publicKey(receiverInfo.owner)
-    const accounts = await getLzReceiveAccounts(rpc, payer, receiver, receiverProgram, params, commitment)
 
-    const MSG_TYPE_OFFSET = 0
-    // const msgType: string = message[MSG_TYPE_OFFSET].toString()
-    // if (msgType !== MessageType.COMPOSED_TYPE.toString() && msgType !== MessageType.VANILLA.toString()) {
-    //     throw new Error(`Invalid message type ${msgType}`)
-    // }
+    // Try to detect version by calling lz_receive_types_info
+    let version = 1
+    let receiveTypesAccounts: LzReceiveTypesV2Accounts | undefined
+    try {
+        // V2: lz_receive_types_info returns version 2
+        receiveTypesAccounts = await getLzReceiveTypesInfo(
+            rpc,
+            payer,
+            receiverPubkey,
+            receiverProgram,
+            params,
+            commitment
+        )
+        version = 2
+    } catch (e) {
+        // If info call fails or version !== 2, fallback to V1
+        version = 1
+    }
 
-    const data = getLzReceiveParamsSerializer().serialize(params)
-    return {
-        programId: receiverProgram,
-        keys: accounts,
-        data: Buffer.concat([instructionDiscriminator('lz_receive'), data]),
+    if (version === 2) {
+        return buildLzReceiveExecutionPlan(
+            rpc,
+            executorProgram,
+            payer,
+            receiverPubkey,
+            receiverProgram,
+            params,
+            receiveTypesAccounts,
+            commitment
+        )
+    } else {
+        // V1: return a single Instruction (legacy behavior)
+        const accounts = await getLzReceiveAccountsFromTypesV1(
+            rpc,
+            payer,
+            receiverPubkey,
+            receiverProgram,
+            params,
+            commitment
+        )
+        const data = getLzReceiveParamsSerializer().serialize(params)
+        return {
+            instruction: {
+                programId: receiverProgram,
+                keys: accounts,
+                data: Buffer.concat([instructionDiscriminator('lz_receive'), data]),
+            },
+            contextVersion: 1,
+        }
     }
 }
 
@@ -115,82 +155,6 @@ export async function lzCompose(
     }
 }
 
-/// LzReceiveTypes instruction provides a list of accounts that are used in the LzReceive
-/// instruction. The list of accounts required by this LzReceiveTypes instruction can be found
-/// from the specific PDA account that is generated by the LZ_RECEIVE_TYPES_SEED.
-/**
- * Retrieves the accounts required for the LzReceive instruction.
- *
- * @param {Connection} connection - The Solana connection object.
- * @param {PublicKey} payer - The public key of the payer.
- * @param {PublicKey} receiver - The public key of the receiver.
- * @param {PublicKey} receiverProgram - The public key of the receiver program.
- * @param {LzReceiveParams} params - The parameters for the LzReceive instruction.
- * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
- *
- * @returns {Promise<AccountMeta[]>} The list of account metadata.
- */
-export async function getLzReceiveAccounts(
-    rpc: RpcInterface,
-    payer: PublicKey,
-    receiver: PublicKey,
-    receiverProgram: PublicKey,
-    params: LzReceiveParams,
-    commitment: Commitment = 'confirmed'
-): Promise<AccountMeta[]> {
-    const lzReceiveTypesAccounts = await (async (): Promise<AccountMeta[]> => {
-        const oappPDA = new OmniAppPDA(receiverProgram)
-        const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver)
-        // const [lzReceiveTypesAccountsPDA] = deriveLzReceiveTypesAccountsPDA(receiverProgram, receiver)
-        // Get the lzReceiveTypesAccounts. Deserialize the AccountInfo.data to get the lzReceiveTypesAccounts.
-        const info = await rpc.getAccount(lzReceiveTypesAccountsPDA, { commitment })
-        const accounts = []
-        if (info.exists) {
-            const buffer = Buffer.from(info.data)
-            const len = buffer.length - 8
-            if (len % 32 !== 0) {
-                throw new Error(
-                    `Invalid length of AccountInfo.data. The length must be a multiple of 32 plus 8.(n*32+8). Current length is ${buffer.length}`
-                )
-            }
-            // const serializer = array(publicKeySerializer())
-            // const [addresses] = serializer.deserialize(buffer, 8)
-            // for (const address of addresses) {
-            //     accounts.push({
-            //         pubkey: address,
-            //         isSigner: false,
-            //         isWritable: false,
-            //     })
-            // }
-            for (let i = 8; i < len; i += 32) {
-                const [address] = publicKeySerializer().deserialize(buffer, i)
-                accounts.push({
-                    pubkey: address,
-                    isSigner: false,
-                    isWritable: false,
-                })
-            }
-        }
-        return accounts
-    })()
-
-    const data = getLzReceiveParamsSerializer().serialize(params)
-    const lzReceiveTypesIx: Instruction = {
-        programId: receiverProgram,
-        keys: lzReceiveTypesAccounts,
-        data: Buffer.concat([instructionDiscriminator('lz_receive_types'), data]),
-    }
-    const keys = await simulateWeb3JsTransaction(
-        rpc.getEndpoint(),
-        [toWeb3JsInstruction(lzReceiveTypesIx)],
-        toWeb3JsPublicKey(receiverProgram),
-        toWeb3JsPublicKey(payer),
-        array(getLzReceiveAccountSerializer()),
-        'confirmed'
-    )
-    return updateAccountFromSimulatedResp(keys, payer)
-}
-
 /**
  * Retrieves the accounts required for the LzCompose instruction.
  *
@@ -226,15 +190,6 @@ export async function getLzComposeAccountMeta(
                     `Invalid length of AccountInfo.data. The length must be a multiple of 32 plus 8.(n*32+8). Current length is ${buffer.length}`
                 )
             }
-            // const serializer = array(publicKeySerializer())
-            // const [addresses] = serializer.deserialize(buffer, 8)
-            // for (const address of addresses) {
-            //     accounts.push({
-            //         pubkey: address,
-            //         isSigner: false,
-            //         isWritable: false,
-            //     })
-            // }
             for (let i = 8; i < len; i += 32) {
                 const [address] = publicKeySerializer().deserialize(buffer, i)
                 accounts.push({

package/src/solita/executor.ts

@@ -9,11 +9,8 @@ import {
 } from '@solana/web3.js'
 import BN from 'bn.js'
 
-import { arrayify } from '@layerzerolabs/lz-utilities'
-import { Packet, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
-
 import { EventPDADeriver, ExecutorPDADeriver, MessageLibPDADeriver, PriceFeedPDADeriver } from './pda-deriver'
-import { getLzComposeAccountMeta, getLzReceiveAccounts } from './recevie'
+import { getLzComposeAccountMeta } from './recevie'
 import { ComposeSentEvent } from '../generated/solita/endpoint/events'
 import * as accounts from '../generated/solita/executor/accounts'
 import * as events from '../generated/solita/executor/events'
@@ -409,90 +406,6 @@ export class Executor {
         ].concat(ixAccounts)
     }
 
-    /**
-     * Executes a transaction.
-     *
-     * @param {Connection} connection - The connection.
-     * @param {PublicKey} executor - The executor public key.
-     * @param {PublicKey} endpointProgram - The endpoint program public key.
-     * @param {Packet} packet - The packet.
-     * @param {Uint8Array} extraData - The extra data.
-     * @param {BN} [value] - The value.
-     * @param {number} [computeUnits] - The compute units.
-     * @param {Commitment} [commitmentOrConfig] - The commitment or configuration.
-     *
-     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
-     */
-    async execute(
-        connection: Connection,
-        executor: PublicKey,
-        endpointProgram: PublicKey,
-        packet: Packet,
-        extraData: Uint8Array,
-        value: BN = new BN(0),
-        computeUnits = 200000,
-        commitmentOrConfig?: Commitment
-    ): Promise<TransactionInstruction> {
-        const [config] = this.deriver.config()
-        const endpointEventDeriver = new EventPDADeriver(endpointProgram)
-        const executorEventDeriver = new EventPDADeriver(this.program)
-        const { message: message_, sender: sender, srcEid, guid, receiver: receiver_, nonce } = packet
-        const receiver = new PublicKey(addressToBytes32(receiver_))
-        const receiverInfo = await connection.getParsedAccountInfo(receiver, commitmentOrConfig)
-        const receiverProgram = new PublicKey((receiverInfo.value as AccountInfo<Buffer>).owner)
-        const message = arrayify(message_)
-        const accounts = await getLzReceiveAccounts(
-            connection,
-            executor,
-            receiver,
-            receiverProgram,
-            {
-                srcEid: srcEid,
-                sender: Array.from(arrayify(sender)),
-                guid: Array.from(arrayify(guid)),
-                message,
-                callerParams: extraData,
-                nonce: parseInt(packet.nonce),
-            },
-            commitmentOrConfig
-        )
-
-        return instructions.createExecuteInstruction(
-            {
-                executor,
-                config,
-                endpointProgram,
-                endpointEventAuthority: endpointEventDeriver.eventAuthority()[0],
-                program: this.program,
-                eventAuthority: executorEventDeriver.eventAuthority()[0],
-                anchorRemainingAccounts: [
-                    {
-                        pubkey: receiverProgram,
-                        isWritable: false,
-                        isSigner: false,
-                    },
-                    ...accounts,
-                ],
-            } satisfies instructions.ExecuteInstructionAccounts,
-            {
-                params: {
-                    receiver,
-                    lzReceive: {
-                        srcEid,
-                        sender: Array.from(arrayify(sender)),
-                        nonce: parseInt(nonce),
-                        guid: Array.from(arrayify(guid)),
-                        message,
-                        extraData,
-                    },
-                    value,
-                    computeUnits,
-                } satisfies types.ExecuteParams,
-            } satisfies instructions.ExecuteInstructionArgs,
-            this.program
-        )
-    }
-
     /**
      * Composes a transaction.
      *

package/src/types.ts

@@ -1,13 +1,20 @@
 import { PublicKey } from '@metaplex-foundation/umi'
 import {
+    GetDataEnumKind,
+    GetDataEnumKindContent,
     Serializer,
+    array,
     bool,
     bytes,
+    dataEnum,
     publicKey as publicKeySerializer,
     struct,
+    tuple,
     u16,
     u32,
     u64,
+    u8,
+    unit,
 } from '@metaplex-foundation/umi/serializers'
 
 export interface SolanaPacketPath {
@@ -34,6 +41,11 @@ export enum MessageType {
      * Composed message type.
      */
     COMPOSED_TYPE = 2,
+
+    /**
+     * ABA message type.
+     */
+    ABA = 3,
 }
 
 /**
@@ -214,3 +226,131 @@ export enum ExecutorOptionType {
  * Maximum length for executor option types.
  */
 export const MaxExecutorOptionTypeLength = 10
+
+export interface LzReceiveTypesV2Accounts {
+    accounts: PublicKey[]
+}
+
+export type AddressLocator =
+    | { __kind: 'Address'; fields: [PublicKey] }
+    | { __kind: 'AltIndex'; fields: [number, number] }
+    | { __kind: 'Payer' }
+    | { __kind: 'Signer'; fields: [number] }
+    | { __kind: 'Context' }
+
+export interface AccountMetaRef {
+    pubkey: AddressLocator
+    isWritable: boolean
+}
+
+export type Instruction =
+    | { __kind: 'LzReceive'; accounts: AccountMetaRef[] }
+    | { __kind: 'Standard'; programId: PublicKey; accounts: AccountMetaRef[]; data: Uint8Array }
+
+export interface LzReceiveTypesV2Result {
+    contextVersion: number
+    alts: PublicKey[]
+    instructions: Instruction[]
+}
+
+export function getAddressLocatorSerializer(): Serializer<AddressLocator, AddressLocator> {
+    return dataEnum<AddressLocator>(
+        [
+            [
+                'Address',
+                struct<GetDataEnumKindContent<AddressLocator, 'Address'>>([['fields', tuple([publicKeySerializer()])]]),
+            ],
+            ['AltIndex', struct<GetDataEnumKindContent<AddressLocator, 'AltIndex'>>([['fields', tuple([u8(), u8()])]])],
+            ['Payer', unit()],
+            ['Signer', struct<GetDataEnumKindContent<AddressLocator, 'Signer'>>([['fields', tuple([u8()])]])],
+            ['Context', unit()],
+        ],
+        { description: 'AddressLocator' }
+    )
+}
+
+export function getLzReceiveTypesV2AccountsSerializer(): Serializer<
+    LzReceiveTypesV2Accounts,
+    LzReceiveTypesV2Accounts
+> {
+    return struct<LzReceiveTypesV2Accounts>([['accounts', array(publicKeySerializer())]], {
+        description: 'LzReceiveTypesV2Result',
+    })
+}
+
+export function getAccountMetaRefSerializer(): Serializer<AccountMetaRef, AccountMetaRef> {
+    return struct<AccountMetaRef>(
+        [
+            ['pubkey', getAddressLocatorSerializer()],
+            ['isWritable', bool()],
+        ],
+        { description: 'AccountMetaRef' }
+    )
+}
+
+export function getInstructionSerializer(): Serializer<Instruction, Instruction> {
+    return dataEnum<Instruction>(
+        [
+            [
+                'LzReceive',
+                struct<GetDataEnumKindContent<Instruction, 'LzReceive'>>([
+                    ['accounts', array(getAccountMetaRefSerializer())],
+                ]),
+            ],
+            [
+                'Standard',
+                struct<GetDataEnumKindContent<Instruction, '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())],
+        ],
+        { description: 'LzReceiveTypesV2Result' }
+    )
+}
+
+// Data Enum Helpers.
+export function addressLocator(kind: 'Payer'): GetDataEnumKind<AddressLocator, 'Payer'>
+
+export function addressLocator(
+    kind: 'Signer',
+    data: GetDataEnumKindContent<AddressLocator, 'Signer'>['fields']
+): GetDataEnumKind<AddressLocator, 'Signer'>
+
+export function addressLocator(
+    kind: 'Address',
+    data: GetDataEnumKindContent<AddressLocator, 'Address'>['fields']
+): GetDataEnumKind<AddressLocator, 'Address'>
+
+export function addressLocator(
+    kind: 'AltIndex',
+    data: GetDataEnumKindContent<AddressLocator, 'AltIndex'>['fields']
+): GetDataEnumKind<AddressLocator, 'AltIndex'>
+
+export function addressLocator<K extends AddressLocator['__kind']>(
+    kind: K,
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    data?: any
+): Extract<AddressLocator, { __kind: K }> {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) }
+}
+
+export function isAddressLocator<K extends AddressLocator['__kind']>(
+    kind: K,
+    value: AddressLocator
+): value is AddressLocator & { __kind: K } {
+    return value.__kind === kind
+}

package/src/generated/kinobi/executor/instructions/execute.ts

@@ -1,159 +0,0 @@
-/**
- * This code was AUTOGENERATED using the kinobi library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun kinobi to update it.
- *
- * @see https://github.com/kinobi-so/kinobi
- */
-
-import {
-  Context,
-  Pda,
-  PublicKey,
-  Signer,
-  TransactionBuilder,
-  transactionBuilder,
-} from '@metaplex-foundation/umi';
-import {
-  Serializer,
-  bytes,
-  mapSerializer,
-  publicKey as publicKeySerializer,
-  struct,
-  u64,
-} from '@metaplex-foundation/umi/serializers';
-import {
-  ResolvedAccount,
-  ResolvedAccountsWithIndices,
-  getAccountMetasAndSigners,
-} from '../shared';
-import {
-  LzReceiveParams,
-  LzReceiveParamsArgs,
-  getLzReceiveParamsSerializer,
-} from '../types';
-
-// Accounts.
-export type ExecuteInstructionAccounts = {
-  executor: Signer;
-  config: PublicKey | Pda;
-  endpointProgram: PublicKey | Pda;
-  /** The authority for the endpoint program to emit events */
-  endpointEventAuthority: PublicKey | Pda;
-  eventAuthority: PublicKey | Pda;
-  program: PublicKey | Pda;
-};
-
-// Data.
-export type ExecuteInstructionData = {
-  discriminator: Uint8Array;
-  receiver: PublicKey;
-  lzReceive: LzReceiveParams;
-  value: bigint;
-  computeUnits: bigint;
-};
-
-export type ExecuteInstructionDataArgs = {
-  receiver: PublicKey;
-  lzReceive: LzReceiveParamsArgs;
-  value: number | bigint;
-  computeUnits: number | bigint;
-};
-
-export function getExecuteInstructionDataSerializer(): Serializer<
-  ExecuteInstructionDataArgs,
-  ExecuteInstructionData
-> {
-  return mapSerializer<ExecuteInstructionDataArgs, any, ExecuteInstructionData>(
-    struct<ExecuteInstructionData>(
-      [
-        ['discriminator', bytes({ size: 8 })],
-        ['receiver', publicKeySerializer()],
-        ['lzReceive', getLzReceiveParamsSerializer()],
-        ['value', u64()],
-        ['computeUnits', u64()],
-      ],
-      { description: 'ExecuteInstructionData' }
-    ),
-    (value) => ({
-      ...value,
-      discriminator: new Uint8Array([130, 221, 242, 154, 13, 193, 189, 29]),
-    })
-  ) as Serializer<ExecuteInstructionDataArgs, ExecuteInstructionData>;
-}
-
-// Args.
-export type ExecuteInstructionArgs = ExecuteInstructionDataArgs;
-
-// Instruction.
-export function execute(
-  context: Pick<Context, 'programs'>,
-  input: ExecuteInstructionAccounts & ExecuteInstructionArgs
-): TransactionBuilder {
-  // Program ID.
-  const programId = context.programs.getPublicKey(
-    'executor',
-    '6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn'
-  );
-
-  // Accounts.
-  const resolvedAccounts = {
-    executor: {
-      index: 0,
-      isWritable: true as boolean,
-      value: input.executor ?? null,
-    },
-    config: {
-      index: 1,
-      isWritable: false as boolean,
-      value: input.config ?? null,
-    },
-    endpointProgram: {
-      index: 2,
-      isWritable: false as boolean,
-      value: input.endpointProgram ?? null,
-    },
-    endpointEventAuthority: {
-      index: 3,
-      isWritable: false as boolean,
-      value: input.endpointEventAuthority ?? null,
-    },
-    eventAuthority: {
-      index: 4,
-      isWritable: false as boolean,
-      value: input.eventAuthority ?? null,
-    },
-    program: {
-      index: 5,
-      isWritable: false as boolean,
-      value: input.program ?? null,
-    },
-  } satisfies ResolvedAccountsWithIndices;
-
-  // Arguments.
-  const resolvedArgs: ExecuteInstructionArgs = { ...input };
-
-  // Accounts in order.
-  const orderedAccounts: ResolvedAccount[] = Object.values(
-    resolvedAccounts
-  ).sort((a, b) => a.index - b.index);
-
-  // Keys and Signers.
-  const [keys, signers] = getAccountMetasAndSigners(
-    orderedAccounts,
-    'programId',
-    programId
-  );
-
-  // Data.
-  const data = getExecuteInstructionDataSerializer().serialize(
-    resolvedArgs as ExecuteInstructionDataArgs
-  );
-
-  // Bytes Created On Chain.
-  const bytesCreatedOnChain = 0;
-
-  return transactionBuilder([
-    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
-  ]);
-}