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

package/src/next_nonce.ts

@@ -0,0 +1,107 @@
+import { Commitment, PublicKey, RpcInterface } from '@metaplex-foundation/umi'
+import {
+    Endian,
+    Serializer,
+    bytes,
+    mapSerializer,
+    publicKey as publicKeySerializer,
+    struct,
+    u32,
+    u64,
+} from '@metaplex-foundation/umi/serializers'
+import { fromWeb3JsPublicKey, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import * as web3 from '@solana/web3.js'
+
+import { arrayify } from '@layerzerolabs/lz-utilities'
+import { Packet, addressToBytes32 } from '@layerzerolabs/lz-v2-utilities'
+
+import { EDDSA } from './pda'
+import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
+
+// Data.
+export interface NextNonceInstructionData {
+    discriminator: Uint8Array
+    srcEid: number
+    sender: Uint8Array
+    receiver: PublicKey
+}
+
+export interface NextNonceInstructionDataArgs {
+    srcEid: number
+    sender: Uint8Array
+    receiver: PublicKey
+}
+
+export function getNextNonceInstructionDataSerializer(): Serializer<
+    NextNonceInstructionDataArgs,
+    NextNonceInstructionData
+> {
+    return mapSerializer<NextNonceInstructionDataArgs, any, NextNonceInstructionData>(
+        struct<NextNonceInstructionData>(
+            [
+                ['discriminator', bytes({ size: 8 })],
+                ['srcEid', u32()],
+                ['sender', bytes({ size: 32 })],
+                ['receiver', publicKeySerializer()],
+            ],
+            { description: 'NextNonceInstructionData' }
+        ),
+        (value) => ({
+            ...value,
+            discriminator: instructionDiscriminator('next_nonce'),
+        })
+    )
+}
+
+export async function nextNonce(
+    rpc: RpcInterface | web3.Connection,
+    payer: PublicKey | web3.PublicKey,
+    packet: Pick<Packet, 'sender' | 'srcEid' | 'receiver'>,
+    commitment: Commitment = 'confirmed'
+): Promise<bigint> {
+    const { sender: sender_, srcEid, receiver: receiver_ } = packet
+    const receiver = new web3.PublicKey(addressToBytes32(receiver_))
+    let connection: web3.Connection
+    if (rpc instanceof web3.Connection) {
+        connection = rpc
+    } else if ('connection' in rpc && rpc.connection instanceof web3.Connection) {
+        ;({ connection } = rpc)
+    } else {
+        throw new Error('Invalid connection')
+    }
+    const receiverInfo = await connection.getAccountInfo(receiver)
+    if (receiverInfo === null) {
+        throw new Error(`Receiver account not found: ${receiver.toBase58()}`)
+    }
+
+    const params: NextNonceInstructionDataArgs = {
+        srcEid: srcEid,
+        sender: arrayify(sender_),
+        receiver: fromWeb3JsPublicKey(receiver),
+    }
+    const receiverProgram = receiverInfo.owner
+
+    const [nonceAccount] = EDDSA.findPda(fromWeb3JsPublicKey(receiverProgram), [
+        Buffer.from('Nonce', 'utf8'),
+        params.sender,
+        u32({ endian: Endian.Big }).serialize(srcEid),
+    ])
+    const accounts: web3.AccountMeta[] = [
+        {
+            pubkey: receiver,
+            isSigner: false,
+            isWritable: false,
+        },
+        {
+            pubkey: toWeb3JsPublicKey(nonceAccount),
+            isSigner: false,
+            isWritable: true,
+        },
+    ]
+    const nextNonceIx: web3.TransactionInstruction = {
+        programId: receiverProgram,
+        keys: accounts,
+        data: Buffer.from(getNextNonceInstructionDataSerializer().serialize(params)),
+    }
+    return simulateWeb3JsTransaction(connection, [nextNonceIx], receiverProgram, payer, u64(), commitment)
+}

package/src/pda.ts

@@ -0,0 +1,328 @@
+import { Pda, PublicKey, defaultPublicKey, publicKeyBytes } from '@metaplex-foundation/umi'
+import { Endian, u16, u32, u64 } from '@metaplex-foundation/umi/serializers'
+import { createWeb3JsEddsa } from '@metaplex-foundation/umi-eddsa-web3js'
+
+export const PEER_SEED = 'Peer'
+
+export const MINT_SEED = 'Mint'
+
+export const ENFORCED_OPTIONS_SEED = 'EnforcedOptions'
+
+export const EDDSA = createWeb3JsEddsa()
+
+/**
+ * derive address for endpoint program
+ */
+export class EndpointPDA {
+    static ENDPOINT_SEED = 'Endpoint'
+    static SEND_LIBRARY_CONFIG_SEED = 'SendLibraryConfig'
+    static RECEIVE_LIBRARY_CONFIG_SEED = 'ReceiveLibraryConfig'
+    static NONCE_SEED = 'Nonce'
+    static PENDING_NONCE_SEED = 'PendingNonce'
+    static OAPP_SEED = 'OApp'
+    static PAYLOAD_HASH_SEED = 'PayloadHash'
+    static COMPOSED_MESSAGE_HASH_SEED = 'ComposedMessageHash'
+
+    program: PublicKey
+
+    constructor(program: PublicKey) {
+        this.program = program
+    }
+
+    setting(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(EndpointPDA.ENDPOINT_SEED, 'utf8')])
+    }
+
+    defaultSendLibraryConfig(dstEndpointId: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(EndpointPDA.SEND_LIBRARY_CONFIG_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(dstEndpointId),
+            // new BN(dstEndpointId).toArrayLike(Buffer, 'be', 4),
+        ])
+    }
+
+    sendLibraryConfig(sender: PublicKey, dstEndpointId: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(EndpointPDA.SEND_LIBRARY_CONFIG_SEED, 'utf8'),
+            publicKeyBytes(sender),
+            u32({ endian: Endian.Big }).serialize(dstEndpointId),
+            // new BN(dstEndpointId).toArrayLike(Buffer, 'be', 4),
+        ])
+    }
+
+    /**
+     * @param messageLibrary PDA(derive by message lib program)
+     */
+    messageLibraryInfo(messageLibrary: PublicKey): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(MessageLibPDA.MESSAGE_LIB_SEED, 'utf8'),
+            publicKeyBytes(messageLibrary),
+        ])
+    }
+
+    defaultReceiveLibraryConfig(srcEndpointId: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(EndpointPDA.RECEIVE_LIBRARY_CONFIG_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(srcEndpointId),
+            // new BN(srcEndpointId).toArrayLike(Buffer, 'be', 4),
+        ])
+    }
+
+    receiveLibraryConfig(receiver: PublicKey, srcEndpointId: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(EndpointPDA.RECEIVE_LIBRARY_CONFIG_SEED, 'utf8'),
+            publicKeyBytes(receiver),
+            u32({ endian: Endian.Big }).serialize(srcEndpointId),
+            // new BN(srcEndpointId).toArrayLike(Buffer, 'be', 4),
+        ])
+    }
+
+    receiveLibraryTimeout(_dstEndpointId: number): [PublicKey, number] {
+        // todo: @zzz find the address of receive library timeout config
+        // if it is default config, then get the address of default timeout config
+        // otherwise, get the address of the custom one
+        return [this.program, 0]
+    }
+
+    defaultMessageLib(): Pda {
+        // return this.messageLibraryInfo(PublicKey.default)
+        return this.messageLibraryInfo(defaultPublicKey())
+    }
+
+    blockMessageLib(blockMsgLib: PublicKey): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(MessageLibPDA.MESSAGE_LIB_SEED, 'utf8'),
+            publicKeyBytes(blockMsgLib),
+        ])
+    }
+
+    /**
+     * @param oapp
+     * @param remoteChainId
+     * @param remoteOapp
+     */
+    nonce(oapp: PublicKey, remoteChainId: number, remoteOapp: Uint8Array): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(EndpointPDA.NONCE_SEED, 'utf8'),
+            publicKeyBytes(oapp),
+            u32({ endian: Endian.Big }).serialize(remoteChainId),
+            // new BN(remoteChainId).toArrayLike(Buffer, 'be', 4),
+            remoteOapp,
+        ])
+    }
+
+    pendingNonce(oapp: PublicKey, remoteChainId: number, remoteOapp: Uint8Array): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(EndpointPDA.PENDING_NONCE_SEED, 'utf8'),
+            publicKeyBytes(oapp),
+            u32({ endian: Endian.Big }).serialize(remoteChainId),
+            remoteOapp,
+        ])
+    }
+
+    oappRegistry(oapp: PublicKey): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(EndpointPDA.OAPP_SEED, 'utf8'), publicKeyBytes(oapp)])
+    }
+
+    /***
+     * @param receiver
+     * @param srcEid
+     * @param sender
+     * @param nonce
+     * @param payloadHash
+     * @srcChainId u32 to big endian Uint8Array
+     * @sender [u8; 32] sender Address
+     * @nonce u64 to big endian Uint8Array
+     * @payloadHash [u8; 32]
+     */
+    payloadHash(receiver: PublicKey, srcEid: number, sender: Uint8Array, nonce: number | bigint): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(EndpointPDA.PAYLOAD_HASH_SEED, 'utf8'),
+            publicKeyBytes(receiver),
+            u32({ endian: Endian.Big }).serialize(srcEid),
+            sender,
+            u64({ endian: Endian.Big }).serialize(nonce),
+        ])
+    }
+
+    composedMessage(from: PublicKey, guid: Uint8Array, index: number, to: PublicKey, messageHash: Uint8Array): Pda {
+        return EDDSA.findPda(
+            this.program,
+            [
+                Buffer.from(EndpointPDA.COMPOSED_MESSAGE_HASH_SEED, 'utf8'),
+                publicKeyBytes(from),
+                publicKeyBytes(to),
+                guid,
+                u16({ endian: Endian.Big }).serialize(index),
+                messageHash,
+            ]
+            // this.program
+        )
+    }
+}
+
+/***
+ * derive address by message lib program
+ */
+export class MessageLibPDA {
+    static SEND_CONFIG_SEED = 'SendConfig'
+    static RECEIVE_CONFIG_SEED = 'ReceiveConfig'
+    static MESSAGE_LIB_SEED = 'MessageLib'
+
+    program: PublicKey
+
+    constructor(program: PublicKey) {
+        this.program = program
+    }
+
+    messageLib(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(MessageLibPDA.MESSAGE_LIB_SEED, 'utf8')])
+    }
+
+    sendConfig(eid: number, oapp: PublicKey): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(MessageLibPDA.SEND_CONFIG_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(eid),
+            publicKeyBytes(oapp),
+            // oapp.toBuffer(),
+        ])
+    }
+
+    receiveConfig(eid: number, oapp: PublicKey): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(MessageLibPDA.RECEIVE_CONFIG_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(eid),
+            publicKeyBytes(oapp),
+        ])
+    }
+}
+
+export class UlnPDA extends MessageLibPDA {
+    static ULN_SEED = MessageLibPDA.MESSAGE_LIB_SEED
+    static ULN_CONFIG_SEED = 'UlnConfig'
+    static OPTIONS_SEED = 'Options'
+    static CONFIRMATIONS_SEED = 'Confirmations'
+    static WORKER_SEED = 'Worker'
+
+    setting(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(UlnPDA.ULN_SEED, 'utf8')])
+    }
+
+    config(eid: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(UlnPDA.ULN_CONFIG_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(eid),
+        ])
+    }
+
+    defaultSendConfig(eid: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(MessageLibPDA.SEND_CONFIG_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(eid),
+        ])
+    }
+
+    defaultReceiveConfig(eid: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(MessageLibPDA.RECEIVE_CONFIG_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(eid),
+        ])
+    }
+
+    options(eit: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(UlnPDA.OPTIONS_SEED, 'utf8'),
+            u32({ endian: Endian.Big }).serialize(eit),
+        ])
+    }
+
+    workerConfig(worker: PublicKey): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(UlnPDA.WORKER_SEED, 'utf8'), publicKeyBytes(worker)])
+    }
+
+    confirmations(headerHash: Uint8Array, payloadHash: Uint8Array, dvn: PublicKey): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(UlnPDA.CONFIRMATIONS_SEED, 'utf8'),
+            headerHash,
+            payloadHash,
+            publicKeyBytes(dvn),
+        ])
+    }
+}
+
+/**
+ * derive address by base oapp program
+ */
+export class OmniAppPDA {
+    static REMOTE_SEED = 'Remote'
+    static LZ_RECEIVE_TYPES_SEED = 'LzReceiveTypes'
+    static LZ_COMPOSE_TYPES_SEED = 'LzComposeTypes'
+
+    constructor(public readonly programId: PublicKey) {}
+
+    oapp(): Pda {
+        throw new Error('Method not implemented.')
+    }
+
+    lzReceiveTypesAccounts(receiver?: PublicKey): Pda {
+        return EDDSA.findPda(this.programId, [
+            Buffer.from(OmniAppPDA.LZ_RECEIVE_TYPES_SEED, 'utf8'),
+            publicKeyBytes(receiver ?? this.oapp()[0]),
+        ])
+    }
+
+    lzComposeTypesAccounts(to?: PublicKey): Pda {
+        return EDDSA.findPda(this.programId, [
+            Buffer.from(OmniAppPDA.LZ_COMPOSE_TYPES_SEED, 'utf8'),
+            publicKeyBytes(to ?? this.oapp()[0]),
+        ])
+    }
+}
+
+export class DvnPDA {
+    static DVN_CONFIG_SEED = 'DvnConfig'
+
+    constructor(public program: PublicKey) {}
+
+    authority(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from('dvn', 'utf8')])
+    }
+
+    config(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(DvnPDA.DVN_CONFIG_SEED, 'utf8')])
+    }
+
+    executeHash(digestHash: Buffer): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from('ExecuteHash', 'utf8'), digestHash])
+    }
+}
+
+export class EventPDA {
+    static EVENT_SEED = '__event_authority'
+
+    constructor(public program: PublicKey) {}
+
+    eventAuthority(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(EventPDA.EVENT_SEED, 'utf8')])
+    }
+}
+
+export class ExecutorPDA {
+    static EXECUTOR_CONFIG_SEED = 'ExecutorConfig'
+
+    constructor(public program: PublicKey) {}
+
+    config(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(ExecutorPDA.EXECUTOR_CONFIG_SEED, 'utf8')])
+    }
+}
+
+export class PriceFeedPDA {
+    static PRICE_FEED_SEED = 'PriceFeed'
+
+    constructor(public program: PublicKey) {}
+
+    priceFeed(): Pda {
+        return EDDSA.findPda(this.program, [Buffer.from(PriceFeedPDA.PRICE_FEED_SEED, 'utf8')])
+    }
+}