@layerzerolabs/oft-v2-solana-sdk 3.0.47 → 3.0.49

package/src/oft202.ts

@@ -0,0 +1,618 @@
+/* eslint-disable @typescript-eslint/require-await */
+
+// 1. init native OFT from existing mint
+// 2. init adapter OFT from existing mint, optionally an existing escrow
+// 3. Wire a peer
+// 4. Set the DVN etc. options
+import { hexlify } from '@ethersproject/bytes'
+import {
+    Cluster,
+    Program,
+    ProgramError,
+    ProgramRepositoryInterface,
+    PublicKey,
+    RpcInterface,
+    Signer,
+    WrappedInstruction,
+    createNullRpc,
+    none,
+    publicKeyBytes,
+    some,
+} from '@metaplex-foundation/umi'
+import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
+import { fromWeb3JsPublicKey, toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { AccountMeta, ComputeBudgetProgram, Connection } from '@solana/web3.js'
+
+import {
+    EndpointPDADeriver,
+    EndpointProgram,
+    EventPDADeriver,
+    SimpleMessageLibProgram,
+    UlnProgram,
+    simulateTransaction,
+} from '@layerzerolabs/lz-solana-sdk-v2'
+import { PacketPath } from '@layerzerolabs/lz-v2-utilities'
+
+import { OFT_DECIMALS } from './consts'
+import * as OFTAccounts from './generated/oft202/accounts'
+import * as errors from './generated/oft202/errors'
+import * as instructions from './generated/oft202/instructions'
+import * as types from './generated/oft202/types/index'
+import { OftPDA } from './pda'
+import {
+    SetOFTConfigParams,
+    SetPeerAddressParam,
+    SetPeerEnforcedOptionsParam,
+    SetPeerFeeBpsParam,
+    SetPeerIsEndpointV1Param,
+    SetPeerRateLimitParam,
+} from './types'
+
+export {
+    initSendLibrary,
+    initReceiveLibrary,
+    setSendLibrary,
+    setReceiveLibrary,
+    initConfig,
+    setConfig,
+    initOAppNonce,
+    getEndpointConfig,
+    getPeerAddress,
+    getDelegate,
+    getEnforcedOptions,
+} from './oft302'
+
+export * as accounts from './generated/oft202/accounts'
+export * as instructions from './generated/oft202/instructions'
+export * as programs from './generated/oft202/programs'
+export * as shared from './generated/oft202/shared'
+export * as types from './generated/oft202/types/index'
+export * as errors from './generated/oft202/errors'
+
+const ENDPOINT_PROGRAM_ID = fromWeb3JsPublicKey(EndpointProgram.PROGRAM_ID)
+const PROGRAM_NAME = 'oft'
+
+export function createOFTProgramRepo(oftProgram: PublicKey, rpc?: RpcInterface): ProgramRepositoryInterface {
+    if (rpc === undefined) {
+        rpc = createNullRpc()
+        rpc.getCluster = (): Cluster => 'custom'
+    }
+    return createDefaultProgramRepository({ rpc: rpc }, [
+        {
+            name: PROGRAM_NAME,
+            publicKey: oftProgram,
+            getErrorFromCode(code: number, cause?: Error): ProgramError | null {
+                return errors.getOftErrorFromCode(code, this, cause)
+            },
+            getErrorFromName(name: string, cause?: Error): ProgramError | null {
+                return errors.getOftErrorFromName(name, this, cause)
+            },
+            isOnCluster(): boolean {
+                return true
+            },
+        } satisfies Program,
+    ])
+}
+
+export function initOft(
+    accounts: { payer: Signer; admin: PublicKey; mint: PublicKey; escrow: Signer },
+    oftType: types.OFTType,
+    sharedDecimals = OFT_DECIMALS,
+    programs: { oft: PublicKey; endpoint?: PublicKey; token?: PublicKey }
+): WrappedInstruction {
+    const programsRepo = createOFTProgramRepo(programs.oft)
+    const deriver = new OftPDA(programsRepo.getPublicKey(PROGRAM_NAME))
+    const endpoint = new EndpointProgram.Endpoint(toWeb3JsPublicKey(programs.endpoint ?? ENDPOINT_PROGRAM_ID))
+    const { payer, admin, mint, escrow } = accounts
+    const [oftStore] = deriver.oftStore(escrow.publicKey)
+    const [lzReceiveTypes] = deriver.lzReceiveTypesAccounts(oftStore)
+
+    const txBuilder = instructions.initOft(
+        {
+            payer: payer,
+            programs: programsRepo,
+        },
+        {
+            // accounts
+            oftStore: oftStore,
+            lzReceiveTypesAccounts: lzReceiveTypes,
+            tokenMint: mint,
+            tokenEscrow: escrow,
+            tokenProgram: programs.token ?? fromWeb3JsPublicKey(TOKEN_PROGRAM_ID),
+            // params
+            oftType: oftType,
+            admin: admin,
+            sharedDecimals: sharedDecimals,
+            endpointProgram: fromWeb3JsPublicKey(endpoint.program),
+        }
+    )
+    const retval = txBuilder.addRemainingAccounts(
+        endpoint
+            .getRegisterOappIxAccountMetaForCPI(toWeb3JsPublicKey(payer.publicKey), toWeb3JsPublicKey(oftStore))
+            .map((acc) => {
+                return {
+                    pubkey: fromWeb3JsPublicKey(acc.pubkey),
+                    isSigner: acc.isSigner,
+                    isWritable: acc.isWritable,
+                }
+            })
+    ).items[0]
+    retval.signers = [payer, escrow]
+    return retval
+}
+
+export function setOFTConfig(
+    accounts: {
+        oftStore: PublicKey
+        admin: Signer
+    },
+    params: SetOFTConfigParams,
+    programs: {
+        oft: PublicKey
+        endpoint?: PublicKey
+    }
+): WrappedInstruction {
+    let actualParams: types.SetOFTConfigParamsArgs
+    const { oftStore, admin } = accounts
+    const oftStoreWeb3Js = toWeb3JsPublicKey(oftStore)
+    const remainingAccounts: AccountMeta[] = []
+    if (params.__kind === 'Admin') {
+        if (params.admin === undefined) {
+            throw new Error('Admin is required')
+        }
+        actualParams = {
+            __kind: 'Admin',
+            fields: [params.admin],
+        }
+    } else if (params.__kind === 'Delegate') {
+        if (params.delegate === undefined) {
+            throw new Error('Delegate is required')
+        }
+        actualParams = {
+            __kind: 'Delegate',
+            fields: [params.delegate],
+        }
+        const endpointProgram = toWeb3JsPublicKey(programs.endpoint ?? ENDPOINT_PROGRAM_ID)
+        const [oAppRegistry] = new EndpointPDADeriver(endpointProgram).oappRegistry(oftStoreWeb3Js)
+        const [endpointEventAuthority] = new EventPDADeriver(endpointProgram).eventAuthority()
+        const keys = EndpointProgram.instructions.createSetDelegateInstructionAccounts(
+            {
+                oapp: oftStoreWeb3Js,
+                oappRegistry: oAppRegistry,
+                eventAuthority: endpointEventAuthority,
+                program: endpointProgram,
+            },
+            endpointProgram
+        )
+        for (const acc of keys) {
+            acc.isSigner = false
+        }
+        remainingAccounts.push(
+            {
+                pubkey: endpointProgram,
+                isSigner: false,
+                isWritable: false,
+            },
+            ...keys
+        )
+    } else if (params.__kind === 'DefaultFee') {
+        if (params.defaultFee === undefined) {
+            throw new Error('DefaultFee is required')
+        }
+        actualParams = {
+            __kind: 'DefaultFee',
+            fields: [params.defaultFee],
+        }
+    } else if (params.__kind === 'Paused') {
+        if (params.paused === undefined) {
+            throw new Error('Paused is required')
+        }
+        actualParams = {
+            __kind: 'Paused',
+            fields: [params.paused],
+        }
+    } else if (params.__kind === 'Pauser') {
+        actualParams = {
+            __kind: 'Pauser',
+            fields: [params.pauser ? some(params.pauser) : none()],
+        }
+    } else {
+        actualParams = {
+            __kind: 'Unpauser',
+            fields: [params.unpauser ? some(params.unpauser) : none()],
+        }
+    }
+
+    const txBuilder = instructions.setOftConfig(
+        { programs: createOFTProgramRepo(programs.oft) },
+        {
+            admin: admin,
+            oftStore: oftStore,
+            params: actualParams,
+        }
+    )
+    return txBuilder.addRemainingAccounts(
+        remainingAccounts.map((acc) => {
+            return {
+                pubkey: fromWeb3JsPublicKey(acc.pubkey),
+                isSigner: acc.isSigner,
+                isWritable: acc.isWritable,
+            }
+        })
+    ).items[0]
+}
+
+export function setPeerConfig(
+    accounts: {
+        admin: Signer
+        oftStore: PublicKey
+    },
+    param: (
+        | SetPeerAddressParam
+        | SetPeerFeeBpsParam
+        | SetPeerEnforcedOptionsParam
+        | SetPeerRateLimitParam
+        | SetPeerIsEndpointV1Param
+    ) & {
+        remote: number
+    },
+    oftProgramId: PublicKey | ProgramRepositoryInterface
+): WrappedInstruction {
+    const programsRepo = typeof oftProgramId === 'string' ? createOFTProgramRepo(oftProgramId) : oftProgramId
+    const { remote: remoteId } = param
+    if (remoteId % 30000 == 0) {
+        throw new Error('Invalid remote ID')
+    }
+    const { admin, oftStore } = accounts
+    const [peerPda] = new OftPDA(programsRepo.getPublicKey(PROGRAM_NAME)).peer(oftStore, remoteId)
+    let config: types.PeerConfigParamArgs
+    if (param.__kind === 'PeerAddress') {
+        if (param.peer.length !== 32) {
+            throw new Error('Peer must be 32 bytes (left-padded with zeroes)')
+        }
+        config = types.peerConfigParam('PeerAddress', [param.peer])
+    } else if (param.__kind === 'FeeBps') {
+        config = { __kind: 'FeeBps', fields: [some(param.feeBps)] }
+    } else if (param.__kind === 'EnforcedOptions') {
+        config = {
+            __kind: 'EnforcedOptions',
+            send: param.send,
+            sendAndCall: param.sendAndCall,
+        }
+    } else if (param.__kind === 'OutboundRateLimit' || param.__kind === 'InboundRateLimit') {
+        config = {
+            __kind: param.__kind,
+            fields: [
+                param.rateLimit
+                    ? some({
+                          refillPerSecond: some(param.rateLimit.refillPerSecond),
+                          capacity: some(param.rateLimit.capacity),
+                      })
+                    : null,
+            ],
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    } else if (param.__kind === 'IsEndpointV1') {
+        config = { __kind: 'IsEndpointV1', fields: [param.isEndpointV1] }
+    } else {
+        throw new Error('Invalid peer config')
+    }
+
+    return instructions.setPeerConfig(
+        { programs: programsRepo },
+        {
+            admin: admin,
+            peer: peerPda,
+            oftStore: oftStore,
+            // params
+            remoteEid: remoteId,
+            config: config,
+        }
+    ).items[0]
+}
+
+// copied from oft302.ts withdrawFee
+export function withdrawFee(
+    accounts: {
+        admin: Signer
+        mint: PublicKey
+        escrow: PublicKey
+        dest: PublicKey
+    },
+    amount: bigint,
+    programs: {
+        oft: PublicKey | ProgramRepositoryInterface
+        token?: PublicKey
+    }
+): WrappedInstruction {
+    const { admin, mint, escrow, dest } = accounts
+    const programsRepo = typeof programs.oft === 'string' ? createOFTProgramRepo(programs.oft) : programs.oft
+    const [oftStore] = new OftPDA(programsRepo.getPublicKey('oft')).oftStore(escrow)
+    return instructions.withdrawFee(
+        { programs: programsRepo },
+        {
+            admin: admin,
+            tokenEscrow: escrow,
+            tokenDest: dest,
+            tokenProgram: programs.token ?? fromWeb3JsPublicKey(TOKEN_PROGRAM_ID),
+            oftStore: oftStore,
+            tokenMint: mint,
+            // params
+            feeLd: amount,
+        }
+    ).items[0]
+}
+
+export async function send(
+    rpc: RpcInterface,
+    accounts: {
+        payer: Signer
+        tokenMint: PublicKey
+        tokenEscrow: PublicKey
+        tokenSource: PublicKey
+        peerAddr?: Uint8Array
+    },
+    sendParams: {
+        dstEid: number
+        to: Uint8Array
+        amountLd: bigint
+        minAmountLd: bigint
+        options?: Uint8Array
+        nativeFee: bigint
+        lzTokenFee?: bigint
+        composeParams?: {
+            composeGas: number | bigint
+            composeMsg: Uint8Array
+        }
+    },
+    programs: {
+        oft: PublicKey | ProgramRepositoryInterface
+        endpoint?: PublicKey // default is ENDPOINT_PROGRAM(76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6)
+        token?: PublicKey // default is TOKEN_PROGRAM_ID(TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA)
+    },
+    remainingAccounts?: AccountMeta[]
+): Promise<WrappedInstruction> {
+    const { payer, tokenMint, tokenEscrow, tokenSource } = accounts
+    const { dstEid, to, amountLd, minAmountLd, options, composeParams, nativeFee, lzTokenFee } = sendParams
+    const programsRepo = typeof programs.oft === 'string' ? createOFTProgramRepo(programs.oft) : programs.oft
+    const oftProgramId = programsRepo.getPublicKey(PROGRAM_NAME)
+    const deriver = new OftPDA(oftProgramId)
+    const [oftStore] = deriver.oftStore(tokenEscrow)
+    const [peer] = deriver.peer(oftStore, dstEid)
+
+    const connection = new Connection(rpc.getEndpoint())
+    if (remainingAccounts === undefined || remainingAccounts.length === 0) {
+        const peerAddr: Uint8Array =
+            accounts.peerAddr ??
+            (await OFTAccounts.fetchPeerConfig({ rpc }, peer).then((peerInfo) => peerInfo.peerAddress))
+
+        const endpoint = new EndpointProgram.Endpoint(toWeb3JsPublicKey(programs.endpoint ?? ENDPOINT_PROGRAM_ID))
+        const msgLibProgram = await getSendLibraryProgram(connection, endpoint, payer.publicKey, oftStore, dstEid)
+        const packetPath: PacketPath = {
+            srcEid: 0,
+            dstEid,
+            sender: hexlify(publicKeyBytes(oftStore)),
+            receiver: hexlify(peerAddr),
+        }
+        remainingAccounts = await endpoint.getSendIXAccountMetaForCPI(
+            connection,
+            toWeb3JsPublicKey(payer.publicKey),
+            packetPath,
+            msgLibProgram
+        )
+    }
+
+    const [eventAuthorityPDA] = new EventPDADeriver(toWeb3JsPublicKey(oftProgramId)).eventAuthority()
+    const tokenProgram: PublicKey = programs.token ?? fromWeb3JsPublicKey(TOKEN_PROGRAM_ID)
+    const txBuilder = instructions.send(
+        { programs: programsRepo },
+        {
+            signer: payer,
+            peer: peer,
+            oftStore: oftStore,
+            tokenSource: tokenSource,
+            tokenEscrow: tokenEscrow,
+            tokenMint: tokenMint,
+            tokenProgram: tokenProgram,
+            eventAuthority: fromWeb3JsPublicKey(eventAuthorityPDA),
+            program: oftProgramId,
+            // params
+            dstEid: dstEid,
+            to: to,
+            amountLd,
+            minAmountLd,
+            options: options ?? new Uint8Array(),
+            nativeFee,
+            lzTokenFee: lzTokenFee ?? 0,
+            composeParams: composeParams ?? null,
+        }
+    )
+
+    // Get remaining accounts from msgLib(simple_msgLib or uln)
+    return txBuilder.addRemainingAccounts(
+        remainingAccounts.map((acc) => {
+            return {
+                pubkey: fromWeb3JsPublicKey(acc.pubkey),
+                isSigner: acc.isSigner,
+                isWritable: acc.isWritable,
+            }
+        })
+    ).items[0]
+}
+
+export async function quote(
+    rpc: RpcInterface,
+    accounts: {
+        payer: PublicKey
+        tokenMint: PublicKey
+        tokenEscrow: PublicKey
+        peerAddr?: Uint8Array
+    },
+    quoteParams: {
+        dstEid: number
+        to: Uint8Array
+        amountLd: bigint
+        minAmountLd: bigint
+        options?: Uint8Array
+        payInLzToken?: boolean
+        composeParams?: {
+            composeGas: number | bigint
+            composeMsg: Uint8Array
+        }
+    },
+    programs: {
+        oft: PublicKey | ProgramRepositoryInterface
+        endpoint?: PublicKey
+    },
+    remainingAccounts?: AccountMeta[]
+): Promise<{ nativeFee: bigint; lzTokenFee: bigint }> {
+    const { dstEid, to, amountLd, minAmountLd, options, payInLzToken, composeParams } = quoteParams
+    const { payer, tokenMint, tokenEscrow } = accounts
+    const programsRepo = typeof programs.oft === 'string' ? createOFTProgramRepo(programs.oft) : programs.oft
+    const deriver = new OftPDA(programsRepo.getPublicKey(PROGRAM_NAME))
+    const [oftStore] = deriver.oftStore(tokenEscrow)
+    const [peer] = deriver.peer(oftStore, dstEid)
+
+    const connection = new Connection(rpc.getEndpoint(), 'confirmed')
+    if (remainingAccounts === undefined || remainingAccounts.length === 0) {
+        const peerAddr: Uint8Array =
+            accounts.peerAddr ??
+            (await OFTAccounts.fetchPeerConfig({ rpc }, peer).then((peerInfo) => peerInfo.peerAddress))
+
+        const endpoint = new EndpointProgram.Endpoint(toWeb3JsPublicKey(programs.endpoint ?? ENDPOINT_PROGRAM_ID))
+        const messageLib = await getSendLibraryProgram(connection, endpoint, payer, oftStore, dstEid)
+
+        remainingAccounts = await endpoint.getQuoteIXAccountMetaForCPI(
+            connection,
+            toWeb3JsPublicKey(payer),
+            {
+                sender: hexlify(publicKeyBytes(oftStore)),
+                dstEid: dstEid,
+                receiver: hexlify(peerAddr),
+            },
+            messageLib
+        )
+    }
+
+    let txBuilder = instructions.quoteSend(
+        { programs: programsRepo },
+        {
+            oftStore: oftStore,
+            peer: peer,
+            tokenMint: tokenMint,
+            // params
+            dstEid: dstEid,
+            to: to,
+            amountLd: amountLd,
+            minAmountLd: minAmountLd,
+            options: options ?? new Uint8Array(),
+            payInLzToken: payInLzToken ?? false,
+            composeParams: composeParams ?? null,
+        }
+    )
+
+    txBuilder = txBuilder.addRemainingAccounts(
+        // Get remaining accounts from msgLib(simple_msgLib or uln)
+        remainingAccounts.map((acc) => {
+            return {
+                pubkey: fromWeb3JsPublicKey(acc.pubkey),
+                isSigner: acc.isSigner,
+                isWritable: acc.isWritable,
+            }
+        })
+    )
+    const web3Ix = toWeb3JsInstruction(txBuilder.getInstructions()[0])
+    const modifyComputeUnits = ComputeBudgetProgram.setComputeUnitLimit({
+        units: 1000000,
+    })
+    const buffer = await simulateTransaction(
+        connection,
+        [modifyComputeUnits, web3Ix],
+        web3Ix.programId,
+        toWeb3JsPublicKey(payer),
+        'confirmed'
+    )
+    const fee = EndpointProgram.types.messagingFeeBeet.read(buffer, 0)
+    return { nativeFee: BigInt(fee.nativeFee.toString()), lzTokenFee: BigInt(fee.lzTokenFee.toString()) }
+}
+
+export async function quoteOft(
+    rpc: RpcInterface,
+    accounts: {
+        payer: PublicKey
+        tokenMint: PublicKey
+        tokenEscrow: PublicKey
+    },
+    quoteParams: {
+        dstEid: number
+        to: Uint8Array
+        amountLd: bigint
+        minAmountLd: bigint
+        options?: Uint8Array
+        payInLzToken?: boolean
+        composeMsg?: Uint8Array
+    },
+    oftProgram: PublicKey | ProgramRepositoryInterface
+): Promise<types.QuoteOFTResult> {
+    const { payer, tokenMint, tokenEscrow } = accounts
+    const { dstEid, to, amountLd, minAmountLd, options, payInLzToken, composeMsg } = quoteParams
+    const programsRepo = typeof oftProgram === 'string' ? createOFTProgramRepo(oftProgram) : oftProgram
+    const deriver = new OftPDA(programsRepo.getPublicKey(PROGRAM_NAME))
+    const [oftStore] = deriver.oftStore(tokenEscrow)
+    const [peer] = deriver.peer(oftStore, dstEid)
+    const ix = instructions
+        .quoteOft(
+            { programs: programsRepo },
+            {
+                oftStore: oftStore,
+                peer: peer,
+                tokenMint: tokenMint,
+                // params
+                dstEid: dstEid,
+                to: to,
+                amountLd: amountLd,
+                minAmountLd: minAmountLd,
+                options: options ?? new Uint8Array(),
+                payInLzToken: payInLzToken ?? false,
+                composeMsg: composeMsg ?? null,
+            }
+        )
+        .getInstructions()[0]
+    const web3Ix = toWeb3JsInstruction(ix)
+    const connection = new Connection(rpc.getEndpoint())
+    const returnedValues = await simulateTransaction(
+        connection,
+        [web3Ix],
+        web3Ix.programId,
+        toWeb3JsPublicKey(payer),
+        'confirmed'
+    )
+    const [result] = types.getQuoteOFTResultSerializer().deserialize(returnedValues, 0)
+    return result
+}
+
+async function getSendLibraryProgram(
+    connection: Connection,
+    endpoint: EndpointProgram.Endpoint,
+    payer: PublicKey,
+    oftStore: PublicKey,
+    remoteEid: number
+): Promise<SimpleMessageLibProgram.SimpleMessageLib | UlnProgram.Uln> {
+    const sendLibInfo = await endpoint.getSendLibrary(connection, toWeb3JsPublicKey(oftStore), remoteEid)
+    if (!sendLibInfo?.programId) {
+        throw new Error('Send library not initialized or blocked message library')
+    }
+    const { programId: msgLibProgram } = sendLibInfo
+    const msgLibVersion = await endpoint.getMessageLibVersion(connection, toWeb3JsPublicKey(payer), msgLibProgram)
+    if (msgLibVersion?.major.toString() === '0' && msgLibVersion.minor == 0 && msgLibVersion.endpointVersion == 2) {
+        return new SimpleMessageLibProgram.SimpleMessageLib(msgLibProgram)
+    } else if (
+        msgLibVersion?.major.toString() === '3' &&
+        msgLibVersion.minor == 0 &&
+        msgLibVersion.endpointVersion == 2
+    ) {
+        return new UlnProgram.Uln(msgLibProgram)
+    }
+    throw new Error(`Unsupported message library version: ${JSON.stringify(msgLibVersion, null, 2)}`)
+}