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

package/src/modules/utils.ts

@@ -0,0 +1,390 @@
+import { bcs } from '@mysten/sui/bcs'
+import { SuiClient } from '@mysten/sui/client'
+import { Transaction, TransactionResult } from '@mysten/sui/transactions'
+
+import { Context } from '../types'
+
+export class Utils {
+    public packageId: string
+    public readonly client: SuiClient
+    private readonly context: Context
+
+    constructor(packageId: string, client: SuiClient, context: Context) {
+        this.packageId = packageId
+        this.client = client
+        this.context = context
+
+        // Validate that package ID is not empty
+        if (this.packageId.trim() === '') {
+            throw new Error('utils package ID cannot be empty')
+        }
+    }
+
+    // === bytes32 Functions ===
+
+    fromBytesMoveCall(tx: Transaction, peer: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::from_bytes`,
+            typeArguments: [],
+            arguments: [tx.pure(bcs.vector(bcs.u8()).serialize(peer))],
+        })
+    }
+
+    fromBytesLeftPaddedMoveCall(tx: Transaction, bytes: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::from_bytes_left_padded`,
+            typeArguments: [],
+            arguments: [tx.pure(bcs.vector(bcs.u8()).serialize(bytes))],
+        })
+    }
+
+    fromBytesRightPaddedMoveCall(tx: Transaction, bytes: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::from_bytes_right_padded`,
+            typeArguments: [],
+            arguments: [tx.pure(bcs.vector(bcs.u8()).serialize(bytes))],
+        })
+    }
+
+    fromAddressMoveCall(tx: Transaction, address: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::from_address`,
+            typeArguments: [],
+            arguments: [tx.pure.address(address)],
+        })
+    }
+
+    fromIdMoveCall(tx: Transaction, id: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::from_id`,
+            typeArguments: [],
+            arguments: [tx.object(id)],
+        })
+    }
+
+    zeroBytes32MoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::zero_bytes32`,
+            typeArguments: [],
+            arguments: [],
+        })
+    }
+
+    ffBytes32MoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::ff_bytes32`,
+            typeArguments: [],
+            arguments: [],
+        })
+    }
+
+    isZeroMoveCall(tx: Transaction, bytes32: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::is_zero`,
+            typeArguments: [],
+            arguments: [tx.object(bytes32)],
+        })
+    }
+
+    isFfMoveCall(tx: Transaction, bytes32: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::is_ff`,
+            typeArguments: [],
+            arguments: [tx.object(bytes32)],
+        })
+    }
+
+    toBytesMoveCall(tx: Transaction, bytes32: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::to_bytes`,
+            typeArguments: [],
+            arguments: [tx.object(bytes32)],
+        })
+    }
+
+    toAddressMoveCall(tx: Transaction, bytes32: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::to_address`,
+            typeArguments: [],
+            arguments: [tx.object(bytes32)],
+        })
+    }
+
+    toIdMoveCall(tx: Transaction, bytes32: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::bytes32::to_id`,
+            typeArguments: [],
+            arguments: [tx.object(bytes32)],
+        })
+    }
+
+    // === Buffer Functions ===
+
+    newReaderMoveCall(tx: Transaction, buffer: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::new_reader`,
+            typeArguments: [],
+            arguments: [tx.pure(bcs.vector(bcs.u8()).serialize(buffer))],
+        })
+    }
+
+    newWriterMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::new_writer`,
+            typeArguments: [],
+            arguments: [],
+        })
+    }
+
+    createWriterMoveCall(tx: Transaction, buffer: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::create_writer`,
+            typeArguments: [],
+            arguments: [tx.pure(bcs.vector(bcs.u8()).serialize(buffer))],
+        })
+    }
+
+    // Reader functions
+    positionMoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::position`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    remainingLengthMoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::remaining_length`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    skipMoveCall(tx: Transaction, reader: TransactionResult, len: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::skip`,
+            typeArguments: [],
+            arguments: [reader, tx.pure.u64(len)],
+        })
+    }
+
+    setPositionMoveCall(tx: Transaction, reader: TransactionResult, position: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::set_position`,
+            typeArguments: [],
+            arguments: [reader, tx.pure.u64(position)],
+        })
+    }
+
+    rewindMoveCall(tx: Transaction, reader: TransactionResult, len: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::rewind`,
+            typeArguments: [],
+            arguments: [reader, tx.pure.u64(len)],
+        })
+    }
+
+    readU8MoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_u8`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readU16MoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_u16`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readU32MoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_u32`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readU64MoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_u64`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readU128MoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_u128`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readU256MoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_u256`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readBytes32MoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_bytes32`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readAddressMoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_address`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readFixedLenBytesMoveCall(tx: Transaction, reader: TransactionResult, len: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_fixed_len_bytes`,
+            typeArguments: [],
+            arguments: [reader, tx.pure.u64(len)],
+        })
+    }
+
+    readBytesUntilEndMoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::read_bytes_until_end`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readerBufferLengthMoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::reader_buffer_length`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    readerToBytesMoveCall(tx: Transaction, reader: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::reader_to_bytes`,
+            typeArguments: [],
+            arguments: [reader],
+        })
+    }
+
+    // Writer functions
+    writerBufferLengthMoveCall(tx: Transaction, writer: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::writer_buffer_length`,
+            typeArguments: [],
+            arguments: [writer],
+        })
+    }
+
+    writerToBytesMoveCall(tx: Transaction, writer: TransactionResult): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::writer_to_bytes`,
+            typeArguments: [],
+            arguments: [writer],
+        })
+    }
+
+    writeU8MoveCall(tx: Transaction, writer: TransactionResult, value: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_u8`,
+            typeArguments: [],
+            arguments: [writer, tx.pure.u8(value)],
+        })
+    }
+
+    writeU16MoveCall(tx: Transaction, writer: TransactionResult, value: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_u16`,
+            typeArguments: [],
+            arguments: [writer, tx.pure.u16(value)],
+        })
+    }
+
+    writeU32MoveCall(tx: Transaction, writer: TransactionResult, value: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_u32`,
+            typeArguments: [],
+            arguments: [writer, tx.pure.u32(value)],
+        })
+    }
+
+    writeU64MoveCall(tx: Transaction, writer: TransactionResult, value: number): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_u64`,
+            typeArguments: [],
+            arguments: [writer, tx.pure.u64(value)],
+        })
+    }
+
+    writeU128MoveCall(tx: Transaction, writer: TransactionResult, value: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_u128`,
+            typeArguments: [],
+            arguments: [writer, tx.pure.u128(value)],
+        })
+    }
+
+    writeU256MoveCall(tx: Transaction, writer: TransactionResult, value: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_u256`,
+            typeArguments: [],
+            arguments: [writer, tx.pure.u256(value)],
+        })
+    }
+
+    writeBytesMoveCall(tx: Transaction, writer: TransactionResult, bytes: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_bytes`,
+            typeArguments: [],
+            arguments: [writer, tx.pure(bcs.vector(bcs.u8()).serialize(bytes))],
+        })
+    }
+
+    writeAddressMoveCall(tx: Transaction, writer: TransactionResult, address: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_address`,
+            typeArguments: [],
+            arguments: [writer, tx.pure.address(address)],
+        })
+    }
+
+    writeBytes32MoveCall(tx: Transaction, writer: TransactionResult, bytes32: string): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::buffer::write_bytes32`,
+            typeArguments: [],
+            arguments: [writer, tx.object(bytes32)],
+        })
+    }
+
+    // === Hash Functions ===
+
+    blake2b256MoveCall(tx: Transaction, bytes: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::hash::blake2b256`,
+            typeArguments: [],
+            arguments: [tx.pure(bcs.vector(bcs.u8()).serialize(bytes))],
+        })
+    }
+
+    keccak256MoveCall(tx: Transaction, bytes: Uint8Array): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::hash::keccak256`,
+            typeArguments: [],
+            arguments: [tx.pure(bcs.vector(bcs.u8()).serialize(bytes))],
+        })
+    }
+}

package/src/modules/zro.ts

@@ -0,0 +1,38 @@
+import { SuiClient } from '@mysten/sui/client'
+import { Transaction, TransactionResult } from '@mysten/sui/transactions'
+
+import { Context } from '../types'
+
+export class Zro {
+    public packageId: string
+    public readonly client: SuiClient
+
+    constructor(
+        packageId: string,
+        client: SuiClient,
+        private readonly context: Context
+    ) {
+        this.packageId = packageId
+        this.client = client
+    }
+
+    zeroOptionMoveCall(tx: Transaction): TransactionResult {
+        const zroToken = tx.moveCall({
+            target: `0x2::coin::zero`,
+            typeArguments: [`${this.packageId}::zro::ZRO`],
+        })
+        const zroOption = tx.moveCall({
+            target: `0x1::option::some`,
+            typeArguments: [`0x2::coin::Coin<${this.packageId}::zro::ZRO>`],
+            arguments: [zroToken],
+        })
+        return zroOption
+    }
+
+    noneOptionMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `0x1::option::none`,
+            typeArguments: [`0x2::coin::Coin<${this.packageId}::zro::ZRO>`],
+        })
+    }
+}

package/src/sdk.ts

@@ -0,0 +1,233 @@
+import { SuiClient } from '@mysten/sui/client'
+
+import { Provider } from '@layerzerolabs/lz-core'
+import { SuiProvider } from '@layerzerolabs/lz-corekit-sui'
+import { Chain, Stage, chainAndStageToNetwork } from '@layerzerolabs/lz-definitions'
+
+import { Counter } from './modules/counter'
+import { Endpoint } from './modules/endpoint'
+import { SimpleMessageLib } from './modules/simple-message-lib'
+import { Utils } from './modules/utils'
+import { Zro } from './modules/zro'
+import { Context, ObjectOptions, PackageOptions } from './types'
+import { readAddressFromDeployment } from './utils'
+
+/**
+ * Asserts that the given provider is an instance of SuiProvider.
+ *
+ * @param {unknown} provider - The provider to check.
+ * @throws {Error} If the provider is not an instance of SuiProvider.
+ */
+function assertSuiProvider(provider: Provider): asserts provider is SuiProvider {
+    if (!(provider instanceof SuiProvider)) {
+        throw new Error('Invalid provider')
+    }
+}
+
+/**
+ * Creates an instance of the SDK from the given provider.
+ *
+ * @param {unknown} provider - The provider of the current chain.
+ * @param {Stage} [stage] - The stage of the SDK. {@link Stage}
+ * @returns {SDK} The initialized SDK instance.
+ */
+export function getSDKFromProvider(provider: Provider, stage?: Stage): SDK {
+    assertSuiProvider(provider)
+    const client = provider.native
+
+    return new SDK({
+        client,
+        stage,
+    })
+}
+
+/**
+ * Options for initializing the SDK.
+ */
+export interface SdkOptions {
+    /**
+     * The chain for the SDK (optional).
+     * default value is Chain.SUI
+     */
+    chain?: Chain
+    /**
+     * The Sui client for the SDK.
+     */
+    client: SuiClient
+
+    /**
+     * The stage of the SDK (optional).
+     * default value is Stage.SANDBOX
+     */
+    stage?: Stage
+
+    /**
+     * The package options for the SDK.
+     */
+    packages?: Partial<PackageOptions>
+
+    /**
+     * The object options for the SDK.
+     */
+    objects?: Partial<ObjectOptions>
+}
+
+/**
+ * The SDK class provides methods to interact with LayerZero on Sui.
+ * It initializes all modules at once and provides access to them.
+ */
+export class SDK {
+    chain: Chain
+    stage: Stage
+    client: SuiClient
+    public readonly packages: PackageOptions
+    public readonly objects: ObjectOptions
+
+    // Module instances
+    endpoint: Endpoint
+    counter: Counter
+    simpleMessageLib: SimpleMessageLib
+    utils: Utils
+    zro: Zro
+
+    /**
+     * Creates an instance of the SDK.
+     *
+     * @param {SdkOptions} options - The SDK options.
+     */
+    constructor(options: SdkOptions) {
+        this.chain = options.chain ?? Chain.PLACEHOLDER0
+        this.stage = options.stage ?? Stage.SANDBOX
+        this.client = options.client
+        const network = chainAndStageToNetwork(this.chain, this.stage, this.stage === Stage.SANDBOX)
+        const defaultPackages = {
+            utils: readAddressFromDeployment(network, 'utils')!,
+            endpoint_v2: readAddressFromDeployment(network, 'endpoint_v2')!,
+            counter_v2: readAddressFromDeployment(network, 'counter')!,
+            simple_message_lib: readAddressFromDeployment(network, 'simple_message_lib')!,
+            zro: readAddressFromDeployment(network, 'zro')!,
+        }
+        this.packages = {
+            ...defaultPackages,
+            ...options.packages,
+        }
+        const defaultObjects = {
+            endpoint_v2: readAddressFromDeployment(network, 'object-EndpointV2')!,
+            simple_message_lib: readAddressFromDeployment(network, 'object-SimpleMessageLib')!,
+            uln_302: readAddressFromDeployment(network, 'object-ULN302')!,
+            blocked_message_lib: readAddressFromDeployment(network, 'object-BlockedMessageLib')!,
+            discovery: readAddressFromDeployment(network, 'object-Discovery')!,
+            counter: readAddressFromDeployment(network, 'object-Counter')!,
+            counter_admin_cap: readAddressFromDeployment(network, 'object-CounterAdminCap')!,
+            endpoint_admin_cap: readAddressFromDeployment(network, 'object-EndpointV2AdminCap')!,
+            oapp_core: readAddressFromDeployment(network, 'object-OAppCore')!,
+        }
+        this.objects = {
+            ...defaultObjects,
+            ...options.objects,
+        }
+        const context: Context = {} as unknown as Context
+        // Initialize all modules
+        this.endpoint = new Endpoint(this.packages.endpoint_v2, this.client, this.objects, context)
+
+        this.counter = new Counter(this.packages.counter_v2, this.packages.utils, this.client, this.objects, context)
+
+        this.simpleMessageLib = new SimpleMessageLib(
+            this.packages.simple_message_lib,
+            this.client,
+            this.objects,
+            context
+        )
+
+        this.utils = new Utils(this.packages.utils, this.client, context)
+
+        this.zro = new Zro(this.packages.zro, this.client, context)
+
+        context.endpoint = this.endpoint
+        context.counter = this.counter
+        context.simpleMessageLib = this.simpleMessageLib
+        context.utils = this.utils
+        context.zro = this.zro
+    }
+
+    /**
+     * Gets the Sui client.
+     *
+     * @returns {SuiClient} The Sui client.
+     */
+    getSuiClient(): SuiClient {
+        return this.client
+    }
+
+    /**
+     * Gets the chain.
+     *
+     * @returns {Chain} The chain.
+     */
+    getChain(): Chain {
+        return this.chain
+    }
+
+    /**
+     * Gets the stage.
+     *
+     * @returns {Stage} The stage.
+     */
+    getStage(): Stage {
+        return this.stage
+    }
+
+    /**
+     * Gets the package options.
+     *
+     * @returns {PackageOptions} The package options.
+     */
+    getPackages(): PackageOptions {
+        return this.packages
+    }
+
+    /**
+     * Gets the object options.
+     *
+     * @returns {ObjectOptions} The object options.
+     */
+    getObjects(): ObjectOptions {
+        return this.objects
+    }
+
+    /**
+     * Gets the endpoint module.
+     *
+     * @returns {Endpoint} The endpoint module.
+     */
+    getEndpoint(): Endpoint {
+        return this.endpoint
+    }
+
+    /**
+     * Gets the counter module.
+     *
+     * @returns {Counter} The counter module.
+     */
+    getCounter(): Counter {
+        return this.counter
+    }
+
+    /**
+     * Gets the simple message library module.
+     *
+     * @returns {SimpleMessageLib} The simple message library module.
+     */
+    getSimpleMessageLib(): SimpleMessageLib {
+        return this.simpleMessageLib
+    }
+
+    /**
+     * Gets the utils module.
+     *
+     * @returns {Utils} The utils module.
+     */
+    getUtils(): Utils {
+        return this.utils
+    }
+}