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

package/src/send-helper.ts

@@ -1,14 +1,24 @@
-import { AccountInfo, AccountMeta, Commitment, Connection, GetAccountInfoConfig, PublicKey } from '@solana/web3.js'
+import {
+    AccountMeta,
+    Commitment,
+    MaybeRpcAccount,
+    PublicKey,
+    RpcInterface,
+    createNoopSigner,
+    defaultPublicKey,
+    isSome,
+} from '@metaplex-foundation/umi'
+import { fromWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import * as web3 from '@solana/web3.js'
 import invariant from 'tiny-invariant'
 
 import { addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
 
+import { EndpointProgram, SimpleMessageLibProgram, UlnProgram } from '.'
 import { DVN, accounts as DvnAccounts } from './dvn'
 import { DefaultMessageLib } from './endpoint'
 import { Executor, accounts as ExecutorAccounts } from './executor'
 
-import { EndpointProgram, SimpleMessageLibProgram, UlnProgram } from '.'
-
 /**
  * Interface representing keyed account information.
  */
@@ -17,11 +27,7 @@ interface KeyedAccountInfo {
      * The account ID.
      */
     accountId: PublicKey
-
-    /**
-     * The account information.
-     */
-    accountInfo: AccountInfo<Buffer> | null
+    accountInfo: MaybeRpcAccount
 }
 
 /**
@@ -46,7 +52,7 @@ export class SendHelper {
     private endpoint: EndpointProgram.Endpoint
     private uln: UlnProgram.Uln
     private simpleMsgLib: SimpleMessageLibProgram.SimpleMessageLib
-    private accounts = new Map<string, AccountInfo<Buffer> | null>()
+    private accounts = new Map<string, MaybeRpcAccount>()
 
     /**
      * Creates an instance of the SendHelper class.
@@ -56,9 +62,9 @@ export class SendHelper {
      * @param {PublicKey} [simpleMsgLibProgram=SimpleMessageLibProgram.PROGRAM_ID] - The simple message library program public key.
      */
     constructor(
-        public readonly endpointProgram: PublicKey = EndpointProgram.PROGRAM_ID,
-        public readonly ulnProgram: PublicKey = UlnProgram.PROGRAM_ID,
-        public readonly simpleMsgLibProgram: PublicKey = SimpleMessageLibProgram.PROGRAM_ID
+        public readonly endpointProgram: PublicKey = EndpointProgram.ENDPOINT_PROGRAM_ID,
+        public readonly ulnProgram: PublicKey = UlnProgram.ULN_PROGRAM_ID,
+        public readonly simpleMsgLibProgram: PublicKey = SimpleMessageLibProgram.SIMPLE_MESSAGELIB_PROGRAM_ID
     ) {
         this.endpoint = new EndpointProgram.Endpoint(endpointProgram)
         this.uln = new UlnProgram.Uln(ulnProgram)
@@ -74,50 +80,45 @@ export class SendHelper {
      * @returns {Promise<(AccountInfo<Buffer> | null)[]>} A promise that resolves to an array of account information.
      */
     private async getMultipleAccountsInfo(
-        connection: Connection,
+        rpc: RpcInterface,
         keys: PublicKey[],
-        commitment?: Commitment | GetAccountInfoConfig
-    ): Promise<(AccountInfo<Buffer> | null)[]> {
+        commitment: Commitment = 'confirmed'
+    ): Promise<MaybeRpcAccount[]> {
         // check if all accounts are already fetched
-        const missingKeys = keys.filter((key) => !this.accounts.has(key.toBase58()))
+        const missingKeys = keys.filter((key) => !this.accounts.has(key))
 
         // fetch missing accounts
         if (missingKeys.length > 0) {
-            const infos = await connection.getMultipleAccountsInfo(missingKeys, commitment)
+            const infos = await rpc.getAccounts(missingKeys, { commitment })
             infos.forEach((info, i) => {
-                this.accounts.set(missingKeys[i].toBase58(), info)
+                this.accounts.set(missingKeys[i], info)
             })
         }
 
         // return all accounts
-        return keys.map((key) => this.accounts.get(key.toBase58())!)
+        return keys.map((key) => this.accounts.get(key)!)
     }
 
-    /**
-     * Gets the account metadata for the quote instruction.
-     *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {PublicKey} payer - The payer public key.
-     * @param {PublicKey} sender - The sender public key.
-     * @param {number} dstEid - The destination endpoint ID.
-     * @param {string} receiver - The receiver address.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig='confirmed'] - The commitment level or account info configuration.
-     * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
-     */
     async getQuoteAccounts(
-        connection: Connection,
-        payer: PublicKey,
-        sender: PublicKey,
-        dstEid: number,
-        receiver: string,
-        commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
+        rpc: RpcInterface,
+        params: {
+            payer: PublicKey | web3.PublicKey
+            sender: PublicKey | web3.PublicKey
+            dstEid: number
+            receiver: string | Uint8Array
+        },
+        commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const [sendLibConfig] = this.endpoint.deriver.sendLibraryConfig(sender, dstEid)
-        const [defaultSendLibConfig] = this.endpoint.deriver.defaultSendLibraryConfig(dstEid)
-        const [simpleMsgLib] = this.simpleMsgLib.deriver.messageLib()
-        const [uln] = this.uln.deriver.messageLib()
-        const [ulnDefaultSendConfig] = this.uln.deriver.defaultSendConfig(dstEid)
-        const [ulnSendConfig] = this.uln.deriver.sendConfig(dstEid, sender)
+        const { payer: _payer, sender: _sender, dstEid, receiver } = params
+        const payer = _payer instanceof web3.PublicKey ? fromWeb3JsPublicKey(_payer) : _payer
+        const sender = _sender instanceof web3.PublicKey ? fromWeb3JsPublicKey(_sender) : _sender
+
+        const [sendLibConfig] = this.endpoint.pda.sendLibraryConfig(sender, dstEid)
+        const [defaultSendLibConfig] = this.endpoint.pda.defaultSendLibraryConfig(dstEid)
+        const [simpleMsgLib] = this.simpleMsgLib.pda.messageLib()
+        const [uln] = this.uln.pda.messageLib()
+        const [ulnDefaultSendConfig] = this.uln.pda.defaultSendConfig(dstEid)
+        const [ulnSendConfig] = this.uln.pda.sendConfig(dstEid, sender)
         const [
             sendLibConfigBuf,
             defaultSendLibConfigBuf,
@@ -126,35 +127,32 @@ export class SendHelper {
             ulnDefaultSendConfigBuf,
             ulnSendConfigBuf,
         ] = await this.getMultipleAccountsInfo(
-            connection,
+            rpc,
             [sendLibConfig, defaultSendLibConfig, simpleMsgLib, uln, ulnDefaultSendConfig, ulnSendConfig],
-            commitmentOrConfig
-        )
-        invariant(defaultSendLibConfigBuf && sendLibConfigBuf, 'endpoint send library not initialized')
-        const [sendLibConfigInfo] = EndpointProgram.accounts.SendLibraryConfig.fromAccountInfo(sendLibConfigBuf, 0)
-        const [defaultSendLibConfigInfo] = EndpointProgram.accounts.SendLibraryConfig.fromAccountInfo(
-            defaultSendLibConfigBuf,
-            0
+            commitment
         )
+        invariant(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, 'endpoint send library not initialized')
+        const sendLibConfigInfo = EndpointProgram.accounts.deserializeSendLibraryConfig(sendLibConfigBuf)
+        const defaultSendLibConfigInfo = EndpointProgram.accounts.deserializeSendLibraryConfig(defaultSendLibConfigBuf)
         const msgLib =
             sendLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString()
                 ? defaultSendLibConfigInfo.messageLib
                 : sendLibConfigInfo.messageLib
 
         let msgLibProgram = this.ulnProgram
-        if (msgLib.toBase58() === this.simpleMsgLib.deriver.messageLib()[0].toBase58()) {
+        if (msgLib === this.simpleMsgLib.pda.messageLib()[0]) {
             msgLibProgram = this.simpleMsgLibProgram
             return this.getEndpointAccounts(msgLibProgram, msgLib, sender, dstEid, receiver, QuoteOrSend.Quote).concat(
                 this.getSimpleMsgLibAccounts(payer, QuoteOrSend.Quote)
             )
         }
-        if (msgLib.toBase58() !== this.uln.deriver.messageLib()[0].toBase58()) {
+        if (msgLib !== this.uln.pda.messageLib()[0]) {
             throw new Error('Invalid message library')
         }
 
         return this.getEndpointAccounts(msgLibProgram, msgLib, sender, dstEid, receiver, QuoteOrSend.Quote).concat(
             await this.getUlnAccounts(
-                connection,
+                rpc,
                 payer,
                 {
                     accountId: uln,
@@ -169,36 +167,40 @@ export class SendHelper {
                     accountInfo: ulnSendConfigBuf,
                 },
                 QuoteOrSend.Quote,
-                commitmentOrConfig
+                commitment
             )
         )
     }
 
     /**
-     * Gets the account metadata for the send instruction.
-     *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {PublicKey} payer - The payer public key.
-     * @param {PublicKey} sender - The sender public key.
-     * @param {number} dstEid - The destination endpoint ID.
-     * @param {string} receiver - The receiver address.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig='confirmed'] - The commitment level or account info configuration.
-     * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
-     */
+     * @param connection
+     * @param payer
+     * @param sender the PDA of the oApp
+     * @param dstEid the destination endpoint id
+     * @param receiver the remote peer's address
+     * @param commitmentOrConfig
+     * 1 or 3(1+2) RPC calls
+     * */
     async getSendAccounts(
-        connection: Connection,
-        payer: PublicKey,
-        sender: PublicKey,
-        dstEid: number,
-        receiver: string,
-        commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
+        rpc: RpcInterface,
+        params: {
+            payer: PublicKey | web3.PublicKey
+            sender: PublicKey | web3.PublicKey
+            dstEid: number
+            receiver: string | Uint8Array
+        },
+        commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const [sendLibConfig] = this.endpoint.deriver.sendLibraryConfig(sender, dstEid)
-        const [defaultSendLibConfig] = this.endpoint.deriver.defaultSendLibraryConfig(dstEid)
-        const [simpleMsgLib] = this.simpleMsgLib.deriver.messageLib()
-        const [uln] = this.uln.deriver.messageLib()
-        const [ulnDefaultSendConfig] = this.uln.deriver.defaultSendConfig(dstEid)
-        const [ulnSendConfig] = this.uln.deriver.sendConfig(dstEid, sender)
+        const { payer: _payer, sender: _sender, dstEid, receiver } = params
+        const payer = _payer instanceof web3.PublicKey ? fromWeb3JsPublicKey(_payer) : _payer
+        const sender = _sender instanceof web3.PublicKey ? fromWeb3JsPublicKey(_sender) : _sender
+
+        const [sendLibConfig] = this.endpoint.pda.sendLibraryConfig(sender, dstEid)
+        const [defaultSendLibConfig] = this.endpoint.pda.defaultSendLibraryConfig(dstEid)
+        const [simpleMsgLib] = this.simpleMsgLib.pda.messageLib()
+        const [uln] = this.uln.pda.messageLib()
+        const [ulnDefaultSendConfig] = this.uln.pda.defaultSendConfig(dstEid)
+        const [ulnSendConfig] = this.uln.pda.sendConfig(dstEid, sender)
         const [
             sendLibConfigBuf,
             defaultSendLibConfigBuf,
@@ -207,34 +209,31 @@ export class SendHelper {
             ulnDefaultSendConfigBuf,
             ulnSendConfigBuf,
         ] = await this.getMultipleAccountsInfo(
-            connection,
+            rpc,
             [sendLibConfig, defaultSendLibConfig, simpleMsgLib, uln, ulnDefaultSendConfig, ulnSendConfig],
-            commitmentOrConfig
-        )
-        invariant(defaultSendLibConfigBuf && sendLibConfigBuf, 'endpoint send library not initialized')
-        const [sendLibConfigInfo] = EndpointProgram.accounts.SendLibraryConfig.fromAccountInfo(sendLibConfigBuf, 0)
-        const [defaultSendLibConfigInfo] = EndpointProgram.accounts.SendLibraryConfig.fromAccountInfo(
-            defaultSendLibConfigBuf,
-            0
+            commitment
         )
+        invariant(defaultSendLibConfigBuf.exists && sendLibConfigBuf.exists, 'endpoint send library not initialized')
+        const sendLibConfigInfo = EndpointProgram.accounts.deserializeSendLibraryConfig(sendLibConfigBuf)
+        const defaultSendLibConfigInfo = EndpointProgram.accounts.deserializeSendLibraryConfig(defaultSendLibConfigBuf)
         const msgLib =
             sendLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString()
                 ? defaultSendLibConfigInfo.messageLib
                 : sendLibConfigInfo.messageLib
 
         let msgLibProgram = this.ulnProgram
-        if (msgLib.toBase58() === this.simpleMsgLib.deriver.messageLib()[0].toBase58()) {
+        if (msgLib === this.simpleMsgLib.pda.messageLib()[0]) {
             msgLibProgram = this.simpleMsgLibProgram
             return this.getEndpointAccounts(msgLibProgram, msgLib, sender, dstEid, receiver, QuoteOrSend.Send).concat(
                 this.getSimpleMsgLibAccounts(payer, QuoteOrSend.Send)
             )
         }
-        if (msgLib.toBase58() !== this.uln.deriver.messageLib()[0].toBase58()) {
+        if (msgLib !== this.uln.pda.messageLib()[0]) {
             throw new Error('Invalid message library')
         }
         return this.getEndpointAccounts(msgLibProgram, msgLib, sender, dstEid, receiver, QuoteOrSend.Send).concat(
             await this.getUlnAccounts(
-                connection,
+                rpc,
                 payer,
                 {
                     accountId: uln,
@@ -249,7 +248,7 @@ export class SendHelper {
                     accountInfo: ulnSendConfigBuf,
                 },
                 QuoteOrSend.Send,
-                commitmentOrConfig
+                commitment
             )
         )
     }
@@ -270,41 +269,63 @@ export class SendHelper {
         msgLib: PublicKey,
         sender: PublicKey,
         dstEid: number,
-        receiver: string,
+        _receiver: string | Uint8Array,
         quoteOrSend: QuoteOrSend
     ): AccountMeta[] {
-        const [sendLibraryConfig] = this.endpoint.deriver.sendLibraryConfig(sender, dstEid)
-        const [defaultSendLibraryConfig] = this.endpoint.deriver.defaultSendLibraryConfig(dstEid)
-        const [sendLibraryInfo] = this.endpoint.deriver.messageLibraryInfo(msgLib)
-        const [nonce] = this.endpoint.deriver.nonce(sender, dstEid, addressToBytes32(receiver))
+        const receiver = typeof _receiver === 'string' ? addressToBytes32(_receiver) : _receiver
+        const [sendLibraryConfig] = this.endpoint.pda.sendLibraryConfig(sender, dstEid)
+        const [defaultSendLibraryConfig] = this.endpoint.pda.defaultSendLibraryConfig(dstEid)
+        const [sendLibraryInfo] = this.endpoint.pda.messageLibraryInfo(msgLib)
+        const [nonce] = this.endpoint.pda.nonce(sender, dstEid, receiver)
         let accounts: AccountMeta[]
+        const endpoint = new EndpointProgram.Endpoint(this.endpointProgram)
         if (quoteOrSend === QuoteOrSend.Quote) {
-            accounts = EndpointProgram.instructions.createQuoteInstructionAccounts(
-                {
-                    sendLibraryProgram: msgLibProgram,
-                    sendLibraryConfig,
-                    defaultSendLibraryConfig,
-                    sendLibraryInfo,
-                    endpoint: this.endpoint.deriver.setting()[0],
-                    nonce,
-                } satisfies EndpointProgram.instructions.QuoteInstructionAccounts,
-                this.endpointProgram
-            )
+            accounts = EndpointProgram.instructions
+                .quote(
+                    { programs: endpoint.programRepo },
+                    {
+                        sendLibraryProgram: msgLibProgram,
+                        sendLibraryConfig,
+                        defaultSendLibraryConfig,
+                        sendLibraryInfo,
+                        endpoint: this.endpoint.pda.setting()[0],
+                        nonce,
+
+                        // param
+                        sender: defaultPublicKey(),
+                        dstEid: 0,
+                        receiver: new Uint8Array(32),
+                        message: new Uint8Array(32),
+                        options: new Uint8Array(32),
+                        payInLzToken: false,
+                    }
+                )
+                .getInstructions()[0].keys
         } else {
-            accounts = EndpointProgram.instructions.createSendInstructionAccounts(
-                {
-                    sender, //signer
-                    sendLibraryProgram: msgLibProgram,
-                    sendLibraryConfig,
-                    defaultSendLibraryConfig,
-                    sendLibraryInfo,
-                    endpoint: this.endpoint.deriver.setting()[0],
-                    nonce,
-                    program: this.endpointProgram,
-                    eventAuthority: this.endpoint.eventAuthorityPDA,
-                } satisfies EndpointProgram.instructions.SendInstructionAccounts,
-                this.endpoint.program
-            )
+            accounts = EndpointProgram.instructions
+                .send(
+                    { programs: endpoint.programRepo },
+                    {
+                        sender: createNoopSigner(sender), //signer
+                        sendLibraryProgram: msgLibProgram,
+                        sendLibraryConfig,
+                        defaultSendLibraryConfig,
+                        sendLibraryInfo,
+                        endpoint: this.endpoint.pda.setting()[0],
+                        nonce,
+                        program: this.endpointProgram,
+                        eventAuthority: this.endpoint.eventAuthority,
+
+                        // param
+                        dstEid: 0,
+                        receiver: new Uint8Array(32),
+                        message: new Uint8Array(32),
+                        options: new Uint8Array(32),
+                        nativeFee: 0,
+                        lzTokenFee: 0,
+                    }
+                )
+                .getInstructions()[0].keys
         }
 
         accounts.forEach((item: AccountMeta) => {
@@ -312,11 +333,12 @@ export class SendHelper {
         })
         return [
             {
-                pubkey: this.endpoint.program,
+                pubkey: this.endpoint.programId,
                 isSigner: false,
                 isWritable: false,
             },
-        ].concat(accounts)
+            ...accounts,
+        ]
     }
 
     /**
@@ -327,28 +349,57 @@ export class SendHelper {
      * @returns {AccountMeta[]} An array of account metadata.
      */
     private getSimpleMsgLibAccounts(payer: PublicKey, quoteOrSend: QuoteOrSend): AccountMeta[] {
-        const [msgLib] = this.simpleMsgLib.deriver.messageLib()
+        const [msgLib] = this.simpleMsgLib.pda.messageLib()
         let accounts: AccountMeta[]
+        const simpleMsgLib = new SimpleMessageLibProgram.SimpleMessageLib(this.simpleMsgLibProgram)
         if (quoteOrSend === QuoteOrSend.Quote) {
-            accounts = SimpleMessageLibProgram.instructions.createQuoteInstructionAccounts(
-                {
-                    endpoint: PublicKey.default, // useless
-                    messageLib: msgLib,
-                } satisfies SimpleMessageLibProgram.instructions.QuoteInstructionAccounts,
-                this.simpleMsgLibProgram
-            )
+            accounts = SimpleMessageLibProgram.instructions
+                .quote(
+                    { programs: simpleMsgLib.programRepo },
+                    {
+                        endpoint: createNoopSigner(defaultPublicKey()),
+                        messageLib: msgLib,
+                        // param
+                        packet: {
+                            nonce: 0,
+                            srcEid: 0,
+                            sender: defaultPublicKey(),
+                            dstEid: 0,
+                            receiver: new Uint8Array(32),
+                            guid: new Uint8Array(32),
+                            message: new Uint8Array(4),
+                        },
+                        options: new Uint8Array(4),
+                        payInLzToken: false,
+                    }
+                )
+                .getInstructions()[0].keys
         } else {
-            accounts = SimpleMessageLibProgram.instructions.createSendInstructionAccounts(
-                {
-                    endpoint: PublicKey.default, // useless
-                    messageLib: msgLib,
-                    payer,
-                } satisfies SimpleMessageLibProgram.instructions.SendInstructionAccounts,
-                this.simpleMsgLibProgram
-            )
+            accounts = SimpleMessageLibProgram.instructions
+                .send(
+                    { programs: simpleMsgLib.programRepo, payer: createNoopSigner(payer) },
+                    {
+                        endpoint: createNoopSigner(defaultPublicKey()), // useless
+                        messageLib: msgLib,
+                        payer: createNoopSigner(payer),
+                        // param
+                        packet: {
+                            nonce: 0,
+                            srcEid: 0,
+                            sender: defaultPublicKey(),
+                            dstEid: 0,
+                            receiver: new Uint8Array(32),
+                            guid: new Uint8Array(32),
+                            message: new Uint8Array(4),
+                        },
+                        options: new Uint8Array(4),
+                        nativeFee: 0,
+                    }
+                )
+                .getInstructions()[0].keys
         }
         accounts.forEach((key) => {
-            if (!payer.equals(key.pubkey)) {
+            if (payer !== key.pubkey) {
                 key.isSigner = false
             }
         })
@@ -368,22 +419,22 @@ export class SendHelper {
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
      */
     private async getUlnAccounts(
-        connection: Connection,
+        rpc: RpcInterface,
         payer: PublicKey,
         ulnInfo: KeyedAccountInfo,
         ulnDefaultSendConfigInfo: KeyedAccountInfo,
         ulnSendConfigInfo: KeyedAccountInfo,
         quoteOrSend: QuoteOrSend,
-        commitment?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        invariant(ulnInfo.accountInfo && ulnDefaultSendConfigInfo.accountInfo, 'uln send library not initialized')
-        const [ulnState] = UlnProgram.accounts.UlnSettings.fromAccountInfo(ulnInfo.accountInfo, 0)
-        const [defaultSendConfigState] = UlnProgram.accounts.SendConfig.fromAccountInfo(
-            ulnDefaultSendConfigInfo.accountInfo,
-            0
+        invariant(
+            ulnInfo.accountInfo.exists && ulnDefaultSendConfigInfo.accountInfo.exists,
+            'uln send library not initialized'
         )
-        const sendConfigState = ulnSendConfigInfo.accountInfo
-            ? UlnProgram.accounts.SendConfig.fromAccountInfo(ulnSendConfigInfo.accountInfo)[0]
+        const ulnState = UlnProgram.accounts.deserializeUlnSettings(ulnInfo.accountInfo)
+        const defaultSendConfigState = UlnProgram.accounts.deserializeSendConfig(ulnDefaultSendConfigInfo.accountInfo)
+        const sendConfigState = ulnSendConfigInfo.accountInfo.exists
+            ? UlnProgram.accounts.deserializeSendConfig(ulnSendConfigInfo.accountInfo)
             : null
 
         let {
@@ -392,42 +443,42 @@ export class SendHelper {
         } = defaultSendConfigState
 
         // if the executor is set in the send config, use it
-        if (sendConfigState?.executor && !sendConfigState.executor.executor.equals(PublicKey.default)) {
+        if (sendConfigState?.executor && sendConfigState.executor.executor !== defaultPublicKey()) {
             ;({ executor } = sendConfigState)
         }
 
         // if the requiredDvns is set in the send config, use it
         if (sendConfigState && sendConfigState.uln.requiredDvns.length > 0) {
             requiredDvns = sendConfigState.uln.requiredDvns.filter((p) => {
-                return !p.equals(PublicKey.default)
+                return p !== defaultPublicKey()
             })
         }
 
         // if the optionalDvns is set in the send config, use it
         if (sendConfigState && sendConfigState.uln.optionalDvns.length > 0) {
             optionalDvns = sendConfigState.uln.optionalDvns.filter((p) => {
-                return !p.equals(PublicKey.default)
+                return p !== defaultPublicKey()
             })
         }
 
         const dvnsKey = requiredDvns.concat(optionalDvns)
         const [executorBuf, ...dvnBuf] = await this.getMultipleAccountsInfo(
-            connection,
+            rpc,
             [executor.executor, ...dvnsKey],
             commitment
         )
-        invariant(executorBuf, `executor:${executor.executor.toBase58()} not initialized`)
+        invariant(executorBuf.exists, `executor:${executor.executor} not initialized`)
 
         let executorAccounts: AccountMeta[], dvnAccounts: AccountMeta[]
         {
             const executor = {
-                config: ExecutorAccounts.ExecutorConfig.fromAccountInfo(executorBuf)[0],
+                config: ExecutorAccounts.deserializeExecutorConfig(executorBuf),
                 owner: executorBuf.owner,
             }
             const dvns = dvnBuf.map((dvn, i) => {
-                invariant(dvn, `dvn:${dvnsKey[i].toBase58()} not initialized`)
+                invariant(dvn.exists, `dvn:${dvnsKey[i]} not initialized`)
                 return {
-                    config: DvnAccounts.DvnConfig.fromAccountInfo(dvn)[0],
+                    config: DvnAccounts.deserializeDvnConfig(dvn),
                     owner: dvn.owner,
                 }
             })
@@ -436,24 +487,25 @@ export class SendHelper {
             ;[executor.config, ...dvns.map((dvn) => dvn.config)].forEach((config) => {
                 priceFeeds.push(config.priceFeed)
             })
-            const priceFeedInfos = await this.getMultipleAccountsInfo(connection, priceFeeds, commitment)
+            const priceFeedInfos = await this.getMultipleAccountsInfo(rpc, priceFeeds, commitment)
             priceFeedInfos.forEach((info, i) => {
-                invariant(info, `priceFeed:${priceFeeds[i].toBase58()} not initialized`)
+                invariant(info.exists, `priceFeed:${priceFeeds[i]} not initialized`)
             })
+            const executorPriceFeed = await this.getMultipleAccountsInfo(rpc, [executor.config.priceFeed], commitment)
+            invariant(executorPriceFeed[0].exists, `executor priceFeed:${executor.config.priceFeed} not initialized`)
             executorAccounts = new Executor(executor.owner).getQuoteIXAccountMetaForCPI(
                 executor.config.priceFeed,
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                (await this.getMultipleAccountsInfo(connection, [executor.config.priceFeed], commitment))[0]!.owner,
+                executorPriceFeed[0].owner,
                 quoteOrSend === QuoteOrSend.Send
             )
             dvnAccounts = (
                 await Promise.all(
                     dvns.map(async (p, i) => {
+                        const dvnPriceFeed = await this.getMultipleAccountsInfo(rpc, [p.config.priceFeed], commitment)
+                        invariant(dvnPriceFeed[0].exists, `dvn priceFeed:${p.config.priceFeed} not initialized`)
                         return new DVN(p.owner).getQuoteIXAccountMetaForCPI(
                             p.config.priceFeed,
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            (await this.getMultipleAccountsInfo(connection, [p.config.priceFeed], commitment))[0]!
-                                .owner,
+                            dvnPriceFeed[0].owner,
                             quoteOrSend === QuoteOrSend.Send
                         )
                     })
@@ -461,41 +513,70 @@ export class SendHelper {
             ).flat()
         }
 
-        const treasury = ulnState.treasury?.nativeReceiver
+        const treasury = isSome(ulnState.treasury) ? ulnState.treasury.value.nativeReceiver : undefined
         let accounts: AccountMeta[]
+        const uln = new UlnProgram.Uln(this.ulnProgram)
         if (quoteOrSend === QuoteOrSend.Quote) {
-            accounts = UlnProgram.instructions.createQuoteInstructionAccounts(
-                {
-                    endpoint: PublicKey.default, // useless
-                    uln: this.uln.deriver.setting()[0],
-                    sendConfig: ulnSendConfigInfo.accountId,
-                    defaultSendConfig: ulnDefaultSendConfigInfo.accountId,
-                    anchorRemainingAccounts: executorAccounts.concat(dvnAccounts),
-                } satisfies UlnProgram.instructions.QuoteInstructionAccounts,
-                this.ulnProgram
-            )
+            const txBuilder = UlnProgram.instructions
+                .quote(
+                    { programs: uln.programRepo },
+                    {
+                        endpoint: createNoopSigner(defaultPublicKey()),
+                        uln: this.uln.pda.setting()[0],
+                        sendConfig: ulnSendConfigInfo.accountId,
+                        defaultSendConfig: ulnDefaultSendConfigInfo.accountId,
+                        // param
+                        packet: {
+                            nonce: 0,
+                            srcEid: 0,
+                            sender: defaultPublicKey(),
+                            dstEid: 0,
+                            receiver: new Uint8Array(32),
+                            guid: new Uint8Array(32),
+                            message: new Uint8Array(4),
+                        },
+                        options: new Uint8Array(4),
+                        payInLzToken: false,
+                    }
+                )
+                .addRemainingAccounts(executorAccounts.concat(dvnAccounts))
+            accounts = txBuilder.getInstructions()[0].keys
         } else {
-            accounts = UlnProgram.instructions.createSendInstructionAccounts(
-                {
-                    endpoint: PublicKey.default, // useless
-                    uln: this.uln.deriver.setting()[0],
-                    sendConfig: ulnSendConfigInfo.accountId,
-                    defaultSendConfig: ulnDefaultSendConfigInfo.accountId,
-                    payer,
-                    treasury,
-                    eventAuthority: this.uln.eventAuthorityPDA,
-                    program: this.uln.program,
-                    anchorRemainingAccounts: executorAccounts.concat(dvnAccounts),
-                } satisfies UlnProgram.instructions.SendInstructionAccounts,
-                this.ulnProgram
-            )
+            const txBuilder = UlnProgram.instructions
+                .send(
+                    { programs: uln.programRepo, payer: createNoopSigner(payer) },
+                    {
+                        endpoint: createNoopSigner(defaultPublicKey()),
+                        uln: this.uln.pda.setting()[0],
+                        sendConfig: ulnSendConfigInfo.accountId,
+                        defaultSendConfig: ulnDefaultSendConfigInfo.accountId,
+                        payer: createNoopSigner(payer),
+                        treasury,
+                        eventAuthority: this.uln.eventAuthority,
+                        program: this.uln.programId,
+
+                        packet: {
+                            nonce: 0,
+                            srcEid: 0,
+                            sender: defaultPublicKey(),
+                            dstEid: 0,
+                            receiver: new Uint8Array(32),
+                            guid: new Uint8Array(32),
+                            message: new Uint8Array(4),
+                        },
+                        options: new Uint8Array(4),
+                        nativeFee: 0,
+                    }
+                )
+                .addRemainingAccounts(executorAccounts.concat(dvnAccounts))
+            accounts = txBuilder.getInstructions()[0].keys
             if (treasury) {
-                const treasuryIndex = accounts.findIndex((k) => k.pubkey.toBase58() == treasury.toBase58())
+                const treasuryIndex = accounts.findIndex((k) => k.pubkey == treasury)
                 accounts[treasuryIndex].isWritable = true // treasury account
             }
         }
         accounts.forEach((key) => {
-            if (!payer.equals(key.pubkey)) {
+            if (payer !== key.pubkey) {
                 key.isSigner = false
             }
         })