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

package/src/uln.ts

@@ -1,12 +1,25 @@
 import {
     AccountMeta,
+    Cluster,
+    ClusterFilter,
     Commitment,
-    Connection,
-    GetAccountInfoConfig,
+    Option,
+    Program,
+    ProgramError,
+    ProgramRepositoryInterface,
     PublicKey,
-    TransactionInstruction,
-} from '@solana/web3.js'
-import BN from 'bn.js'
+    RpcInterface,
+    Signer,
+    WrappedInstruction,
+    createNoopSigner,
+    createNullRpc,
+    defaultPublicKey,
+    isSome,
+    publicKey,
+} from '@metaplex-foundation/umi'
+import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
+import { fromWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import invariant from 'tiny-invariant'
 
 import { arrayify } from '@layerzerolabs/lz-utilities'
@@ -14,15 +27,17 @@ import { PacketV1Codec } from '@layerzerolabs/lz-v2-utilities'
 
 import { EndpointProgram, MessageLibInterface, SetConfigType, SolanaPacketPath } from '.'
 import { DVN, accounts as DvnAccounts } from './dvn'
+import { ENDPOINT_PROGRAM_ID } from './endpoint'
 import { Executor, accounts as ExecutorAccounts } from './executor'
-import * as accounts from './generated/uln/accounts'
-import * as errors from './generated/uln/errors'
-import * as events from './generated/uln/events'
-import * as instructions from './generated/uln/instructions'
-import * as types from './generated/uln/types'
-import { EndpointPDADeriver, EventPDADeriver, UlnPDADeriver } from './pda-deriver'
-
-export * from './generated/uln'
+import { ULN_PROGRAM_ID } from './generated/kinobi/uln'
+import * as accounts from './generated/kinobi/uln/accounts'
+import * as errors from './generated/kinobi/uln/errors'
+import * as events from './generated/kinobi/uln/events'
+import * as instructions from './generated/kinobi/uln/instructions'
+import * as types from './generated/kinobi/uln/types'
+import { EndpointPDA, EventPDA, UlnPDA } from './pda'
+
+export { ULN_PROGRAM_ID } from './generated/kinobi/uln'
 export { accounts, instructions, types, events, errors }
 
 /**
@@ -120,53 +135,63 @@ export interface OptionalOracles {
  * @see {@link MessageLibInterface}
  */
 export class Uln implements MessageLibInterface {
-    deriver: UlnPDADeriver
-    eventAuthorityPDA: PublicKey
+    public readonly pda: UlnPDA
+    public readonly programRepo: ProgramRepositoryInterface
+    public readonly eventAuthority: PublicKey
 
     /**
      * Creates an instance of the Uln class.
      *
-     * @param {PublicKey} program - The program public key.
+     * @param {PublicKey} programId - The program public key.
      */
-    constructor(public program: PublicKey) {
-        this.deriver = new UlnPDADeriver(program)
-        const [eventAuthorityPDA] = new EventPDADeriver(program).eventAuthority()
-        this.eventAuthorityPDA = eventAuthorityPDA
+    constructor(
+        public programId: PublicKey = ULN_PROGRAM_ID,
+        rpc?: RpcInterface
+    ) {
+        this.pda = new UlnPDA(programId)
+        if (rpc === undefined) {
+            rpc = createNullRpc()
+            rpc.getCluster = (): Cluster => 'custom'
+        }
+        this.programRepo = createDefaultProgramRepository({ rpc }, [
+            {
+                name: 'uln',
+                publicKey: programId,
+                getErrorFromCode(code: number, cause?: Error): ProgramError | null {
+                    return errors.getUlnErrorFromCode(code, this, cause)
+                },
+                getErrorFromName(name: string, cause?: Error): ProgramError | null {
+                    return errors.getUlnErrorFromName(name, this, cause)
+                },
+                isOnCluster(): boolean {
+                    return true
+                },
+            } satisfies Program,
+        ])
+
+        this.eventAuthority = new EventPDA(programId).eventAuthority()[0]
     }
 
-    /**
-     * Initializes the ULN.
-     *
-     * @param {PublicKey} endpointProgram - The endpoint program public key.
-     * @param {PublicKey} payer - The payer public key.
-     * @param {PublicKey} admin - The admin public key.
-     * @param {number} eid - The endpoint ID.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    initUln(endpointProgram: PublicKey, payer: PublicKey, admin: PublicKey, eid: number): TransactionInstruction {
-        const [setting] = this.deriver.setting()
-        const [msgLib] = this.deriver.messageLib()
-        const [endpointAuth] = new EndpointPDADeriver(endpointProgram).messageLibraryInfo(msgLib)
-        // const info = await connection.getAccountInfo(setting, commitmentOrConfig)
-        // if (info) {
-        //     throw new Error('uln already initialized')
-        // }
+    getProgram(clusterFilter: ClusterFilter = 'custom'): Program {
+        return this.programRepo.get('uln', clusterFilter)
+    }
 
-        return instructions.createInitUlnInstruction(
+    initUln(payer: Signer, param: { admin: PublicKey; eid: number; endpointProgram?: PublicKey }): WrappedInstruction {
+        const { admin, eid, endpointProgram } = param
+        const [msgLib] = this.pda.messageLib()
+        const [endpointAuth] = new EndpointPDA(endpointProgram ?? ENDPOINT_PROGRAM_ID).messageLibraryInfo(msgLib)
+        return instructions.initUln(
+            { programs: this.programRepo, payer },
             {
                 payer,
-                uln: setting,
-            } satisfies instructions.InitUlnInstructionAccounts,
-            {
-                params: {
-                    eid,
-                    admin,
-                    endpoint: endpointAuth,
-                    endpointProgram: endpointProgram,
-                } satisfies types.InitUlnParams,
-            } satisfies instructions.InitUlnInstructionArgs,
-            this.program
-        )
+                uln: this.pda.setting(),
+                // param
+                eid,
+                admin,
+                endpoint: endpointAuth,
+                endpointProgram: endpointProgram ?? ENDPOINT_PROGRAM_ID,
+            }
+        ).items[0]
     }
 
     /**
@@ -183,60 +208,60 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
      */
     async initOrUpdateDefaultConfig(
-        connection: Connection,
-        admin: PublicKey,
-        eid: number,
-        sendUlnConfig: types.UlnConfig,
-        receiveUlnConfig: types.UlnConfig,
-        executorConfig: types.ExecutorConfig,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<TransactionInstruction> {
-        const [setting] = this.deriver.setting()
-        const [sendConfigPDA] = this.deriver.defaultSendConfig(eid)
-        const [receiveConfigPDA] = this.deriver.defaultReceiveConfig(eid)
-        const configInfo = await connection.getAccountInfo(sendConfigPDA, commitmentOrConfig)
-        if (configInfo) {
+        rpc: RpcInterface,
+        admin: Signer,
+        param: {
+            remote: number
+            sendUlnConfig: Option<types.UlnConfig>
+            receiveUlnConfig: Option<types.UlnConfig>
+            executorConfig: Option<types.ExecutorConfig>
+        }
+    ): Promise<WrappedInstruction> {
+        const { remote, sendUlnConfig, receiveUlnConfig, executorConfig } = param
+        const [setting] = this.pda.setting()
+        const [sendConfig] = this.pda.defaultSendConfig(remote)
+        const [receiveConfigPDA] = this.pda.defaultReceiveConfig(remote)
+        const sendConfigExists = await rpc.accountExists(sendConfig, { commitment: 'confirmed' })
+        if (sendConfigExists) {
             // update default config
-            return instructions.createSetDefaultConfigInstruction(
+            return instructions.setDefaultConfig(
+                { programs: this.programRepo },
                 {
                     admin,
                     uln: setting,
-                    sendConfig: sendConfigPDA,
+                    sendConfig: sendConfig,
                     receiveConfig: receiveConfigPDA,
-                    eventAuthority: this.eventAuthorityPDA,
-                    program: this.program,
-                } satisfies instructions.SetDefaultConfigInstructionAccounts,
-                {
-                    params: {
-                        eid,
-                        sendUlnConfig,
-                        receiveUlnConfig,
-                        executorConfig,
-                    } satisfies types.SetDefaultConfigParams,
-                } satisfies instructions.SetDefaultConfigInstructionArgs,
-                this.program
-            )
+                    eventAuthority: this.eventAuthority,
+                    program: this.programId,
+                    // param
+                    eid: remote,
+                    sendUlnConfig,
+                    receiveUlnConfig,
+                    executorConfig,
+                }
+            ).items[0]
         } else {
+            invariant(isSome(sendUlnConfig), 'sendUlnConfig is required')
+            invariant(isSome(receiveUlnConfig), 'receiveUlnConfig is required')
+            invariant(isSome(executorConfig), 'executorConfig is required')
+
             // init default config
-            return instructions.createInitDefaultConfigInstruction(
+            return instructions.initDefaultConfig(
+                { programs: this.programRepo },
                 {
                     admin,
                     uln: setting,
-                    sendConfig: sendConfigPDA,
+                    sendConfig: sendConfig,
                     receiveConfig: receiveConfigPDA,
-                    eventAuthority: this.eventAuthorityPDA,
-                    program: this.program,
-                } satisfies instructions.InitDefaultConfigInstructionAccounts,
-                {
-                    params: {
-                        eid,
-                        sendUlnConfig,
-                        receiveUlnConfig,
-                        executorConfig,
-                    } satisfies types.InitDefaultConfigParams,
-                } satisfies instructions.InitDefaultConfigInstructionArgs,
-                this.program
-            )
+                    eventAuthority: this.eventAuthority,
+                    program: this.programId,
+                    // param
+                    eid: remote,
+                    sendUlnConfig: sendUlnConfig.value,
+                    receiveUlnConfig: receiveUlnConfig.value,
+                    executorConfig: executorConfig.value,
+                }
+            ).items[0]
         }
     }
 
@@ -255,103 +280,83 @@ export class Uln implements MessageLibInterface {
      * @param {number} treasury.lzToken.fee - The LZ token fee.
      * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
      */
-    async setTreasury(
-        admin: PublicKey,
+    setTreasury(
+        admin: Signer,
         treasury: {
             admin: PublicKey
             nativeReceiver: PublicKey
             nativeFeeBps: number
             lzToken: { receiver: PublicKey; fee: number } | null
         } | null
-    ): Promise<TransactionInstruction> {
-        const [setting] = this.deriver.setting()
-        const ix = instructions.createSetTreasuryInstruction(
+    ): WrappedInstruction {
+        return instructions.setTreasury(
+            { programs: this.programRepo },
             {
                 signer: admin,
-                uln: setting,
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
-            } satisfies instructions.SetTreasuryInstructionAccounts,
-            {
-                params: {
-                    treasury,
-                } satisfies types.SetTreasuryParams,
-            } satisfies instructions.SetTreasuryInstructionArgs,
-            this.program
-        )
-        return Promise.resolve(ix)
+                uln: this.pda.setting(),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                // param
+                treasury,
+            }
+        ).items[0]
     }
 
-    /**
-     * Transfers the admin role to a new admin.
-     *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {PublicKey} admin - The current admin public key.
-     * @param {PublicKey} newAdmin - The new admin public key.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
-     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
-     * @throws {Error} If the ULN is not initialized.
-     */
-    async transferAdmin(
-        connection: Connection,
-        admin: PublicKey,
-        newAdmin: PublicKey,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<TransactionInstruction> {
-        const [setting] = this.deriver.setting()
-        const info = await connection.getAccountInfo(setting, commitmentOrConfig)
-        if (!info) {
-            throw new Error('uln not initialized')
-        }
-        return instructions.createTransferAdminInstruction(
+    transferAdmin(admin: Signer, newAdmin: PublicKey): WrappedInstruction {
+        return instructions.transferAdmin(
+            { programs: this.programRepo },
             {
                 admin,
-                uln: setting,
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
-            } satisfies instructions.TransferAdminInstructionAccounts,
-            {
-                params: {
-                    admin: newAdmin,
-                } satisfies types.TransferAdminParams,
-            } satisfies instructions.TransferAdminInstructionArgs,
-            this.program
-        )
+                uln: this.pda.setting(),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+            },
+            { admin: newAdmin }
+        ).items[0]
     }
 
     /**
      * Gets the account metadata for the CPI (Cross-Program Invocation) of the quote instruction.
      *
-     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {RpcInterface} rpc - The connection to the Solana cluster.
      * @param {PublicKey} _payer - The payer public key.
-     * @param {PacketPath} path - The packet path.
+     * @param {SolanaPacketPath} path - The packet path.
      * @param {Commitment} [commitment] - The commitment level.
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
      */
     async getQuoteIXAccountMetaForCPI(
-        connection: Connection,
+        rpc: RpcInterface,
         _payer: PublicKey,
         path: SolanaPacketPath,
-        commitment?: Commitment
+        commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const { sender: sender_, dstEid } = path
-        const sender = new PublicKey(arrayify(sender_))
-        const [defaultSendConfig] = this.deriver.defaultSendConfig(dstEid)
-        const [sendConfig] = this.deriver.sendConfig(dstEid, sender)
-        const [setting] = this.deriver.setting()
-
-        const remainingAccounts = await this.getSendIxRemainingAccounts(connection, sender, dstEid, false, commitment)
-        const accounts = instructions.createQuoteInstructionAccounts(
+        const { sender, dstEid } = path
+        // const sender = publicKey(arrayify(sender_))
+        const txBuilder = instructions.quote(
+            { programs: this.programRepo },
             {
-                endpoint: PublicKey.default, // useless
-                uln: setting,
-                sendConfig,
-                defaultSendConfig: defaultSendConfig,
-                anchorRemainingAccounts: remainingAccounts,
-            } satisfies instructions.QuoteInstructionAccounts,
-            this.program
+                endpoint: createNoopSigner(defaultPublicKey()),
+                uln: this.pda.setting(),
+                sendConfig: this.pda.sendConfig(dstEid, sender),
+                defaultSendConfig: this.pda.defaultSendConfig(dstEid),
+
+                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,
+            }
         )
-        return accounts.slice(1)
+        return txBuilder
+            .addRemainingAccounts(await this.getSendIxRemainingAccounts(rpc, sender, dstEid, false, commitment))
+            .getInstructions()[0]
+            .keys.slice(1)
     }
 
     /**
@@ -364,47 +369,132 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
      */
     async getSendIXAccountMetaForCPI(
-        connection: Connection,
+        rpc: RpcInterface,
         payer: PublicKey,
         path: SolanaPacketPath,
         commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const { sender: sender_, dstEid } = path
-        const sender = new PublicKey(arrayify(sender_))
-        const [sendConfig] = this.deriver.sendConfig(dstEid, sender)
-        const [defaultSendConfig] = this.deriver.defaultSendConfig(dstEid)
-
-        const [setting] = this.deriver.setting()
-        const ulnState = await this.getSetting(connection, commitment)
-        const treasury = ulnState?.treasury?.nativeReceiver
-        const remainingAccounts = await this.getSendIxRemainingAccounts(connection, sender, dstEid, true, commitment)
-        const accounts = instructions.createSendInstructionAccounts(
+        const { sender, dstEid } = path
+
+        const ulnState = await this.getSetting(rpc, commitment)
+        let treasury: PublicKey | undefined
+        if (ulnState !== null && isSome(ulnState.treasury)) {
+            treasury = ulnState.treasury.value.nativeReceiver
+        }
+
+        let txBuilder = instructions.send(
+            { payer: createNoopSigner(payer), programs: this.programRepo },
             {
-                endpoint: PublicKey.default, // useless
-                uln: setting,
-                sendConfig,
-                defaultSendConfig,
-                payer,
+                endpoint: createNoopSigner(defaultPublicKey()),
+                payer: createNoopSigner(payer),
+                uln: this.pda.setting(),
+                sendConfig: this.pda.sendConfig(dstEid, sender),
+                defaultSendConfig: this.pda.defaultSendConfig(dstEid),
                 treasury,
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
-                anchorRemainingAccounts: remainingAccounts,
-            } satisfies instructions.SendInstructionAccounts,
-            this.program
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+
+                // 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,
+            }
         )
-        accounts.forEach((key) => {
-            if (!payer.equals(key.pubkey)) {
+        txBuilder = txBuilder.addRemainingAccounts(
+            await this.getSendIxRemainingAccounts(rpc, sender, dstEid, true, commitment)
+        )
+        const accounts = txBuilder.getInstructions()[0].keys.map((key) => {
+            if (payer !== key.pubkey) {
                 key.isSigner = false
             }
+            if (treasury !== undefined && key.pubkey === treasury) {
+                key.isWritable = true
+            }
+            return key
         })
-
-        if (treasury) {
-            const treasuryIndex = accounts.findIndex((k) => k.pubkey.toBase58() == treasury.toBase58())
-            accounts[treasuryIndex].isWritable = true // treasury account
-        }
         return accounts.slice(1)
     }
 
+    /***
+     * Get the account meta of the send instruction for CPI(Cross-Program Invocation ) with lzToken
+     */
+    async getSendWithLzTokenIXAccountMetaForCPI(
+        rpc: RpcInterface,
+        accounts: {
+            payer: PublicKey
+            tokenMint: PublicKey
+            tokenSource: PublicKey
+        },
+        path: SolanaPacketPath,
+        programs: {
+            tokenProgram?: PublicKey
+            associatedTokenProgram?: PublicKey
+        },
+        commitment: Commitment = 'confirmed'
+    ): Promise<AccountMeta[]> {
+        const { payer, tokenMint, tokenSource } = accounts
+        const { sender, dstEid } = path
+
+        const ulnState = await this.getSetting(rpc, commitment)
+        invariant(ulnState !== null, 'ULN not initialized')
+        invariant(isSome(ulnState.treasury), 'treasury not set')
+        invariant(isSome(ulnState.treasury.value.lzToken), 'lzToken treasury not set')
+        const lzTokenTreasury = ulnState.treasury.value.lzToken.value.receiver
+
+        let txBuilder = instructions.sendWithLzToken(
+            { payer: createNoopSigner(payer), programs: this.programRepo },
+            {
+                endpoint: createNoopSigner(defaultPublicKey()),
+                payer: createNoopSigner(payer),
+                uln: this.pda.setting(),
+                sendConfig: this.pda.sendConfig(dstEid, sender),
+                defaultSendConfig: this.pda.defaultSendConfig(dstEid),
+                lzTokenTreasury,
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                lzTokenSource: tokenSource,
+                lzTokenMint: tokenMint,
+                tokenProgram: programs.tokenProgram ?? fromWeb3JsPublicKey(TOKEN_PROGRAM_ID),
+            },
+            {
+                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,
+                lzTokenFee: 0,
+                lzTokenMint: tokenMint,
+            }
+        )
+        txBuilder = txBuilder.addRemainingAccounts(
+            await this.getSendIxRemainingAccounts(rpc, sender, dstEid, true, commitment)
+        )
+        const keys = txBuilder.getInstructions()[0].keys.map((key) => {
+            if (payer !== key.pubkey) {
+                key.isSigner = false
+            }
+            if (key.pubkey === lzTokenTreasury) {
+                key.isWritable = true
+            }
+            return key
+        })
+        return keys.slice(1)
+    }
+
     // 3 RPC requests
     /**
      * Gets the remaining accounts for the send instruction.
@@ -417,37 +507,37 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
      */
     async getSendIxRemainingAccounts(
-        connection: Connection,
+        rpc: RpcInterface,
         sender: PublicKey,
         dstEid: number,
         payment: boolean,
-        commitment: Commitment | GetAccountInfoConfig = 'confirmed'
+        commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const { executor, dvns } = await this.getWorkers(connection, sender, dstEid, commitment)
+        const { executor, dvns } = await this.getWorkers(rpc, sender, dstEid)
 
         const priceFeeds = new Array<PublicKey>()
         ;[executor.config, ...dvns.map((dvn) => dvn.config)].forEach((config) => {
-            if (!priceFeeds.find((p) => p.equals(config.priceFeed))) {
+            if (!priceFeeds.find((p) => p === config.priceFeed)) {
                 priceFeeds.push(config.priceFeed)
             }
         })
-        const priceFeedInfos = await connection.getMultipleAccountsInfo(priceFeeds, commitment)
+        const priceFeedInfos = await rpc.getAccounts(priceFeeds, { commitment })
         const priceFeedDict = priceFeedInfos.reduce((acc, info, i) => {
-            invariant(info, `priceFeed:${priceFeeds[i].toBase58()} not initialized`)
-            acc.set(priceFeeds[i].toBase58(), info.owner)
+            invariant(info.exists, `priceFeed:${priceFeeds[i]} not initialized`)
+            acc.set(priceFeeds[i], info.owner)
             return acc
-        }, new Map<string, PublicKey>())
+        }, new Map<PublicKey, PublicKey>())
         const executorAccounts = new Executor(executor.owner).getQuoteIXAccountMetaForCPI(
             executor.config.priceFeed,
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            priceFeedDict.get(executor.config.priceFeed.toBase58())!,
+            priceFeedDict.get(executor.config.priceFeed)!,
             payment
         )
         const dvnAccounts = dvns.map((p, i) => {
             return new DVN(p.owner).getQuoteIXAccountMetaForCPI(
                 p.config.priceFeed,
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                priceFeedDict.get(p.config.priceFeed.toBase58())!,
+                priceFeedDict.get(p.config.priceFeed)!,
                 payment
             )
         })
@@ -465,63 +555,61 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<{ executor: { config: ExecutorAccounts.ExecutorConfig; owner: PublicKey }; dvns: { config: DvnAccounts.DvnConfig; owner: PublicKey }[] }>} A promise that resolves to an object containing the executor and DVN configurations.
      */
     async getWorkers(
-        connection: Connection,
+        rpc: RpcInterface,
         sender: PublicKey,
         eid: number,
-        commitment: Commitment | GetAccountInfoConfig = 'confirmed'
+        commitment: Commitment = 'confirmed'
     ): Promise<{
         executor: { config: ExecutorAccounts.ExecutorConfig; owner: PublicKey }
         dvns: { config: DvnAccounts.DvnConfig; owner: PublicKey }[]
     }> {
-        const [defaultSendConfig] = this.deriver.defaultSendConfig(eid)
-        const [sendConfig] = this.deriver.sendConfig(eid, sender)
-        const [defaultSendConfigBuf, sendConfigBuf] = await connection.getMultipleAccountsInfo(
-            [defaultSendConfig, sendConfig],
-            commitment
-        )
-        invariant(defaultSendConfigBuf, 'defaultSendConfig not initialized')
+        const [defaultSendConfig] = this.pda.defaultSendConfig(eid)
+        const [sendConfig] = this.pda.sendConfig(eid, sender)
+        const [defaultSendConfigBuf, sendConfigBuf] = await rpc.getAccounts([defaultSendConfig, sendConfig], {
+            commitment,
+        })
+        invariant(defaultSendConfigBuf.exists, 'defaultSendConfig not initialized')
 
-        const [defaultSendConfigState] = accounts.SendConfig.fromAccountInfo(defaultSendConfigBuf)
+        const defaultSendConfigState = accounts.deserializeSendConfig(defaultSendConfigBuf)
         let {
             executor,
             uln: { requiredDvns, optionalDvns },
         } = defaultSendConfigState
-        const sendConfigState = sendConfigBuf ? accounts.SendConfig.fromAccountInfo(sendConfigBuf)[0] : null
+        const sendConfigState = sendConfigBuf.exists ? accounts.deserializeSendConfig(sendConfigBuf) : null
 
         // 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 dvns = requiredDvns.concat(optionalDvns)
-        const [executorBuf, ...dvnBuf] = await connection.getMultipleAccountsInfo(
-            [executor.executor, ...dvns],
-            commitment
-        )
-        invariant(executorBuf, `executor:${executor.executor.toBase58()} not initialized`)
+        const [executorBuf, ...dvnBuf] = await rpc.getAccounts([executor.executor, ...dvns], {
+            commitment,
+        })
+        invariant(executorBuf.exists, `executor:${executor.executor} not initialized`)
 
         return {
             executor: {
-                config: ExecutorAccounts.ExecutorConfig.fromAccountInfo(executorBuf)[0],
+                config: ExecutorAccounts.deserializeExecutorConfig(executorBuf),
                 owner: executorBuf.owner,
             },
             dvns: dvnBuf.map((dvn, i) => {
-                invariant(dvn, `dvn:${dvns[i].toBase58()} not initialized`)
+                invariant(dvn.exists, `dvn:${dvns[i]} not initialized`)
                 return {
-                    config: DvnAccounts.DvnConfig.fromAccountInfo(dvn)[0],
+                    config: DvnAccounts.deserializeDvnConfig(dvn),
                     owner: dvn.owner,
                 }
             }),
@@ -531,109 +619,74 @@ export class Uln implements MessageLibInterface {
     /**
      * Initializes the verification process.
      *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {PublicKey} payer - The payer public key.
-     * @param {PublicKey} dvn - The DVN public key.
-     * @param {Uint8Array} packetBytes - The packet bytes.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
-     * @returns {Promise<TransactionInstruction | null>} A promise that resolves to the transaction instruction or null if not needed.
      */
-    async initVerify(
-        connection: Connection,
-        payer: PublicKey,
-        dvn: PublicKey,
-        packetBytes: Uint8Array,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<TransactionInstruction | null> {
+    initVerify(payer: Signer, param: { dvn: PublicKey; packetBytes: Uint8Array }): WrappedInstruction {
+        const { dvn, packetBytes } = param
         const packet = PacketV1Codec.fromBytes(packetBytes)
         const headerHash = packet.headerHash()
         const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
         const payloadHash = packet.payloadHash()
         const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
-        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
-        const confirmationsInfo = await connection.getAccountInfo(confirmationsPDA, commitmentOrConfig)
-        if (confirmationsInfo) {
-            // throw new Error('init verify already executed')
-            return null
-        }
-        return instructions.createInitVerifyInstruction(
+        // const confirmationsInfo = await rpc.getAccount(confirmationsPDA, { commitment })
+        // if (confirmationsInfo.exists) {
+        //     // throw new Error('init verify already executed')
+        //     return null
+        // }
+        return instructions.initVerify(
+            { programs: this.programRepo, payer },
             {
                 payer,
-                confirmations: confirmationsPDA,
-            } satisfies instructions.InitVerifyInstructionAccounts,
-            {
-                params: {
-                    packetHeader: Array.from(Uint8Array.from(Buffer.from(packet.header().slice(2), 'hex'))),
-                    payloadHash: Array.from(payloadHashBytes),
-                    dvn,
-                } satisfies types.InitVerifyParams,
-            } satisfies instructions.InitVerifyInstructionArgs,
-            this.program
-        )
+                confirmations: this.pda.confirmations(headerHashBytes, payloadHashBytes, dvn),
+                // param
+                packetHeader: Array.from(Uint8Array.from(Buffer.from(packet.header().slice(2), 'hex'))),
+                payloadHash: payloadHashBytes,
+                dvn,
+            }
+        ).items[0]
     }
 
-    /**
-     * Verifies the packet.
-     *
-     * @param {PublicKey} dvn - The DVN public key.
-     * @param {Uint8Array} packetBytes - The packet bytes.
-     * @param {number | string} confirmations - The number of confirmations.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    verify(dvn: PublicKey, packetBytes: Uint8Array, confirmations: number | string): TransactionInstruction {
+    verify(dvn: Signer, param: { packetBytes: Uint8Array; confirmations: number | bigint }): WrappedInstruction {
+        const { packetBytes, confirmations } = param
         const packet = PacketV1Codec.fromBytes(packetBytes)
         const headerHash = packet.headerHash()
         const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
         const payloadHash = packet.payloadHash()
         const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
-        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
-        return instructions.createVerifyInstruction(
+        return instructions.verify(
+            { programs: this.programRepo },
             {
                 dvn,
-                confirmations: confirmationsPDA,
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
-            } satisfies instructions.VerifyInstructionAccounts,
+                confirmations: this.pda.confirmations(headerHashBytes, payloadHashBytes, dvn.publicKey),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+            },
             {
-                params: {
-                    packetHeader: Array.from(Uint8Array.from(Buffer.from(packet.header().slice(2), 'hex'))),
-                    payloadHash: Array.from(payloadHashBytes),
-                    confirmations: typeof confirmations === 'string' ? new BN(confirmations) : confirmations,
-                } satisfies types.VerifyParams,
-            } satisfies instructions.VerifyInstructionArgs,
-            this.program
-        )
+                packetHeader: Array.from(Uint8Array.from(Buffer.from(packet.header().slice(2), 'hex'))),
+                payloadHash: payloadHashBytes,
+                confirmations: confirmations,
+            }
+        ).items[0]
     }
 
-    /**
-     * Closes the verification process.
-     *
-     * @param {PublicKey} dvn - The DVN public key.
-     * @param {PublicKey} receiver - The receiver public key.
-     * @param {Uint8Array} packetBytes - The packet bytes.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    closeVerify(dvn: PublicKey, receiver: PublicKey, packetBytes: Uint8Array): TransactionInstruction {
+    closeVerify(dvn: Signer, param: { receiver: PublicKey; packetBytes: Uint8Array }): WrappedInstruction {
+        const { receiver, packetBytes } = param
         const packet = PacketV1Codec.fromBytes(packetBytes)
         const headerHash = packet.headerHash()
         const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
         const payloadHash = packet.payloadHash()
         const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
-        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
-        return instructions.createCloseVerifyInstruction(
+        return instructions.closeVerify(
+            { programs: this.programRepo },
             {
                 dvn,
                 receiver,
-                confirmations: confirmationsPDA,
-            } satisfies instructions.CloseVerifyInstructionAccounts,
-            {
-                params: {
-                    packetHeaderHash: Array.from(headerHashBytes),
-                    payloadHash: Array.from(payloadHashBytes),
-                } satisfies types.CloseVerifyParams,
-            } satisfies instructions.CloseVerifyInstructionArgs,
-            this.program
-        )
+                confirmations: this.pda.confirmations(headerHashBytes, payloadHashBytes, dvn.publicKey),
+
+                // param
+                packetHeaderHash: headerHashBytes,
+                payloadHash: payloadHashBytes,
+            }
+        ).items[0]
     }
 
     /**
@@ -647,29 +700,23 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<boolean>} A promise that resolves to true if the DVN is verified, false otherwise.
      */
     async isDvnVerified(
-        connection: Connection,
+        rpc: RpcInterface,
         endpointProgram: PublicKey,
         dvn: PublicKey,
         packetBytes: Uint8Array,
-        commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
+        commitment: Commitment = 'confirmed'
     ): Promise<boolean> {
         const packet = PacketV1Codec.fromBytes(packetBytes)
         const headerHash = packet.headerHash()
         const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
         const payloadHash = packet.payloadHash()
         const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
-        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
+        const [confirmationsPDA] = this.pda.confirmations(headerHashBytes, payloadHashBytes, dvn)
         const endpoint = new EndpointProgram.Endpoint(endpointProgram)
-        const receiver = new PublicKey(arrayify(packet.receiver()))
+        const receiver = publicKey(arrayify(packet.receiver()))
         const sender = arrayify(packet.sender())
-        const nonce = await endpoint.getNonce(connection, receiver, packet.srcEid(), sender, commitmentOrConfig)
-        const pendingNonce = await endpoint.getPendingInboundNonce(
-            connection,
-            receiver,
-            packet.srcEid(),
-            sender,
-            commitmentOrConfig
-        )
+        const nonce = await endpoint.getNonce(rpc, receiver, packet.srcEid(), sender, commitment)
+        const pendingNonce = await endpoint.getPendingInboundNonce(rpc, receiver, packet.srcEid(), sender, commitment)
         if (!nonce || !pendingNonce) {
             return false
         }
@@ -682,24 +729,15 @@ export class Uln implements MessageLibInterface {
         if (pendingNonce.nonces.find((n) => n.toString() === packet.nonce()) !== undefined) {
             return true
         }
-        try {
-            // before commitVerification, should call initVerify and verify
-            const confirmation = await accounts.Confirmations.fromAccountAddress(
-                connection,
-                confirmationsPDA,
-                commitmentOrConfig
-            )
-            if (confirmation.value === null) {
-                // initial value is null
-                // not verified
-                return false
-            } else {
-                // TODO check confirmation value
-                return true
-            }
-        } catch (e: unknown) {
-            // don't invoke initVerify
+
+        // before commitVerification, should call initVerify and verify
+        const confirmation = await accounts.safeFetchConfirmations({ rpc }, confirmationsPDA, { commitment })
+        if (confirmation?.value == null) {
+            // initial value is null not verified
             return false
+        } else {
+            // TODO check confirmation value
+            return true
         }
     }
 
@@ -712,28 +750,26 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
      */
     async commitVerification(
-        connection: Connection,
-        endpointProgram: PublicKey,
-        packetBytes: Uint8Array
-    ): Promise<TransactionInstruction> {
+        rpc: RpcInterface,
+        packetBytes: Uint8Array,
+        endpointProgram: PublicKey = ENDPOINT_PROGRAM_ID
+    ): Promise<WrappedInstruction> {
         const packet = PacketV1Codec.fromBytes(packetBytes)
         const payloadHash = packet.payloadHash()
         const srcEid = packet.srcEid()
-        const receiver = new PublicKey(arrayify(packet.receiver()))
+        const receiver = publicKey(arrayify(packet.receiver()))
         const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
-        const [defaultReceiveConfig] = this.deriver.defaultReceiveConfig(srcEid)
-        const [receiveConfig] = this.deriver.receiveConfig(srcEid, receiver)
-        const [setting] = this.deriver.setting()
-        const [msgLib] = this.deriver.messageLib()
-        const receiveConfigState = await this.getFinalReceiveConfigState(connection, receiver, srcEid)
+
+        const [msgLib] = this.pda.messageLib()
+        const receiveConfigState = await this.getFinalReceiveConfigState(rpc, receiver, srcEid)
 
         const headerHash = packet.headerHash()
         const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
 
-        const confirmations: AccountMeta[] = receiveConfigState.uln.requiredDvns
-            .concat(receiveConfigState.uln.optionalDvns)
+        const confirmations: AccountMeta[] = receiveConfigState.requiredDvns
+            .concat(receiveConfigState.optionalDvns)
             .map((p) => {
-                const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, p)
+                const [confirmationsPDA] = this.pda.confirmations(headerHashBytes, payloadHashBytes, p)
                 return {
                     pubkey: confirmationsPDA,
                     isSigner: false,
@@ -743,21 +779,19 @@ export class Uln implements MessageLibInterface {
         const endpoint = new EndpointProgram.Endpoint(endpointProgram)
         const verifyAccounts = endpoint.getVerifyIXAccountMetaForCPI(packet, msgLib)
 
-        return instructions.createCommitVerificationInstruction(
+        const txBuilder = instructions.commitVerification(
+            { programs: this.programRepo },
             {
-                uln: setting,
-                defaultReceiveConfig,
-                receiveConfig,
-                anchorRemainingAccounts: confirmations.concat(verifyAccounts),
-            } satisfies instructions.CommitVerificationInstructionAccounts,
-            {
-                params: {
-                    packetHeader: Array.from(arrayify(packet.header())),
-                    payloadHash: Array.from(payloadHashBytes),
-                } satisfies types.CommitVerificationParams,
-            } satisfies instructions.CommitVerificationInstructionArgs,
-            this.program
+                uln: this.pda.setting(),
+                defaultReceiveConfig: this.pda.defaultReceiveConfig(srcEid),
+                receiveConfig: this.pda.receiveConfig(srcEid, receiver),
+
+                // param
+                packetHeader: Array.from(arrayify(packet.header())),
+                payloadHash: payloadHashBytes,
+            }
         )
+        return txBuilder.addRemainingAccounts(confirmations.concat(verifyAccounts)).items[0]
     }
 
     /**
@@ -769,24 +803,25 @@ export class Uln implements MessageLibInterface {
      * @returns {AccountMeta[]} An array of account metadata.
      */
     getInitConfigIXAccountMetaForCPI(payer: PublicKey, oappID: PublicKey, eid: number): AccountMeta[] {
-        const [sendConfig] = this.deriver.sendConfig(eid, oappID)
-        const [receiveConfig] = this.deriver.receiveConfig(eid, oappID)
-        const [setting] = this.deriver.setting()
-
-        const accounts = instructions.createInitConfigInstructionAccounts(
+        const txBuilder = instructions.initConfig(
+            { payer: createNoopSigner(payer), programs: this.programRepo },
             {
-                endpoint: PublicKey.default, // useless
-                payer,
-                uln: setting,
-                sendConfig,
-                receiveConfig,
-            } satisfies instructions.InitConfigInstructionAccounts,
-            this.program
+                endpoint: createNoopSigner(defaultPublicKey()),
+                payer: createNoopSigner(payer),
+                uln: this.pda.setting(),
+                sendConfig: this.pda.sendConfig(eid, oappID),
+                receiveConfig: this.pda.receiveConfig(eid, oappID),
+
+                // params
+                oapp: defaultPublicKey(),
+                eid: 0,
+            }
         )
-        accounts.forEach((key) => {
-            if (!payer.equals(key.pubkey)) {
+        const accounts = txBuilder.getInstructions()[0].keys.map((key) => {
+            if (payer !== key.pubkey) {
                 key.isSigner = false
             }
+            return key
         })
         return accounts.slice(1)
     }
@@ -805,13 +840,11 @@ export class Uln implements MessageLibInterface {
     ): Uint8Array {
         switch (configType) {
             case SetConfigType.EXECUTOR: {
-                const [data] = types.executorConfigBeet.serialize(configData as types.ExecutorConfig)
-                return Uint8Array.from(data)
+                return types.getExecutorConfigSerializer().serialize(configData as types.ExecutorConfig)
             }
             case SetConfigType.SEND_ULN:
             case SetConfigType.RECEIVE_ULN: {
-                const [data] = types.ulnConfigBeet.serialize(configData as types.UlnConfig)
-                return Uint8Array.from(data)
+                return types.getUlnConfigSerializer().serialize(configData as types.UlnConfig)
             }
             default:
                 throw new Error(`invalid config type: ${configType as number}`)
@@ -826,54 +859,45 @@ export class Uln implements MessageLibInterface {
      * @param {number} eid - The endpoint ID.
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
      */
-    async getSetConfigIXAccountMetaForCPI(
-        endpointProgram: PublicKey,
-        oappID: PublicKey,
-        eid: number
-    ): Promise<AccountMeta[]> {
-        const [sendConfig] = this.deriver.sendConfig(eid, oappID)
-        const [receiveConfig] = this.deriver.receiveConfig(eid, oappID)
-        const [defaultSendConfig] = this.deriver.defaultSendConfig(eid)
-        const [defaultReceiveConfig] = this.deriver.defaultReceiveConfig(eid)
-        const [setting] = this.deriver.setting()
-        const [msgLib] = this.deriver.messageLib()
-        const [msgLibInfo] = new EndpointPDADeriver(endpointProgram).messageLibraryInfo(msgLib)
-
-        const accounts = instructions.createSetConfigInstructionAccounts(
+    getSetConfigIXAccountMetaForCPI(
+        oapp: PublicKey,
+        eid: number,
+        endpointProgram: PublicKey = ENDPOINT_PROGRAM_ID
+    ): AccountMeta[] {
+        const [msgLib] = this.pda.messageLib()
+        const [msgLibInfo] = new EndpointPDA(endpointProgram).messageLibraryInfo(msgLib)
+
+        const txBuilder = instructions.setConfig(
+            { programs: this.programRepo },
             {
-                endpoint: msgLibInfo,
-                uln: setting,
-                sendConfig,
-                defaultSendConfig,
-                defaultReceiveConfig,
-                receiveConfig,
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
-            } satisfies instructions.SetConfigInstructionAccounts,
-            this.program
+                endpoint: createNoopSigner(msgLibInfo),
+                uln: this.pda.setting(),
+                sendConfig: this.pda.sendConfig(eid, oapp),
+                defaultSendConfig: this.pda.defaultSendConfig(eid),
+                defaultReceiveConfig: this.pda.defaultReceiveConfig(eid),
+                receiveConfig: this.pda.receiveConfig(eid, oapp),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                // param
+                oapp: defaultPublicKey(),
+                eid: 0,
+                configType: 0,
+                config: new Uint8Array(32),
+            }
         )
-        return Promise.resolve(accounts.slice(1))
+        return txBuilder.getInstructions()[0].keys.slice(1)
     }
 
-    //
-    // all of below functions are retrieving accounts state
     /**
      * Gets the ULN settings.
      *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @param {RpcInterface} rpc - The connection to the Solana cluster.
+     * @param {Commitment} [commitment] - The commitment level or account info configuration.
      * @returns {Promise<accounts.UlnSettings | null>} A promise that resolves to the ULN settings or null if not found.
      */
-    async getSetting(
-        connection: Connection,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<accounts.UlnSettings | null> {
-        const [setting] = this.deriver.setting()
-        try {
-            return await accounts.UlnSettings.fromAccountAddress(connection, setting, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+    async getSetting(rpc: RpcInterface, commitment: Commitment = 'confirmed'): Promise<accounts.UlnSettings | null> {
+        const [setting] = this.pda.setting()
+        return accounts.safeFetchUlnSettings({ rpc }, setting, { commitment })
     }
 
     /**
@@ -885,16 +909,12 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<accounts.SendConfig | null>} A promise that resolves to the default send configuration state or null if not found.
      */
     async getDefaultSendConfigState(
-        connection: Connection,
+        rpc: RpcInterface,
         eid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<accounts.SendConfig | null> {
-        const [config] = this.deriver.defaultSendConfig(eid)
-        try {
-            return await accounts.SendConfig.fromAccountAddress(connection, config, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        const [config] = this.pda.defaultSendConfig(eid)
+        return accounts.safeFetchSendConfig({ rpc }, config, { commitment })
     }
 
     /**
@@ -907,17 +927,13 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<accounts.SendConfig | null>} A promise that resolves to the send configuration state or null if not found.
      */
     async getSendConfigState(
-        connection: Connection,
+        rpc: RpcInterface,
         sender: PublicKey,
         eid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<accounts.SendConfig | null> {
-        const [config] = this.deriver.sendConfig(eid, sender)
-        try {
-            return await accounts.SendConfig.fromAccountAddress(connection, config, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        const [config] = this.pda.sendConfig(eid, sender)
+        return accounts.safeFetchSendConfig({ rpc }, config, { commitment })
     }
 
     /**
@@ -929,16 +945,12 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<accounts.ReceiveConfig | null>} A promise that resolves to the default receive configuration state or null if not found.
      */
     async getDefaultReceiveConfigState(
-        connection: Connection,
+        rpc: RpcInterface,
         eid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<accounts.ReceiveConfig | null> {
-        const [config] = this.deriver.defaultReceiveConfig(eid)
-        try {
-            return await accounts.ReceiveConfig.fromAccountAddress(connection, config, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        const [config] = this.pda.defaultReceiveConfig(eid)
+        return accounts.safeFetchReceiveConfig({ rpc }, config, { commitment })
     }
 
     /**
@@ -951,17 +963,13 @@ export class Uln implements MessageLibInterface {
      * @returns {Promise<accounts.ReceiveConfig | null>} A promise that resolves to the receive configuration state or null if not found.
      */
     async getReceiveConfigState(
-        connection: Connection,
+        rpc: RpcInterface,
         receiver: PublicKey,
         eid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<accounts.ReceiveConfig | null> {
-        const [config] = this.deriver.receiveConfig(eid, receiver)
-        try {
-            return await accounts.ReceiveConfig.fromAccountAddress(connection, config, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        const [config] = this.pda.receiveConfig(eid, receiver)
+        return accounts.safeFetchReceiveConfig({ rpc }, config, { commitment })
     }
 
     /**
@@ -975,16 +983,54 @@ export class Uln implements MessageLibInterface {
      * @throws {Error} If no DVN is found.
      */
     async getFinalReceiveConfigState(
-        connection: Connection,
+        rpc: RpcInterface,
         receiver: PublicKey,
         eid: number,
-        commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
-    ): Promise<accounts.ReceiveConfig> {
-        const NIL_CONFIRMATIONS = '18446744073709551615' // max u64
+        commitment: Commitment = 'confirmed'
+    ): Promise<types.UlnConfig> {
+        const [defaultConfig] = this.pda.defaultReceiveConfig(eid)
+        const [customConfig] = this.pda.receiveConfig(eid, receiver)
+
+        const [defaultConfigInfo, customConfigInfo] = await rpc.getAccounts([defaultConfig, customConfig], {
+            commitment,
+        })
+        if (!defaultConfigInfo.exists) {
+            throw new Error(`please init default receive config first. ${defaultConfig}`)
+        }
+        const defaultConfigState = accounts.deserializeReceiveConfig(defaultConfigInfo)
+        const customConfigState = customConfigInfo.exists ? accounts.deserializeReceiveConfig(customConfigInfo) : null
+        return this.getConfigState(defaultConfigState, customConfigState)
+    }
+
+    async getFinalSendConfigState(
+        rpc: RpcInterface,
+        sender: PublicKey,
+        eid: number,
+        commitment: Commitment = 'confirmed'
+    ): Promise<types.UlnConfig> {
+        const [defaultConfig] = this.pda.defaultSendConfig(eid)
+        const [customConfig] = this.pda.sendConfig(eid, sender)
+
+        const [defaultConfigInfo, customConfigInfo] = await rpc.getAccounts([defaultConfig, customConfig], {
+            commitment,
+        })
+        if (!defaultConfigInfo.exists) {
+            throw new Error(`please init default send config first. ${defaultConfig}`)
+        }
+        const defaultConfigState = accounts.deserializeSendConfig(defaultConfigInfo)
+        const customConfigState = customConfigInfo.exists ? accounts.deserializeSendConfig(customConfigInfo) : null
+        return this.getConfigState(defaultConfigState, customConfigState)
+    }
+
+    private getConfigState(
+        defaultConfigState: accounts.ReceiveConfig | accounts.SendConfig,
+        customConfigState: accounts.ReceiveConfig | accounts.SendConfig | null
+    ): types.UlnConfig {
+        const NIL_CONFIRMATIONS = '18446744073709551615' // max uint64
         const NIL_DVN_COUNT = '255'
 
         const rtn_config: types.UlnConfig = {
-            confirmations: 0,
+            confirmations: 0n,
             requiredDvnCount: 0,
             optionalDvnCount: 0,
             optionalDvnThreshold: 0,
@@ -992,20 +1038,7 @@ export class Uln implements MessageLibInterface {
             optionalDvns: [],
         }
 
-        const [defaultConfig] = this.deriver.defaultReceiveConfig(eid)
-        const [customConfig] = this.deriver.receiveConfig(eid, receiver)
-
-        const [defaultConfigInfo, customConfigInfo] = await connection.getMultipleAccountsInfo(
-            [defaultConfig, customConfig],
-            commitmentOrConfig
-        )
-        if (defaultConfigInfo == null) {
-            throw new Error(`please init default receive config first. ${defaultConfig.toBase58()}`)
-        }
-        const defaultConfigState = accounts.ReceiveConfig.fromAccountInfo(defaultConfigInfo)[0]
-        const customConfigState = customConfigInfo ? accounts.ReceiveConfig.fromAccountInfo(customConfigInfo)[0] : null
-
-        if (customConfigState == null || customConfigState.uln.confirmations == 0) {
+        if (customConfigState == null || customConfigState.uln.confirmations === 0n) {
             rtn_config.confirmations = defaultConfigState.uln.confirmations
         } else if (customConfigState.uln.confirmations.toString() !== NIL_CONFIRMATIONS) {
             rtn_config.confirmations = customConfigState.uln.confirmations
@@ -1036,10 +1069,6 @@ export class Uln implements MessageLibInterface {
         if (rtn_config.requiredDvnCount === 0 && rtn_config.optionalDvnCount === 0) {
             throw new Error('no dvn')
         }
-
-        return accounts.ReceiveConfig.fromArgs({
-            bump: defaultConfigState.bump,
-            uln: rtn_config,
-        })
+        return rtn_config
     }
 }