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

package/src/pricefeed.ts

@@ -1,208 +1,155 @@
-import { bignum } from '@metaplex-foundation/beet'
-import { Commitment, Connection, GetAccountInfoConfig, PublicKey, TransactionInstruction } from '@solana/web3.js'
+import {
+    Cluster,
+    ClusterFilter,
+    Commitment,
+    OptionOrNullable,
+    Program,
+    ProgramError,
+    ProgramRepositoryInterface,
+    PublicKey,
+    RpcInterface,
+    Signer,
+    WrappedInstruction,
+    createNullRpc,
+} from '@metaplex-foundation/umi'
+import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
 
-import * as accounts from './generated/pricefeed/accounts'
-import * as instructions from './generated/pricefeed/instructions'
-import * as types from './generated/pricefeed/types'
-import { PriceFeedPDADeriver } from './pda-deriver'
+import { PRICEFEED_PROGRAM_ID } from './generated/kinobi/pricefeed'
+import * as accounts from './generated/kinobi/pricefeed/accounts'
+import * as errors from './generated/kinobi/pricefeed/errors'
+import * as instructions from './generated/kinobi/pricefeed/instructions'
+import * as types from './generated/kinobi/pricefeed/types'
+import { PriceFeedPDA } from './pda'
 
-export { accounts, instructions, types }
-export { PROGRAM_ID } from './generated/pricefeed'
+export { PRICEFEED_PROGRAM_ID } from './generated/kinobi/pricefeed'
+export { accounts, instructions, types, errors }
 
 /**
  * Class representing the PriceFeed.
  */
 export class PriceFeed {
-    deriver: PriceFeedPDADeriver
+    public readonly pda: PriceFeedPDA
+    public readonly programRepo: ProgramRepositoryInterface
 
-    /**
-     * Creates an instance of the PriceFeed class.
-     *
-     * @param {PublicKey} program - The public key of the program.
-     */
-    constructor(public readonly program: PublicKey) {
-        this.deriver = new PriceFeedPDADeriver(this.program)
+    constructor(
+        public readonly programId: PublicKey = PRICEFEED_PROGRAM_ID,
+        rpc?: RpcInterface
+    ) {
+        this.pda = new PriceFeedPDA(this.programId)
+        if (rpc === undefined) {
+            rpc = createNullRpc()
+            rpc.getCluster = (): Cluster => 'custom'
+        }
+        this.programRepo = createDefaultProgramRepository({ rpc }, [
+            {
+                name: 'pricefeed',
+                publicKey: programId,
+                getErrorFromCode(code: number, cause?: Error): ProgramError | null {
+                    return errors.getPricefeedErrorFromCode(code, this, cause)
+                },
+                getErrorFromName(name: string, cause?: Error): ProgramError | null {
+                    return errors.getPricefeedErrorFromName(name, this, cause)
+                },
+                isOnCluster(): boolean {
+                    return true
+                },
+            } satisfies Program,
+        ])
     }
 
-    /**
-     * Initializes the price feed.
-     *
-     * @param {Connection} connection - The Solana connection object.
-     * @param {PublicKey} payer - The public key of the payer.
-     * @param {PublicKey} admin - The public key of the admin.
-     * @param {PublicKey[]} updaters - The list of public keys of the updaters.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
-     *
-     * @returns {Promise<TransactionInstruction>} The transaction instruction.
-     */
-    async initPriceFeed(
-        connection: Connection,
-        payer: PublicKey,
-        admin: PublicKey,
-        updaters: PublicKey[],
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<TransactionInstruction> {
-        const [priceFeed] = this.deriver.priceFeed()
-        const info = await connection.getAccountInfo(priceFeed, commitmentOrConfig)
-        if (info) {
-            throw new Error('Pricefeed already initialized')
-        }
-        return instructions.createInitPriceFeedInstruction(
+    getProgram(clusterFilter: ClusterFilter = 'custom'): Program {
+        return this.programRepo.get('pricefeed', clusterFilter)
+    }
+
+    initPriceFeed(payer: Signer, param: instructions.InitPriceFeedInstructionDataArgs): WrappedInstruction {
+        return instructions.initPriceFeed(
+            { programs: this.programRepo, payer },
             {
                 payer,
-                priceFeed,
-            } satisfies instructions.InitPriceFeedInstructionAccounts,
-            {
-                params: {
-                    admin,
-                    updaters,
-                } satisfies types.InitPriceFeedParams,
-            } satisfies instructions.InitPriceFeedInstructionArgs,
-            this.program
-        )
+                priceFeed: this.pda.priceFeed(),
+                ...param,
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the price feed.
-     *
-     * @param {PublicKey} admin - The public key of the admin.
-     * @param {PublicKey[]} updaters - The list of public keys of the updaters.
-     * @param {bignum} priceRatioDenominator - The price ratio denominator.
-     * @param {number} arbitrumCompressionPercent - The Arbitrum compression percentage.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setPriceFeed(
-        admin: PublicKey,
-        updaters: PublicKey[],
-        priceRatioDenominator: bignum,
-        arbitrumCompressionPercent: number
-    ): TransactionInstruction {
-        const [priceFeed] = this.deriver.priceFeed()
-        return instructions.createSetPriceFeedInstruction(
+    setPriceFeed(admin: Signer, param: instructions.SetPriceFeedInstructionArgs): WrappedInstruction {
+        return instructions.setPriceFeed(
+            { programs: this.programRepo },
             {
                 admin,
-                priceFeed,
-            } satisfies instructions.SetPriceFeedInstructionAccounts,
-            {
-                params: {
-                    updaters,
-                    priceRatioDenominator,
-                    arbitrumCompressionPercent,
-                } satisfies types.SetPriceFeedParams,
-            } satisfies instructions.SetPriceFeedInstructionArgs,
-            this.program
-        )
+                priceFeed: this.pda.priceFeed(),
+                ...param,
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the price.
-     *
-     * @param {PublicKey} updater - The public key of the updater.
-     * @param {number} dstEid - The destination EID.
-     * @param {bignum} priceRatio - The price ratio.
-     * @param {bignum} gasPriceInUnit - The gas price in unit.
-     * @param {number} gasPerByte - The gas per byte.
-     * @param {types.ModelType | null} modelType - The model type.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setPrice(
-        updater: PublicKey,
-        dstEid: number,
-        priceRatio: bignum,
-        gasPriceInUnit: bignum,
-        gasPerByte: number,
-        modelType: types.ModelType | null
-    ): TransactionInstruction {
+    setPrice(updater: Signer, param: { dstEid: number } & OptionOrNullable<types.PriceParamsArgs>): WrappedInstruction {
         const EID_MODULUS = 30000
-        dstEid = dstEid % EID_MODULUS
-        const [priceFeed] = this.deriver.priceFeed()
-        return instructions.createSetPriceInstruction(
+        const dstEid = param.dstEid % EID_MODULUS
+        const isParamsNull = !('priceRatio' in param)
+
+        return instructions.setPrice(
+            { programs: this.programRepo },
             {
                 updater,
-                priceFeed,
-            } satisfies instructions.SetPriceInstructionAccounts,
-            {
-                params: {
-                    dstEid,
-                    params: {
-                        priceRatio,
-                        gasPriceInUnit,
-                        gasPerByte,
-                        modelType,
-                    },
-                } satisfies types.SetPriceParams,
-            } satisfies instructions.SetPriceInstructionArgs,
-            this.program
-        )
+                priceFeed: this.pda.priceFeed(),
+                dstEid,
+                params: isParamsNull
+                    ? null
+                    : {
+                          priceRatio: param.priceRatio,
+                          gasPriceInUnit: param.gasPriceInUnit,
+                          gasPerByte: param.gasPerByte,
+                          modelType: param.modelType,
+                      },
+            }
+        ).items[0]
     }
 
-    /**
-     * Sets the SOL price.
-     *
-     * @param {PublicKey} updater - The public key of the updater.
-     * @param {bignum | null} nativeTokenPriceUsd - The native token price in USD.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    setSolPrice(updater: PublicKey, nativeTokenPriceUsd: bignum | null): TransactionInstruction {
-        const [priceFeed] = this.deriver.priceFeed()
-        return instructions.createSetSolPriceInstruction(
+    setSolPrice(updater: Signer, nativeTokenPriceUsd: OptionOrNullable<number | bigint>): WrappedInstruction {
+        return instructions.setSolPrice(
+            { programs: this.programRepo },
             {
-                priceFeed,
                 updater,
-            } satisfies instructions.SetSolPriceInstructionAccounts,
-            {
-                params: {
-                    nativeTokenPriceUsd,
-                } satisfies types.SetSolPriceParams,
-            } satisfies instructions.SetSolPriceInstructionArgs,
-            this.program
-        )
+                priceFeed: this.pda.priceFeed(),
+                nativeTokenPriceUsd,
+            }
+        ).items[0]
     }
 
-    /**
-     * Transfers the admin role.
-     *
-     * @param {PublicKey} admin - The public key of the current admin.
-     * @param {PublicKey} newAdmin - The public key of the new admin.
-     *
-     * @returns {TransactionInstruction} The transaction instruction.
-     */
-    transferAdmin(admin: PublicKey, newAdmin: PublicKey): TransactionInstruction {
-        const [priceFeed] = this.deriver.priceFeed()
-        return instructions.createTransferAdminInstruction(
+    transferAdmin(admin: Signer, newAdmin: PublicKey): WrappedInstruction {
+        return instructions.transferAdmin(
+            { programs: this.programRepo },
             {
                 admin,
-                priceFeed,
-            } satisfies instructions.TransferAdminInstructionAccounts,
+                priceFeed: this.pda.priceFeed(),
+            },
             {
-                params: {
-                    admin: newAdmin,
-                } satisfies types.TransferAdminParams,
-            } satisfies instructions.TransferAdminInstructionArgs,
-            this.program
-        )
+                admin: newAdmin,
+            }
+        ).items[0]
+    }
+
+    getFee(param: instructions.GetFeeInstructionArgs): WrappedInstruction {
+        return instructions.getFee(
+            { programs: this.programRepo },
+            {
+                priceFeed: this.pda.priceFeed(),
+                ...param,
+            }
+        ).items[0]
     }
 
     /**
      * Retrieves the price feed account.
      *
-     * @param {Connection} connection - The Solana connection object.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
+     * @param {RpcInterface} rpc - The Solana connection object.
+     * @param {Commitment} [commitment] - Optional commitment or configuration.
      *
      * @returns {Promise<accounts.PriceFeed | null>} The price feed account or null if not found.
      */
-    async getPriceFeed(
-        connection: Connection,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<accounts.PriceFeed | null> {
-        const [priceFeed] = this.deriver.priceFeed()
-        try {
-            return await accounts.PriceFeed.fromAccountAddress(connection, priceFeed, commitmentOrConfig)
-        } catch (e) {
-            return null
-        }
+    async getPriceFeed(rpc: RpcInterface, commitment: Commitment = 'confirmed'): Promise<accounts.PriceFeed | null> {
+        const [priceFeed] = this.pda.priceFeed()
+        return accounts.safeFetchPriceFeed({ rpc }, priceFeed, { commitment })
     }
 }

package/src/receive.ts

@@ -0,0 +1,285 @@
+import {
+    AccountMeta,
+    Commitment,
+    Instruction,
+    PublicKey,
+    RpcInterface,
+    defaultPublicKey,
+    publicKey,
+} from '@metaplex-foundation/umi'
+import { array, publicKey as publicKeySerializer } from '@metaplex-foundation/umi/serializers'
+import { toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import invariant from 'tiny-invariant'
+
+import { arrayify } from '@layerzerolabs/lz-utilities'
+import { Packet, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
+
+import { OmniAppPDA } from '.'
+import { ComposeSentEvent } from './generated/kinobi/endpoint/events'
+import {
+    LzComposeParams,
+    LzReceiveParams,
+    getLzComposeParamsSerializer,
+    getLzReceiveAccountSerializer,
+    getLzReceiveParamsSerializer,
+} from './types'
+import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
+
+/**
+ * Receives a LayerZero message.
+ *
+ * @param {Connection} connection - The Solana connection object.
+ * @param {PublicKey} payer - The public key of the payer.
+ * @param {Packet} packet - The packet containing the message.
+ * @param {Uint8Array} [callerParams] - Optional caller parameters.
+ * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
+ *
+ * @returns {Promise<TransactionInstruction>} The transaction instruction.
+ */
+export async function lzReceive(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    packet: Pick<Packet, 'message' | 'sender' | 'srcEid' | 'guid' | 'receiver' | 'nonce'>,
+    callerParams: Uint8Array = Uint8Array.from([0, 0]),
+    commitment: Commitment = 'confirmed'
+): Promise<Instruction> {
+    const { message: message_, sender: sender, srcEid, guid, receiver: receiver_ } = packet
+    const receiver = publicKey(addressToBytes32(receiver_))
+    const message = arrayify(message_)
+    const params: LzReceiveParams = {
+        srcEid: srcEid,
+        sender: arrayify(sender),
+        guid: arrayify(guid),
+        message,
+        callerParams,
+        nonce: BigInt(packet.nonce),
+    }
+    const receiverInfo = await rpc.getAccount(receiver, { commitment })
+    invariant(receiverInfo.exists, `Receiver account not found: ${receiver}`)
+    const receiverProgram = publicKey(receiverInfo.owner)
+    const accounts = await getLzReceiveAccounts(rpc, payer, receiver, receiverProgram, params, commitment)
+
+    const MSG_TYPE_OFFSET = 0
+    // const msgType: string = message[MSG_TYPE_OFFSET].toString()
+    // if (msgType !== MessageType.COMPOSED_TYPE.toString() && msgType !== MessageType.VANILLA.toString()) {
+    //     throw new Error(`Invalid message type ${msgType}`)
+    // }
+
+    const data = getLzReceiveParamsSerializer().serialize(params)
+    return {
+        programId: receiverProgram,
+        keys: accounts,
+        data: Buffer.concat([instructionDiscriminator('lz_receive'), data]),
+    }
+}
+
+/**
+ * Composes a LayerZero message.
+ *
+ * @param {Connection} connection - The Solana connection object.
+ * @param {PublicKey} payer - The public key of the payer.
+ * @param {ComposeSentEvent} event - The event containing the message details.
+ * @param {Uint8Array} [extraData] - Optional extra data.
+ * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
+ *
+ * @returns {Promise<TransactionInstruction>} The transaction instruction.
+ */
+export async function lzCompose(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    event: ComposeSentEvent,
+    extraData: Uint8Array = Uint8Array.from([0, 0]),
+    commitment: Commitment = 'confirmed'
+): Promise<Instruction> {
+    const { to, from, guid, index, message } = event
+    const params: LzComposeParams = {
+        from,
+        to,
+        guid,
+        index,
+        message,
+        extraData,
+    }
+    const accountInfo = await rpc.getAccount(to, { commitment })
+    if (!accountInfo.exists) {
+        throw new Error(`Account not found: ${to}`)
+    }
+    const programId = accountInfo.owner
+    const accounts = await getLzComposeAccountMeta(rpc, payer, to, programId, params, commitment)
+
+    const data = getLzComposeParamsSerializer().serialize(params)
+    return {
+        programId,
+        keys: accounts,
+        data: Buffer.concat([instructionDiscriminator('lz_compose'), data]),
+    }
+}
+
+/// LzReceiveTypes instruction provides a list of accounts that are used in the LzReceive
+/// instruction. The list of accounts required by this LzReceiveTypes instruction can be found
+/// from the specific PDA account that is generated by the LZ_RECEIVE_TYPES_SEED.
+/**
+ * Retrieves the accounts required for the LzReceive instruction.
+ *
+ * @param {Connection} connection - The Solana connection object.
+ * @param {PublicKey} payer - The public key of the payer.
+ * @param {PublicKey} receiver - The public key of the receiver.
+ * @param {PublicKey} receiverProgram - The public key of the receiver program.
+ * @param {LzReceiveParams} params - The parameters for the LzReceive instruction.
+ * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
+ *
+ * @returns {Promise<AccountMeta[]>} The list of account metadata.
+ */
+export async function getLzReceiveAccounts(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    receiver: PublicKey,
+    receiverProgram: PublicKey,
+    params: LzReceiveParams,
+    commitment: Commitment = 'confirmed'
+): Promise<AccountMeta[]> {
+    const lzReceiveTypesAccounts = await (async (): Promise<AccountMeta[]> => {
+        const oappPDA = new OmniAppPDA(receiverProgram)
+        const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver)
+        // const [lzReceiveTypesAccountsPDA] = deriveLzReceiveTypesAccountsPDA(receiverProgram, receiver)
+        // Get the lzReceiveTypesAccounts. Deserialize the AccountInfo.data to get the lzReceiveTypesAccounts.
+        const info = await rpc.getAccount(lzReceiveTypesAccountsPDA, { commitment })
+        const accounts = []
+        if (info.exists) {
+            const buffer = Buffer.from(info.data)
+            const len = buffer.length - 8
+            if (len % 32 !== 0) {
+                throw new Error(
+                    `Invalid length of AccountInfo.data. The length must be a multiple of 32 plus 8.(n*32+8). Current length is ${buffer.length}`
+                )
+            }
+            // const serializer = array(publicKeySerializer())
+            // const [addresses] = serializer.deserialize(buffer, 8)
+            // for (const address of addresses) {
+            //     accounts.push({
+            //         pubkey: address,
+            //         isSigner: false,
+            //         isWritable: false,
+            //     })
+            // }
+            for (let i = 8; i < len; i += 32) {
+                const [address] = publicKeySerializer().deserialize(buffer, i)
+                accounts.push({
+                    pubkey: address,
+                    isSigner: false,
+                    isWritable: false,
+                })
+            }
+        }
+        return accounts
+    })()
+
+    const data = getLzReceiveParamsSerializer().serialize(params)
+    const lzReceiveTypesIx: Instruction = {
+        programId: receiverProgram,
+        keys: lzReceiveTypesAccounts,
+        data: Buffer.concat([instructionDiscriminator('lz_receive_types'), data]),
+    }
+    const keys = await simulateWeb3JsTransaction(
+        rpc.getEndpoint(),
+        [toWeb3JsInstruction(lzReceiveTypesIx)],
+        toWeb3JsPublicKey(receiverProgram),
+        toWeb3JsPublicKey(payer),
+        array(getLzReceiveAccountSerializer()),
+        'confirmed'
+    )
+    return updateAccountFromSimulatedResp(keys, payer)
+}
+
+/**
+ * Retrieves the accounts required for the LzCompose instruction.
+ *
+ * @param {Connection} connection - The Solana connection object.
+ * @param {PublicKey} payer - The public key of the payer.
+ * @param {PublicKey} to - The public key of the recipient.
+ * @param {PublicKey} composerProgram - The public key of the composer program.
+ * @param {LzComposeParams} params - The parameters for the LzCompose instruction.
+ * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - Optional commitment or configuration.
+ *
+ * @returns {Promise<AccountMeta[]>} The list of account metadata.
+ */
+export async function getLzComposeAccountMeta(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    to: PublicKey,
+    composerProgram: PublicKey,
+    params: LzComposeParams,
+    commitment: Commitment = 'confirmed'
+): Promise<AccountMeta[]> {
+    const lzComposeTypesAccounts = await (async (): Promise<AccountMeta[]> => {
+        const oappPDA = new OmniAppPDA(composerProgram)
+        const [lzComposeTypesAccountsPDA] = oappPDA.lzComposeTypesAccounts(to)
+        // const [lzComposeTypesAccountsPDA] = deriveLzComposeTypesAccountsPDA(composerProgram, to)
+        // Get the lzReceiveTypesAccounts. Deserialize the AccountInfo.data to get the lzComposeTypesAccounts.
+        const info = await rpc.getAccount(lzComposeTypesAccountsPDA, { commitment })
+        const accounts = []
+        if (info.exists) {
+            const buffer = Buffer.from(info.data)
+            const len = buffer.length - 8
+            if (len % 32 !== 0) {
+                throw new Error(
+                    `Invalid length of AccountInfo.data. The length must be a multiple of 32 plus 8.(n*32+8). Current length is ${buffer.length}`
+                )
+            }
+            // const serializer = array(publicKeySerializer())
+            // const [addresses] = serializer.deserialize(buffer, 8)
+            // for (const address of addresses) {
+            //     accounts.push({
+            //         pubkey: address,
+            //         isSigner: false,
+            //         isWritable: false,
+            //     })
+            // }
+            for (let i = 8; i < len; i += 32) {
+                const [address] = publicKeySerializer().deserialize(buffer, i)
+                accounts.push({
+                    pubkey: address,
+                    isSigner: false,
+                    isWritable: false,
+                })
+            }
+        }
+        return accounts
+    })()
+
+    const data = getLzComposeParamsSerializer().serialize(params)
+    const lzComposeTypesIx: Instruction = {
+        programId: composerProgram,
+        keys: lzComposeTypesAccounts,
+        data: Buffer.concat([instructionDiscriminator('lz_compose_types'), data]),
+    }
+
+    const keys = await simulateWeb3JsTransaction(
+        rpc.getEndpoint(),
+        [toWeb3JsInstruction(lzComposeTypesIx)],
+        toWeb3JsPublicKey(composerProgram),
+        toWeb3JsPublicKey(payer),
+        array(getLzReceiveAccountSerializer()),
+        'confirmed'
+    )
+    return updateAccountFromSimulatedResp(keys, payer)
+}
+
+function updateAccountFromSimulatedResp(accounts: AccountMeta[], payer?: PublicKey): AccountMeta[] {
+    return accounts.map((r) => {
+        if (r.pubkey == defaultPublicKey() && r.isSigner) {
+            if (!payer) throw new Error('payer is required')
+            return {
+                pubkey: payer,
+                isSigner: true,
+                isWritable: r.isWritable,
+            } satisfies AccountMeta
+        } else {
+            return {
+                pubkey: r.pubkey,
+                isSigner: r.isSigner,
+                isWritable: r.isWritable,
+            } satisfies AccountMeta
+        }
+    })
+}