@layerzerolabs/lz-sui-sdk-v2 3.0.73 → 3.0.75

package/src/modules/endpoint.ts

@@ -0,0 +1,303 @@
+import { bcs } from '@mysten/sui/bcs'
+import { SuiClient } from '@mysten/sui/client'
+import { Transaction, TransactionResult } from '@mysten/sui/transactions'
+
+import { Context, ObjectOptions } from '../types'
+import { moveView } from '../utils'
+
+export class Endpoint {
+    public packageId: string
+    public readonly client: SuiClient
+    private readonly objects: Pick<ObjectOptions, 'endpoint_v2' | 'endpoint_admin_cap'>
+
+    constructor(
+        packageId: string,
+        client: SuiClient,
+        objects: Pick<ObjectOptions, 'endpoint_v2' | 'endpoint_admin_cap'>,
+        private readonly context: Context
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.objects = objects
+
+        // Validate that required objects are not empty strings
+        if (this.objects.endpoint_v2.trim() === '') {
+            throw new Error('endpoint_v2 object cannot be empty')
+        }
+        if (this.objects.endpoint_admin_cap.trim() === '') {
+            throw new Error('endpoint_admin_cap object cannot be empty')
+        }
+    }
+
+    async eid(): Promise<number> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::eid`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_v2)],
+        })
+        try {
+            const result = await moveView(this.client, tx)
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const bytes = new Uint8Array(result?.returnValues![0][0]!)
+            return bcs.U32.parse(bytes)
+        } catch (e) {
+            //TODO need to handle error properly
+            return 0
+        }
+    }
+
+    populateInitEidTransaction(eid: number): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::init_eid`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.pure.u32(eid),
+            ],
+        })
+        return tx
+    }
+
+    async getDefaultSendLibrary(srcEid: number): Promise<string> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_default_send_library`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_v2), tx.pure.u32(srcEid)],
+        })
+        try {
+            const result = await moveView(this.client, tx)
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const bytes = new Uint8Array(result?.returnValues![0][0]!)
+            return bcs.Address.parse(bytes)
+        } catch (error) {
+            //TODO need to handle error properly
+            return '0x0'
+        }
+    }
+
+    populateSetDefaultSendLibraryTransaction(dstEid: number, newLib: string): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::set_default_send_library`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.pure.u32(dstEid),
+                tx.pure.address(newLib),
+            ],
+        })
+        return tx
+    }
+
+    async getDefaultReceiveLibrary(srcEid: number): Promise<string> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_default_receive_library`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_v2), tx.pure.u32(srcEid)],
+        })
+        try {
+            const result = await moveView(this.client, tx)
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const bytes = new Uint8Array(result?.returnValues![0][0]!)
+            return bcs.Address.parse(bytes)
+        } catch (error) {
+            return '0x'
+        }
+    }
+
+    populateSetDefaultReceiveLibraryTransaction(srcEid: number, newLib: string, gracePeriod: number): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::set_default_receive_library`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.pure.u32(srcEid),
+                tx.pure.address(newLib),
+                tx.pure.u64(gracePeriod),
+                tx.object('0x6'), // Clock Object TODO try to get it from the client or sdk
+            ],
+        })
+        return tx
+    }
+
+    confirmQuoteMoveCall(tx: Transaction, executedCall: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::confirm_quote`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_v2), executedCall],
+        })
+    }
+
+    confirmSendMoveCall(tx: Transaction, executedCall: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::confirm_send`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_v2), executedCall],
+        })
+    }
+
+    // === Worker Endpoint Required Methods ===
+
+    async getSendLibrary(sender: string, dstEid: number): Promise<[string, boolean]> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_send_library`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_v2), tx.pure.address(sender), tx.pure.u32(dstEid)],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        const lib = bcs.Address.parse(bytes)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const isDefaultBytes = new Uint8Array(result?.returnValues![1][0]!)
+        const isDefault = bcs.Bool.parse(isDefaultBytes)
+        return [lib, isDefault]
+    }
+
+    async getReceiveLibrary(receiver: string, srcEid: number): Promise<[string, boolean]> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_receive_library`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_v2), tx.pure.address(receiver), tx.pure.u32(srcEid)],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        const lib = bcs.Address.parse(bytes)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const isDefaultBytes = new Uint8Array(result?.returnValues![1][0]!)
+        const isDefault = bcs.Bool.parse(isDefaultBytes)
+        return [lib, isDefault]
+    }
+
+    async getInboundNonce(receiver: string, srcEid: number, sender: Uint8Array): Promise<bigint> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_inbound_nonce`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.pure.address(receiver),
+                tx.pure.u32(srcEid),
+                tx.pure(bcs.vector(bcs.u8()).serialize(sender)),
+            ],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        return BigInt(bcs.U64.parse(bytes))
+    }
+
+    async getLazyInboundNonce(receiver: string, srcEid: number, sender: Uint8Array): Promise<bigint> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_lazy_inbound_nonce`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.pure.address(receiver),
+                tx.pure.u32(srcEid),
+                tx.pure(bcs.vector(bcs.u8()).serialize(sender)),
+            ],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        return BigInt(bcs.U64.parse(bytes))
+    }
+
+    async getOutboundNonce(sender: string, dstEid: number, receiver: Uint8Array): Promise<bigint> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_outbound_nonce`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.pure.address(sender),
+                tx.pure.u32(dstEid),
+                tx.pure(bcs.vector(bcs.u8()).serialize(receiver)),
+            ],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        return BigInt(bcs.U64.parse(bytes))
+    }
+
+    async getInboundPayloadHash(
+        receiver: string,
+        srcEid: number,
+        sender: Uint8Array,
+        nonce: bigint
+    ): Promise<Uint8Array | null> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_inbound_payload_hash`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.pure.address(receiver),
+                tx.pure.u32(srcEid),
+                tx.pure(bcs.vector(bcs.u8()).serialize(sender)),
+                tx.pure.u64(nonce),
+            ],
+        })
+        try {
+            const result = await moveView(this.client, tx)
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const bytes = new Uint8Array(result?.returnValues![0][0]!)
+            const parsed = bcs.vector(bcs.u8()).parse(bytes)
+            return Buffer.from(parsed)
+        } catch (error) {
+            //TODO need to handle error properly
+            return null
+        }
+    }
+
+    async getComposeMessageHash(from: string, to: string, guid: Uint8Array, index: number): Promise<Uint8Array> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::endpoint_v2::get_compose_message_hash`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.endpoint_v2),
+                tx.pure.address(from),
+                tx.pure.address(to),
+                tx.pure(bcs.vector(bcs.u8()).serialize(guid)),
+                tx.pure.u16(index),
+            ],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        const parsed = bcs.vector(bcs.u8()).parse(bytes)
+        return Buffer.from(parsed)
+    }
+
+    // TODO: more view functions to be added here
+    populateQuoteTransaction(tx: Transaction): void {
+        // TODO: implement
+    }
+
+    populateSendTransaction(tx: Transaction): void {
+        // TODO: implement
+    }
+
+    populateGetConfigTransaction(tx: Transaction): void {
+        // TODO: implement
+    }
+
+    populateSetConfigTransaction(tx: Transaction): void {
+        // TODO: implement
+    }
+}

package/src/modules/index.ts

@@ -0,0 +1,5 @@
+export * from './simple-message-lib'
+export * from './endpoint'
+export * from './counter'
+export * from './utils'
+export * from './zro'

package/src/modules/simple-message-lib.ts

@@ -0,0 +1,240 @@
+import { bcs } from '@mysten/sui/bcs'
+import { SuiClient } from '@mysten/sui/client'
+import { Transaction, TransactionResult } from '@mysten/sui/transactions'
+
+import { Context, ObjectOptions } from '../types'
+import { moveView } from '../utils'
+
+export class SimpleMessageLib {
+    public packageId: string
+    public readonly client: SuiClient
+    private readonly objects: Pick<
+        ObjectOptions,
+        'simple_message_lib' | 'endpoint_admin_cap' | 'endpoint_v2' | 'discovery'
+    >
+
+    constructor(
+        packageId: string,
+        client: SuiClient,
+        objects: Pick<ObjectOptions, 'simple_message_lib' | 'endpoint_admin_cap' | 'endpoint_v2' | 'discovery'>,
+        private readonly context: Context
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.objects = objects
+
+        // Validate that required objects are not empty strings
+        if (this.objects.simple_message_lib.trim() === '') {
+            throw new Error('simple_message_lib object cannot be empty')
+        }
+        if (this.objects.endpoint_admin_cap.trim() === '') {
+            throw new Error('admin_cap object cannot be empty')
+        }
+        if (this.objects.endpoint_v2.trim() === '') {
+            throw new Error('endpoint_v2 object cannot be empty')
+        }
+    }
+
+    populateInitializeTransaction(): Transaction {
+        const tx = new Transaction()
+
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::initialize`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.endpoint_admin_cap), tx.object(this.objects.endpoint_v2)],
+        })
+        return tx
+    }
+
+    // === View Functions ===
+
+    async getNativeFee(): Promise<string> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::get_native_fee`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.simple_message_lib)],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        return bcs.U64.parse(bytes)
+    }
+
+    async getZroFee(): Promise<string> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::get_zro_fee`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.simple_message_lib)],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        return bcs.U64.parse(bytes)
+    }
+
+    async getFeeRecipient(): Promise<string> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::get_fee_recipient`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.simple_message_lib)],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        return bcs.Address.parse(bytes)
+    }
+
+    async isRegistered(): Promise<boolean> {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::is_registered`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.simple_message_lib), tx.object(this.objects.endpoint_v2)],
+        })
+        const result = await moveView(this.client, tx)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bytes = new Uint8Array(result?.returnValues![0][0]!)
+        return bcs.Bool.parse(bytes)
+    }
+
+    // === Admin Functions ===
+
+    populateRegisterLibraryTransaction(): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::register_library`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.simple_message_lib),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.object(this.objects.endpoint_v2),
+            ],
+        })
+        return tx
+    }
+
+    populateSetMessagingFeeTransaction(zroFee: number, nativeFee: number): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::set_messaging_fee`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.simple_message_lib),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.pure.u64(zroFee),
+                tx.pure.u64(nativeFee),
+            ],
+        })
+        return tx
+    }
+
+    populateSetDefaultConfigTransaction(eid: number, configType: number, config: Uint8Array): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::set_default_config`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.simple_message_lib),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.pure.u32(eid),
+                tx.pure.u32(configType),
+                tx.pure(bcs.vector(bcs.u8()).serialize(config)),
+            ],
+        })
+        return tx
+    }
+
+    populateSetFeeRecipientTransaction(feeRecipient: string): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::set_fee_recipient`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.simple_message_lib),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.pure.address(feeRecipient),
+            ],
+        })
+        return tx
+    }
+
+    // === Endpoint Validation ===
+
+    populateValidatePacketTransaction(packetHeader: Uint8Array, payloadHash: Uint8Array): Transaction {
+        const tx = new Transaction()
+        const payloadHashBytes32 = this.context.utils.fromBytesMoveCall(tx, payloadHash)
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::validate_packet`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.simple_message_lib),
+                tx.object(this.objects.endpoint_v2),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.pure(bcs.vector(bcs.u8()).serialize(packetHeader)),
+                payloadHashBytes32,
+                tx.object('0x6'), // Clock Object TODO try to get it from the client or sdk
+            ],
+        })
+        return tx
+    }
+
+    // === Protocol Discovery ===
+
+    populateRegisterMessageLibDiscoveryTransaction(): Transaction {
+        const tx = new Transaction()
+        tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::register_message_lib_discovery`,
+            typeArguments: [],
+            arguments: [
+                tx.object(this.objects.simple_message_lib),
+                tx.object(this.objects.endpoint_admin_cap),
+                tx.object(this.objects.endpoint_v2),
+                tx.object(this.objects.discovery),
+            ],
+        })
+        return tx
+    }
+
+    quoteMoveCall(tx: Transaction, quoteCall: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::quote`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.simple_message_lib), quoteCall],
+        })
+    }
+
+    sendMoveCall(tx: Transaction, sendCall: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::simple_message_lib::send`,
+            typeArguments: [],
+            arguments: [tx.object(this.objects.simple_message_lib), tx.object(this.objects.endpoint_v2), sendCall],
+        })
+    }
+
+    // === TODO: Core Message Lib Functions ===
+    // These functions are called by the endpoint and require specific parameter types
+    // that need to be implemented based on the endpoint_v2 module interfaces
+
+    populateQuoteTransaction(tx: Transaction): void {
+        // TODO: implement quote functionality
+        // This requires Call<QuoteParam> parameter from endpoint_v2
+    }
+
+    populateSendTransaction(tx: Transaction): void {
+        // TODO: implement send functionality
+        // This requires Call<SendParam> parameter from endpoint_v2
+    }
+
+    populateSetConfigTransaction(tx: Transaction): void {
+        // TODO: implement set_config functionality
+        // This requires Call<SetConfigParam> parameter from endpoint_v2
+    }
+
+    populateGetConfigTransaction(tx: Transaction): void {
+        // TODO: implement get_config functionality
+        // This requires Call<GetConfigParam> parameter from endpoint_v2
+    }
+}