@layerzerolabs/lz-solana-sdk-v2 3.0.53 → 3.0.54

package/src/executor.ts

@@ -1,532 +1,407 @@
 import {
-    AccountInfo,
     AccountMeta,
+    Cluster,
+    ClusterFilter,
     Commitment,
-    Connection,
-    GetAccountInfoConfig,
+    Program,
+    ProgramError,
+    ProgramRepositoryInterface,
     PublicKey,
-    TransactionInstruction,
-} from '@solana/web3.js'
-import BN from 'bn.js'
+    RpcInterface,
+    Signer,
+    WrappedInstruction,
+    createNullRpc,
+    defaultPublicKey,
+    publicKey,
+} from '@metaplex-foundation/umi'
+import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
+import invariant from 'tiny-invariant'
 
 import { arrayify } from '@layerzerolabs/lz-utilities'
 import { Packet, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
 
-import { ComposeSentEvent } from './generated/endpoint/events'
-import * as accounts from './generated/executor/accounts'
-import * as events from './generated/executor/events'
-import * as instructions from './generated/executor/instructions'
-import * as types from './generated/executor/types'
-import { EventPDADeriver, ExecutorPDADeriver, MessageLibPDADeriver, PriceFeedPDADeriver } from './pda-deriver'
-import { getLzComposeAccountMeta, getLzReceiveAccounts } from './recevie'
+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'
+import * as events from './generated/kinobi/executor/events'
+import * as instructions from './generated/kinobi/executor/instructions'
+import { NativeDropInstructionDataArgs, QuoteExecutorInstructionArgs } from './generated/kinobi/executor/instructions'
+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, getLzReceiveAccounts } from './receive'
 
-export * from './generated/executor'
-export { accounts, instructions, types, events }
+export { EXECUTOR_PROGRAM_ID } from './generated/kinobi/executor/programs'
+export { accounts, instructions, types, events, errors }
 
