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

package/src/dvn.ts

@@ -1,36 +1,38 @@
 import {
     AccountMeta,
+    Cluster,
+    ClusterFilter,
     Commitment,
-    Connection,
-    GetAccountInfoConfig,
+    Instruction,
+    Program,
+    ProgramError,
+    ProgramRepositoryInterface,
     PublicKey,
-    TransactionInstruction,
-} from '@solana/web3.js'
+    RpcInterface,
+    Signer,
+    WrappedInstruction,
+    createNullRpc,
+    defaultPublicKey,
+    publicKey,
+} from '@metaplex-foundation/umi'
+import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
 
-import { EndpointId } from '@layerzerolabs/lz-definitions'
 import { HashSigner, keccak_256 } from '@layerzerolabs/lz-foundation'
+import { PacketV1Codec, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
 
-import { InitDvnParams, MultisigConfig, multisigConfigBeet } from './generated/dvn'
-import * as accounts from './generated/dvn/accounts'
-import * as errors from './generated/dvn/errors'
-import * as events from './generated/dvn/events'
-import * as instructions from './generated/dvn/instructions'
-import * as types from './generated/dvn/types'
-import { DVNDeriver, EventPDADeriver, PriceFeedPDADeriver } from './pda-deriver'
+import { EndpointProgram, UlnProgram } from '.'
+import * as accounts from './generated/kinobi/dvn/accounts'
+import * as errors from './generated/kinobi/dvn/errors'
+import * as events from './generated/kinobi/dvn/events'
+import * as instructions from './generated/kinobi/dvn/instructions'
+import { QuoteDvnInstructionArgs } from './generated/kinobi/dvn/instructions'
+import * as types from './generated/kinobi/dvn/types'
+import { DvnPDA, EndpointPDA, EventPDA, PriceFeedPDA } from './pda'
 
 export { accounts, errors, instructions, types, events }
-export { PROGRAM_ID } from './generated/dvn'
+export { DVN_PROGRAM_ID } from './generated/kinobi/dvn'
 
-/**
- * Interface representing a sign function.
- */
 export interface SignFunc {
-    /**
-     * Signs a message.
-     *
-     * @param {Buffer} message - The message to sign.
-     * @returns {Promise<{ signature: Uint8Array; recoveryId: number }[]>} A promise that resolves to an array of signature objects.
-     */
     sign(message: Buffer): Promise<
         {
             signature: Uint8Array
@@ -39,9 +41,6 @@ export interface SignFunc {
     >
 }
 
-/**
- * Class representing a Solana signer extension.
- */
 export class SolanaSignerExt implements SignFunc {
     private readonly signers: HashSigner[]
 
@@ -49,22 +48,10 @@ export class SolanaSignerExt implements SignFunc {
         this.signers = signers
     }
 
-    /**
-     * Creates an instance of the SolanaSignerExt class.
-     *
-     * @param {HashSigner[]} signers - The signers.
-     * @returns {SolanaSignerExt} The SolanaSignerExt instance.
-     */
     static from(signers: HashSigner[]): SolanaSignerExt {
         return new SolanaSignerExt(signers)
     }
 
-    /**
-     * Signs a message.
-     *
-     * @param {Buffer} message - The message to sign.
-     * @returns {Promise<{ signature: Uint8Array; recoveryId: number }[]>} A promise that resolves to an array of signature objects.
-     */
     async sign(message: Buffer): Promise<{ signature: Uint8Array; recoveryId: number }[]> {
         return Promise.all(
             this.signers.map(async (s) => {
@@ -75,65 +62,65 @@ export class SolanaSignerExt implements SignFunc {
     }
 }
 
-/**
- * Class representing a DVN (Decentralized Validator Network).
- */
 export class DVN {
-    dvnDeriver: DVNDeriver
-    vid: number
-    eventAuthority: PublicKey
-
-    /**
-     * Creates an instance of the DVN class.
-     *
-     * @param {PublicKey} programId - The program ID.
-     * @param {EndpointId} [endpointId=EndpointId.SOLANA_V2_SANDBOX] - The endpoint ID.
-     */
+    public readonly pda: DvnPDA
+    public readonly eventAuthority: PublicKey
+    public readonly programRepo: ProgramRepositoryInterface
+
     constructor(
         readonly programId: PublicKey,
-        endpointId: EndpointId = EndpointId.SOLANA_V2_SANDBOX
+        rpc?: RpcInterface
     ) {
-        this.dvnDeriver = new DVNDeriver(programId)
-        this.vid = endpointId % 30000
-        this.eventAuthority = new EventPDADeriver(programId).eventAuthority()[0]
+        this.pda = new DvnPDA(programId)
+        // this.vid = endpointId % 30000
+        this.eventAuthority = new EventPDA(programId).eventAuthority()[0]
+        if (rpc === undefined) {
+            rpc = createNullRpc()
+            rpc.getCluster = (): Cluster => 'custom'
+        }
+        this.programRepo = createDefaultProgramRepository({ rpc }, [
+            {
+                name: 'dvn',
+                publicKey: programId,
+                getErrorFromCode(code: number, cause?: Error): ProgramError | null {
+                    return errors.getDvnErrorFromCode(code, this, cause)
+                },
+                getErrorFromName(name: string, cause?: Error): ProgramError | null {
+                    return errors.getDvnErrorFromName(name, this, cause)
+                },
+                isOnCluster(): boolean {
+                    return true
+                },
+            } satisfies Program,
+        ])
     }
 
-    /**
-     * Initializes the DVN.
-     *
-     * @param {Connection} connection - The connection.
-     * @param {PublicKey} payer - The payer.
-     * @param {InitDvnParams} params - The initialization parameters.
-     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
-     * @throws {Error} If the DVN is already initialized.
-     */
-    async initDVN(connection: Connection, payer: PublicKey, params: InitDvnParams): Promise<TransactionInstruction> {
-        const [config] = this.dvnDeriver.config()
-        const info = await connection.getAccountInfo(config)
-        if (info) {
+    getProgram(clusterFilter: ClusterFilter = 'custom'): Program {
+        return this.programRepo.get('dvn', clusterFilter)
+    }
+
+    async initDVN(
+        rpc: RpcInterface,
+        payer: Signer,
+        params: instructions.InitDvnInstructionArgs
+    ): Promise<WrappedInstruction> {
+        const [config] = this.pda.config()
+        const info = await rpc.getAccount(config)
+        if (info.exists) {
             throw new Error('DVN already initialized')
         }
-        return instructions.createInitDvnInstruction(
+        return instructions.initDvn(
+            { programs: this.programRepo, payer: payer },
             {
                 payer,
                 config,
-            } satisfies instructions.InitDvnInstructionAccounts,
-            {
-                params,
-            } satisfies instructions.InitDvnInstructionArgs,
-            this.programId
-        )
+                //
+                ...params,
+            }
+        ).items[0]
     }
 
-    /**
-     * Gets the digest for a transaction.
-     *
-     * @param {number} vid - The validator ID.
-     * @param {TransactionInstruction} instruction - The transaction instruction.
-     * @param {number} expiration - The expiration time.
-     * @returns {types.ExecuteTransactionDigest} The transaction digest.
-     */
-    getDigest(vid: number, instruction: TransactionInstruction, expiration: number): types.ExecuteTransactionDigest {
+    getDigest(vid: number, instruction: Instruction, expiration: bigint): types.ExecuteTransactionDigest {
         return {
             vid,
             programId: instruction.programId,
@@ -149,429 +136,255 @@ export class DVN {
         }
     }
 
-    /**
-     * Gets the execute hash for a given hash bytes.
-     *
-     * @param {Buffer} hashBytes - The hash bytes.
-     * @returns {PublicKey} The execute hash.
-     */
     getExecuteHash(hashBytes: Buffer): PublicKey {
-        const [executeHash] = this.dvnDeriver.executeHash(hashBytes)
-        return executeHash
+        return this.pda.executeHash(hashBytes)[0]
     }
 
-    /**
-     * Gets the hash bytes for a given digest.
-     *
-     * @param {types.ExecuteTransactionDigest} digest - The transaction digest.
-     * @returns {Buffer} The hash bytes.
-     */
     getHashBytes(digest: types.ExecuteTransactionDigest): Buffer {
-        const [digestBytes] = types.executeTransactionDigestBeet.serialize(digest)
-
+        const digestBytes = types.getExecuteTransactionDigestSerializer().serialize(digest)
         const hash = keccak_256(digestBytes)
         return Buffer.from(hash)
     }
 
-    /**
-     * Invokes a transaction.
-     *
-     * @param {Connection} connection - The connection.
-     * @param {number} vid - The validator ID.
-     * @param {PublicKey} payer - The payer.
-     * @param {TransactionInstruction} instruction - The transaction instruction.
-     * @param {number} expiration - The expiration time.
-     * @param {SignFunc} sign - The sign function.
-     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
-     * @throws {Error} If the DVN is not initialized.
-     */
     async invoke(
-        connection: Connection,
-        vid: number,
-        payer: PublicKey,
-        instruction: TransactionInstruction,
-        expiration: number,
+        rpc: RpcInterface,
+        payer: Signer,
+        params: {
+            vid: number
+            instruction: Instruction
+            expiration: bigint
+        },
         sign: SignFunc
-    ): Promise<TransactionInstruction> {
-        const configState = await this.getConfigState(connection, 'confirmed')
+    ): Promise<WrappedInstruction> {
+        const configState = await this.getConfigState(rpc, 'confirmed')
         if (!configState) {
             throw new Error('DVN not initialized')
         }
-        const [config] = this.dvnDeriver.config()
+
+        const { vid, instruction, expiration } = params
         const digest: types.ExecuteTransactionDigest = this.getDigest(vid, instruction, expiration)
         const hashBytes = this.getHashBytes(digest)
         const executeHash = this.getExecuteHash(hashBytes)
         const signatures: number[][] = []
         const signResult = await sign.sign(hashBytes)
         signatures.push(...signResult.map((s) => Array.from(s.signature).concat([s.recoveryId])))
-        const param: types.InvokeParams = {
-            digest,
-            signatures,
-        }
-        const remainingAccounts = instruction.keys.map((key) => {
-            key.isSigner = false
-            return key
-        })
-        return instructions.createInvokeInstruction(
+
+        const txBuilder = instructions.invoke(
+            { programs: this.programRepo },
             {
                 signer: payer,
-                config,
+                config: this.pda.config(),
                 executeHash,
                 program: this.programId,
                 eventAuthority: this.eventAuthority,
-                anchorRemainingAccounts: [
-                    {
-                        pubkey: instruction.programId,
-                        isSigner: false,
-                        isWritable: false,
-                    },
-                ].concat(remainingAccounts),
-            } satisfies instructions.InvokeInstructionAccounts,
-            {
-                params: param,
-            } satisfies instructions.InvokeInstructionArgs,
-            this.programId
+
+                digest: digest,
+                signatures: signatures,
+            }
         )
+        return txBuilder.addRemainingAccounts([
+            {
+                pubkey: instruction.programId,
+                isSigner: false,
+                isWritable: false,
+            },
+            ...instruction.keys.map((key) => {
+                key.isSigner = false
+                return key
+            }),
+        ]).items[0]
     }
 
-    /**
-     * Creates a transaction instruction to set the quorum.
-     *
-     * @param {number} quorum - The quorum.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetQuorumInstruction(quorum: number): TransactionInstruction {
-        const params: MultisigConfig = {
-            fields: [quorum],
-            __kind: 'Quorum',
-        }
-        const fixedBeet = multisigConfigBeet.toFixedFromValue(params)
-        const buffer = Buffer.alloc(fixedBeet.byteSize)
-        fixedBeet.write(buffer, 0, params)
-        return new TransactionInstruction({
+    async setMultisigConfig(
+        rpc: RpcInterface,
+        payer: Signer,
+        params: {
+            vid: number
+            config: types.MultisigConfig
+            expiration: bigint
+        },
+        sign: SignFunc
+    ): Promise<[WrappedInstruction, Buffer]> {
+        const { vid, expiration } = params
+        const innerInstruction: Instruction = {
             programId: this.programId,
             keys: [],
-            data: buffer,
-        })
+            data: Buffer.from(types.getMultisigConfigSerializer().serialize(params.config)),
+        }
+        const digest: types.ExecuteTransactionDigest = this.getDigest(vid, innerInstruction, expiration)
+        return [
+            await this.invoke(
+                rpc,
+                payer,
+                {
+                    vid: vid,
+                    instruction: innerInstruction,
+                    expiration,
+                },
+                sign
+            ),
+            this.getHashBytes(digest),
+        ]
     }
 
-    /**
-     * Creates a transaction instruction to set the admins.
-     *
-     * @param {PublicKey[]} admins - The admin public keys.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetAdminsInstruction(admins: PublicKey[]): TransactionInstruction {
-        const params: MultisigConfig = {
-            fields: [admins] satisfies [PublicKey[]],
-            __kind: 'Admins',
-        }
-        const fixedBeet = multisigConfigBeet.toFixedFromValue(params)
-        const buffer = Buffer.alloc(fixedBeet.byteSize)
-        fixedBeet.write(buffer, 0, params)
-        return new TransactionInstruction({
-            programId: this.programId,
-            keys: [],
-            data: buffer,
-        })
+    // set admin config, can call by one of the admins
+    setConfig(admin: Signer, adminConfig: types.AdminConfigArgs): WrappedInstruction {
+        return instructions.setConfig(
+            { programs: this.programRepo },
+            {
+                admin,
+                config: this.pda.config(),
+                program: this.programId,
+                eventAuthority: this.eventAuthority,
+            },
+            {
+                config: adminConfig,
+            }
+        ).items[0]
     }
 
-    /**
-     * Creates a transaction instruction to set the signers.
-     *
-     * @param {Uint8Array[]} signers - The signer public keys.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetSignersInstruction(signers: Uint8Array[]): TransactionInstruction {
-        const params: MultisigConfig = {
-            fields: [signers.map((s) => Array.from(s))],
-            __kind: 'Signers',
-        }
-        const fixedBeet = multisigConfigBeet.toFixedFromValue(params)
-        const buffer = Buffer.alloc(fixedBeet.byteSize)
-        fixedBeet.write(buffer, 0, params)
-        return new TransactionInstruction({
-            programId: this.programId,
-            keys: [],
-            data: buffer,
+    setDstConfig(admin: Signer, dstConfigs: types.DstConfig[]): WrappedInstruction {
+        return this.setConfig(admin, {
+            __kind: 'DstConfigs',
+            fields: [dstConfigs],
         })
     }
 
-    /**
-     * Creates a transaction instruction to set the allowlist.
-     *
-     * @param {PublicKey[]} allowlist - The allowlist public keys.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetAllowlistInstruction(allowlist: PublicKey[]): TransactionInstruction {
-        const params: MultisigConfig = {
-            fields: [allowlist],
-            __kind: 'Allowlist',
-        }
-        const fixedBeet = multisigConfigBeet.toFixedFromValue(params)
-        const buffer = Buffer.alloc(fixedBeet.byteSize)
-        fixedBeet.write(buffer, 0, params)
-        return new TransactionInstruction({
-            programId: this.programId,
-            keys: [],
-            data: buffer,
+    setAdmins(admin: Signer, admins: PublicKey[]): WrappedInstruction {
+        return this.setConfig(admin, {
+            __kind: 'Admins',
+            fields: [admins],
         })
     }
 
-    /**
-     * Creates a transaction instruction to set the denylist.
-     *
-     * @param {PublicKey[]} denylist - The denylist public keys.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetDenylistInstruction(denylist: PublicKey[]): TransactionInstruction {
-        const params: MultisigConfig = {
-            fields: [denylist],
-            __kind: 'Denylist',
-        }
-        const fixedBeet = multisigConfigBeet.toFixedFromValue(params)
-        const buffer = Buffer.alloc(fixedBeet.byteSize)
-        fixedBeet.write(buffer, 0, params)
-        return new TransactionInstruction({
-            programId: this.programId,
-            keys: [],
-            data: buffer,
+    setDefaultMultiplierBps(admin: Signer, defaultMultiplierBps: number): WrappedInstruction {
+        return this.setConfig(admin, {
+            __kind: 'DefaultMultiplierBps',
+            fields: [defaultMultiplierBps],
         })
     }
 
-    /**
-     * Creates a transaction instruction to set the pause state.
-     *
-     * @param {boolean} pause - The pause state.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetPauseInstruction(pause: boolean): TransactionInstruction {
-        const params: MultisigConfig = {
-            fields: [pause],
-            __kind: 'Paused',
-        }
-        const fixedBeet = multisigConfigBeet.toFixedFromValue(params)
-        const buffer = Buffer.alloc(fixedBeet.byteSize)
-        fixedBeet.write(buffer, 0, params)
-        return new TransactionInstruction({
-            programId: this.programId,
-            keys: [],
-            data: buffer,
+    setPriceFeed(admin: Signer, priceFeedProgram: PublicKey): WrappedInstruction {
+        const [priceFeedPda] = new PriceFeedPDA(priceFeedProgram).priceFeed()
+        return this.setConfig(admin, {
+            fields: [priceFeedPda],
+            __kind: 'PriceFeed',
         })
     }
 
-    /**
-     * Creates a transaction instruction to set the default multiplier basis points.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {number} defaultMultiplierBps - The default multiplier basis points.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetDefaultMultiplierBpsInstruction(admin: PublicKey, defaultMultiplierBps: number): TransactionInstruction {
-        const [configAccount] = this.dvnDeriver.config()
-        return instructions.createSetConfigInstruction(
-            {
-                admin,
-                config: configAccount,
-                program: this.programId,
-                eventAuthority: this.eventAuthority,
-            } satisfies instructions.SetConfigInstructionAccounts,
-            {
-                params: {
-                    config: {
-                        fields: [defaultMultiplierBps],
-                        __kind: 'DefaultMultiplierBps',
-                    },
-                },
-            } satisfies instructions.SetConfigInstructionArgs,
-            this.programId
-        )
+    _getExpiration(): bigint {
+        return BigInt(new Date().getTime() / 1000 + 120)
     }
 
-    /**
-     * Creates a transaction instruction to change the admins.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {PublicKey[]} admins - The new admin public keys.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createChangeAdminsInstruction(admin: PublicKey, admins: PublicKey[]): TransactionInstruction {
-        const [configAccount] = this.dvnDeriver.config()
-        return instructions.createSetConfigInstruction(
+    withdrawFee(admin: Signer, param: { receiver: PublicKey; amount: number | bigint }): WrappedInstruction {
+        return instructions.withdrawFee(
+            { programs: this.programRepo },
             {
                 admin,
-                config: configAccount,
+                config: this.pda.config(),
+                receiver: param.receiver,
                 program: this.programId,
                 eventAuthority: this.eventAuthority,
-            } satisfies instructions.SetConfigInstructionAccounts,
-            {
-                params: {
-                    config: {
-                        fields: [admins],
-                        __kind: 'Admins',
-                    },
-                },
-            } satisfies instructions.SetConfigInstructionArgs,
-            this.programId
-        )
+                amount: param.amount,
+            }
+        ).items[0]
     }
 
-    /**
-     * Creates a transaction instruction to set the destination configurations.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {types.DstConfig[]} dstConfigs - The destination configurations.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetDstConfigInstruction(admin: PublicKey, dstConfigs: types.DstConfig[]): TransactionInstruction {
-        const [configAccount] = this.dvnDeriver.config()
-        return instructions.createSetConfigInstruction(
+    closeExecute(admin: Signer, digestHash: Buffer): WrappedInstruction {
+        return instructions.closeExecute(
+            { programs: this.programRepo },
             {
                 admin,
-                config: configAccount,
-                program: this.programId,
-                eventAuthority: this.eventAuthority,
-            } satisfies instructions.SetConfigInstructionAccounts,
-            {
-                params: {
-                    config: {
-                        fields: [dstConfigs],
-                        __kind: 'DstConfigs',
-                    },
-                },
-            } satisfies instructions.SetConfigInstructionArgs,
-            this.programId
-        )
+                config: this.pda.config(),
+                executeHash: this.pda.executeHash(digestHash),
+                digestHash,
+            }
+        ).items[0]
     }
 
-    /**
-     * Creates a transaction instruction to remove the destination configurations.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {number[]} removeEids - The endpoint IDs to remove.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createRemoveDstConfigInstruction(admin: PublicKey, removeEids: number[]): TransactionInstruction {
-        const [configAccount] = this.dvnDeriver.config()
-        return instructions.createSetConfigInstruction(
+    quoteDvn(param: { priceFeedProgram: PublicKey } & QuoteDvnInstructionArgs): WrappedInstruction {
+        const [priceFeed] = new PriceFeedPDA(param.priceFeedProgram).priceFeed()
+        return instructions.quoteDvn(
+            { programs: this.programRepo },
             {
-                admin,
-                config: configAccount,
-                program: this.programId,
-                eventAuthority: this.eventAuthority,
-            } satisfies instructions.SetConfigInstructionAccounts,
-            {
-                params: {
-                    config: {
-                        fields: [removeEids],
-                        __kind: 'RemoveDstConfigs',
-                    },
-                },
-            } satisfies instructions.SetConfigInstructionArgs,
-            this.programId
-        )
+                dvnConfig: this.pda.config(),
+                priceFeedConfig: priceFeed,
+                ...param,
+            }
+        ).items[0]
     }
 
-    /**
-     * Creates a transaction instruction to set the message libraries.
-     *
-     * @param {PublicKey[]} msglibPrograms - The message library public keys.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetMsgLibsInstruction(msglibPrograms: PublicKey[]): TransactionInstruction {
-        const params: MultisigConfig = {
-            fields: [msglibPrograms],
-            __kind: 'Msglibs',
+    async verifiable(
+        rpc: RpcInterface,
+        params: {
+            packetBytes: Uint8Array
+            endpointProgram?: PublicKey
+            msgLibProgram?: PublicKey
         }
-        const fixedBeet = multisigConfigBeet.toFixedFromValue(params)
-        const buffer = Buffer.alloc(fixedBeet.byteSize)
-        fixedBeet.write(buffer, 0, params)
-        return new TransactionInstruction({
-            programId: this.programId,
-            keys: [],
-            data: buffer,
+    ): Promise<WrappedInstruction> {
+        const { packetBytes } = params
+        const packet = PacketV1Codec.fromBytes(packetBytes)
+        const receiver = publicKey(Buffer.from(packet.receiver().slice(2), 'hex'))
+        const srcEid = packet.srcEid()
+        const sender = addressToBytes32(packet.sender())
+        const packetNonce = parseInt(packet.nonce())
+        const headerHashBytes = Uint8Array.from(Buffer.from(packet.headerHash().slice(2), 'hex'))
+        const payloadHashBytes = Uint8Array.from(Buffer.from(packet.payloadHash().slice(2), 'hex'))
+
+        const endpointPDA = new EndpointPDA(params.endpointProgram ?? EndpointProgram.ENDPOINT_PROGRAM_ID)
+        const ulnSDK = new UlnProgram.Uln(params.msgLibProgram ?? UlnProgram.ULN_PROGRAM_ID)
+
+        const finalReceiveConfig = await ulnSDK.getFinalReceiveConfigState(rpc, receiver, srcEid, 'confirmed')
+        const confirmations: AccountMeta[] = [
+            ...finalReceiveConfig.requiredDvns,
+            ...finalReceiveConfig.optionalDvns,
+        ].map((dvn) => {
+            return {
+                pubkey: ulnSDK.pda.confirmations(headerHashBytes, payloadHashBytes, dvn)[0],
+                isSigner: false,
+                isWritable: false,
+            }
         })
-    }
-
-    /**
-     * Gets the expiration time.
-     *
-     * @returns {number} The expiration time.
-     */
-    _getExpiration(): number {
-        return new Date().getTime() / 1000 + 120
-    }
-
-    /**
-     * Sets the message libraries.
-     *
-     * @param {Connection} connection - The connection.
-     * @param {PublicKey} payer - The payer.
-     * @param {PublicKey[]} msgLibs - The message library public keys.
-     * @param {SignFunc} sign - The sign function.
-     * @returns {Promise<TransactionInstruction>} A promise that resolves to the transaction instruction.
-     */
-    async setMsgLibs(
-        connection: Connection,
-        payer: PublicKey,
-        msgLibs: PublicKey[],
-        sign: SignFunc
-    ): Promise<TransactionInstruction> {
-        const expiration = this._getExpiration()
-        return this.invoke(connection, this.vid, payer, this.createSetMsgLibsInstruction(msgLibs), expiration, sign)
-    }
-
-    /**
-     * Creates a transaction instruction to set the price feed.
-     *
-     * @param {PublicKey} admin - The admin public key.
-     * @param {PublicKey} priceFeedProgram - The price feed program public key.
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    createSetPriceFeedInstruction(admin: PublicKey, priceFeedProgram: PublicKey): TransactionInstruction {
-        const [configAccount] = this.dvnDeriver.config()
-        const [priceFeedPda] = new PriceFeedPDADeriver(priceFeedProgram).priceFeed()
-        return instructions.createSetConfigInstruction(
-            {
-                admin,
-                config: configAccount,
-                program: this.programId,
-                eventAuthority: this.eventAuthority,
-            } satisfies instructions.SetConfigInstructionAccounts,
-            {
-                params: {
-                    config: {
-                        fields: [priceFeedPda],
-                        __kind: 'PriceFeed',
-                    },
+        return instructions
+            .verifiable(
+                { programs: this.programRepo },
+                {
+                    nonce: endpointPDA.nonce(receiver, srcEid, sender),
+                    payloadHash: endpointPDA.payloadHash(receiver, srcEid, sender, packetNonce),
+                    receiveConfig: ulnSDK.pda.receiveConfig(srcEid, receiver),
+                    defaultReceiveConfig: ulnSDK.pda.defaultReceiveConfig(srcEid),
                 },
-            } satisfies instructions.SetConfigInstructionArgs,
-            this.programId
-        )
+                {
+                    packetHeader: Array.from(Uint8Array.from(Buffer.from(packet.header().slice(2), 'hex'))),
+                    payloadHash: payloadHashBytes,
+                }
+            )
+            .addRemainingAccounts(confirmations).items[0]
     }
 
-    /**
-     * Gets the account metadata for the CPI (Cross-Program Invocation) of the quote instruction.
-     *
-     * @param {PublicKey} priceFeedConfig - The price feed configuration public key.
-     * @param {PublicKey} priceFeedProgram - The price feed program public key.
-     * @param {boolean} payment - Indicates if payment is required.
-     * @returns {AccountMeta[]} An array of account metadata.
-     */
     getQuoteIXAccountMetaForCPI(
         priceFeedConfig: PublicKey,
         priceFeedProgram: PublicKey,
         payment: boolean
     ): AccountMeta[] {
-        const [config] = this.dvnDeriver.config()
-        const keys = instructions.createQuoteDvnInstructionAccounts(
+        const txBuilder = instructions.quoteDvn(
+            { programs: this.programRepo },
             {
-                dvnConfig: config,
+                dvnConfig: this.pda.config(),
                 priceFeedConfig,
                 priceFeedProgram: priceFeedProgram,
-            } satisfies instructions.QuoteDvnInstructionAccounts,
-            this.programId
+
+                // param
+                msglib: defaultPublicKey(),
+                dstEid: 0,
+                sender: defaultPublicKey(),
+                packetHeader: new Uint8Array(4),
+                payloadHash: new Uint8Array(32),
+                confirmations: 0,
+                options: [],
+            }
         )
+        const { keys } = txBuilder.getInstructions()[0]
         if (payment) {
             // if payment is required, the first account is required to be writable to receive the payment
             keys[0].isWritable = true
@@ -585,22 +398,8 @@ export class DVN {
         ].concat(keys)
     }
 
-    /**
-     * Gets the configuration state.
-     *
-     * @param {Connection} connection - The connection to the Solana cluster.
-     * @param {Commitment | GetAccountInfoConfig} [commitment='confirmed'] - The commitment level or account info configuration.
-     * @returns {Promise<accounts.DvnConfig | null>} A promise that resolves to the configuration state or null if not found.
-     */
-    async getConfigState(
-        connection: Connection,
-        commitment: Commitment | GetAccountInfoConfig = 'confirmed'
-    ): Promise<accounts.DvnConfig | null> {
-        const [config] = this.dvnDeriver.config()
-        try {
-            return await accounts.DvnConfig.fromAccountAddress(connection, config, commitment)
-        } catch (e) {
-            return null
-        }
+    async getConfigState(rpc: RpcInterface, commitment: Commitment = 'confirmed'): Promise<accounts.DvnConfig | null> {
+        const [config] = this.pda.config()
+        return accounts.safeFetchDvnConfig({ rpc }, config, { commitment })
     }
 }