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

package/src/solita/uln.ts

@@ -0,0 +1,1045 @@
+import {
+    AccountMeta,
+    Commitment,
+    Connection,
+    GetAccountInfoConfig,
+    PublicKey,
+    TransactionInstruction,
+} from '@solana/web3.js'
+import BN from 'bn.js'
+import invariant from 'tiny-invariant'
+
+import { arrayify } from '@layerzerolabs/lz-utilities'
+import { PacketV1Codec } from '@layerzerolabs/lz-v2-utilities'
+
+import { EndpointProgram, MessageLibInterface, SetConfigType, SolanaPacketPath } from '.'
+import { DVN, accounts as DvnAccounts } from './dvn'
+import { Executor, accounts as ExecutorAccounts } from './executor'
+import { EndpointPDADeriver, EventPDADeriver, UlnPDADeriver } from './pda-deriver'
+import * as accounts from '../generated/solita/uln/accounts'
+import * as errors from '../generated/solita/uln/errors'
+import * as events from '../generated/solita/uln/events'
+import * as instructions from '../generated/solita/uln/instructions'
+import * as types from '../generated/solita/uln/types'
+
+export * from '../generated/solita/uln'
+export { accounts, instructions, types, events, errors }
+
+/**
+ * Interface representing the maximum message size.
+ */
+export interface MaxMessageSize {
+    /**
+     * The size of the message.
+     */
+    size: number
+
+    /**
+     * The kind of the message size.
+     */
+    __kind: 'MaxMessageSize'
+}
+
+/**
+ * Interface representing the outbound confirmations.
+ */
+export interface OutboundConfirmations {
+    /**
+     * The number of confirmations.
+     */
+    confirmations: number
+
+    /**
+     * The kind of the outbound confirmations.
+     */
+    __kind: 'OutboundConfirmations'
+}
+
+/**
+ * Interface representing the inbound confirmations.
+ */
+export interface InboundConfirmations {
+    /**
+     * The number of confirmations.
+     */
+    confirmations: number
+
+    /**
+     * The kind of the inbound confirmations.
+     */
+    __kind: 'InboundConfirmations'
+}
+
+/**
+ * Interface representing the oracles.
+ */
+export interface Oracles {
+    /**
+     * Indicates if custom oracles are used.
+     */
+    useCustomOracles: boolean
+
+    /**
+     * The array of oracle public keys.
+     */
+    oracles: PublicKey[]
+
+    /**
+     * The kind of the oracles.
+     */
+    __kind: 'Oracles'
+}
+
+/**
+ * Interface representing the optional oracles.
+ */
+export interface OptionalOracles {
+    /**
+     * Indicates if custom optional oracles are used.
+     */
+    useCustomOptionalOracles: boolean
+
+    /**
+     * The array of optional oracle public keys.
+     */
+    optionalOracles: PublicKey[]
+
+    /**
+     * The threshold for the optional oracles.
+     */
+    threshold: number
+
+    /**
+     * The kind of the optional oracles.
+     */
+    __kind: 'OptionalOracles'
+}
+
+/**
+ * Class representing the ULN (Ultra Light Node).
+ * @see {@link MessageLibInterface}
+ */
+export class Uln implements MessageLibInterface {
+    deriver: UlnPDADeriver
+    eventAuthorityPDA: PublicKey
+
+    /**
+     * Creates an instance of the Uln class.
+     *
+     * @param {PublicKey} program - The program public key.
+     */
+    constructor(public program: PublicKey) {
+        this.deriver = new UlnPDADeriver(program)
+        const [eventAuthorityPDA] = new EventPDADeriver(program).eventAuthority()
+        this.eventAuthorityPDA = eventAuthorityPDA
+    }
+
+    /**
+     * Initializes the ULN.
+     *
+     * @param {PublicKey} endpointProgram - The endpoint program public key.
+     * @param {PublicKey} payer - The payer public key.
+     * @param {PublicKey} admin - The admin public key.
+     * @param {number} eid - The endpoint ID.
+     * @returns {TransactionInstruction} The transaction instruction.
+     */
+    initUln(endpointProgram: PublicKey, payer: PublicKey, admin: PublicKey, eid: number): TransactionInstruction {
+        const [setting] = this.deriver.setting()
+        const [msgLib] = this.deriver.messageLib()
+        const [endpointAuth] = new EndpointPDADeriver(endpointProgram).messageLibraryInfo(msgLib)
+        // const info = await connection.getAccountInfo(setting, commitmentOrConfig)
+        // if (info) {
+        //     throw new Error('uln already initialized')
+        // }
+
+        return instructions.createInitUlnInstruction(
+            {
+                payer,
+                uln: setting,
+            } satisfies instructions.InitUlnInstructionAccounts,
+            {
+                params: {
+                    eid,
+                    admin,
+                    endpoint: endpointAuth,
+                    endpointProgram: endpointProgram,
+                } satisfies types.InitUlnParams,
+            } satisfies instructions.InitUlnInstructionArgs,
+            this.program
+        )
+    }
+
+    /**
+     * Initializes or updates the default configuration.
+     * before calling this function, you should call initUln to initialize the uln
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} admin - The admin public key.
+     * @param {number} eid - The endpoint ID.
+     * @param {types.UlnConfig} sendUlnConfig - The send ULN configuration.
+     * @param {types.UlnConfig} receiveUlnConfig - The receive ULN configuration.
+     * @param {types.ExecutorConfig} executorConfig - The executor configuration.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
+     */
+    async initOrUpdateDefaultConfig(
+        connection: Connection,
+        admin: PublicKey,
+        eid: number,
+        sendUlnConfig: types.UlnConfig,
+        receiveUlnConfig: types.UlnConfig,
+        executorConfig: types.ExecutorConfig,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<TransactionInstruction> {
+        const [setting] = this.deriver.setting()
+        const [sendConfigPDA] = this.deriver.defaultSendConfig(eid)
+        const [receiveConfigPDA] = this.deriver.defaultReceiveConfig(eid)
+        const configInfo = await connection.getAccountInfo(sendConfigPDA, commitmentOrConfig)
+        if (configInfo) {
+            // update default config
+            return instructions.createSetDefaultConfigInstruction(
+                {
+                    admin,
+                    uln: setting,
+                    sendConfig: sendConfigPDA,
+                    receiveConfig: receiveConfigPDA,
+                    eventAuthority: this.eventAuthorityPDA,
+                    program: this.program,
+                } satisfies instructions.SetDefaultConfigInstructionAccounts,
+                {
+                    params: {
+                        eid,
+                        sendUlnConfig,
+                        receiveUlnConfig,
+                        executorConfig,
+                    } satisfies types.SetDefaultConfigParams,
+                } satisfies instructions.SetDefaultConfigInstructionArgs,
+                this.program
+            )
+        } else {
+            // init default config
+            return instructions.createInitDefaultConfigInstruction(
+                {
+                    admin,
+                    uln: setting,
+                    sendConfig: sendConfigPDA,
+                    receiveConfig: receiveConfigPDA,
+                    eventAuthority: this.eventAuthorityPDA,
+                    program: this.program,
+                } satisfies instructions.InitDefaultConfigInstructionAccounts,
+                {
+                    params: {
+                        eid,
+                        sendUlnConfig,
+                        receiveUlnConfig,
+                        executorConfig,
+                    } satisfies types.InitDefaultConfigParams,
+                } satisfies instructions.InitDefaultConfigInstructionArgs,
+                this.program
+            )
+        }
+    }
+
+    // msg_lib -> msg_lib_program ->
+    /**
+     * Sets the treasury.
+     * before calling this function, you should call initUln to initialize the uln
+     *
+     * @param {PublicKey} admin - The admin public key.
+     * @param {object} treasury - The treasury object.
+     * @param {PublicKey} treasury.admin - The treasury admin public key.
+     * @param {PublicKey} treasury.nativeReceiver - The native receiver public key.
+     * @param {number} treasury.nativeFeeBps - The native fee basis points.
+     * @param {object} treasury.lzToken - The LZ token object.
+     * @param {PublicKey} treasury.lzToken.receiver - The LZ token receiver public key.
+     * @param {number} treasury.lzToken.fee - The LZ token fee.
+     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
+     */
+    async setTreasury(
+        admin: PublicKey,
+        treasury: {
+            admin: PublicKey
+            nativeReceiver: PublicKey
+            nativeFeeBps: number
+            lzToken: { receiver: PublicKey; fee: number } | null
+        } | null
+    ): Promise<TransactionInstruction> {
+        const [setting] = this.deriver.setting()
+        const ix = instructions.createSetTreasuryInstruction(
+            {
+                signer: admin,
+                uln: setting,
+                eventAuthority: this.eventAuthorityPDA,
+                program: this.program,
+            } satisfies instructions.SetTreasuryInstructionAccounts,
+            {
+                params: {
+                    treasury,
+                } satisfies types.SetTreasuryParams,
+            } satisfies instructions.SetTreasuryInstructionArgs,
+            this.program
+        )
+        return Promise.resolve(ix)
+    }
+
+    /**
+     * Transfers the admin role to a new admin.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} admin - The current admin public key.
+     * @param {PublicKey} newAdmin - The new admin public key.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
+     * @throws {Error} If the ULN is not initialized.
+     */
+    async transferAdmin(
+        connection: Connection,
+        admin: PublicKey,
+        newAdmin: PublicKey,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<TransactionInstruction> {
+        const [setting] = this.deriver.setting()
+        const info = await connection.getAccountInfo(setting, commitmentOrConfig)
+        if (!info) {
+            throw new Error('uln not initialized')
+        }
+        return instructions.createTransferAdminInstruction(
+            {
+                admin,
+                uln: setting,
+                eventAuthority: this.eventAuthorityPDA,
+                program: this.program,
+            } satisfies instructions.TransferAdminInstructionAccounts,
+            {
+                params: {
+                    admin: newAdmin,
+                } satisfies types.TransferAdminParams,
+            } satisfies instructions.TransferAdminInstructionArgs,
+            this.program
+        )
+    }
+
+    /**
+     * Gets the account metadata for the CPI (Cross-Program Invocation) of the quote instruction.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} _payer - The payer public key.
+     * @param {PacketPath} path - The packet path.
+     * @param {Commitment} [commitment] - The commitment level.
+     * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
+     */
+    async getQuoteIXAccountMetaForCPI(
+        connection: Connection,
+        _payer: PublicKey,
+        path: SolanaPacketPath,
+        commitment?: Commitment
+    ): Promise<AccountMeta[]> {
+        const { sender: sender_, dstEid } = path
+        const sender = new PublicKey(arrayify(sender_))
+        const [defaultSendConfig] = this.deriver.defaultSendConfig(dstEid)
+        const [sendConfig] = this.deriver.sendConfig(dstEid, sender)
+        const [setting] = this.deriver.setting()
+
+        const remainingAccounts = await this.getSendIxRemainingAccounts(connection, sender, dstEid, false, commitment)
+        const accounts = instructions.createQuoteInstructionAccounts(
+            {
+                endpoint: PublicKey.default, // useless
+                uln: setting,
+                sendConfig,
+                defaultSendConfig: defaultSendConfig,
+                anchorRemainingAccounts: remainingAccounts,
+            } satisfies instructions.QuoteInstructionAccounts,
+            this.program
+        )
+        return accounts.slice(1)
+    }
+
+    /**
+     * Gets the account metadata for the CPI (Cross-Program Invocation) of the send instruction.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} payer - The payer public key.
+     * @param {PacketPath} path - The packet path.
+     * @param {Commitment} [commitment='confirmed'] - The commitment level.
+     * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
+     */
+    async getSendIXAccountMetaForCPI(
+        connection: Connection,
+        payer: PublicKey,
+        path: SolanaPacketPath,
+        commitment: Commitment = 'confirmed'
+    ): Promise<AccountMeta[]> {
+        const { sender: sender_, dstEid } = path
+        const sender = new PublicKey(arrayify(sender_))
+        const [sendConfig] = this.deriver.sendConfig(dstEid, sender)
+        const [defaultSendConfig] = this.deriver.defaultSendConfig(dstEid)
+
+        const [setting] = this.deriver.setting()
+        const ulnState = await this.getSetting(connection, commitment)
+        const treasury = ulnState?.treasury?.nativeReceiver
+        const remainingAccounts = await this.getSendIxRemainingAccounts(connection, sender, dstEid, true, commitment)
+        const accounts = instructions.createSendInstructionAccounts(
+            {
+                endpoint: PublicKey.default, // useless
+                uln: setting,
+                sendConfig,
+                defaultSendConfig,
+                payer,
+                treasury,
+                eventAuthority: this.eventAuthorityPDA,
+                program: this.program,
+                anchorRemainingAccounts: remainingAccounts,
+            } satisfies instructions.SendInstructionAccounts,
+            this.program
+        )
+        accounts.forEach((key) => {
+            if (!payer.equals(key.pubkey)) {
+                key.isSigner = false
+            }
+        })
+
+        if (treasury) {
+            const treasuryIndex = accounts.findIndex((k) => k.pubkey.toBase58() == treasury.toBase58())
+            accounts[treasuryIndex].isWritable = true // treasury account
+        }
+        return accounts.slice(1)
+    }
+
+    // 3 RPC requests
+    /**
+     * Gets the remaining accounts for the send instruction.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} sender - The sender public key.
+     * @param {number} dstEid - The destination endpoint ID.
+     * @param {boolean} payment - Indicates if payment is required.
+     * @param {Commitment | GetAccountInfoConfig} [commitment='confirmed'] - The commitment level or account info configuration.
+     * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
+     */
+    async getSendIxRemainingAccounts(
+        connection: Connection,
+        sender: PublicKey,
+        dstEid: number,
+        payment: boolean,
+        commitment: Commitment | GetAccountInfoConfig = 'confirmed'
+    ): Promise<AccountMeta[]> {
+        const { executor, dvns } = await this.getWorkers(connection, sender, dstEid, commitment)
+
+        const priceFeeds = new Array<PublicKey>()
+        ;[executor.config, ...dvns.map((dvn) => dvn.config)].forEach((config) => {
+            if (!priceFeeds.find((p) => p.equals(config.priceFeed))) {
+                priceFeeds.push(config.priceFeed)
+            }
+        })
+        const priceFeedInfos = await connection.getMultipleAccountsInfo(priceFeeds, commitment)
+        const priceFeedDict = priceFeedInfos.reduce((acc, info, i) => {
+            invariant(info, `priceFeed:${priceFeeds[i].toBase58()} not initialized`)
+            acc.set(priceFeeds[i].toBase58(), info.owner)
+            return acc
+        }, new Map<string, PublicKey>())
+        const executorAccounts = new Executor(executor.owner).getQuoteIXAccountMetaForCPI(
+            executor.config.priceFeed,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            priceFeedDict.get(executor.config.priceFeed.toBase58())!,
+            payment
+        )
+        const dvnAccounts = dvns.map((p, i) => {
+            return new DVN(p.owner).getQuoteIXAccountMetaForCPI(
+                p.config.priceFeed,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                priceFeedDict.get(p.config.priceFeed.toBase58())!,
+                payment
+            )
+        })
+        return executorAccounts.concat(dvnAccounts.flat())
+    }
+
+    /**
+     * Gets all workers (executor and DVN).
+     * 2 RPC requests
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} sender - The sender public key.
+     * @param {number} eid - The endpoint ID.
+     * @param {Commitment | GetAccountInfoConfig} [commitment='confirmed'] - The commitment level or account info configuration.
+     * @returns {Promise<{ executor: { config: ExecutorAccounts.ExecutorConfig; owner: PublicKey }; dvns: { config: DvnAccounts.DvnConfig; owner: PublicKey }[] }>} A promise that resolves to an object containing the executor and DVN configurations.
+     */
+    async getWorkers(
+        connection: Connection,
+        sender: PublicKey,
+        eid: number,
+        commitment: Commitment | GetAccountInfoConfig = 'confirmed'
+    ): Promise<{
+        executor: { config: ExecutorAccounts.ExecutorConfig; owner: PublicKey }
+        dvns: { config: DvnAccounts.DvnConfig; owner: PublicKey }[]
+    }> {
+        const [defaultSendConfig] = this.deriver.defaultSendConfig(eid)
+        const [sendConfig] = this.deriver.sendConfig(eid, sender)
+        const [defaultSendConfigBuf, sendConfigBuf] = await connection.getMultipleAccountsInfo(
+            [defaultSendConfig, sendConfig],
+            commitment
+        )
+        invariant(defaultSendConfigBuf, 'defaultSendConfig not initialized')
+
+        const [defaultSendConfigState] = accounts.SendConfig.fromAccountInfo(defaultSendConfigBuf)
+        let {
+            executor,
+            uln: { requiredDvns, optionalDvns },
+        } = defaultSendConfigState
+        const sendConfigState = sendConfigBuf ? accounts.SendConfig.fromAccountInfo(sendConfigBuf)[0] : null
+
+        // if the executor is set in the send config, use it
+        if (sendConfigState?.executor && !sendConfigState.executor.executor.equals(PublicKey.default)) {
+            ;({ executor } = sendConfigState)
+        }
+
+        // if the requiredDvns is set in the send config, use it
+        if (sendConfigState && sendConfigState.uln.requiredDvns.length > 0) {
+            requiredDvns = sendConfigState.uln.requiredDvns.filter((p) => {
+                return !p.equals(PublicKey.default)
+            })
+        }
+
+        // if the optionalDvns is set in the send config, use it
+        if (sendConfigState && sendConfigState.uln.optionalDvns.length > 0) {
+            optionalDvns = sendConfigState.uln.optionalDvns.filter((p) => {
+                return !p.equals(PublicKey.default)
+            })
+        }
+        const dvns = requiredDvns.concat(optionalDvns)
+        const [executorBuf, ...dvnBuf] = await connection.getMultipleAccountsInfo(
+            [executor.executor, ...dvns],
+            commitment
+        )
+        invariant(executorBuf, `executor:${executor.executor.toBase58()} not initialized`)
+
+        return {
+            executor: {
+                config: ExecutorAccounts.ExecutorConfig.fromAccountInfo(executorBuf)[0],
+                owner: executorBuf.owner,
+            },
+            dvns: dvnBuf.map((dvn, i) => {
+                invariant(dvn, `dvn:${dvns[i].toBase58()} not initialized`)
+                return {
+                    config: DvnAccounts.DvnConfig.fromAccountInfo(dvn)[0],
+                    owner: dvn.owner,
+                }
+            }),
+        }
+    }
+
+    /**
+     * Initializes the verification process.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} payer - The payer public key.
+     * @param {PublicKey} dvn - The DVN public key.
+     * @param {Uint8Array} packetBytes - The packet bytes.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<TransactionInstruction | null>} A promise that resolves to the transaction instruction or null if not needed.
+     */
+    async initVerify(
+        connection: Connection,
+        payer: PublicKey,
+        dvn: PublicKey,
+        packetBytes: Uint8Array,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<TransactionInstruction | null> {
+        const packet = PacketV1Codec.fromBytes(packetBytes)
+        const headerHash = packet.headerHash()
+        const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
+        const payloadHash = packet.payloadHash()
+        const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
+        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
+        const confirmationsInfo = await connection.getAccountInfo(confirmationsPDA, commitmentOrConfig)
+        if (confirmationsInfo) {
+            // throw new Error('init verify already executed')
+            return null
+        }
+        return instructions.createInitVerifyInstruction(
+            {
+                payer,
+                confirmations: confirmationsPDA,
+            } satisfies instructions.InitVerifyInstructionAccounts,
+            {
+                params: {
+                    packetHeader: Array.from(Uint8Array.from(Buffer.from(packet.header().slice(2), 'hex'))),
+                    payloadHash: Array.from(payloadHashBytes),
+                    dvn,
+                } satisfies types.InitVerifyParams,
+            } satisfies instructions.InitVerifyInstructionArgs,
+            this.program
+        )
+    }
+
+    /**
+     * Verifies the packet.
+     *
+     * @param {PublicKey} dvn - The DVN public key.
+     * @param {Uint8Array} packetBytes - The packet bytes.
+     * @param {number | string} confirmations - The number of confirmations.
+     * @returns {TransactionInstruction} The transaction instruction.
+     */
+    verify(dvn: PublicKey, packetBytes: Uint8Array, confirmations: number | string): TransactionInstruction {
+        const packet = PacketV1Codec.fromBytes(packetBytes)
+        const headerHash = packet.headerHash()
+        const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
+        const payloadHash = packet.payloadHash()
+        const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
+        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
+        return instructions.createVerifyInstruction(
+            {
+                dvn,
+                confirmations: confirmationsPDA,
+                eventAuthority: this.eventAuthorityPDA,
+                program: this.program,
+            } satisfies instructions.VerifyInstructionAccounts,
+            {
+                params: {
+                    packetHeader: Array.from(Uint8Array.from(Buffer.from(packet.header().slice(2), 'hex'))),
+                    payloadHash: Array.from(payloadHashBytes),
+                    confirmations: typeof confirmations === 'string' ? new BN(confirmations) : confirmations,
+                } satisfies types.VerifyParams,
+            } satisfies instructions.VerifyInstructionArgs,
+            this.program
+        )
+    }
+
+    /**
+     * Closes the verification process.
+     *
+     * @param {PublicKey} dvn - The DVN public key.
+     * @param {PublicKey} receiver - The receiver public key.
+     * @param {Uint8Array} packetBytes - The packet bytes.
+     * @returns {TransactionInstruction} The transaction instruction.
+     */
+    closeVerify(dvn: PublicKey, receiver: PublicKey, packetBytes: Uint8Array): TransactionInstruction {
+        const packet = PacketV1Codec.fromBytes(packetBytes)
+        const headerHash = packet.headerHash()
+        const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
+        const payloadHash = packet.payloadHash()
+        const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
+        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
+        return instructions.createCloseVerifyInstruction(
+            {
+                dvn,
+                receiver,
+                confirmations: confirmationsPDA,
+            } satisfies instructions.CloseVerifyInstructionAccounts,
+            {
+                params: {
+                    packetHeaderHash: Array.from(headerHashBytes),
+                    payloadHash: Array.from(payloadHashBytes),
+                } satisfies types.CloseVerifyParams,
+            } satisfies instructions.CloseVerifyInstructionArgs,
+            this.program
+        )
+    }
+
+    /**
+     * Checks if the DVN is verified.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} endpointProgram - The endpoint program public key.
+     * @param {PublicKey} dvn - The DVN public key.
+     * @param {Uint8Array} packetBytes - The packet bytes.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig='confirmed'] - The commitment level or account info configuration.
+     * @returns {Promise<boolean>} A promise that resolves to true if the DVN is verified, false otherwise.
+     */
+    async isDvnVerified(
+        connection: Connection,
+        endpointProgram: PublicKey,
+        dvn: PublicKey,
+        packetBytes: Uint8Array,
+        commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
+    ): Promise<boolean> {
+        const packet = PacketV1Codec.fromBytes(packetBytes)
+        const headerHash = packet.headerHash()
+        const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
+        const payloadHash = packet.payloadHash()
+        const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
+        const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, dvn)
+        const endpoint = new EndpointProgram.Endpoint(endpointProgram)
+        const receiver = new PublicKey(arrayify(packet.receiver()))
+        const sender = arrayify(packet.sender())
+        const nonce = await endpoint.getNonce(connection, receiver, packet.srcEid(), sender, commitmentOrConfig)
+        const pendingNonce = await endpoint.getPendingInboundNonce(
+            connection,
+            receiver,
+            packet.srcEid(),
+            sender,
+            commitmentOrConfig
+        )
+        if (!nonce || !pendingNonce) {
+            return false
+        }
+
+        // after lzReceive, the inboundNonce is increased by 1
+        if (parseInt(nonce.inboundNonce.toString()) >= parseInt(packet.nonce())) {
+            return true
+        }
+        // after commitVerification, the nonce is added to pendingNonce
+        if (pendingNonce.nonces.find((n) => n.toString() === packet.nonce()) !== undefined) {
+            return true
+        }
+        try {
+            // before commitVerification, should call initVerify and verify
+            const confirmation = await accounts.Confirmations.fromAccountAddress(
+                connection,
+                confirmationsPDA,
+                commitmentOrConfig
+            )
+            if (confirmation.value === null) {
+                // initial value is null
+                // not verified
+                return false
+            } else {
+                // TODO check confirmation value
+                return true
+            }
+        } catch (e: unknown) {
+            // don't invoke initVerify
+            return false
+        }
+    }
+
+    /**
+     * Commits the verification process.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} endpointProgram - The endpoint program public key.
+     * @param {Uint8Array} packetBytes - The packet bytes.
+     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
+     */
+    async commitVerification(
+        connection: Connection,
+        endpointProgram: PublicKey,
+        packetBytes: Uint8Array
+    ): Promise<TransactionInstruction> {
+        const packet = PacketV1Codec.fromBytes(packetBytes)
+        const payloadHash = packet.payloadHash()
+        const srcEid = packet.srcEid()
+        const receiver = new PublicKey(arrayify(packet.receiver()))
+        const payloadHashBytes = Uint8Array.from(Buffer.from(payloadHash.slice(2), 'hex'))
+        const [defaultReceiveConfig] = this.deriver.defaultReceiveConfig(srcEid)
+        const [receiveConfig] = this.deriver.receiveConfig(srcEid, receiver)
+        const [setting] = this.deriver.setting()
+        const [msgLib] = this.deriver.messageLib()
+        const receiveConfigState = await this.getFinalReceiveConfigState(connection, receiver, srcEid)
+
+        const headerHash = packet.headerHash()
+        const headerHashBytes = Uint8Array.from(Buffer.from(headerHash.slice(2), 'hex'))
+
+        const confirmations: AccountMeta[] = receiveConfigState.uln.requiredDvns
+            .concat(receiveConfigState.uln.optionalDvns)
+            .map((p) => {
+                const [confirmationsPDA] = this.deriver.confirmations(headerHashBytes, payloadHashBytes, p)
+                return {
+                    pubkey: confirmationsPDA,
+                    isSigner: false,
+                    isWritable: true,
+                }
+            })
+        const endpoint = new EndpointProgram.Endpoint(endpointProgram)
+        const verifyAccounts = endpoint.getVerifyIXAccountMetaForCPI(packet, msgLib)
+
+        return instructions.createCommitVerificationInstruction(
+            {
+                uln: setting,
+                defaultReceiveConfig,
+                receiveConfig,
+                anchorRemainingAccounts: confirmations.concat(verifyAccounts),
+            } satisfies instructions.CommitVerificationInstructionAccounts,
+            {
+                params: {
+                    packetHeader: Array.from(arrayify(packet.header())),
+                    payloadHash: Array.from(payloadHashBytes),
+                } satisfies types.CommitVerificationParams,
+            } satisfies instructions.CommitVerificationInstructionArgs,
+            this.program
+        )
+    }
+
+    /**
+     * Gets the account metadata for the CPI (Cross-Program Invocation) of the init config instruction.
+     *
+     * @param {PublicKey} payer - The payer public key.
+     * @param {PublicKey} oappID - The OApp ID public key.
+     * @param {number} eid - The endpoint ID.
+     * @returns {AccountMeta[]} An array of account metadata.
+     */
+    getInitConfigIXAccountMetaForCPI(payer: PublicKey, oappID: PublicKey, eid: number): AccountMeta[] {
+        const [sendConfig] = this.deriver.sendConfig(eid, oappID)
+        const [receiveConfig] = this.deriver.receiveConfig(eid, oappID)
+        const [setting] = this.deriver.setting()
+
+        const accounts = instructions.createInitConfigInstructionAccounts(
+            {
+                endpoint: PublicKey.default, // useless
+                payer,
+                uln: setting,
+                sendConfig,
+                receiveConfig,
+            } satisfies instructions.InitConfigInstructionAccounts,
+            this.program
+        )
+        accounts.forEach((key) => {
+            if (!payer.equals(key.pubkey)) {
+                key.isSigner = false
+            }
+        })
+        return accounts.slice(1)
+    }
+
+    /**
+     * Constructs the set config data.
+     *
+     * @param {SetConfigType} configType - The configuration type.
+     * @param {types.ExecutorConfig | types.UlnConfig} configData - The configuration data.
+     * @returns {Uint8Array} The constructed set config data.
+     * @throws {Error} If the configuration type is invalid.
+     */
+    static constructSetConfigData(
+        configType: SetConfigType,
+        configData: types.ExecutorConfig | types.UlnConfig
+    ): Uint8Array {
+        switch (configType) {
+            case SetConfigType.EXECUTOR: {
+                const [data] = types.executorConfigBeet.serialize(configData as types.ExecutorConfig)
+                return Uint8Array.from(data)
+            }
+            case SetConfigType.SEND_ULN:
+            case SetConfigType.RECEIVE_ULN: {
+                const [data] = types.ulnConfigBeet.serialize(configData as types.UlnConfig)
+                return Uint8Array.from(data)
+            }
+            default:
+                throw new Error(`invalid config type: ${configType as number}`)
+        }
+    }
+
+    /**
+     * Gets the account metadata for the CPI (Cross-Program Invocation) of the set config instruction.
+     *
+     * @param {PublicKey} endpointProgram - The endpoint program public key.
+     * @param {PublicKey} oappID - The OApp ID public key.
+     * @param {number} eid - The endpoint ID.
+     * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account metadata.
+     */
+    async getSetConfigIXAccountMetaForCPI(
+        endpointProgram: PublicKey,
+        oappID: PublicKey,
+        eid: number
+    ): Promise<AccountMeta[]> {
+        const [sendConfig] = this.deriver.sendConfig(eid, oappID)
+        const [receiveConfig] = this.deriver.receiveConfig(eid, oappID)
+        const [defaultSendConfig] = this.deriver.defaultSendConfig(eid)
+        const [defaultReceiveConfig] = this.deriver.defaultReceiveConfig(eid)
+        const [setting] = this.deriver.setting()
+        const [msgLib] = this.deriver.messageLib()
+        const [msgLibInfo] = new EndpointPDADeriver(endpointProgram).messageLibraryInfo(msgLib)
+
+        const accounts = instructions.createSetConfigInstructionAccounts(
+            {
+                endpoint: msgLibInfo,
+                uln: setting,
+                sendConfig,
+                defaultSendConfig,
+                defaultReceiveConfig,
+                receiveConfig,
+                eventAuthority: this.eventAuthorityPDA,
+                program: this.program,
+            } satisfies instructions.SetConfigInstructionAccounts,
+            this.program
+        )
+        return Promise.resolve(accounts.slice(1))
+    }
+
+    //
+    // all of below functions are retrieving accounts state
+    /**
+     * Gets the ULN settings.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<accounts.UlnSettings | null>} A promise that resolves to the ULN settings or null if not found.
+     */
+    async getSetting(
+        connection: Connection,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<accounts.UlnSettings | null> {
+        const [setting] = this.deriver.setting()
+        try {
+            return await accounts.UlnSettings.fromAccountAddress(connection, setting, commitmentOrConfig)
+        } catch (e) {
+            return null
+        }
+    }
+
+    /**
+     * Gets the default send configuration state.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {number} eid - The endpoint ID.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<accounts.SendConfig | null>} A promise that resolves to the default send configuration state or null if not found.
+     */
+    async getDefaultSendConfigState(
+        connection: Connection,
+        eid: number,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<accounts.SendConfig | null> {
+        const [config] = this.deriver.defaultSendConfig(eid)
+        try {
+            return await accounts.SendConfig.fromAccountAddress(connection, config, commitmentOrConfig)
+        } catch (e) {
+            return null
+        }
+    }
+
+    /**
+     * Gets the send configuration state.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} sender - The sender public key.
+     * @param {number} eid - The endpoint ID.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<accounts.SendConfig | null>} A promise that resolves to the send configuration state or null if not found.
+     */
+    async getSendConfigState(
+        connection: Connection,
+        sender: PublicKey,
+        eid: number,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<accounts.SendConfig | null> {
+        const [config] = this.deriver.sendConfig(eid, sender)
+        try {
+            return await accounts.SendConfig.fromAccountAddress(connection, config, commitmentOrConfig)
+        } catch (e) {
+            return null
+        }
+    }
+
+    /**
+     * Gets the default receive configuration state.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {number} eid - The endpoint ID.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<accounts.ReceiveConfig | null>} A promise that resolves to the default receive configuration state or null if not found.
+     */
+    async getDefaultReceiveConfigState(
+        connection: Connection,
+        eid: number,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<accounts.ReceiveConfig | null> {
+        const [config] = this.deriver.defaultReceiveConfig(eid)
+        try {
+            return await accounts.ReceiveConfig.fromAccountAddress(connection, config, commitmentOrConfig)
+        } catch (e) {
+            return null
+        }
+    }
+
+    /**
+     * Gets the receive configuration state.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} receiver - The receiver public key.
+     * @param {number} eid - The endpoint ID.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment level or account info configuration.
+     * @returns {Promise<accounts.ReceiveConfig | null>} A promise that resolves to the receive configuration state or null if not found.
+     */
+    async getReceiveConfigState(
+        connection: Connection,
+        receiver: PublicKey,
+        eid: number,
+        commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    ): Promise<accounts.ReceiveConfig | null> {
+        const [config] = this.deriver.receiveConfig(eid, receiver)
+        try {
+            return await accounts.ReceiveConfig.fromAccountAddress(connection, config, commitmentOrConfig)
+        } catch (e) {
+            return null
+        }
+    }
+
+    /**
+     * Gets the final receive configuration state.
+     *
+     * @param {Connection} connection - The connection to the Solana cluster.
+     * @param {PublicKey} receiver - The receiver public key.
+     * @param {number} eid - The endpoint ID.
+     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig='confirmed'] - The commitment level or account info configuration.
+     * @returns {Promise<accounts.ReceiveConfig>} A promise that resolves to the final receive configuration state.
+     * @throws {Error} If no DVN is found.
+     */
+    async getFinalReceiveConfigState(
+        connection: Connection,
+        receiver: PublicKey,
+        eid: number,
+        commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed'
+    ): Promise<accounts.ReceiveConfig> {
+        const NIL_CONFIRMATIONS = '18446744073709551615' // max u64
+        const NIL_DVN_COUNT = '255'
+
+        const rtn_config: types.UlnConfig = {
+            confirmations: 0,
+            requiredDvnCount: 0,
+            optionalDvnCount: 0,
+            optionalDvnThreshold: 0,
+            requiredDvns: [],
+            optionalDvns: [],
+        }
+
+        const [defaultConfig] = this.deriver.defaultReceiveConfig(eid)
+        const [customConfig] = this.deriver.receiveConfig(eid, receiver)
+
+        const [defaultConfigInfo, customConfigInfo] = await connection.getMultipleAccountsInfo(
+            [defaultConfig, customConfig],
+            commitmentOrConfig
+        )
+        if (defaultConfigInfo == null) {
+            throw new Error(`please init default receive config first. ${defaultConfig.toBase58()}`)
+        }
+        const defaultConfigState = accounts.ReceiveConfig.fromAccountInfo(defaultConfigInfo)[0]
+        const customConfigState = customConfigInfo ? accounts.ReceiveConfig.fromAccountInfo(customConfigInfo)[0] : null
+
+        if (customConfigState == null || customConfigState.uln.confirmations == 0) {
+            rtn_config.confirmations = defaultConfigState.uln.confirmations
+        } else if (customConfigState.uln.confirmations.toString() !== NIL_CONFIRMATIONS) {
+            rtn_config.confirmations = customConfigState.uln.confirmations
+        }
+
+        if (customConfigState == null || customConfigState.uln.requiredDvnCount == 0) {
+            if (defaultConfigState.uln.requiredDvnCount > 0) {
+                rtn_config.requiredDvns = defaultConfigState.uln.requiredDvns
+                rtn_config.requiredDvnCount = defaultConfigState.uln.requiredDvnCount
+            }
+        } else if (customConfigState.uln.requiredDvnCount.toString() !== NIL_DVN_COUNT) {
+            rtn_config.requiredDvns = customConfigState.uln.requiredDvns
+            rtn_config.requiredDvnCount = customConfigState.uln.requiredDvnCount
+        }
+
+        if (customConfigState == null || customConfigState.uln.optionalDvnCount == 0) {
+            if (defaultConfigState.uln.optionalDvnCount > 0) {
+                rtn_config.optionalDvns = defaultConfigState.uln.optionalDvns
+                rtn_config.optionalDvnCount = defaultConfigState.uln.optionalDvnCount
+                rtn_config.optionalDvnThreshold = defaultConfigState.uln.optionalDvnThreshold
+            }
+        } else if (customConfigState.uln.optionalDvnCount.toString() !== NIL_DVN_COUNT) {
+            rtn_config.optionalDvns = customConfigState.uln.optionalDvns
+            rtn_config.optionalDvnCount = customConfigState.uln.optionalDvnCount
+            rtn_config.optionalDvnThreshold = customConfigState.uln.optionalDvnThreshold
+        }
+
+        if (rtn_config.requiredDvnCount === 0 && rtn_config.optionalDvnCount === 0) {
+            throw new Error('no dvn')
+        }
+
+        return accounts.ReceiveConfig.fromArgs({
+            bump: defaultConfigState.bump,
+            uln: rtn_config,
+        })
+    }
+}