-/**
- * Class representing the Executor.
- */
 export class Executor {
-    deriver: ExecutorPDADeriver
+    public readonly pda: ExecutorPDA
+    public readonly programRepo: ProgramRepositoryInterface
+    public readonly eventAuthority: PublicKey
 
-    /**
-     * Creates an instance of the Executor class.
-     *
-     * @param {PublicKey} program - The program public key.
-     */
-    constructor(public program: PublicKey) {
-        this.deriver = new ExecutorPDADeriver(this.program)
+    constructor(
+        public programId: PublicKey = EXECUTOR_PROGRAM_ID,
+        rpc?: RpcInterface
+    ) {
+        this.pda = new ExecutorPDA(this.programId)
+        if (rpc === undefined) {
+            rpc = createNullRpc()
+            rpc.getCluster = (): Cluster => 'custom'
+        }
+        this.programRepo = createDefaultProgramRepository({ rpc }, [
+            {
+                name: 'executor',
+                publicKey: programId,
+                getErrorFromCode(code: number, cause?: Error): ProgramError | null {
+                    return errors.getExecutorErrorFromCode(code, this, cause)
+                },
+                getErrorFromName(name: string, cause?: Error): ProgramError | null {
+                    return errors.getExecutorErrorFromName(name, this, cause)
+                },
+                isOnCluster(): boolean {
+                    return true
+                },
+            } satisfies Program,
+        ])
+
+        this.eventAuthority = new EventPDA(programId).eventAuthority()[0]
     }
 
-    // owner methods
+    getProgram(clusterFilter: ClusterFilter = 'custom'): Program {
+        return this.programRepo.get('executor', clusterFilter)
+    }
 
-    /**
-     * Initializes the executor.
-     *
-     * @param {PublicKey} payer - The payer public key.
-     * @param {PublicKey} owner - The owner public key.
-     * @param {PublicKey[]} admins - The admin public keys.
-     * @param {PublicKey[]} executors - The executor public keys.
-     * @param {PublicKey[]} msglibs - The message library public keys.
-     * @param {PublicKey} priceFeed - The price feed public key.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    initExecutor(
-        payer: PublicKey,
-        owner: PublicKey,
-        admins: PublicKey[],
-        executors: PublicKey[],
-        msglibs: PublicKey[],
-        priceFeed: PublicKey
-    ): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createInitExecutorInstruction(
+    // owner methods
+    initExecutor(payer: Signer, param: instructions.InitExecutorInstructionDataArgs): WrappedInstruction {
+        return instructions.initExecutor(
+            { programs: this.programRepo, payer },
             {
                 payer,
-                config: configAccount,
-            } satisfies instructions.InitExecutorInstructionAccounts,
-            {
-                params: {
-                    owner,
-                    admins,
-                    executors,
-                    msglibs,
-                    priceFeed,
-                } satisfies types.InitExecutorParams,
-            } satisfies instructions.InitExecutorInstructionArgs,
-            this.program
-        )
+                config: this.pda.config(),
+                ...param,
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the owner.
-     *
-     * @param {PublicKey} owner - The current owner public key.
-     * @param {PublicKey} newOwner - The new owner public key.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setOwner(owner: PublicKey, newOwner: PublicKey): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createOwnerSetConfigInstruction(
+    setOwner(owner: Signer, newOwner: PublicKey): WrappedInstruction {
+        return instructions.ownerSetConfig(
+            { programs: this.programRepo },
             {
                 owner,
-                config: configAccount,
-            } satisfies instructions.OwnerSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [newOwner],
                     __kind: 'Owner',
-                } satisfies types.OwnerSetConfigParams,
-            } satisfies instructions.OwnerSetConfigInstructionArgs,
-            this.program
-        )
+                },
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the admins.
-     *
-     * @param {PublicKey} owner - The owner public key.
-     * @param {PublicKey[]} admins - The admin public keys.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setAdmins(owner: PublicKey, admins: PublicKey[]): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createOwnerSetConfigInstruction(
+    setAdmins(owner: Signer, admins: PublicKey[]): WrappedInstruction {
+        return instructions.ownerSetConfig(
+            { programs: this.programRepo },
             {
                 owner,
-                config: configAccount,
-            } satisfies instructions.OwnerSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [admins],
                     __kind: 'Admins',
-                } satisfies types.OwnerSetConfigParams,
-            } satisfies instructions.OwnerSetConfigInstructionArgs,
-            this.program
-        )
+                },
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the allow list.
-     *
-     * @param {PublicKey} owner - The owner public key.
-     * @param {PublicKey[]} allowlist - The allow list public keys.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setAllowList(owner: PublicKey, allowlist: PublicKey[]): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createOwnerSetConfigInstruction(
+    setAllowList(owner: Signer, allowlist: PublicKey[]): WrappedInstruction {
+        return instructions.ownerSetConfig(
+            { programs: this.programRepo },
             {
                 owner,
-                config: configAccount,
-            } satisfies instructions.OwnerSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [allowlist],
                     __kind: 'Allowlist',
-                } satisfies types.OwnerSetConfigParams,
-            } satisfies instructions.OwnerSetConfigInstructionArgs,
-            this.program
-        )
+                },
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the deny list.
-     *
-     * @param {PublicKey} owner - The owner public key.
-     * @param {PublicKey[]} denylist - The deny list public keys.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setDenyList(owner: PublicKey, denylist: PublicKey[]): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createOwnerSetConfigInstruction(
+    setDenyList(owner: Signer, denylist: PublicKey[]): WrappedInstruction {
+        return instructions.ownerSetConfig(
+            { programs: this.programRepo },
             {
                 owner,
-                config: configAccount,
-            } satisfies instructions.OwnerSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [denylist],
                     __kind: 'Denylist',
-                } satisfies types.OwnerSetConfigParams,
-            } satisfies instructions.OwnerSetConfigInstructionArgs,
-            this.program
-        )
+                },
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the paused state.
-     *
-     * @param {PublicKey} owner - The owner public key.
-     * @param {boolean} paused - The paused state.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setPaused(owner: PublicKey, paused: boolean): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createOwnerSetConfigInstruction(
+    setPaused(owner: Signer, paused: boolean): WrappedInstruction {
+        return instructions.ownerSetConfig(
+            { programs: this.programRepo },
             {
                 owner,
-                config: configAccount,
-            } satisfies instructions.OwnerSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [paused],
                     __kind: 'Paused',
-                } satisfies types.OwnerSetConfigParams,
-            } satisfies instructions.OwnerSetConfigInstructionArgs,
-            this.program
-        )
+                },
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the executors.
-     *
-     * @param {PublicKey} owner - The owner public key.
-     * @param {PublicKey[]} executors - The executor public keys.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setExecutors(owner: PublicKey, executors: PublicKey[]): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createOwnerSetConfigInstruction(
-            {
-                owner,
-                config: configAccount,
-            } satisfies instructions.OwnerSetConfigInstructionAccounts,
+    setExecutors(owner: Signer, executors: PublicKey[]): WrappedInstruction {
+        return instructions.ownerSetConfig(
+            { programs: this.programRepo },
             {
+                owner: owner,
+                config: this.pda.config(),
                 params: {
                     fields: [executors],
                     __kind: 'Executors',
-                } satisfies types.OwnerSetConfigParams,
-            } satisfies instructions.OwnerSetConfigInstructionArgs,
-            this.program
-        )
+                },
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the message libraries by programs.
-     *
-     * @param {PublicKey} owner - The owner public key.
-     * @param {PublicKey[]} msglibPrograms - The message library program public keys.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setMsglibByPrograms(owner: PublicKey, msglibPrograms: PublicKey[]): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
+    setMsglibByPrograms(owner: Signer, msglibPrograms: PublicKey[]): WrappedInstruction {
         const msglibPdas = msglibPrograms.map((program) => {
-            return new MessageLibPDADeriver(program).messageLib()[0]
+            return new MessageLibPDA(program).messageLib()[0]
         })
         return this.setMsglibByPDAs(owner, msglibPdas)
     }
 
-    /**
-     * Sets the message libraries by PDAs.
-     *
-     * @param {PublicKey} owner - The owner public key.
-     * @param {PublicKey[]} msglibPDAs - The message library PDA public keys.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setMsglibByPDAs(owner: PublicKey, msglibPDAs: PublicKey[]): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createOwnerSetConfigInstruction(
+    setMsglibByPDAs(owner: Signer, msglibPDAs: PublicKey[]): WrappedInstruction {
+        return instructions.ownerSetConfig(
+            { programs: this.programRepo },
             {
                 owner,
-                config: configAccount,
-            } satisfies instructions.OwnerSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [msglibPDAs],
                     __kind: 'Msglibs',
-                } satisfies types.OwnerSetConfigParams,
-            } satisfies instructions.OwnerSetConfigInstructionArgs,
-            this.program
-        )
+                },
+            }
+        ).items[0]
     }
 
     // admin methods
-
-    /**
-     * Sets the default multiplier BPS.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {number} defaultMultiplierBps - The default multiplier BPS.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setDefaultMultiplierBps(admin: PublicKey, defaultMultiplierBps: number): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createAdminSetConfigInstruction(
+    setDefaultMultiplierBps(admin: Signer, defaultMultiplierBps: number): WrappedInstruction {
+        return instructions.adminSetConfig(
+            { programs: this.programRepo },
             {
                 admin,
-                config: configAccount,
-            } satisfies instructions.AdminSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [defaultMultiplierBps],
                     __kind: 'DefaultMultiplierBps',
                 } satisfies types.AdminSetConfigParams,
-            } satisfies instructions.AdminSetConfigInstructionArgs,
-            this.program
-        )
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the destination configurations.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {types.DstConfig[]} dstConfigs - The destination configurations.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setDstConfig(admin: PublicKey, dstConfigs: types.DstConfig[]): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        return instructions.createAdminSetConfigInstruction(
+    setDstConfig(admin: Signer, dstConfigs: types.DstConfig[]): WrappedInstruction {
+        return instructions.adminSetConfig(
+            { programs: this.programRepo },
             {
                 admin,
-                config: configAccount,
-            } satisfies instructions.AdminSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [dstConfigs],
                     __kind: 'DstConfigs',
                 } satisfies types.AdminSetConfigParams,
-            } satisfies instructions.AdminSetConfigInstructionArgs,
-            this.program
-        )
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the price feed.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {PublicKey} priceFeedProgram - The price feed program public key.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setPriceFeed(admin: PublicKey, priceFeedProgram: PublicKey): TransactionInstruction {
-        const [configAccount] = this.deriver.config()
-        const [priceFeed] = new PriceFeedPDADeriver(priceFeedProgram).priceFeed()
-        return instructions.createAdminSetConfigInstruction(
+    setPriceFeed(admin: Signer, priceFeedProgram: PublicKey): WrappedInstruction {
+        const [priceFeed] = new PriceFeedPDA(priceFeedProgram).priceFeed()
+        return instructions.adminSetConfig(
+            { programs: this.programRepo },
             {
                 admin,
-                config: configAccount,
-            } satisfies instructions.AdminSetConfigInstructionAccounts,
-            {
+                config: this.pda.config(),
                 params: {
                     fields: [priceFeed],
                     __kind: 'PriceFeed',
                 } satisfies types.AdminSetConfigParams,
-            } satisfies instructions.AdminSetConfigInstructionArgs,
-            this.program
-        )
+            }
+        ).items[0]
+    }
+
+    nativeDrop(executor: Signer, param: NativeDropInstructionDataArgs): WrappedInstruction {
+        const receivers: AccountMeta[] = param.nativeDropRequests.map((request) => {
+            return {
+                pubkey: request.receiver,
+                isSigner: false,
+                isWritable: true,
+            } satisfies AccountMeta
+        })
+        return instructions
+            .nativeDrop(
+                { programs: this.programRepo },
+                {
+                    executor: executor,
+                    config: this.pda.config(),
+                    eventAuthority: new EventPDA(this.programId).eventAuthority()[0],
+                    program: this.programId,
+                    ...param,
+                }
+            )
+            .addRemainingAccounts(receivers).items[0]
+    }
+
+    quoteExecutor(param: { priceFeedProgram: PublicKey } & QuoteExecutorInstructionArgs): WrappedInstruction {
+        const [priceFeed] = new PriceFeedPDA(param.priceFeedProgram).priceFeed()
+        return instructions.quoteExecutor(
+            { programs: this.programRepo },
+            {
+                executorConfig: this.pda.config(),
+                priceFeedConfig: priceFeed,
+                ...param,
+            }
+        ).items[0]
     }
 
-    /**
-     * Gets the executor configuration.
-     *
-     * @param {Connection} connection - The connection.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment or configuration.
-     *
-     * @returns {Promise<accounts.ExecutorConfig | null>} A promise that resolves to the executor configuration or null.
-     */
     async getExecutorConfig(
-        connection: Connection,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        rpc: RpcInterface,
+        commitment: Commitment = 'confirmed'
     ): Promise<accounts.ExecutorConfig | null> {
-        const [configAccount] = this.deriver.config()
-        try {
-            const config = await accounts.ExecutorConfig.fromAccountAddress(
-                connection,
-                configAccount,
-                commitmentOrConfig
-            )
-            return config
-        } catch (error) {
-            return null
-        }
+        const [configAccount] = this.pda.config()
+        const config = await accounts.safeFetchExecutorConfig({ rpc }, configAccount, { commitment })
+        return config
     }
 
-    /**
-     * Gets the quote instruction account meta for CPI.
-     *
-     * @param {PublicKey} priceFeedConfig - The price feed configuration public key.
-     * @param {PublicKey} priceFeedProgram - The price feed program public key.
-     * @param {boolean} payment - Whether payment is required.
-     *
-     * @returns {AccountMeta[]} The account meta array.
-     */
     getQuoteIXAccountMetaForCPI(
         priceFeedConfig: PublicKey,
         priceFeedProgram: PublicKey,
         payment: boolean
     ): AccountMeta[] {
-        const [config] = this.deriver.config()
-        const ixAccounts = instructions.createQuoteExecutorInstructionAccounts(
+        const txBuilder = instructions.quoteExecutor(
+            { programs: this.programRepo },
             {
-                executorConfig: config,
+                executorConfig: this.pda.config(),
                 priceFeedConfig,
                 priceFeedProgram: priceFeedProgram,
-            } satisfies instructions.QuoteExecutorInstructionAccounts,
-            this.program
+                // param
+                msglib: defaultPublicKey(),
+                dstEid: 0,
+                sender: defaultPublicKey(),
+                calldataSize: 0,
+                options: [],
+            }
         )
+        const ixAccounts = txBuilder.getInstructions()[0].keys
         if (payment) {
             // if payment is required, the first account is required to be writable to receive the payment
             ixAccounts[0].isWritable = true
         }
         return [
             {
-                pubkey: this.program,
+                pubkey: this.programId,
                 isWritable: false,
                 isSigner: false,
             },
         ].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)
+        rpc: RpcInterface,
+        executor: Signer,
+        param: {
+            packet: Packet
+            extraData: Uint8Array
+            value?: bigint
+            computeUnits?: number
+            endpointProgram?: PublicKey
+        },
+        commitment: Commitment = 'confirmed'
+    ): Promise<WrappedInstruction> {
+        const { packet, extraData, value = 0n, computeUnits = 200000, endpointProgram = ENDPOINT_PROGRAM_ID } = param
+        const endpointEventPDA = new EventPDA(endpointProgram)
+        const executorEventPDA = new EventPDA(this.programId)
         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 receiver = publicKey(addressToBytes32(receiver_))
+        const receiverInfo = await rpc.getAccount(receiver, { commitment })
+        invariant(receiverInfo.exists, `Receiver account not found: ${receiver}`)
+        const receiverProgram = publicKey(receiverInfo.owner)
         const message = arrayify(message_)
         const accounts = await getLzReceiveAccounts(
-            connection,
-            executor,
+            rpc,
+            executor.publicKey,
             receiver,
             receiverProgram,
             {
                 srcEid: srcEid,
-                sender: Array.from(arrayify(sender)),
-                guid: Array.from(arrayify(guid)),
+                sender: arrayify(sender),
+                guid: arrayify(guid),
                 message,
                 callerParams: extraData,
-                nonce: parseInt(packet.nonce),
+                nonce: BigInt(packet.nonce),
             },
-            commitmentOrConfig
+            commitment
         )
 
-        return instructions.createExecuteInstruction(
+        const txBuilder = instructions.execute(
+            { programs: this.programRepo },
             {
                 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
+                config: this.pda.config(),
+                endpointProgram: endpointProgram,
+                endpointEventAuthority: endpointEventPDA.eventAuthority()[0],
+                program: this.programId,
+                eventAuthority: executorEventPDA.eventAuthority()[0],
+                // param
+                receiver,
+                lzReceive: {
+                    srcEid,
+                    sender: arrayify(sender),
+                    nonce: parseInt(nonce),
+                    guid: arrayify(guid),
+                    message,
+                    extraData,
+                },
+                value,
+                computeUnits,
+            }
         )
+        return txBuilder.addRemainingAccounts([
+            {
+                pubkey: receiverProgram,
+                isWritable: false,
+                isSigner: false,
+            },
+            ...accounts,
+        ]).items[0]
     }
 
-    /**
-     * Composes a transaction.
-     *
-     * @param {Connection} connection - The connection.
-     * @param {PublicKey} executor - The executor public key.
-     * @param {PublicKey} endpointProgram - The endpoint program public key.
-     * @param {ComposeSentEvent} event - The compose sent event.
-     * @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 compose(
-        connection: Connection,
-        executor: PublicKey,
-        endpointProgram: PublicKey,
-        event: ComposeSentEvent,
-        extraData: Uint8Array,
-        value: BN = new BN(0),
-        computeUnits = 400000,
-        commitmentOrConfig?: Commitment
-    ): Promise<TransactionInstruction> {
-        const [config] = this.deriver.config()
-        const endpointEventDeriver = new EventPDADeriver(endpointProgram)
-        const executorEventDeriver = new EventPDADeriver(this.program)
+        rpc: RpcInterface,
+        executor: Signer,
+        param: {
+            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 connection.getParsedAccountInfo(to, commitmentOrConfig)
-        const receiverProgram = new PublicKey((receiverInfo.value as AccountInfo<Buffer>).owner)
+        const receiverInfo = await rpc.getAccount(to, { commitment })
+        invariant(receiverInfo.exists, `Receiver account not found: ${to}`)
+        const receiverProgram = publicKey(receiverInfo.owner)
 
         const accounts = await getLzComposeAccountMeta(
-            connection,
-            executor,
+            rpc,
+            executor.publicKey,
             to,
             receiverProgram,
             {
@@ -537,41 +412,39 @@ export class Executor {
                 message,
                 extraData,
             },
-            commitmentOrConfig
+            commitment
         )
 
-        return instructions.createComposeInstruction(
+        const txBuilder = instructions.compose(
+            { programs: this.programRepo },
             {
                 executor,
-                config,
+                config: this.pda.config(),
                 endpointProgram,
                 endpointEventAuthority: endpointEventDeriver.eventAuthority()[0],
-                program: this.program,
+                program: this.programId,
                 eventAuthority: executorEventDeriver.eventAuthority()[0],
-                anchorRemainingAccounts: [
-                    {
-                        pubkey: receiverProgram,
-                        isWritable: false,
-                        isSigner: false,
-                    },
-                    ...accounts,
-                ],
-            } satisfies instructions.ComposeInstructionAccounts,
-            {
-                params: {
-                    lzCompose: {
-                        to,
-                        from,
-                        guid,
-                        index,
-                        message,
-                        extraData,
-                    },
-                    computeUnits,
-                    value,
-                } satisfies types.ComposeParams,
-            } satisfies instructions.ComposeInstructionArgs,
-            this.program
+
+                // param
+                lzCompose: {
+                    to,
+                    from,
+                    guid,
+                    index,
+                    message,
+                    extraData,
+                },
+                computeUnits,
+                value,
+            }
         )
+        return txBuilder.addRemainingAccounts([
+            {
+                pubkey: receiverProgram,
+                isWritable: false,
+                isSigner: false,
+            },
+            ...accounts,
+        ]).items[0]
     }
 }