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

package/src/simple-message-lib.ts

@@ -1,24 +1,35 @@
 import {
     AccountMeta,
+    Cluster,
+    ClusterFilter,
     Commitment,
-    Connection,
-    GetAccountInfoConfig,
+    Program,
+    ProgramError,
+    ProgramRepositoryInterface,
     PublicKey,
-    TransactionInstruction,
-} from '@solana/web3.js'
+    RpcInterface,
+    Signer,
+    WrappedInstruction,
+    createNoopSigner,
+    createNullRpc,
+    defaultPublicKey,
+} from '@metaplex-foundation/umi'
+import { createDefaultProgramRepository } from '@metaplex-foundation/umi-program-repository'
+import { fromWeb3JsPublicKey, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from '@solana/spl-token'
 
 import { PacketV1Codec } from '@layerzerolabs/lz-v2-utilities'
 
-import * as accounts from './generated/simple_messagelib/accounts'
-import * as errors from './generated/simple_messagelib/errors'
-import * as instructions from './generated/simple_messagelib/instructions'
-import * as types from './generated/simple_messagelib/types'
-import { EndpointPDADeriver, MessageLibPDADeriver } from './pda-deriver'
-
 import { EndpointProgram, MessageLibInterface, SolanaPacketPath } from '.'
+import { ENDPOINT_PROGRAM_ID } from './endpoint'
+import { SIMPLE_MESSAGELIB_PROGRAM_ID } from './generated/kinobi/simple_messagelib'
+import * as accounts from './generated/kinobi/simple_messagelib/accounts'
+import * as errors from './generated/kinobi/simple_messagelib/errors'
+import * as instructions from './generated/kinobi/simple_messagelib/instructions'
+import * as types from './generated/kinobi/simple_messagelib/types'
+import { EndpointPDA, MessageLibPDA } from './pda'
 
-export { PROGRAM_ID } from './generated/simple_messagelib'
-
+export { SIMPLE_MESSAGELIB_PROGRAM_ID } from './generated/kinobi/simple_messagelib'
 export { accounts, instructions, types, errors }
 
 /**
@@ -26,18 +37,37 @@ export { accounts, instructions, types, errors }
  * @see {@link MessageLibInterface}
  */
 export class SimpleMessageLib implements MessageLibInterface {
-    /**
-     * The PDA deriver for the message library.
-     */
-    deriver: MessageLibPDADeriver
+    public readonly pda: MessageLibPDA
+    public readonly programRepo: ProgramRepositoryInterface
 
-    /**
-     * Creates an instance of the SimpleMessageLib class.
-     *
-     * @param {PublicKey} program - The program public key.
-     */
-    constructor(public program: PublicKey) {
-        this.deriver = new MessageLibPDADeriver(program)
+    constructor(
+        public programId: PublicKey = SIMPLE_MESSAGELIB_PROGRAM_ID,
+        rpc?: RpcInterface
+    ) {
+        this.pda = new MessageLibPDA(programId)
+        if (rpc === undefined) {
+            rpc = createNullRpc()
+            rpc.getCluster = (): Cluster => 'custom'
+        }
+        this.programRepo = createDefaultProgramRepository({ rpc }, [
+            {
+                name: 'simpleMessagelib',
+                publicKey: programId,
+                getErrorFromCode(code: number, cause?: Error): ProgramError | null {
+                    return errors.getSimpleMessagelibErrorFromCode(code, this, cause)
+                },
+                getErrorFromName(name: string, cause?: Error): ProgramError | null {
+                    return errors.getSimpleMessagelibErrorFromName(name, this, cause)
+                },
+                isOnCluster(): boolean {
+                    return true
+                },
+            } satisfies Program,
+        ])
+    }
+
+    getProgram(clusterFilter: ClusterFilter = 'custom'): Program {
+        return this.programRepo.get('simpleMessagelib', clusterFilter)
     }
 
     /**
@@ -53,75 +83,67 @@ export class SimpleMessageLib implements MessageLibInterface {
      * @returns {TransactionInstruction} The transaction instruction.
      */
     initSimpleMessageLib(
-        endpointProgram: PublicKey,
-        payer: PublicKey,
-        admin: PublicKey,
-        eid: number,
-        nativeFee: number,
-        lzTokenFee = 0
-    ): TransactionInstruction {
-        const [messageLibPda] = this.deriver.messageLib()
-        const [endpointAuth] = new EndpointPDADeriver(endpointProgram).messageLibraryInfo(messageLibPda)
-        return instructions.createInitMessageLibInstruction(
+        payer: Signer,
+        param: {
+            endpointProgram?: PublicKey
+            admin: PublicKey
+            eid: number
+            nativeFee: number
+            lzTokenFee: number
+        }
+    ): WrappedInstruction {
+        const [messageLib] = this.pda.messageLib()
+        const { endpointProgram, admin, eid, nativeFee, lzTokenFee } = param
+        const [endpointAuth] = new EndpointPDA(endpointProgram ?? ENDPOINT_PROGRAM_ID).messageLibraryInfo(messageLib)
+        return instructions.initMessageLib(
+            { payer, programs: this.programRepo },
             {
                 payer,
-                messageLib: messageLibPda,
-            } satisfies instructions.InitMessageLibInstructionAccounts,
-            {
-                params: {
-                    endpointProgram: endpointProgram,
-                    endpoint: endpointAuth,
-                    eid,
-                    admin,
-                    fee: nativeFee,
-                    lzTokenFee,
-                } satisfies types.InitMessageLibParams,
-            },
-            this.program
-        )
+                messageLib: messageLib,
+
+                // param
+                endpointProgram: endpointProgram ?? ENDPOINT_PROGRAM_ID,
+                endpoint: endpointAuth,
+                eid,
+                admin,
+                fee: nativeFee,
+                lzTokenFee,
+            }
+        ).items[0]
     }
 
     /**
      * Sets the whitelist caller.
      *
-     * @param {PublicKey} admin - The admin public key.
+     * @param {Signer} admin - The admin public key.
      * @param {PublicKey} newCaller - The new caller public key.
      *
      * @returns {TransactionInstruction} The transaction instruction.
      */
-    setWhitelistCaller(admin: PublicKey, newCaller: PublicKey): TransactionInstruction {
-        const [messageLibPDA] = this.deriver.messageLib()
-        return instructions.createSetWlCallerInstruction(
+    setWhitelistCaller(admin: Signer, newCaller: PublicKey): WrappedInstruction {
+        const [messageLibPDA] = this.pda.messageLib()
+        return instructions.setWlCaller(
+            { programs: this.programRepo },
             {
                 admin,
                 messageLib: messageLibPDA,
-            } satisfies instructions.SetWlCallerInstructionAccounts,
-            {
-                params: {
-                    newCaller,
-                } satisfies types.SetWlCallerParams,
-            } satisfies instructions.SetWlCallerInstructionArgs,
-            this.program
-        )
+                newCaller,
+            }
+        ).items[0]
     }
 
     /**
      * Checks if a caller is whitelisted.
      *
-     * @param {Connection} connection - The connection object.
+     * @param {RpcInterface} rpc - The connection object.
      * @param {PublicKey} caller - The caller public key.
-     * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment or config.
      *
      * @returns {Promise<boolean>} A promise that resolves to true if the caller is whitelisted, false otherwise.
      */
-    async isWhiteListed(
-        connection: Connection,
-        caller: PublicKey,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<boolean> {
+    async isWhiteListed(rpc: RpcInterface, caller: PublicKey): Promise<boolean> {
         try {
-            const exceptedCaller = await this.getWhiteListCaller(connection, commitmentOrConfig)
-            return exceptedCaller.equals(caller)
+            const exceptedCaller = await this.getWhiteListCaller(rpc)
+            return exceptedCaller === caller
         } catch (e) {
             return false
         }
@@ -130,86 +152,152 @@ export class SimpleMessageLib implements MessageLibInterface {
     /**
      * Gets the whitelisted caller.
      *
-     * @param {Connection} connection - The connection object.
+     * @param {RpcInterface} rpc - The connection object.
      * @param {Commitment | GetAccountInfoConfig} [commitmentOrConfig] - The commitment or config.
      *
      * @returns {Promise<PublicKey>} A promise that resolves to the whitelisted caller public key.
      */
-    async getWhiteListCaller(
-        connection: Connection,
-        commitmentOrConfig?: Commitment | GetAccountInfoConfig
-    ): Promise<PublicKey> {
-        const [messageLibPDA] = this.deriver.messageLib()
-        const messageLibInfo = await accounts.MessageLib.fromAccountAddress(
-            connection,
-            messageLibPDA,
-            commitmentOrConfig
-        )
+    async getWhiteListCaller(rpc: RpcInterface): Promise<PublicKey> {
+        const [messageLib] = this.pda.messageLib()
+        const messageLibInfo = await accounts.fetchMessageLib({ rpc }, messageLib, {})
         return messageLibInfo.wlCaller
     }
 
     /**
      * Validates a packet.
      *
-     * @param {Connection} _connection - The connection object.
-     * @param {PublicKey} endpointProgram - The endpoint program public key.
-     * @param {PublicKey} payer - The payer public key.
+     * @param {Signer} payer - The payer public key.
      * @param {Uint8Array} encodedPacket - The encoded packet.
+     * @param {PublicKey} endpointProgram - The endpoint program public key.
      *
      * @returns {TransactionInstruction} The transaction instruction.
      */
-    validatePacket(
-        _connection: Connection,
-        endpointProgram: PublicKey,
-        payer: PublicKey,
-        encodedPacket: Uint8Array
-    ): TransactionInstruction {
+    validatePacket(payer: Signer, encodedPacket: Uint8Array, endpointProgram?: PublicKey): WrappedInstruction {
         const packet = PacketV1Codec.fromBytes(encodedPacket)
-        const [receiveLibrary] = this.deriver.messageLib()
-        const endpoint = new EndpointProgram.Endpoint(endpointProgram)
+        const [receiveLibrary] = this.pda.messageLib()
+        const endpoint = new EndpointProgram.Endpoint(endpointProgram ?? ENDPOINT_PROGRAM_ID)
 
-        return instructions.createValidatePacketInstruction(
+        const txBuilder = instructions.validatePacket(
+            { programs: this.programRepo, payer: payer },
             {
-                payer: payer,
                 receiveLibrary,
-                anchorRemainingAccounts: endpoint.getVerifyIXAccountMetaForCPI(packet, receiveLibrary),
-            } satisfies instructions.ValidatePacketInstructionAccounts,
-            {
-                params: { packet: encodedPacket } satisfies types.ValidatePacketParams,
-            } satisfies instructions.ValidatePacketInstructionArgs,
-            this.program
+                packet: encodedPacket,
+            }
         )
+        return txBuilder.addRemainingAccounts(endpoint.getVerifyIXAccountMetaForCPI(packet, receiveLibrary)).items[0]
     }
 
     /**
      * Gets the account meta of the send instruction for CPI (Cross-Program Invocation).
      *
-     * @param {Connection} _connection - The connection object.
+     * @param {RpcInterface} _rpc - The connection object.
      * @param {PublicKey} payer - The payer public key.
-     * @param {PacketPath} _path - The packet path.
+     * @param {SolanaPacketPath} _path - The packet path.
      *
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account meta.
      */
     async getSendIXAccountMetaForCPI(
-        _connection: Connection,
+        _rpc: RpcInterface,
         payer: PublicKey,
         _path: SolanaPacketPath
     ): Promise<AccountMeta[]> {
-        const [msgLib] = this.deriver.messageLib()
-        const cpiAccounts = instructions.createSendInstructionAccounts(
+        const [msgLib] = this.pda.messageLib()
+        const txBuilder = instructions.send(
+            { payer: createNoopSigner(payer), programs: this.programRepo },
             {
-                endpoint: PublicKey.default, // useless
+                endpoint: createNoopSigner(defaultPublicKey()), // useless
                 messageLib: msgLib,
-                payer,
-            } satisfies instructions.SendInstructionAccounts,
-            this.program
+                payer: createNoopSigner(payer),
+
+                //param
+                packet: {
+                    nonce: 0,
+                    srcEid: 0,
+                    sender: defaultPublicKey(),
+                    dstEid: 0,
+                    receiver: new Uint8Array(32),
+                    guid: new Uint8Array(32),
+                    message: new Uint8Array(0),
+                },
+                options: new Uint8Array([0, 0, 0, 0]),
+                nativeFee: 0,
+            }
         )
-        cpiAccounts.forEach((key) => {
-            if (!payer.equals(key.pubkey)) {
+        const cpiAccounts = txBuilder.getInstructions()[0].keys.map((key) => {
+            if (payer !== key.pubkey) {
                 key.isSigner = false
             }
+            return key
         })
+        return Promise.resolve(cpiAccounts.slice(1))
+    }
 
+    /***
+     * Get the account meta of the send instruction for CPI(Cross-Program Invocation ) with lzToken
+     */
+    async getSendWithLzTokenIXAccountMetaForCPI(
+        _rpc: RpcInterface,
+        accounts: {
+            payer: PublicKey
+            tokenMint: PublicKey
+            tokenSource: PublicKey
+        },
+        _path: SolanaPacketPath,
+        programs: {
+            tokenProgram?: PublicKey
+            associatedTokenProgram?: PublicKey
+        } = {
+            tokenProgram: fromWeb3JsPublicKey(TOKEN_PROGRAM_ID),
+            associatedTokenProgram: fromWeb3JsPublicKey(ASSOCIATED_TOKEN_PROGRAM_ID),
+        },
+        _commitment: Commitment = 'confirmed'
+    ): Promise<AccountMeta[]> {
+        const { payer, tokenMint, tokenSource } = accounts
+        const [msgLib] = this.pda.messageLib()
+        const {
+            tokenProgram = fromWeb3JsPublicKey(TOKEN_PROGRAM_ID),
+            associatedTokenProgram = fromWeb3JsPublicKey(ASSOCIATED_TOKEN_PROGRAM_ID),
+        } = programs
+        const messageLibLzToken = await getAssociatedTokenAddress(
+            toWeb3JsPublicKey(tokenMint),
+            toWeb3JsPublicKey(msgLib),
+            true,
+            toWeb3JsPublicKey(tokenProgram),
+            toWeb3JsPublicKey(associatedTokenProgram)
+        )
+        const txBuilder = instructions.sendWithLzToken(
+            { payer: createNoopSigner(payer), programs: this.programRepo },
+            {
+                endpoint: createNoopSigner(defaultPublicKey()),
+                messageLib: msgLib,
+                payer: createNoopSigner(payer),
+                messageLibLzToken: fromWeb3JsPublicKey(messageLibLzToken),
+                lzTokenSource: tokenSource,
+                lzTokenMint: tokenMint,
+            },
+            {
+                //param
+                packet: {
+                    nonce: 0,
+                    srcEid: 0,
+                    sender: defaultPublicKey(),
+                    dstEid: 0,
+                    receiver: new Uint8Array(32),
+                    guid: new Uint8Array(32),
+                    message: new Uint8Array(0),
+                },
+                options: new Uint8Array([0, 0, 0, 0]),
+                nativeFee: 0,
+                lzTokenFee: 0,
+                lzTokenMint: tokenMint,
+            }
+        )
+        const cpiAccounts = txBuilder.getInstructions()[0].keys.map((key) => {
+            if (payer !== key.pubkey) {
+                key.isSigner = false
+            }
+            return key
+        })
         return Promise.resolve(cpiAccounts.slice(1))
     }
 
@@ -224,80 +312,100 @@ export class SimpleMessageLib implements MessageLibInterface {
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account meta.
      */
     async getQuoteIXAccountMetaForCPI(
-        _connection: Connection,
+        _rpc: RpcInterface,
         _payer: PublicKey,
         _path: SolanaPacketPath,
-        _commitment?: Commitment
+        _commitment: Commitment = 'confirmed'
     ): Promise<AccountMeta[]> {
-        const [msgLib] = this.deriver.messageLib()
-        const keys = instructions.createQuoteInstructionAccounts(
+        const [msgLib] = this.pda.messageLib()
+        const txBuilder = instructions.quote(
+            { programs: this.programRepo },
             {
-                endpoint: PublicKey.default, // useless
+                endpoint: createNoopSigner(defaultPublicKey()), // useless
                 messageLib: msgLib,
-            } satisfies instructions.QuoteInstructionAccounts,
-            this.program
+                //param
+                packet: {
+                    nonce: 0,
+                    srcEid: 0,
+                    sender: defaultPublicKey(),
+                    dstEid: 0,
+                    receiver: new Uint8Array(32),
+                    guid: new Uint8Array(32),
+                    message: new Uint8Array(0),
+                },
+                options: new Uint8Array([0, 0, 0, 0]),
+                payInLzToken: false,
+            }
         )
-        return Promise.resolve(keys.slice(1))
+        return Promise.resolve(txBuilder.getInstructions()[0].keys.slice(1))
     }
 
     /**
      * Gets the account meta of the init config instruction for CPI (Cross-Program Invocation).
      *
      * @param {PublicKey} payer - The payer public key.
-     * @param {PublicKey} oappID - The oapp ID public key.
+     * @param {PublicKey} oapp - The oapp ID public key.
      * @param {number} eid - The endpoint ID.
      *
      * @returns {AccountMeta[]} An array of account meta.
      */
-    getInitConfigIXAccountMetaForCPI(payer: PublicKey, oappID: PublicKey, eid: number): AccountMeta[] {
-        const [sendConfig] = this.deriver.sendConfig(eid, oappID)
-        const [receiveConfig] = this.deriver.receiveConfig(eid, oappID)
-        const [messageLib] = this.deriver.messageLib()
-
-        const keys = instructions.createInitConfigInstructionAccounts(
+    getInitConfigIXAccountMetaForCPI(payer: PublicKey, oapp: PublicKey, eid: number): AccountMeta[] {
+        const [sendConfig] = this.pda.sendConfig(eid, oapp)
+        const [receiveConfig] = this.pda.receiveConfig(eid, oapp)
+        const [messageLib] = this.pda.messageLib()
+        const txBuilder = instructions.initConfig(
+            { payer: createNoopSigner(payer), programs: this.programRepo },
             {
-                endpoint: PublicKey.default, // useless
-                payer,
+                endpoint: createNoopSigner(defaultPublicKey()),
+                payer: createNoopSigner(payer),
                 messageLib,
                 sendConfig,
                 receiveConfig,
-            } satisfies instructions.InitConfigInstructionAccounts,
-            this.program
+                // param
+                oapp,
+                eid,
+            }
         )
-        keys.forEach((key) => {
-            if (!payer.equals(key.pubkey)) {
+        const cpiAccounts = txBuilder.getInstructions()[0].keys.map((key) => {
+            if (payer !== key.pubkey) {
                 key.isSigner = false
             }
+            return key
         })
-        return keys.slice(1)
+        return cpiAccounts.slice(1)
     }
 
     /**
      * Gets the account meta of the set config instruction for CPI (Cross-Program Invocation).
      *
-     * @param {PublicKey} endpointProgram - The endpoint program public key.
-     * @param {PublicKey} oappID - The oapp ID public key.
+     * @param {PublicKey} oapp - The oapp ID public key.
      * @param {number} eid - The endpoint ID.
+     * @param {PublicKey} _endpointProgram - The endpoint program public key.
      *
      * @returns {Promise<AccountMeta[]>} A promise that resolves to an array of account meta.
      */
-    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 [msgLib] = this.deriver.messageLib()
-        const accounts = instructions.createSetConfigInstructionAccounts(
+    getSetConfigIXAccountMetaForCPI(
+        oapp: PublicKey,
+        eid: number,
+        _endpointProgram: PublicKey = ENDPOINT_PROGRAM_ID
+    ): AccountMeta[] {
+        const [sendConfig] = this.pda.sendConfig(eid, oapp)
+        const [receiveConfig] = this.pda.receiveConfig(eid, oapp)
+        const [msgLib] = this.pda.messageLib()
+        const txBuilder = instructions.setConfig(
+            { programs: this.programRepo },
             {
-                endpoint: PublicKey.default, // useless
+                endpoint: createNoopSigner(ENDPOINT_PROGRAM_ID), // useless
                 sendConfig,
                 receiveConfig,
                 messageLib: msgLib,
-            } satisfies instructions.SetConfigInstructionAccounts,
-            this.program
+                // param
+                oapp: oapp,
+                eid: 0,
+                configType: 0,
+                config: new Uint8Array(0),
+            }
         )
-        return Promise.resolve(accounts.slice(1))
+        return txBuilder.getInstructions()[0].keys.slice(1)
     }
 }

package/src/{base-oapp.ts → solita/base-oapp.ts}

@@ -1,12 +1,11 @@
 import { AccountInfo, Commitment, Connection, GetAccountInfoConfig, PublicKey } from '@solana/web3.js'
 import BN from 'bn.js'
 
+import { SimpleMessageLibProgram, UlnProgram } from '.'
 import * as EndpointProgram from './endpoint'
 import { COUNT_SEED, LZ_COMPOSE_TYPES_SEED, LZ_RECEIVE_TYPES_SEED, OAppBasePDADeriver } from './pda-deriver'
 import { AddressType } from './types'
 
-import { SimpleMessageLibProgram, UlnProgram } from '.'
-
 // TODO - replace default seed to a convention ID Seed
 
 /**
@@ -150,7 +149,7 @@ export abstract class BaseOApp {
         const [remotePDA] = this.oappBaseDeriver.remote(dstEid)
         const info = await this.queryPDAInfo(connection, remotePDA, commitmentOrConfig)
         if (info) {
-            // the first 8 bytes is account discriminator, so skip it. After that, the next 32 bytes is the address.
+            // the first 8 bytes is account discriminator, so skip it. The next 32 bytes is the address.
             const result = AddressType.read(info.data, 8)
             return Uint8Array.from(result)
         }

package/src/solita/config.ts

@@ -0,0 +1,32 @@
+import { Environment } from '@layerzerolabs/lz-definitions'
+
+/**
+ * Array of IDL types.
+ */
+export const idlTypes = [
+    'MessageLibQuoteParams',
+    'MessageLibSendParams',
+    'MessagingFee',
+    'MessagingReceipt',
+    'PacketForQuote',
+    'Packet',
+    'InitConfigParams',
+    'MessageLibSetConfigParams',
+    'MessageLibSnapshotConfigParams',
+    'MessageLibResetConfigParams',
+]
+
+/**
+ * Array of message libraries.
+ */
+export const messageLibs = ['uln', 'simple_messagelib']
+
+/**
+ * Faucet URLs for different environments.
+ */
+export const FAUCET_URL: { [env in Environment]: string } = {
+    [Environment.MAINNET]: '',
+    [Environment.TESTNET]: '',
+    [Environment.DEVNET]: '',
+    [Environment.LOCAL]: 'http://127.0.0.1:9900',
+}