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

package/src/endpoint.ts

@@ -1,61 +1,93 @@
 import {
     AccountMeta,
+    Cluster,
+    ClusterFilter,
     Commitment,
-    Connection,
-    GetAccountInfoConfig,
+    Program,
+    ProgramError,
+    ProgramRepositoryInterface,
     PublicKey,
-    TransactionInstruction,
-} from '@solana/web3.js'
-import BN from 'bn.js'
-import invariant from 'tiny-invariant'
+    RpcInterface,
+    Signer,
+    TransactionBuilder,
+    WrappedInstruction,
+    createNoopSigner,
+    createNullRpc,
+    defaultPublicKey,
+    isSome,
+    publicKey,
+    some,
+} from '@metaplex-foundation/umi'
+import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
+import { toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import { TransactionInstruction } from '@solana/web3.js'
 
 import { keccak_256 } from '@layerzerolabs/lz-foundation'
 import { arrayify } from '@layerzerolabs/lz-utilities'
 import { PacketV1Codec, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
 
-import { ComposeMessageState, EndpointSettings, MessageLibInfo, PayloadHash } from './generated/endpoint'
-import * as accounts from './generated/endpoint/accounts'
-import * as errors from './generated/endpoint/errors'
-import * as events from './generated/endpoint/events'
-import * as instructions from './generated/endpoint/instructions'
-import * as types from './generated/endpoint/types'
-import { Version } from './generated/simple_messagelib'
-import * as pdaDeriver from './pda-deriver'
-import { EventPDADeriver, MessageLibPDADeriver, OAPP_SEED } from './pda-deriver'
-
 import {
     MessageLibInterface,
     SetConfigType,
     SimpleMessageLibProgram,
     SolanaPacketPath,
     UlnProgram,
-    simulateTransaction,
+    simulateWeb3JsTransaction,
 } from '.'
+import { ENDPOINT_PROGRAM_ID } from './generated/kinobi/endpoint'
+import * as accounts from './generated/kinobi/endpoint/accounts'
+import * as errors from './generated/kinobi/endpoint/errors'
+import * as events from './generated/kinobi/endpoint/events'
+import * as instructions from './generated/kinobi/endpoint/instructions'
+import * as types from './generated/kinobi/endpoint/types'
+import { SIMPLE_MESSAGELIB_PROGRAM_ID, Version } from './generated/kinobi/simple_messagelib'
+import { EndpointPDA, EventPDA, MessageLibPDA } from './pda'
 
 export { accounts, instructions, types, events, errors }
-export { PROGRAM_ID } from './generated/endpoint'
+export { ENDPOINT_PROGRAM_ID } from './generated/kinobi/endpoint'
 
 // https://github.com/coral-xyz/anchor/blob/c7ccbb8f620aed3ffecf8ab2f9c9007946f0f5cc/lang/src/event.rs#L2
 export const EventEmitDiscriminator = 'e445a52e51cb9a1d' // Sha256(anchor:event)[..8] then evert
 
-export const DefaultMessageLib = PublicKey.default // [0u8; 32]
+export const DefaultMessageLib = defaultPublicKey() // [0u8; 32]
 
 /**
  * Class representing an Endpoint.
  */
 export class Endpoint {
-    deriver: pdaDeriver.EndpointPDADeriver
-    eventAuthorityPDA: PublicKey
+    public readonly pda: EndpointPDA
+    public readonly eventAuthority: PublicKey
+    public readonly programRepo: ProgramRepositoryInterface
+
+    constructor(
+        public programId: PublicKey = ENDPOINT_PROGRAM_ID,
+        rpc?: RpcInterface
+    ) {
+        this.pda = new EndpointPDA(programId)
+        if (rpc === undefined) {
+            rpc = createNullRpc()
+            rpc.getCluster = (): Cluster => 'custom'
+        }
+        this.programRepo = createDefaultProgramRepository({ rpc: rpc }, [
+            {
+                name: 'endpoint',
+                publicKey: programId,
+                getErrorFromCode(code: number, cause?: Error): ProgramError | null {
+                    return errors.getEndpointErrorFromCode(code, this, cause)
+                },
+                getErrorFromName(name: string, cause?: Error): ProgramError | null {
+                    return errors.getEndpointErrorFromName(name, this, cause)
+                },
+                isOnCluster(): boolean {
+                    return true
+                },
+            } satisfies Program,
+        ])
+        this.eventAuthority = new EventPDA(programId).eventAuthority()[0]
+    }
 
-    /**
-     * Creates an instance of the Endpoint class.
-     *
-     * @param {PublicKey} program - The program public key.
-     */
-    constructor(public program: PublicKey) {
-        this.deriver = new pdaDeriver.EndpointPDADeriver(program)
-        const [eventAuthorityPDA] = new EventPDADeriver(program).eventAuthority()
-        this.eventAuthorityPDA = eventAuthorityPDA
+    getProgram(clusterFilter: ClusterFilter = 'custom'): Program {
+        return this.programRepo.get('endpoint', clusterFilter)
     }
 
     /**
@@ -66,24 +98,22 @@ export class Endpoint {
      * @param {PublicKey} admin - The admin public key.
      * @returns {TransactionInstruction} The transaction instruction.
      */
-    initEndpoint(endpointId: number, payer: PublicKey, admin: PublicKey): TransactionInstruction {
-        const [settingPDA] = this.deriver.setting()
-        return instructions.createInitEndpointInstruction(
+    initEndpoint(payer: Signer, params: { eid: number; admin: PublicKey }): WrappedInstruction {
+        const txBuilder = instructions.initEndpoint(
             {
+                programs: this.programRepo,
                 payer,
-                endpoint: settingPDA,
-            } satisfies instructions.InitEndpointInstructionAccounts,
+            },
             {
-                params: {
-                    eid: endpointId,
-                    admin,
-                } satisfies types.InitEndpointParams,
-            } satisfies instructions.InitEndpointInstructionArgs,
-            this.program
+                payer,
+                endpoint: this.pda.setting(),
+                eid: params.eid,
+                admin: params.admin,
+            }
         )
+        return txBuilder.items[0]
     }
 
-    // async initOrUpdateConfig(connection:Connection,)
     /**
      * Registers a library.
      * call this function after endpoint initialized. Only admin can call this function.
@@ -94,106 +124,98 @@ export class Endpoint {
      * @returns {TransactionInstruction} The transaction instruction.
      */
     registerLibrary(
-        admin: PublicKey,
-        messageLibProgram: PublicKey,
-        libType: types.MessageLibType = types.MessageLibType.SendAndReceive
-    ): TransactionInstruction {
-        const [msgLibPda] = new pdaDeriver.MessageLibPDADeriver(messageLibProgram).messageLib()
-        const [msgLibInfoPda] = this.deriver.messageLibraryInfo(msgLibPda)
-
-        const [settingPDA] = this.deriver.setting()
-        return instructions.createRegisterLibraryInstruction(
+        admin: Signer,
+        params: { messageLibProgram: PublicKey; libType?: types.MessageLibType }
+    ): WrappedInstruction {
+        const [msgLib] = new MessageLibPDA(params.messageLibProgram).messageLib()
+        return instructions.registerLibrary(
             {
-                admin,
-                endpoint: settingPDA,
-                messageLibInfo: msgLibInfoPda,
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
+                programs: this.programRepo,
             },
             {
-                params: {
-                    libProgram: messageLibProgram,
-                    libType,
-                },
-            },
-            this.program
-        )
+                admin,
+                endpoint: this.pda.setting(),
+                messageLibInfo: this.pda.messageLibraryInfo(msgLib),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                libProgram: params.messageLibProgram,
+                libType: params.libType ?? types.MessageLibType.SendAndReceive,
+            }
+        ).items[0]
     }
 
     /**
-     * Sets the default send library.
+     * Sets the default send library for a given remote endpoint.
+     * This function configures the default message library for sending messages to a specified remote endpoint.
+     * It requires administrative privileges to execute.
      *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {PublicKey} admin - The admin public key.
+     * @param {RpcInterface} rpc - The connection to the Solana cluster.
+     * @param {Signer} admin - The admin public key.
      * @param {PublicKey} messageLibProgram - The message library program public key.
      * @param {number} dstEid - The destination endpoint ID.
      * @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.
+     * This method initializes or updates the default send library configuration for a specified remote endpoint.
+     * If the configuration does not exist, it initializes it. Otherwise, it updates the existing configuration.
      */
     async setDefaultSendLibrary(
-        connection: Connection,
-        admin: PublicKey,
-        messageLibProgram: PublicKey,
-        dstEid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<TransactionInstruction | null> {
-        const [msgLib] = new pdaDeriver.MessageLibPDADeriver(messageLibProgram).messageLib()
-        const [defaultSendLibConfig] = this.deriver.defaultSendLibraryConfig(dstEid)
-        const [settingPDA] = this.deriver.setting()
-        const [msgLibInfo] = this.deriver.messageLibraryInfo(msgLib)
-
-        const info = await connection.getAccountInfo(defaultSendLibConfig, commitmentOrConfig)
-        if (!info) {
-            return instructions.createInitDefaultSendLibraryInstruction(
+        rpc: RpcInterface,
+        admin: Signer,
+        params: { messageLibProgram: PublicKey; remote: number }
+    ): Promise<WrappedInstruction> {
+        const [msgLib] = new MessageLibPDA(params.messageLibProgram).messageLib()
+        const [defaultSendLibConfig] = this.pda.defaultSendLibraryConfig(params.remote)
+        const [setting] = this.pda.setting()
+        const [msgLibInfo] = this.pda.messageLibraryInfo(msgLib)
+
+        const defaultSendLibConfigInfo = await rpc.getAccount(defaultSendLibConfig, {
+            commitment: 'confirmed',
+        })
+        let txBuilder: TransactionBuilder
+        if (!defaultSendLibConfigInfo.exists) {
+            txBuilder = instructions.initDefaultSendLibrary(
+                { programs: this.programRepo },
                 {
                     admin,
-                    endpoint: settingPDA,
+                    endpoint: setting,
                     defaultSendLibraryConfig: defaultSendLibConfig,
                     messageLibInfo: msgLibInfo,
-                    program: this.program,
-                    eventAuthority: this.eventAuthorityPDA,
-                } satisfies instructions.InitDefaultSendLibraryInstructionAccounts,
-                {
-                    params: {
-                        eid: dstEid,
-                        newLib: msgLib,
-                    } satisfies types.InitDefaultSendLibraryParams,
-                } satisfies instructions.InitDefaultSendLibraryInstructionArgs,
-                this.program
+                    program: this.programId,
+                    eventAuthority: this.eventAuthority,
+                    // params
+                    eid: params.remote,
+                    newLib: msgLib,
+                }
             )
         } else {
-            // get current default send library
-            const sendLibConfig = await accounts.SendLibraryConfig.fromAccountAddress(
-                connection,
-                defaultSendLibConfig,
-                commitmentOrConfig
-            )
-            if (sendLibConfig.messageLib.toBase58() === msgLib.toBase58()) {
-                return null
-            }
-
-            return instructions.createSetDefaultSendLibraryInstruction(
+            // need to check if the new lib is the same as the current one
+            // if (defaultSendLibConfigInfo.messageLib === msgLib) {
+            //     return null
+            // }
+            txBuilder = instructions.setDefaultSendLibrary(
+                {
+                    programs: this.programRepo,
+                },
                 {
                     admin,
-                    endpoint: settingPDA,
+                    endpoint: setting,
                     defaultSendLibraryConfig: defaultSendLibConfig,
                     messageLibInfo: msgLibInfo,
-                    program: this.program,
-                    eventAuthority: this.eventAuthorityPDA,
-                } satisfies instructions.SetDefaultSendLibraryInstructionAccounts,
-                {
-                    params: {
-                        eid: dstEid,
-                        newLib: msgLib,
-                    } satisfies types.SetDefaultSendLibraryParams,
-                } satisfies instructions.SetDefaultSendLibraryInstructionArgs,
-                this.program
+                    program: this.programId,
+                    eventAuthority: this.eventAuthority,
+                    // params
+                    eid: params.remote,
+                    newLib: msgLib,
+                }
             )
         }
+        return txBuilder.items[0]
     }
 
     /**
-     * Sets the default receive library.
+     * Sets the default receive library for a given endpoint.
+     * This function configures the default message library for receiving messages at a specified endpoint.
+     * It requires administrative privileges to execute.
      *
      * @param {Connection} connection - The connection to the Solana cluster.
      * @param {PublicKey} admin - The admin public key.
@@ -201,109 +223,160 @@ export class Endpoint {
      * @param {number} srcEid - The source endpoint ID.
      * @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.
+     * This method initializes or updates the default receive library configuration for a specified remote endpoint.
+     * If the configuration does not exist, it initializes it. Otherwise, it updates the existing configuration.
      */
     async setDefaultReceiveLibrary(
-        connection: Connection,
-        admin: PublicKey,
-        messageLibProgram: PublicKey,
-        srcEid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<TransactionInstruction | null> {
-        const [msgLib] = new pdaDeriver.MessageLibPDADeriver(messageLibProgram).messageLib()
-        const [defaultReceiveLibConfig] = this.deriver.defaultReceiveLibraryConfig(srcEid)
-        const [settingPDA] = this.deriver.setting()
-        const [defaultMsgLibInfo] = this.deriver.messageLibraryInfo(msgLib)
-        const info = await connection.getAccountInfo(defaultReceiveLibConfig, commitmentOrConfig)
-        if (!info) {
-            return instructions.createInitDefaultReceiveLibraryInstruction(
+        rpc: RpcInterface,
+        admin: Signer,
+        params: { messageLibProgram: PublicKey; remote: number; gracePeriod?: bigint | number }
+    ): Promise<WrappedInstruction> {
+        const [msgLib] = new MessageLibPDA(params.messageLibProgram).messageLib()
+        const [defaultReceiveLibConfig] = this.pda.defaultReceiveLibraryConfig(params.remote)
+        const [setting] = this.pda.setting()
+        const [defaultMsgLibInfo] = this.pda.messageLibraryInfo(msgLib)
+        const defaultReceiveLibConfigInfo = await rpc.getAccount(defaultReceiveLibConfig, { commitment: 'confirmed' })
+        let txBuilder: TransactionBuilder
+        if (!defaultReceiveLibConfigInfo.exists) {
+            txBuilder = instructions.initDefaultReceiveLibrary(
+                { programs: this.programRepo },
                 {
                     admin,
-                    endpoint: settingPDA,
+                    endpoint: setting,
                     defaultReceiveLibraryConfig: defaultReceiveLibConfig,
                     messageLibInfo: defaultMsgLibInfo,
-                    program: this.program,
-                    eventAuthority: this.eventAuthorityPDA,
-                } satisfies instructions.InitDefaultReceiveLibraryInstructionAccounts,
-                {
-                    params: {
-                        eid: srcEid,
-                        newLib: msgLib,
-                    } satisfies types.InitDefaultReceiveLibraryParams,
-                } satisfies instructions.InitDefaultReceiveLibraryInstructionArgs,
-                this.program
+                    program: this.programId,
+                    eventAuthority: this.eventAuthority,
+                    // param
+                    eid: params.remote,
+                    newLib: msgLib,
+                }
             )
         } else {
-            // get current default receive library
-            const receiveLibConfig = await accounts.ReceiveLibraryConfig.fromAccountAddress(
-                connection,
-                defaultReceiveLibConfig,
-                commitmentOrConfig
-            )
-            if (receiveLibConfig.messageLib.toBase58() === msgLib.toBase58()) {
-                return null
-            }
-
-            return instructions.createSetDefaultReceiveLibraryInstruction(
+            // need to check if the new lib is the same as the current one
+            // if (defaultReceiveLibConfigInfo.messageLib === msgLib) {
+            //     return null
+            // }
+            txBuilder = instructions.setDefaultReceiveLibrary(
+                { programs: this.programRepo },
                 {
                     admin,
-                    endpoint: settingPDA,
+                    endpoint: setting,
                     defaultReceiveLibraryConfig: defaultReceiveLibConfig,
                     messageLibInfo: defaultMsgLibInfo,
-                    program: this.program,
-                    eventAuthority: this.eventAuthorityPDA,
-                } satisfies instructions.SetDefaultReceiveLibraryInstructionAccounts,
-                {
-                    params: {
-                        eid: srcEid,
-                        newLib: msgLib,
-                        gracePeriod: 0, // TODO: set grace period
-                    } satisfies types.SetDefaultReceiveLibraryParams,
-                } satisfies instructions.SetDefaultReceiveLibraryInstructionArgs,
-                this.program
+                    program: this.programId,
+                    eventAuthority: this.eventAuthority,
+
+                    // param
+                    eid: params.remote,
+                    newLib: msgLib,
+                    gracePeriod: params.gracePeriod ?? 0,
+                }
             )
         }
+        return txBuilder.items[0]
+    }
+
+    /**
+     * Sets the default receive library timeout for a given message library program and remote endpoint.
+     *
+     * @param admin - The signer who has administrative privileges to set the timeout.
+     * @param param - An object containing the following properties:
+     *   @param param.msgLibProgram - The public key of the message library program.
+     *   @param param.remote - The remote endpoint identifier.
+     *   @param param.expiry - The expiry time for the timeout, can be a bigint or number.
+     * @returns A WrappedInstruction object representing the instruction to set the default receive library timeout.
+     */
+    setDefaultReceiveLibraryTimeout(
+        admin: Signer,
+        params: { msgLibProgram: PublicKey; remote: number; expiry: bigint | number }
+    ): WrappedInstruction {
+        const [msgLib] = new MessageLibPDA(params.msgLibProgram).messageLib()
+        return instructions.setDefaultReceiveLibraryTimeout(
+            { programs: this.programRepo },
+            {
+                admin,
+                endpoint: this.pda.setting(),
+                program: this.programId,
+                eventAuthority: this.eventAuthority,
+                defaultReceiveLibraryConfig: this.pda.defaultReceiveLibraryConfig(params.remote),
+                messageLibInfo: this.pda.messageLibraryInfo(msgLib),
+                // param
+                eid: params.remote,
+                lib: msgLib,
+                expiry: params.expiry,
+            }
+        ).items[0]
+    }
+
+    setLzToken(admin: Signer, lzToken: PublicKey | null): WrappedInstruction {
+        return instructions.setLzToken(
+            { programs: this.programRepo },
+            {
+                admin: admin,
+                endpoint: this.pda.setting(),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                lzToken: lzToken == null ? null : some(lzToken),
+            }
+        ).items[0]
+    }
+
+    withdrawRent(admin: Signer, params: { amount: bigint; receiver: PublicKey }): WrappedInstruction {
+        const { amount, receiver } = params
+        return instructions.withdrawRent(
+            { programs: this.programRepo },
+            {
+                admin: admin,
+                endpoint: this.pda.setting(),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                // param
+                amount,
+                receiver,
+            }
+        ).items[0]
     }
 
     /**
      * Initializes the OApp configuration.
      *
-     * @param {PublicKey} delegate - The delegate public key.
-     * @param {MessageLibInterface} msgLibSDK - The message library SDK.
-     * @param {PublicKey} payer - The payer public key.
-     * @param {PublicKey} oappID - The OApp ID public key.
-     * @param {number} eid - The endpoint ID.
-     * @returns {TransactionInstruction} The transaction instruction.
+     * @param accounts - The accounts object.
+     * @param accounts.delegate - The delegate public key.
+     * @param accounts.payer - The payer public key.
+     * @param params - The parameters object.
+     *  @param params.msgLibSDK - The message library SDK.
+     *  @param params.oapp - The OApp ID public key.
+     *  @param params.remote - The endpoint ID.
+     * @returns A WrappedInstruction object representing the instruction to initialize the OApp configuration.
      */
     initOAppConfig(
-        delegate: PublicKey,
-        msgLibSDK: MessageLibInterface,
-        payer: PublicKey,
-        oappID: PublicKey,
-        eid: number
-    ): TransactionInstruction {
-        const [msgLib] = new MessageLibPDADeriver(msgLibSDK.program).messageLib()
-        const [oappRegistry] = this.deriver.oappRegistry(oappID)
-
-        const [msgLibInfo] = this.deriver.messageLibraryInfo(msgLib)
+        accounts: { delegate: Signer; payer: PublicKey },
+        params: {
+            msgLibSDK: MessageLibInterface
+            oapp: PublicKey // this is the PDA of the oapp
+            remote: number
+        }
+    ): WrappedInstruction {
+        const [msgLib] = new MessageLibPDA(params.msgLibSDK.programId).messageLib()
         // if (!(await uln.getOappConfig(connection, oappID, eid, commitmentOrConfig))) {
         // init oapp config
-        return instructions.createInitConfigInstruction(
+        const txBuilder = instructions.initConfig(
+            { programs: this.programRepo },
             {
-                delegate,
-                oappRegistry,
+                delegate: accounts.delegate,
+                oappRegistry: this.pda.oappRegistry(params.oapp),
                 messageLib: msgLib,
-                messageLibInfo: msgLibInfo,
-                messageLibProgram: msgLibSDK.program,
-                anchorRemainingAccounts: msgLibSDK.getInitConfigIXAccountMetaForCPI(payer, oappID, eid),
-            } satisfies instructions.InitConfigInstructionAccounts,
-            {
-                params: {
-                    eid: eid,
-                    oapp: oappID,
-                } satisfies types.InitConfigParams,
-            } satisfies instructions.InitConfigInstructionArgs,
-            this.program
+                messageLibInfo: this.pda.messageLibraryInfo(msgLib),
+                messageLibProgram: params.msgLibSDK.programId,
+                // param
+                eid: params.remote,
+                oapp: params.oapp,
+            }
         )
+        return txBuilder.addRemainingAccounts(
+            params.msgLibSDK.getInitConfigIXAccountMetaForCPI(accounts.payer, params.oapp, params.remote)
+        ).items[0]
     }
 
     /**
@@ -316,244 +389,216 @@ export class Endpoint {
      * @returns {TransactionInstruction} The transaction instruction.
      */
     initOAppNonce(
-        delegate: PublicKey, // payer
-        dstEid: number,
-        oappIDPDA: PublicKey,
-        remoteOappAddr: Uint8Array
-    ): TransactionInstruction {
-        const [nonce] = this.deriver.nonce(oappIDPDA, dstEid, remoteOappAddr)
-        const [pendingNonce] = this.deriver.pendingNonce(oappIDPDA, dstEid, remoteOappAddr)
-        const [oappRegistry] = this.deriver.oappRegistry(oappIDPDA)
-
-        return instructions.createInitNonceInstruction(
-            {
-                nonce,
-                pendingInboundNonce: pendingNonce,
-                oappRegistry,
-                delegate,
-            } satisfies instructions.InitNonceInstructionAccounts,
+        delegate: Signer, // the delegate of the oapp
+        params: {
+            localOApp: PublicKey
+            remote: number
+            remoteOApp: Uint8Array
+        }
+    ): WrappedInstruction {
+        const txBuilder = instructions.initNonce(
+            { programs: this.programRepo },
             {
-                params: {
-                    localOapp: oappIDPDA,
-                    remoteOapp: Array.from(remoteOappAddr),
-                    remoteEid: dstEid,
-                } satisfies types.InitNonceParams,
-            } satisfies instructions.InitNonceInstructionArgs,
-            this.program
+                nonce: this.pda.nonce(params.localOApp, params.remote, params.remoteOApp),
+                pendingInboundNonce: this.pda.pendingNonce(params.localOApp, params.remote, params.remoteOApp),
+                oappRegistry: this.pda.oappRegistry(params.localOApp),
+                delegate: delegate,
+                // param
+                localOapp: params.localOApp,
+                remoteOapp: params.remoteOApp,
+                remoteEid: params.remote,
+            }
         )
+        return txBuilder.items[0]
     }
 
-    /**
-     * Initializes the send library.
-     *
-     * @param {PublicKey} delegate - The delegate public key.
-     * @param {PublicKey} sender - The sender public key.
-     * @param {number} dstEid - The destination endpoint ID.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    initSendLibrary(delegate: PublicKey, sender: PublicKey, dstEid: number): TransactionInstruction {
-        const [oappRegistry] = this.deriver.oappRegistry(sender)
-        const [sendLibraryConfig] = this.deriver.sendLibraryConfig(sender, dstEid)
-
-        return instructions.createInitSendLibraryInstruction(
+    initOAppSendLibrary(delegate: Signer, params: { sender: PublicKey; remote: number }): WrappedInstruction {
+        return instructions.initSendLibrary(
+            { programs: this.programRepo },
             {
-                delegate,
-                oappRegistry,
-                sendLibraryConfig: sendLibraryConfig,
-            } satisfies instructions.InitSendLibraryInstructionAccounts,
-            {
-                params: {
-                    sender,
-                    eid: dstEid,
-                } satisfies types.InitSendLibraryParams,
-            } satisfies instructions.InitSendLibraryInstructionArgs,
-            this.program
-        )
+                delegate: delegate,
+                oappRegistry: this.pda.oappRegistry(params.sender),
+                sendLibraryConfig: this.pda.sendLibraryConfig(params.sender, params.remote),
+                // param
+                sender: params.sender,
+                eid: params.remote,
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the send library.
-     *
-     * @param {PublicKey} oappAdmin - The OApp admin public key.
-     * @param {PublicKey} oappIDPDA - The OApp ID PDA.
-     * @param {PublicKey} newSendLibProgram - The new send library program public key.
-     * @param {number} dstEid - The destination endpoint ID.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setSendLibrary(
-        oappAdmin: PublicKey,
-        oappIDPDA: PublicKey,
-        newSendLibProgram: PublicKey,
-        dstEid: number
-    ): TransactionInstruction {
-        const [newSendLib] = new MessageLibPDADeriver(newSendLibProgram).messageLib()
-        const [sendLibraryConfig] = this.deriver.sendLibraryConfig(oappIDPDA, dstEid)
-        const [sendLibraryInfo] = this.deriver.messageLibraryInfo(newSendLib)
-        const [oappRegistry] = this.deriver.oappRegistry(oappIDPDA)
-
-        const ix = instructions.createSetSendLibraryInstruction(
+    setOAppSendLibrary(
+        delegate: Signer,
+        params: { sender: PublicKey; remote: number; msgLibProgram: PublicKey }
+    ): WrappedInstruction {
+        const { sender, remote, msgLibProgram } = params
+        const [newSendLib] = new MessageLibPDA(msgLibProgram).messageLib()
+        return instructions.setSendLibrary(
+            { programs: this.programRepo },
             {
-                signer: oappAdmin,
-                sendLibraryConfig: sendLibraryConfig,
-                messageLibInfo: sendLibraryInfo,
-                oappRegistry,
-                program: this.program,
-                eventAuthority: this.eventAuthorityPDA,
-            } satisfies instructions.SetSendLibraryInstructionAccounts,
-            {
-                params: {
-                    sender: oappIDPDA,
-                    eid: dstEid,
-                    newLib: newSendLib,
-                } satisfies types.SetSendLibraryParams,
-            } satisfies instructions.SetSendLibraryInstructionArgs,
-            this.program
-        )
-        return ix
+                signer: delegate,
+                sendLibraryConfig: this.pda.sendLibraryConfig(sender, remote),
+                messageLibInfo:
+                    msgLibProgram === DefaultMessageLib ? undefined : this.pda.messageLibraryInfo(newSendLib),
+                oappRegistry: this.pda.oappRegistry(sender),
+                program: this.programId,
+                eventAuthority: this.eventAuthority,
+                //param
+                sender: sender,
+                eid: remote,
+                newLib: msgLibProgram === DefaultMessageLib ? DefaultMessageLib : newSendLib,
+            }
+        ).items[0]
     }
 
-    /**
-     * Initializes the receive library.
-     *
-     * @param {PublicKey} delegate - The delegate public key.
-     * @param {PublicKey} receiver - The receiver public key.
-     * @param {number} srcEid - The source endpoint ID.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    initReceiveLibrary(delegate: PublicKey, receiver: PublicKey, srcEid: number): TransactionInstruction {
-        const [oappRegistry] = this.deriver.oappRegistry(receiver)
-        const [receiveLibraryConfig] = this.deriver.receiveLibraryConfig(receiver, srcEid)
-
-        return instructions.createInitReceiveLibraryInstruction(
+    initOAppReceiveLibrary(delegate: Signer, params: { receiver: PublicKey; remote: number }): WrappedInstruction {
+        const { receiver, remote } = params
+        return instructions.initReceiveLibrary(
+            { programs: this.programRepo },
             {
-                delegate,
-                oappRegistry,
-                receiveLibraryConfig: receiveLibraryConfig,
-            } satisfies instructions.InitReceiveLibraryInstructionAccounts,
-            {
-                params: {
-                    receiver,
-                    eid: srcEid,
-                } satisfies types.InitReceiveLibraryParams,
-            } satisfies instructions.InitReceiveLibraryInstructionArgs,
-            this.program
-        )
+                delegate: delegate,
+                oappRegistry: this.pda.oappRegistry(receiver),
+                receiveLibraryConfig: this.pda.receiveLibraryConfig(receiver, remote),
+                // param
+                receiver: receiver,
+                eid: remote,
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the receive library.
-     *
-     * @param {PublicKey} oappAdmin - The OApp admin public key.
-     * @param {PublicKey} oappIDPDA - The OApp ID PDA.
-     * @param {PublicKey} newReceiveLibProgram - The new receive library program public key.
-     * @param {number} srcEid - The source endpoint ID.
-     * @param {bigint | number} [gracePeriod] - The grace period.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setReceiveLibrary(
-        oappAdmin: PublicKey,
-        oappIDPDA: PublicKey,
-        newReceiveLibProgram: PublicKey,
-        srcEid: number,
-        gracePeriod?: bigint | number
-    ): TransactionInstruction {
-        const [newReceiveLib] = new MessageLibPDADeriver(newReceiveLibProgram).messageLib()
-        const [receiveLibraryConfig] = this.deriver.receiveLibraryConfig(oappIDPDA, srcEid)
-        const [receiveLibraryInfo] = this.deriver.messageLibraryInfo(newReceiveLib)
-        const [oappRegistry] = this.deriver.oappRegistry(oappIDPDA)
-
-        const ix = instructions.createSetReceiveLibraryInstruction(
+    setOAppReceiveLibrary(
+        delegate: Signer,
+        params: { receiver: PublicKey; remote: number; msgLibProgram: PublicKey; gracePeriod?: bigint | number }
+    ): WrappedInstruction {
+        const { receiver, remote, msgLibProgram, gracePeriod } = params
+        const [newReceiveLib] = new MessageLibPDA(msgLibProgram).messageLib()
+        return instructions.setReceiveLibrary(
+            { programs: this.programRepo },
             {
-                signer: oappAdmin,
-                receiveLibraryConfig: receiveLibraryConfig,
-                messageLibInfo: receiveLibraryInfo,
-                oappRegistry,
-                program: this.program,
-                eventAuthority: this.eventAuthorityPDA,
-            } satisfies instructions.SetReceiveLibraryInstructionAccounts,
+                signer: delegate,
+                receiveLibraryConfig: this.pda.receiveLibraryConfig(receiver, remote),
+                messageLibInfo:
+                    msgLibProgram === DefaultMessageLib ? undefined : this.pda.messageLibraryInfo(newReceiveLib),
+                oappRegistry: this.pda.oappRegistry(receiver),
+                program: this.programId,
+                eventAuthority: this.eventAuthority,
+                // param
+                receiver: receiver,
+                eid: remote,
+                newLib: msgLibProgram === DefaultMessageLib ? DefaultMessageLib : newReceiveLib,
+                gracePeriod: gracePeriod ?? 0,
+            }
+        ).items[0]
+    }
+
+    setOAppReceiveLibraryTimeout(
+        delegate: Signer,
+        params: { receiver: PublicKey; msgLibProgram: PublicKey; remote: number; expiry: bigint | number }
+    ): WrappedInstruction {
+        const { receiver, remote, msgLibProgram, expiry } = params
+        const [receiveLib] = new MessageLibPDA(msgLibProgram).messageLib()
+        return instructions.setReceiveLibraryTimeout(
+            { programs: this.programRepo },
             {
-                params: {
-                    receiver: oappIDPDA,
-                    eid: srcEid,
-                    newLib: newReceiveLib,
-                    gracePeriod: gracePeriod === undefined ? 0 : new BN(gracePeriod.toString()),
-                } satisfies types.SetReceiveLibraryParams,
-            } satisfies instructions.SetReceiveLibraryInstructionArgs,
-            this.program
-        )
-        return ix
+                signer: delegate,
+                oappRegistry: this.pda.oappRegistry(receiver),
+                receiveLibraryConfig: this.pda.receiveLibraryConfig(receiver, remote),
+                messageLibInfo: this.pda.messageLibraryInfo(receiveLib),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                // param
+                receiver: receiver,
+                eid: remote,
+                lib: receiveLib,
+                expiry,
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the OApp configuration.
-     *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {PublicKey} oappDelegate - The OApp delegate public key.
-     * @param {PublicKey} oappID - The OApp ID public key.
-     * @param {PublicKey} msgLibProgram - The message library program public key.
-     * @param {number} eid - The endpoint ID.
-     * @param {object} config - The configuration object.
-     * @param {SetConfigType} config.configType - The configuration type.
-     * @param {UlnProgram.types.ExecutorConfig | UlnProgram.types.UlnConfig} config.value - The configuration value.
-     * @param {Commitment} [commitment='confirmed'] - The commitment level.
-     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
-     * @throws {Error} If the message library version is unsupported.
-     */
-    async setOappConfig(
-        connection: Connection,
-        oappDelegate: PublicKey,
-        oappID: PublicKey,
-        msgLibProgram: PublicKey,
-        eid: number,
-        config: {
-            configType: SetConfigType
-            value: UlnProgram.types.ExecutorConfig | UlnProgram.types.UlnConfig
+    async setOAppConfig(
+        rpc: RpcInterface,
+        delegate: Signer,
+        params: {
+            oapp: PublicKey // this is the PDA of the oapp
+            eid: number
+            config: {
+                configType: SetConfigType
+                value: UlnProgram.types.ExecutorConfig | UlnProgram.types.UlnConfig
+            }
+            msgLibProgram: PublicKey
+            msgLibVersion?: Version
         },
         commitment: Commitment = 'confirmed'
-    ): Promise<TransactionInstruction> {
-        const [msgLib] = new MessageLibPDADeriver(msgLibProgram).messageLib()
-        const [msgLibInfo] = this.deriver.messageLibraryInfo(msgLib)
+    ): Promise<WrappedInstruction> {
+        const { oapp, eid, config, msgLibProgram } = params
+        const [msgLib] = new MessageLibPDA(msgLibProgram).messageLib()
 
-        const msgLibVersion = await this.getMessageLibVersion(connection, oappDelegate, msgLibProgram, commitment)
+        const msgLibVersion =
+            params.msgLibVersion ??
+            (await this.getMessageLibVersion(rpc, delegate.publicKey, msgLibProgram, commitment))
         let msgLibClient: MessageLibInterface
-        if (msgLibVersion?.major.toString() === '0' && msgLibVersion.minor == 0 && msgLibVersion.endpointVersion == 2) {
+        if (msgLibVersion.major === 0n && msgLibVersion.minor == 0 && msgLibVersion.endpointVersion == 2) {
             msgLibClient = new SimpleMessageLibProgram.SimpleMessageLib(msgLibProgram)
-        } else if (
-            msgLibVersion?.major.toString() === '3' &&
-            msgLibVersion.minor == 0 &&
-            msgLibVersion.endpointVersion == 2
-        ) {
+        } else if (msgLibVersion.major === 3n && msgLibVersion.minor == 0 && msgLibVersion.endpointVersion == 2) {
             msgLibClient = new UlnProgram.Uln(msgLibProgram)
         } else {
             throw new Error(
-                `unsupported message lib version ${msgLibVersion?.major.toString()}.${msgLibVersion?.minor.toString()}`
+                `unsupported message lib version ${msgLibVersion.major.toString()}.${msgLibVersion.minor.toString()}`
             )
         }
 
-        const [oappRegistry] = this.deriver.oappRegistry(oappID)
-        const ix = instructions.createSetConfigInstruction(
+        const txBuilder = instructions.setConfig(
+            { programs: this.programRepo },
             {
-                signer: oappDelegate,
-                messageLibInfo: msgLibInfo,
+                signer: delegate,
+                messageLibInfo: this.pda.messageLibraryInfo(msgLib),
                 messageLib: msgLib,
                 messageLibProgram: msgLibProgram,
-                oappRegistry,
-                anchorRemainingAccounts: await msgLibClient.getSetConfigIXAccountMetaForCPI(this.program, oappID, eid),
+                oappRegistry: this.pda.oappRegistry(oapp),
+                // param
+                eid,
+                configType: config.configType,
+                config:
+                    msgLibProgram === SIMPLE_MESSAGELIB_PROGRAM_ID
+                        ? new Uint8Array(10).fill(0)
+                        : UlnProgram.Uln.constructSetConfigData(config.configType, config.value),
+                oapp: oapp,
+            }
+        )
+        return txBuilder.addRemainingAccounts(msgLibClient.getSetConfigIXAccountMetaForCPI(oapp, eid)).items[0]
+    }
+
+    oAppNilify(delegate: Signer, args: instructions.NilifyInstructionArgs): WrappedInstruction {
+        const { receiver, srcEid, sender, nonce } = args
+        return instructions.nilify(
+            { programs: this.programRepo },
+            {
+                signer: delegate,
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                oappRegistry: this.pda.oappRegistry(receiver),
+                nonce: this.pda.nonce(receiver, srcEid, sender),
+                pendingInboundNonce: this.pda.pendingNonce(receiver, srcEid, sender),
+                payloadHash: this.pda.payloadHash(receiver, srcEid, sender, nonce),
             },
+            args
+        ).items[0]
+    }
+
+    oAppBurnNonce(delegate: Signer, args: instructions.BurnInstructionArgs): WrappedInstruction {
+        const { receiver, srcEid, sender, nonce } = args
+        return instructions.burn(
+            { programs: this.programRepo },
             {
-                params: {
-                    eid,
-                    configType: config.configType,
-                    config:
-                        msgLibProgram.toBase58() === SimpleMessageLibProgram.PROGRAM_ID.toBase58()
-                            ? new Uint8Array(10)
-                            : UlnProgram.Uln.constructSetConfigData(config.configType, config.value),
-                    oapp: oappID,
-                } satisfies types.SetConfigParams,
-            } satisfies instructions.SetConfigInstructionArgs,
-            this.program
-        )
-        return ix
+                signer: delegate,
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                oappRegistry: this.pda.oappRegistry(receiver),
+                nonce: this.pda.nonce(receiver, srcEid, sender),
+                payloadHash: this.pda.payloadHash(receiver, srcEid, sender, nonce),
+                endpoint: this.pda.setting(),
+            },
+            args
+        ).items[0]
     }
 
     /// send a simulated transaction to the endpoint to get the fee for sending a message
@@ -579,48 +624,45 @@ export class Endpoint {
      * @throws {Error} If the default send library is not initialized or the message library is blocked.
      */
     async getQuoteIXAccountMetaForCPI(
-        connection: Connection,
+        rpc: RpcInterface,
         payer: PublicKey,
-        path: SolanaPacketPath,
-        msgLibProgram: MessageLibInterface
+        params: {
+            path: SolanaPacketPath
+            msgLibProgram: MessageLibInterface
+        },
+        commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const { sender: sender_, dstEid, receiver: receiver_ } = path
-        const sender = new PublicKey(arrayify(sender_))
-        const receiver = addressToBytes32(receiver_)
-        const sendLibInfo = await this.getSendLibrary(connection, sender, dstEid)
-        if (!sendLibInfo?.programId) {
+        const { path, msgLibProgram } = params
+        const { sender, dstEid, receiver } = path
+        const sendLibInfo = await this.getSendLibrary(rpc, sender, dstEid, commitment)
+        if (!sendLibInfo.programId) {
             throw new Error('default send library not initialized or blocked message lib')
         }
         const { msgLib, programId: owner } = sendLibInfo
-        const [sendLibraryInfo] = this.deriver.messageLibraryInfo(msgLib)
-        const remainingAccounts = await msgLibProgram.getQuoteIXAccountMetaForCPI(connection, payer, path)
-
-        const [setting] = this.deriver.setting()
-        const [defaultSendLibraryConfig] = this.deriver.defaultSendLibraryConfig(dstEid)
-        const [sendLibraryConfig] = this.deriver.sendLibraryConfig(sender, dstEid)
-        const [nonce] = this.deriver.nonce(sender, dstEid, receiver)
-
-        const accounts = instructions.createQuoteInstructionAccounts(
+        const txBuilder = instructions.quote(
+            { programs: this.programRepo },
             {
-                sendLibraryConfig: sendLibraryConfig,
+                sendLibraryConfig: this.pda.sendLibraryConfig(sender, dstEid),
                 sendLibraryProgram: owner,
-                defaultSendLibraryConfig: defaultSendLibraryConfig,
-                endpoint: setting,
-                nonce,
-                sendLibraryInfo,
-                anchorRemainingAccounts: remainingAccounts,
-            } satisfies instructions.QuoteInstructionAccounts,
-            this.program
-        )
-        return Promise.resolve(
-            [
-                {
-                    pubkey: this.program,
-                    isSigner: false,
-                    isWritable: false,
-                },
-            ].concat(accounts)
+                defaultSendLibraryConfig: this.pda.defaultSendLibraryConfig(dstEid),
+                endpoint: this.pda.setting(),
+                nonce: this.pda.nonce(sender, dstEid, receiver),
+                sendLibraryInfo: this.pda.messageLibraryInfo(msgLib),
+
+                // param
+                sender: defaultPublicKey(),
+                dstEid: 0,
+                receiver: new Uint8Array(32),
+                message: new Uint8Array(32),
+                options: new Uint8Array(32),
+                payInLzToken: false,
+            }
         )
+        const remainingAccounts = await msgLibProgram.getQuoteIXAccountMetaForCPI(rpc, payer, path)
+        return [
+            { pubkey: this.programId, isSigner: false, isWritable: false },
+            ...txBuilder.addRemainingAccounts(remainingAccounts).getInstructions()[0].keys,
+        ]
     }
 
     /**
@@ -635,55 +677,72 @@ export class Endpoint {
      * @throws {Error} If the default send library is not initialized or the message library is blocked.
      */
     async getSendIXAccountMetaForCPI(
-        connection: Connection,
-        payer: PublicKey,
-        path: SolanaPacketPath,
-        msgLibProgram: MessageLibInterface,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        rpc: RpcInterface,
+        payerOrAccounts: PublicKey | { payer: PublicKey; tokenMint: PublicKey; tokenSource: PublicKey },
+        params: {
+            path: SolanaPacketPath
+            msgLibProgram: MessageLibInterface
+            tokenProgram?: PublicKey
+            associatedTokenProgram?: PublicKey
+        },
+        commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const { sender: sender_, dstEid, receiver: receiver_ } = path
-        const sender = new PublicKey(arrayify(sender_))
-        const receiver = addressToBytes32(receiver_)
-        const info = await this.getSendLibrary(connection, sender, dstEid, commitmentOrConfig)
-        if (!info?.programId) {
+        const { path, msgLibProgram } = params
+        const { sender, dstEid, receiver } = path
+        const info = await this.getSendLibrary(rpc, sender, dstEid, commitment)
+        if (!info.programId) {
             throw new Error('default send library not initialized or blocked message lib')
         }
         const sendLibrary = info.msgLib
-
-        const [sendLibraryInfo] = this.deriver.messageLibraryInfo(sendLibrary)
-        const remainingAccounts = await msgLibProgram.getSendIXAccountMetaForCPI(connection, payer, path)
-
-        const [defaultSendLibraryConfig] = this.deriver.defaultSendLibraryConfig(dstEid)
-        const [sendLibraryConfig] = this.deriver.sendLibraryConfig(sender, dstEid)
-        const [nonce] = this.deriver.nonce(sender, dstEid, receiver)
-
-        const accounts = instructions.createSendInstructionAccounts(
+        const txBuilder = instructions.send(
+            { programs: this.programRepo },
             {
-                sender, //signer
+                sender: createNoopSigner(sender),
                 /// this account should be derived from message lib
                 sendLibraryProgram: info.programId,
-                sendLibraryConfig,
-                defaultSendLibraryConfig: defaultSendLibraryConfig,
-                sendLibraryInfo,
-                endpoint: this.deriver.setting()[0],
-                program: this.program,
-                nonce: nonce,
-                eventAuthority: this.eventAuthorityPDA,
-                anchorRemainingAccounts: remainingAccounts,
-            } satisfies instructions.SendInstructionAccounts,
-            this.program
+                sendLibraryConfig: this.pda.sendLibraryConfig(sender, dstEid),
+                defaultSendLibraryConfig: this.pda.defaultSendLibraryConfig(dstEid),
+                sendLibraryInfo: this.pda.messageLibraryInfo(sendLibrary),
+                endpoint: this.pda.setting(),
+                program: this.programId,
+                nonce: this.pda.nonce(sender, dstEid, receiver),
+                eventAuthority: this.eventAuthority,
+
+                // param
+                dstEid: 0,
+                receiver: new Uint8Array(32),
+                message: new Uint8Array(32),
+                options: new Uint8Array(32),
+                nativeFee: 0,
+                lzTokenFee: 0,
+            }
         )
+        let remainingAccounts
+        if (typeof payerOrAccounts === 'object') {
+            remainingAccounts = await msgLibProgram.getSendWithLzTokenIXAccountMetaForCPI(
+                rpc,
+                payerOrAccounts,
+                path,
+                {
+                    tokenProgram: params.tokenProgram,
+                    associatedTokenProgram: params.associatedTokenProgram,
+                },
+                commitment
+            )
+        } else {
+            remainingAccounts = await msgLibProgram.getSendIXAccountMetaForCPI(rpc, payerOrAccounts, path)
+        }
 
-        accounts.forEach((item: AccountMeta) => {
-            item.isSigner = false
-        })
         return [
-            {
-                pubkey: this.program,
-                isSigner: false,
-                isWritable: false,
-            },
-        ].concat(accounts)
+            { pubkey: this.programId, isSigner: false, isWritable: false },
+            ...txBuilder
+                .addRemainingAccounts(remainingAccounts)
+                .getInstructions()[0]
+                .keys.map((key) => {
+                    key.isSigner = false
+                    return key
+                }),
+        ]
     }
 
     /**
@@ -696,43 +755,23 @@ export class Endpoint {
      * @param {string} nonce - The nonce.
      * @returns {Promise<TransactionInstruction | null>} A promise that resolves to the transaction instruction or null if not needed.
      */
-    async skip(
-        payer: PublicKey,
-        sender: PublicKey,
-        receiver: PublicKey,
-        srcEid: number,
-        nonce: string
-    ): Promise<TransactionInstruction | null> {
-        const [nonceAccount] = this.deriver.nonce(receiver, srcEid, addressToBytes32(sender.toBase58()))
-        const [payloadHash] = this.deriver.payloadHash(receiver, srcEid, sender.toBytes(), parseInt(nonce))
-        const [pendingInboundNonce] = this.deriver.pendingNonce(receiver, srcEid, sender.toBytes())
+    skip(payer: Signer, params: instructions.SkipInstructionDataArgs): WrappedInstruction {
+        const { sender, receiver, srcEid, nonce } = params
         // get the delegate from endpoint
-        const [oAppRegistry] = PublicKey.findProgramAddressSync(
-            [Buffer.from(OAPP_SEED, 'utf-8'), receiver.toBuffer()],
-            this.program
-        )
-        const ix = instructions.createSkipInstruction(
+        return instructions.skip(
+            { programs: this.programRepo },
             {
                 signer: payer,
-                oappRegistry: oAppRegistry,
-                nonce: nonceAccount,
-                pendingInboundNonce: pendingInboundNonce,
-                payloadHash: payloadHash,
-                endpoint: this.deriver.setting()[0],
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
-            } satisfies instructions.SkipInstructionAccounts,
-            {
-                params: {
-                    receiver: receiver,
-                    srcEid: srcEid,
-                    sender: Array.from(sender.toBytes()),
-                    nonce: new BN(nonce),
-                } satisfies types.SkipParams,
-            } satisfies instructions.SkipInstructionArgs,
-            this.program
-        )
-        return Promise.resolve(ix)
+                oappRegistry: this.pda.oappRegistry(receiver),
+                nonce: this.pda.nonce(receiver, srcEid, sender),
+                pendingInboundNonce: this.pda.pendingNonce(receiver, srcEid, sender),
+                payloadHash: this.pda.payloadHash(receiver, srcEid, sender, nonce),
+                endpoint: this.pda.setting()[0],
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+            },
+            params
+        ).items[0]
     }
 
     /**
@@ -747,38 +786,18 @@ export class Endpoint {
      * @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,
-        sender: PublicKey,
-        receiver: PublicKey,
-        srcEid: number,
-        nonce: string,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<TransactionInstruction | null> {
-        const [nonceAccount] = this.deriver.nonce(receiver, srcEid, addressToBytes32(sender.toBase58()))
-        const [payloadHash] = this.deriver.payloadHash(receiver, srcEid, sender.toBytes(), parseInt(nonce))
-        const payloadHashInfo = await connection.getAccountInfo(payloadHash, commitmentOrConfig)
-        if (payloadHashInfo) {
-            // throw new Error('init verify already executed')
-            return null
-        }
-        return instructions.createInitVerifyInstruction(
+    initVerify(payer: Signer, params: instructions.InitVerifyInstructionArgs): WrappedInstruction {
+        const { sender, receiver, srcEid, nonce } = params
+
+        return instructions.initVerify(
+            { programs: this.programRepo, payer },
             {
                 payer,
-                nonce: nonceAccount,
-                payloadHash,
-            } satisfies instructions.InitVerifyInstructionAccounts,
-            {
-                params: {
-                    srcEid,
-                    sender: Array.from(sender.toBytes()),
-                    receiver,
-                    nonce: new BN(nonce),
-                } satisfies types.InitVerifyParams,
-            } satisfies instructions.InitVerifyInstructionArgs,
-            this.program
-        )
+                nonce: this.pda.nonce(receiver, srcEid, sender),
+                payloadHash: this.pda.payloadHash(receiver, srcEid, sender, parseInt(nonce.toString())),
+            },
+            params
+        ).items[0]
     }
 
     /**
@@ -789,210 +808,38 @@ export class Endpoint {
      * @returns {AccountMeta[]} An array of account metadata.
      */
     getVerifyIXAccountMetaForCPI(packet: PacketV1Codec, receiveLibrary: PublicKey): AccountMeta[] {
-        const receiver = new PublicKey(Buffer.from(packet.receiver().slice(2), 'hex'))
+        const receiver = publicKey(Buffer.from(packet.receiver().slice(2), 'hex'))
         const srcEid = packet.srcEid()
         const sender = addressToBytes32(packet.sender())
 
-        const [payloadHash] = this.deriver.payloadHash(receiver, srcEid, sender, parseInt(packet.nonce()))
-        const [defaultReceiveLibraryConfig] = this.deriver.defaultReceiveLibraryConfig(srcEid)
-        const [receiveLibraryConfig] = this.deriver.receiveLibraryConfig(receiver, srcEid)
-
-        const [nonce] = this.deriver.nonce(receiver, srcEid, sender)
-        const [pendingNonce] = this.deriver.pendingNonce(receiver, srcEid, sender)
-        // const [receiveLibraryPDA] = this.endpointDeriver.receiveLibrary(receiver, srcEid)
-        const accounts = instructions.createVerifyInstructionAccounts(
+        const txBuilder = instructions.verify(
+            { programs: this.programRepo },
             {
-                receiveLibrary: receiveLibrary,
-                receiveLibraryConfig: receiveLibraryConfig,
-                defaultReceiveLibraryConfig: defaultReceiveLibraryConfig,
-                nonce: nonce,
-                pendingInboundNonce: pendingNonce,
-                payloadHash: payloadHash,
-                program: this.program,
-                eventAuthority: this.eventAuthorityPDA,
-            } satisfies instructions.VerifyInstructionAccounts,
-            this.program
+                receiveLibrary: createNoopSigner(receiveLibrary),
+                receiveLibraryConfig: this.pda.receiveLibraryConfig(receiver, srcEid),
+                defaultReceiveLibraryConfig: this.pda.defaultReceiveLibraryConfig(srcEid),
+                nonce: this.pda.nonce(receiver, srcEid, sender),
+                pendingInboundNonce: this.pda.pendingNonce(receiver, srcEid, sender),
+                payloadHash: this.pda.payloadHash(receiver, srcEid, sender, parseInt(packet.nonce())),
+                program: this.programId,
+                eventAuthority: this.eventAuthority,
+            },
+            {
+                srcEid: 0,
+                sender: new Uint8Array(32),
+                receiver: defaultPublicKey(),
+                nonce: 0,
+                payloadHash: new Uint8Array(32),
+            }
         )
-        accounts.forEach((key) => {
-            key.isSigner = false
-        })
         const program: AccountMeta = {
-            pubkey: this.program,
+            pubkey: this.programId,
             isSigner: false,
             isWritable: false,
         }
-        return [program, ...accounts]
+        return [program, ...txBuilder.getInstructions()[0].keys.map((key) => ({ ...key, isSigner: false }))]
     }
 
-    /***
-     * resetConfig is only supported by ULN
-     */
-    // async getResetConfigIXAccountMetaForCPI(
-    //     connection: Connection,
-    //     msgLibProgram: PublicKey,
-    //     oappID: PublicKey,
-    //     eid: number,
-    //     commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
-    // ): Promise<AccountMeta[]> {
-    //     const uln = new UlnProgram.Uln(msgLibProgram)
-    //     const [msgLib] = uln.ulnDeriver.messageLib()
-    //     const [msgLibInfo] = this.endpointDeriver.messageLibraryAuthority(msgLib)
-
-    //     const ix = instructions.createResetConfigInstruction(
-    //         {
-    //             oapp: oappID,
-    //             messageLibAuthority: msgLibInfo,
-    //             messageLib: msgLib,
-    //             anchorRemainingAccounts: await uln.getResetConfigIXAccountMetaForCPI(
-    //                 connection,
-    //                 this.program,
-    //                 oappID,
-    //                 eid,
-    //                 commitmentOrConfig
-    //             ),
-    //         } as instructions.ResetConfigInstructionAccounts,
-    //         // Fake params. Just to get the ix.keys
-    //         {
-    //             params: {
-    //                 eid: eid,
-    //                 messageLib: msgLib,
-    //             } as types.ResetConfigParams,
-    //         } as instructions.ResetConfigInstructionArgs
-    //     )
-    //     ix.keys.forEach((key) => {
-    //         key.isSigner = false
-    //     })
-    //     return [
-    //         {
-    //             pubkey: this.program,
-    //             isWritable: false,
-    //             isSigner: false,
-    //         } as AccountMeta,
-    //     ].concat(ix.keys)
-    // }
-
-    /**
-     * snapshotConfig is only supported by ULN
-     */
-    // async getSnapshotConfigIXAccountMetaForCPI(
-    //     connection: Connection,
-    //     msgLibProgram: PublicKey,
-    //     oappID: PublicKey,
-    //     eid: number,
-    //     commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
-    // ): Promise<AccountMeta[]> {
-    //     const uln = new UlnProgram.Uln(msgLibProgram)
-    //     const [msgLib] = uln.ulnDeriver.messageLib()
-    //     const [msgLibInfo] = this.endpointDeriver.messageLibraryAuthority(msgLib)
-
-    //     const ix = instructions.createSnapshotConfigInstruction(
-    //         {
-    //             oapp: oappID,
-    //             messageLibAuthority: msgLibInfo,
-    //             messageLib: msgLib,
-    //             anchorRemainingAccounts: await uln.getSnapshotConfigIXAccountMetaForCPI(
-    //                 connection,
-    //                 this.program,
-    //                 oappID,
-    //                 eid,
-    //                 commitmentOrConfig
-    //             ),
-    //         } satisfies instructions.SnapshotConfigInstructionAccounts,
-    //         // Fake params. Just to get the ix.keys
-    //         {
-    //             params: {
-    //                 eid: eid,
-    //                 messageLib: msgLib,
-    //             } as types.SnapshotConfigParams,
-    //         } as instructions.SnapshotConfigInstructionArgs
-    //     )
-    //     ix.keys.forEach((key) => {
-    //         key.isSigner = false
-    //     })
-    //     return [
-    //         {
-    //             pubkey: this.program,
-    //             isWritable: false,
-    //             isSigner: false,
-    //         },
-    //     ].concat(ix.keys)
-    // }
-
-    /**
-     * @param composer. The composer is usually the PDA of the app's ID. It depends on the oapp's implementation.
-     */
-    // getDeliverComposedMessageIXAccountMetaForCPI(
-    //     payer: PublicKey,
-    //     composer: PublicKey,
-    //     packet: PacketV1Codec
-    // ): AccountMeta[] {
-    //     const receiver = new PublicKey(Buffer.from(packet.receiver().slice(2), 'hex'))
-    //     const guid = Uint8Array.from(Buffer.from(packet.guid().slice(2), 'hex'))
-    //     const message = ethers.utils.arrayify(ethers.utils.keccak256(packet.message()))
-    //     const ix = instructions.createDeliverComposedMessageInstruction(
-    //         {
-    //             payer,
-    //             receiver,
-    //             composedMessage: this.endpointDeriver.composedMessage(receiver, guid, composer, message)[0],
-    //             endpoint: this.endpointDeriver.setting()[0],
-    //             endpointProgram: this.program,
-    //         } satisfies instructions.DeliverComposedMessageInstructionAccounts,
-    //         // Fake params. Just to get the ix.keys
-    //         {
-    //             params: {
-    //                 composer: payer,
-    //                 guid: Array.from(guid),
-    //                 message: Uint8Array.from([]),
-    //             } as types.DeliverComposedMessageParams,
-    //         } as instructions.DeliverComposedMessageInstructionArgs
-    //     )
-    //     ix.keys.forEach((key) => {
-    //         key.isSigner = false
-    //     })
-    //     return [
-    //         {
-    //             pubkey: this.program,
-    //             isWritable: false,
-    //             isSigner: false,
-    //         },
-    //     ].concat(ix.keys)
-    // }
-
-    /**
-     * @param composer. The composer is usually the PDA of the app's ID. It depends on the oapp's implementation.
-     */
-    // getClearComposedMessageIXAccountMetaForCPI(composer: PublicKey, packet: PacketV1Codec): AccountMeta[] {
-    //     const receiver = new PublicKey(Buffer.from(packet.receiver().slice(2), 'hex'))
-    //     const guid = Uint8Array.from(Buffer.from(packet.guid().slice(2), 'hex'))
-    //     const message = ethers.utils.arrayify(ethers.utils.keccak256(packet.message()))
-    //     const ix = instructions.createClearComposedMessageInstruction(
-    //         {
-    //             composer,
-    //             composedMessage: this.endpointDeriver.composedMessage(receiver, guid, composer, message)[0],
-    //             endpoint: this.endpointDeriver.setting()[0],
-    //             endpointProgram: this.program,
-    //         } satisfies instructions.ClearComposedMessageInstructionAccounts,
-    //         // Fake params. Just to get the ix.keys
-    //         {
-    //             params: {
-    //                 receiver: composer,
-    //                 guid: Array.from(guid),
-    //                 message: Uint8Array.from([]),
-    //             } as types.ClearComposedMessageParams,
-    //         } as instructions.ClearComposedMessageInstructionArgs
-    //     )
-    //     ix.keys.forEach((key) => {
-    //         key.isSigner = false
-    //     })
-    //     return [
-    //         {
-    //             pubkey: this.program,
-    //             isWritable: false,
-    //             isSigner: false,
-    //         } as AccountMeta,
-    //     ].concat(ix.keys)
-    // }
-
     /**
      * Gets the account metadata for the CPI (Cross-Program Invocation) of the register OApp instruction.
      *
@@ -1001,28 +848,48 @@ export class Endpoint {
      * @returns {AccountMeta[]} An array of account metadata.
      */
     getRegisterOappIxAccountMetaForCPI(payer: PublicKey, oapp: PublicKey): AccountMeta[] {
-        const [oappRegistry] = this.deriver.oappRegistry(oapp)
-        const eventAuthority = this.eventAuthorityPDA
-        const keys = instructions.createRegisterOappInstructionAccounts(
+        const txBuilder = instructions.registerOapp(
+            { programs: this.programRepo, payer: createNoopSigner(payer) },
             {
-                payer,
-                oapp,
-                oappRegistry,
-                eventAuthority,
-                program: this.program,
-            } satisfies instructions.RegisterOappInstructionAccounts,
-            this.program
+                payer: createNoopSigner(payer),
+                oapp: createNoopSigner(oapp),
+                oappRegistry: this.pda.oappRegistry(oapp),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                // param
+                delegate: payer,
+            }
+        )
+        return [
+            {
+                pubkey: this.programId,
+                isSigner: false,
+                isWritable: false,
+            },
+            ...txBuilder.getInstructions()[0].keys.map((key) => ({ ...key, isSigner: false })),
+        ]
+    }
+
+    getSetDelegateIxAccountMetaForCPI(oapp: PublicKey): AccountMeta[] {
+        const txBuilder = instructions.setDelegate(
+            { programs: this.programRepo },
+            {
+                oapp: createNoopSigner(oapp),
+                oappRegistry: this.pda.oappRegistry(oapp),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
+                // param
+                delegate: defaultPublicKey(),
+            }
         )
-        keys.forEach((key) => {
-            key.isSigner = false
-        })
         return [
             {
-                pubkey: this.program,
+                pubkey: this.programId,
                 isSigner: false,
                 isWritable: false,
             },
-        ].concat(keys)
+            ...txBuilder.getInstructions()[0].keys.map((key) => ({ ...key, isSigner: false })),
+        ]
     }
 
     /**
@@ -1034,34 +901,39 @@ export class Endpoint {
      * @param {number} nonce - The nonce.
      * @returns {AccountMeta[]} An array of account metadata.
      */
-    getSkipIxAccountMetaForCPI(receiver: PublicKey, sender: Uint8Array, srcEid: number, nonce: number): AccountMeta[] {
-        const [noncePDA] = this.deriver.nonce(receiver, srcEid, sender)
-        const [pendingNonce] = this.deriver.pendingNonce(receiver, srcEid, sender)
-        const [payloadHash] = this.deriver.payloadHash(receiver, srcEid, sender, nonce)
-        const [oappRegistry] = this.deriver.oappRegistry(receiver)
-        const keys = instructions.createSkipInstructionAccounts(
+    getSkipIxAccountMetaForCPI(
+        receiver: PublicKey,
+        sender: Uint8Array,
+        srcEid: number,
+        nonce: number | bigint
+    ): AccountMeta[] {
+        const txBuilder = instructions.skip(
+            { programs: this.programRepo },
+            {
+                signer: createNoopSigner(receiver),
+                oappRegistry: this.pda.oappRegistry(receiver),
+                nonce: this.pda.nonce(receiver, srcEid, sender),
+                pendingInboundNonce: this.pda.pendingNonce(receiver, srcEid, sender),
+                payloadHash: this.pda.payloadHash(receiver, srcEid, sender, nonce),
+                endpoint: this.pda.setting(),
+                program: this.programId,
+                eventAuthority: this.eventAuthority,
+            },
             {
-                signer: receiver,
-                oappRegistry,
-                nonce: noncePDA,
-                pendingInboundNonce: pendingNonce,
-                payloadHash,
-                endpoint: this.deriver.setting()[0],
-                program: this.program,
-                eventAuthority: this.eventAuthorityPDA,
-            } satisfies instructions.SkipInstructionAccounts,
-            this.program
+                receiver: defaultPublicKey(),
+                srcEid: 0,
+                sender: new Uint8Array(32),
+                nonce: 0,
+            }
         )
-        keys.forEach((key) => {
-            key.isSigner = false
-        })
         return [
             {
-                pubkey: this.program,
+                pubkey: this.programId,
                 isSigner: false,
                 isWritable: false,
             },
-        ].concat(keys)
+            ...txBuilder.getInstructions()[0].keys.map((key) => ({ ...key, isSigner: false })),
+        ]
     }
 
     /**
@@ -1074,16 +946,15 @@ export class Endpoint {
      * @returns {Promise<boolean>} A promise that resolves to true if the message library program is the default send library, false otherwise.
      */
     async isDefaultSendLibrary(
-        connection: Connection,
+        rpc: RpcInterface,
         messageLibProgram: PublicKey,
         dstEid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<boolean> {
-        const [msgLib] = new pdaDeriver.MessageLibPDADeriver(messageLibProgram).messageLib()
-        const info = await this.getDefaultSendLibrary(connection, dstEid, commitmentOrConfig)
+        const [msgLib] = new MessageLibPDA(messageLibProgram).messageLib()
+        const info = await this.getDefaultSendLibrary(rpc, dstEid, commitment)
         if (info) {
-            // const [defaultSendLib] = new MessageLibPDADeriver(messageLibProgram).messageLib()
-            return info.msgLib.equals(msgLib)
+            return info.msgLib === msgLib
         }
         return false
     }
@@ -1098,15 +969,15 @@ export class Endpoint {
      * @returns {Promise<boolean>} A promise that resolves to true if the message library program is the default receive library, false otherwise.
      */
     async isDefaultReceiveLibrary(
-        connection: Connection,
+        rpc: RpcInterface,
         messageLibProgram: PublicKey,
         srcEid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<boolean> {
-        const [msgLib] = new pdaDeriver.MessageLibPDADeriver(messageLibProgram).messageLib()
-        const info = await this.getDefaultReceiveLibrary(connection, srcEid, commitmentOrConfig)
+        const [msgLib] = new MessageLibPDA(messageLibProgram).messageLib()
+        const info = await this.getDefaultReceiveLibrary(rpc, srcEid, commitment)
         if (info) {
-            return info.msgLib.equals(msgLib)
+            return info.msgLib === msgLib
         }
         return false
     }
@@ -1120,15 +991,11 @@ export class Endpoint {
      * @returns {Promise<EndpointSettings | null>} A promise that resolves to the endpoint settings or null if not found.
      */
     async getSetting(
-        connection: Connection,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<EndpointSettings | null> {
-        const [setting] = this.deriver.setting()
-        try {
-            return await accounts.EndpointSettings.fromAccountAddress(connection, setting, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        rpc: RpcInterface,
+        commitment: Commitment = 'confirmed'
+    ): Promise<accounts.EndpointSettings | null> {
+        const [setting] = this.pda.setting()
+        return accounts.safeFetchEndpointSettings({ rpc }, setting, { commitment })
     }
 
     /**
@@ -1140,17 +1007,13 @@ export class Endpoint {
      * @returns {Promise<MessageLibInfo | null>} A promise that resolves to the message library information or null if not found.
      */
     async getMessageLibInfo(
-        connection: Connection,
+        rpc: RpcInterface,
         messageLibProgram: PublicKey,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<MessageLibInfo | null> {
-        const [msgLib] = new pdaDeriver.MessageLibPDADeriver(messageLibProgram).messageLib()
-        const [messageLibInfo] = this.deriver.messageLibraryInfo(msgLib)
-        try {
-            return await accounts.MessageLibInfo.fromAccountAddress(connection, messageLibInfo, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        commitment: Commitment = 'confirmed'
+    ): Promise<accounts.MessageLibInfo | null> {
+        const [msgLib] = new MessageLibPDA(messageLibProgram).messageLib()
+        const [messageLibInfo] = this.pda.messageLibraryInfo(msgLib)
+        return accounts.safeFetchMessageLibInfo({ rpc }, messageLibInfo, { commitment })
     }
 
     /**
@@ -1162,30 +1025,28 @@ export class Endpoint {
      * @returns {Promise<{ msgLib: PublicKey; owner?: PublicKey } | null>} A promise that resolves to the default receive library or null if not found.
      */
     async getDefaultReceiveLibrary(
-        connection: Connection,
+        rpc: RpcInterface,
         srcEid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<{ msgLib: PublicKey; owner?: PublicKey } | null> {
-        const [defaultReceiveLibConfig] = this.deriver.defaultReceiveLibraryConfig(srcEid)
-        try {
-            const defaultInfo = await accounts.ReceiveLibraryConfig.fromAccountAddress(
-                connection,
-                defaultReceiveLibConfig,
-                commitmentOrConfig
-            )
-            const messageLibInfo = await connection.getAccountInfo(defaultInfo.messageLib, commitmentOrConfig)
-            // notice: BlockedMessageLib is not initialized its PDA, so it will be null if defaultInfo.messageLib is BlockedMessageLib
-            if (!messageLibInfo) {
-                return {
-                    msgLib: defaultInfo.messageLib,
-                }
-            }
+        const [defaultReceiveLibConfig] = this.pda.defaultReceiveLibraryConfig(srcEid)
+
+        const defaultInfo = await accounts.safeFetchReceiveLibraryConfig({ rpc }, defaultReceiveLibConfig, {
+            commitment,
+        })
+        if (defaultInfo == null) {
+            return null
+        }
+        const messageLibInfo = await rpc.getAccount(defaultInfo.messageLib, { commitment })
+        // notice: BlockedMessageLib is not initialized its PDA, so it will be null if defaultInfo.messageLib is BlockedMessageLib
+        if (!messageLibInfo.exists) {
             return {
-                owner: messageLibInfo.owner,
                 msgLib: defaultInfo.messageLib,
             }
-        } catch (e) {
-            return null
+        }
+        return {
+            owner: messageLibInfo.owner,
+            msgLib: defaultInfo.messageLib,
         }
     }
 
@@ -1198,30 +1059,26 @@ export class Endpoint {
      * @returns {Promise<{ msgLib: PublicKey; owner?: PublicKey } | null>} A promise that resolves to the default send library or null if not found.
      */
     async getDefaultSendLibrary(
-        connection: Connection,
+        rpc: RpcInterface,
         dstEid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<{ msgLib: PublicKey; owner?: PublicKey } | null> {
-        const [defaultSendLibConfig] = this.deriver.defaultSendLibraryConfig(dstEid)
-        try {
-            const defaultInfo = await accounts.SendLibraryConfig.fromAccountAddress(
-                connection,
-                defaultSendLibConfig,
-                commitmentOrConfig
-            )
-            const messageLibInfo = await connection.getAccountInfo(defaultInfo.messageLib, commitmentOrConfig)
-            // notice: BlockedMessageLib is not initialized its PDA, so it will be null if defaultInfo.messageLib is BlockedMessageLib
-            if (!messageLibInfo) {
-                return {
-                    msgLib: defaultInfo.messageLib,
-                }
-            }
+        const [defaultSendLibConfig] = this.pda.defaultSendLibraryConfig(dstEid)
+
+        const defaultInfo = await accounts.safeFetchSendLibraryConfig({ rpc }, defaultSendLibConfig, { commitment })
+        if (defaultInfo == null) {
+            return null
+        }
+        const messageLibInfo = await rpc.getAccount(defaultInfo.messageLib, { commitment })
+        // notice: BlockedMessageLib is not initialized its PDA, so it will be null if defaultInfo.messageLib is BlockedMessageLib
+        if (!messageLibInfo.exists) {
             return {
-                owner: messageLibInfo.owner,
                 msgLib: defaultInfo.messageLib,
             }
-        } catch (e) {
-            return null
+        }
+        return {
+            owner: messageLibInfo.owner,
+            msgLib: defaultInfo.messageLib,
         }
     }
 
@@ -1235,32 +1092,33 @@ export class Endpoint {
      * @returns {Promise<{ msgLib: PublicKey; programId?: PublicKey; isDefault: boolean } | null>} A promise that resolves to the configured send library or null if not found.
      */
     async getSendLibrary(
-        connection: Connection,
+        rpc: RpcInterface,
         oappPda: PublicKey,
         dstEid: number,
-        commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
-    ): Promise<{ msgLib: PublicKey; programId?: PublicKey; isDefault: boolean } | null> {
-        const [sendLibConfig] = this.deriver.sendLibraryConfig(oappPda, dstEid)
-        const [defaultSendLibConfig] = this.deriver.defaultSendLibraryConfig(dstEid)
-        const [defaultSendLibConfigBuf, sendLibConfigBuf] = await connection.getMultipleAccountsInfo(
+        commitment: Commitment = 'confirmed'
+    ): Promise<{ msgLib: PublicKey; programId?: PublicKey; isDefault: boolean }> {
+        const [sendLibConfig] = this.pda.sendLibraryConfig(oappPda, dstEid)
+        const [defaultSendLibConfig] = this.pda.defaultSendLibraryConfig(dstEid)
+        const [defaultSendLibConfigBuf, sendLibConfigBuf] = await rpc.getAccounts(
             [defaultSendLibConfig, sendLibConfig],
-            commitmentOrConfig
+            { commitment }
         )
-        if (!defaultSendLibConfigBuf || !sendLibConfigBuf) {
-            console.warn('send library not initialized, return empty array')
-            return null
+        if (!defaultSendLibConfigBuf.exists || !sendLibConfigBuf.exists) {
+            throw new Error(
+                `Unable to find defaultSendLibraryConfig/sendLibraryConfig account at ${defaultSendLibConfig}/${sendLibConfig}`
+            )
         }
-        const [sendLibConfigInfo] = accounts.SendLibraryConfig.fromAccountInfo(sendLibConfigBuf, 0)
-        const [defaultSendLibConfigInfo] = accounts.SendLibraryConfig.fromAccountInfo(defaultSendLibConfigBuf, 0)
+        const sendLibConfigInfo = accounts.deserializeSendLibraryConfig(sendLibConfigBuf)
+        const defaultSendLibConfigInfo = accounts.deserializeSendLibraryConfig(defaultSendLibConfigBuf)
         const msgLib =
             sendLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString()
                 ? defaultSendLibConfigInfo.messageLib
                 : sendLibConfigInfo.messageLib
         const isDefault = sendLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString()
-        const msgLibInfo = await connection.getAccountInfo(msgLib, commitmentOrConfig)
+        const msgLibInfo = await rpc.getAccount(msgLib, { commitment })
 
-        // notice: BlockedMessageLib is not initialized its PDA, so it will be null if msgLib is BlockedMessageLib
-        if (!msgLibInfo) {
+        // notice: BlockedMessageLib is not initialized its PDA, so programId will be null if msgLib is BlockedMessageLib
+        if (!msgLibInfo.exists) {
             return {
                 programId: undefined,
                 msgLib,
@@ -1285,66 +1143,59 @@ export class Endpoint {
      * @returns {Promise<{ msgLib: PublicKey; programId?: PublicKey; isDefault: boolean; timeout: { msgLib: PublicKey; expiry: bigint } | null } | null>} A promise that resolves to the configured receive library or null if not found.
      */
     async getReceiveLibrary(
-        connection: Connection,
+        rpc: RpcInterface,
         oappPda: PublicKey,
         srcEid: number,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<{
         msgLib: PublicKey // message library pda, it might be null if the message lib is blocked
         programId?: PublicKey
         isDefault: boolean
-        timeout: { msgLib: PublicKey; expiry: bigint } | null
-    } | null> {
-        const [receiveLibConfig] = this.deriver.receiveLibraryConfig(oappPda, srcEid)
-        const accountInfo = await connection.getAccountInfo(receiveLibConfig, commitmentOrConfig)
-        if (accountInfo == null) {
-            // throw new Error(`Unable to find MessageLibConfig account at ${sendLibPda}`)
-            return null
-        }
-        const [info] = accounts.ReceiveLibraryConfig.fromAccountInfo(accountInfo, 0)
-        if (info.messageLib.toString() == DefaultMessageLib.toString()) {
-            // use default message lib
-            const [defaultReceiveLibConfig] = this.deriver.defaultReceiveLibraryConfig(srcEid)
-            const defaultInfo = await accounts.ReceiveLibraryConfig.fromAccountAddress(
-                connection,
-                defaultReceiveLibConfig,
-                commitmentOrConfig
+        timeout?: { msgLib: PublicKey; expiry: bigint }
+    }> {
+        const [receiveLibConfig] = this.pda.receiveLibraryConfig(oappPda, srcEid)
+        const [defaultReceiveLibConfig] = this.pda.defaultReceiveLibraryConfig(srcEid)
+        const [defaultReceiveLibConfigBuf, receiveLibConfigBuf] = await rpc.getAccounts(
+            [defaultReceiveLibConfig, receiveLibConfig],
+            { commitment }
+        )
+        if (!defaultReceiveLibConfigBuf.exists || !receiveLibConfigBuf.exists) {
+            throw new Error(
+                `Unable to find defaultReceiveLibraryConfig/receiveLibraryConfig account at ${defaultReceiveLibConfig}/${receiveLibConfig}`
             )
-            const messageLibInfo = await connection.getAccountInfo(defaultInfo.messageLib, commitmentOrConfig)
-            if (messageLibInfo) {
-                const { timeout } = defaultInfo
-                if (timeout) {
-                    return {
-                        programId: defaultInfo.messageLib,
-                        msgLib: defaultInfo.messageLib,
-                        isDefault: true,
-                        timeout: { msgLib: timeout.messageLib, expiry: BigInt(timeout.expiry.toString()) },
-                    }
-                }
-            }
-            return {
-                programId: messageLibInfo?.owner,
-                msgLib: defaultInfo.messageLib,
-                isDefault: true,
-                timeout: null,
-            }
         }
-        const messageLibInfo = await connection.getAccountInfo(info.messageLib, commitmentOrConfig)
-        invariant(messageLibInfo, 'messageLibInfo should not be null')
-        const { timeout } = info
-        if (timeout) {
-            // const slot = await connection.getSlot()
-            // const timestamp = await connection.getBlockTime(slot)
-            // invariant(timestamp, 'timestamp should not be null')
-            // const isValid = parseInt(timeout.expiry.toString()) > timestamp
+        const receiveLibConfigInfo = accounts.deserializeReceiveLibraryConfig(receiveLibConfigBuf)
+        const defaultReceiveLibConfigInfo = accounts.deserializeReceiveLibraryConfig(defaultReceiveLibConfigBuf)
+        const finalReceiveLibConfigInfo =
+            receiveLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString()
+                ? defaultReceiveLibConfigInfo
+                : receiveLibConfigInfo
+        const msgLib = finalReceiveLibConfigInfo.messageLib
+        const isDefault = receiveLibConfigInfo.messageLib.toString() === DefaultMessageLib.toString()
+        const msgLibInfo = await rpc.getAccount(msgLib, { commitment })
+
+        const receiveTimeout = isSome(finalReceiveLibConfigInfo.timeout)
+            ? {
+                  msgLib: finalReceiveLibConfigInfo.timeout.value.messageLib,
+                  expiry: finalReceiveLibConfigInfo.timeout.value.expiry,
+              }
+            : undefined
+        // notice: BlockedMessageLib is not initialized its PDA, so programId will be undefined if msgLib is BlockedMessageLib
+        if (!msgLibInfo.exists) {
             return {
-                programId: messageLibInfo.owner,
-                msgLib: info.messageLib,
-                isDefault: false,
-                timeout: { msgLib: timeout.messageLib, expiry: BigInt(timeout.expiry.toString()) },
+                programId: undefined,
+                msgLib,
+                isDefault,
+                timeout: receiveTimeout,
             }
         }
-        return { programId: messageLibInfo.owner, msgLib: info.messageLib, isDefault: false, timeout: null }
+
+        return {
+            programId: msgLibInfo.owner,
+            msgLib,
+            isDefault,
+            timeout: receiveTimeout,
+        }
     }
 
     // rename to a more generic name
@@ -1361,20 +1212,16 @@ export class Endpoint {
      * @returns {Promise<PayloadHash | null>} A promise that resolves to the payload hash or null if not found.
      */
     async getInboundPayloadHash(
-        connection: Connection,
+        rpc: RpcInterface,
         receiver: PublicKey,
         srcEid: number,
         sender: Uint8Array,
         nonce: number,
         _payloadHash: Uint8Array,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<PayloadHash | null> {
-        const [payloadHashPDA] = this.deriver.payloadHash(receiver, srcEid, sender, nonce)
-        const accountInfo = await connection.getAccountInfo(payloadHashPDA, commitmentOrConfig)
-        if (!accountInfo) {
-            return null
-        }
-        return PayloadHash.fromAccountInfo(accountInfo, 0)[0]
+        commitment: Commitment = 'confirmed'
+    ): Promise<accounts.PayloadHash | null> {
+        const [payloadHashPDA] = this.pda.payloadHash(receiver, srcEid, sender, nonce)
+        return accounts.safeFetchPayloadHash({ rpc }, payloadHashPDA, { commitment })
     }
 
     /**
@@ -1387,24 +1234,14 @@ export class Endpoint {
      * @returns {Promise<ComposeMessageState | null>} A promise that resolves to the composed message state or null if not found.
      */
     async getComposedMessageState(
-        connection: Connection,
+        rpc: RpcInterface,
         from: PublicKey,
-        params: types.SendComposeParams,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<ComposeMessageState | null> {
-        const message = keccak_256(params.message)
-        const [composedMessagePDA] = this.deriver.composedMessage(
-            from,
-            Uint8Array.from(params.guid),
-            params.index,
-            params.to,
-            message
-        )
-        const accountInfo = await connection.getAccountInfo(composedMessagePDA, commitmentOrConfig)
-        if (!accountInfo) {
-            return null
-        }
-        return ComposeMessageState.fromAccountInfo(accountInfo, 0)[0]
+        params: instructions.SendComposeInstructionArgs,
+        commitment: Commitment = 'confirmed'
+    ): Promise<accounts.ComposeMessageState | null> {
+        const message = arrayify(keccak_256(params.message))
+        const [composedMessagePDA] = this.pda.composedMessage(from, params.guid, params.index, params.to, message)
+        return accounts.safeFetchComposeMessageState({ rpc }, composedMessagePDA, { commitment })
     }
 
     /**
@@ -1418,18 +1255,14 @@ export class Endpoint {
      * @returns {Promise<accounts.Nonce | null>} A promise that resolves to the nonce or null if not found.
      */
     async getNonce(
-        connection: Connection,
+        rpc: RpcInterface,
         oappIDPDA: PublicKey,
         remoteEid: number,
         remoteOappAddr: Uint8Array,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<accounts.Nonce | null> {
-        const [nonce] = this.deriver.nonce(oappIDPDA, remoteEid, remoteOappAddr)
-        try {
-            return await accounts.Nonce.fromAccountAddress(connection, nonce, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        const [nonce] = this.pda.nonce(oappIDPDA, remoteEid, remoteOappAddr)
+        return accounts.safeFetchNonce({ rpc }, nonce, { commitment })
     }
 
     /**
@@ -1443,18 +1276,14 @@ export class Endpoint {
      * @returns {Promise<accounts.PendingInboundNonce | null>} A promise that resolves to the pending inbound nonce or null if not found.
      */
     async getPendingInboundNonce(
-        connection: Connection,
+        rpc: RpcInterface,
         oappIDPDA: PublicKey,
         remoteEid: number,
         remoteOappAddr: Uint8Array,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+        commitment: Commitment = 'confirmed'
     ): Promise<accounts.PendingInboundNonce | null> {
-        const [nonce] = this.deriver.pendingNonce(oappIDPDA, remoteEid, remoteOappAddr)
-        try {
-            return await accounts.PendingInboundNonce.fromAccountAddress(connection, nonce, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+        const [nonce] = this.pda.pendingNonce(oappIDPDA, remoteEid, remoteOappAddr)
+        return accounts.safeFetchPendingInboundNonce({ rpc }, nonce, { commitment })
     }
 
     /**
@@ -1467,15 +1296,28 @@ export class Endpoint {
      * @returns {Promise<Version | null>} A promise that resolves to the version or null if not found.
      */
     async getMessageLibVersion(
-        connection: Connection,
+        rpc: RpcInterface,
         payer: PublicKey,
         messageLibProgram: PublicKey,
         commitment: Commitment = 'confirmed'
-    ): Promise<Version | null> {
-        const ix = SimpleMessageLibProgram.instructions.createVersionInstruction(messageLibProgram)
-
-        const simulateResp = await simulateTransaction(connection, [ix], messageLibProgram, payer, commitment)
-        const version = SimpleMessageLibProgram.types.versionBeet.read(simulateResp, 0)
+    ): Promise<Version> {
+        const msgLibProgramInWeb3Js = toWeb3JsPublicKey(messageLibProgram)
+        const version = await simulateWeb3JsTransaction(
+            rpc.getEndpoint(),
+            [
+                new TransactionInstruction({
+                    keys: [{ pubkey: msgLibProgramInWeb3Js, isSigner: false, isWritable: false }],
+                    data: Buffer.from(
+                        SimpleMessageLibProgram.instructions.getVersionInstructionDataSerializer().serialize({})
+                    ),
+                    programId: msgLibProgramInWeb3Js,
+                }),
+            ],
+            msgLibProgramInWeb3Js,
+            toWeb3JsPublicKey(payer),
+            SimpleMessageLibProgram.types.getVersionSerializer(),
+            commitment
+        )
         return version
     }
 
@@ -1488,31 +1330,18 @@ export class Endpoint {
      * @param {Commitment} [commitment='confirmed'] - The commitment level.
      * @returns {Promise<TransactionInstruction | null>} A promise that resolves to the transaction instruction or null if not needed.
      */
-    async transferAdmin(
-        connection: Connection,
-        admin: PublicKey,
-        newAdmin: PublicKey,
-        commitment: Commitment = 'confirmed'
-    ): Promise<TransactionInstruction | null> {
-        const [settingPDA] = this.deriver.setting()
-        const endpointSettings = await accounts.EndpointSettings.fromAccountAddress(connection, settingPDA, commitment)
-        if (endpointSettings.admin.toBase58() === newAdmin.toBase58()) {
-            console.warn('endpoint admin not need change')
-            return null
-        }
-        return instructions.createTransferAdminInstruction(
+    transferAdmin(admin: Signer, newAdmin: PublicKey): WrappedInstruction {
+        return instructions.transferAdmin(
+            { programs: this.programRepo },
             {
                 admin,
-                endpoint: settingPDA,
-                eventAuthority: this.eventAuthorityPDA,
-                program: this.program,
+                endpoint: this.pda.setting(),
+                eventAuthority: this.eventAuthority,
+                program: this.programId,
             },
             {
-                params: {
-                    admin: newAdmin,
-                },
-            },
-            this.program
-        )
+                admin: newAdmin,
+            }
+        ).items[0]
     }
 }