@layerzerolabs/lz-iotal1-sdk-v2 3.0.143

package/src/modules/index.ts

@@ -0,0 +1,10 @@
+// Re-export all modules from organized subdirectories
+export * from './endpoint'
+export * from './message-libs'
+export * from './workers'
+export * from './ptb-builders'
+export * from './oapps'
+export * from './layerzero-views'
+export * from './call'
+export * from './utils'
+export * from './zro'

package/src/modules/layerzero-views.ts

@@ -0,0 +1,205 @@
+import { bcs } from '@iota/iota-sdk/bcs'
+import { IotaClient } from '@iota/iota-sdk/client'
+
+import { ModuleManager } from '../module-manager'
+import {
+    EndpointExecutionState,
+    EndpointExecutionStateType,
+    ExecutableParams,
+    InitializableParams,
+    ObjectOptions,
+    UlnVerifiableParams,
+    UlnVerificationState,
+    UlnVerificationStateType,
+    VerifiableParams,
+} from '../types'
+import { asBytes, asObject, asU32, asU64, executeSimulate } from '../utils'
+
+const MODULE_NAME_ENDPOINT_VIEWS = 'endpoint_views'
+const MODULE_NAME_ULN_302_VIEWS = 'uln_302_views'
+
+/**
+ * LayerZero Views SDK
+ *
+ * Provides view functions for checking the state of LayerZero messages
+ * and their executability/verification status without modifying state.
+ */
+export class LayerZeroViews {
+    public packageId: string
+    public readonly client: IotaClient
+    private readonly objects: ObjectOptions
+
+    constructor(
+        packageId: string,
+        client: IotaClient,
+        objects: ObjectOptions,
+        private readonly moduleManager: ModuleManager
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.objects = objects
+    }
+
+    // ======== Endpoint View Functions ========
+
+    /**
+     * Checks if a message path is initializable (channel exists).
+     *
+     * @param params - Parameters containing messaging channel, source EID, and sender
+     * @returns Promise<boolean> - True if the path is initializable
+     */
+    async initializable(params: InitializableParams): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                tx.moveCall({
+                    target: this.#endpointViewsTarget('initializable'),
+                    arguments: [
+                        asObject(tx, params.messagingChannel),
+                        asU32(tx, params.srcEid),
+                        asBytes(tx, params.sender),
+                    ],
+                })
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Checks if a message is verifiable by the endpoint.
+     *
+     * @param params - Parameters containing messaging channel, source EID, sender, and nonce
+     * @returns Promise<boolean> - True if the message is verifiable
+     */
+    async verifiable(params: VerifiableParams): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                tx.moveCall({
+                    target: this.#endpointViewsTarget('verifiable'),
+                    arguments: [
+                        asObject(tx, params.messagingChannel),
+                        asU32(tx, params.srcEid),
+                        asBytes(tx, params.sender),
+                        asU64(tx, params.nonce),
+                    ],
+                })
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Determines the execution state of a message.
+     *
+     * @param params - Parameters containing messaging channel, source EID, sender, and nonce
+     * @returns Promise<EndpointExecutionStateType> - The current execution state
+     */
+    async executable(params: ExecutableParams): Promise<EndpointExecutionStateType> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                tx.moveCall({
+                    target: this.#endpointViewsTarget('executable'),
+                    arguments: [
+                        asObject(tx, params.messagingChannel),
+                        asU32(tx, params.srcEid),
+                        asBytes(tx, params.sender),
+                        asU64(tx, params.nonce),
+                    ],
+                })
+            },
+            (result) => bcs.U8.parse(result[0].value) as EndpointExecutionStateType
+        )
+    }
+
+    // ======== ULN 302 View Functions ========
+
+    /**
+     * Checks the verification state of a message through the ULN 302.
+     *
+     * @param params - Parameters containing ULN, verification, messaging channel, packet header, and payload hash
+     * @returns Promise<UlnVerificationStateType> - The current verification state
+     */
+    async ulnVerifiable(params: UlnVerifiableParams): Promise<UlnVerificationStateType> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                tx.moveCall({
+                    target: this.#uln302ViewsTarget('verifiable'),
+                    arguments: [
+                        tx.object(this.objects.uln302),
+                        asObject(tx, params.verification),
+                        tx.object(this.objects.endpointV2),
+                        asObject(tx, params.messagingChannel),
+                        asBytes(tx, params.packetHeaderBytes),
+                        asBytes(tx, params.payloadHash),
+                    ],
+                })
+            },
+            (result) => bcs.U8.parse(result[0].value) as UlnVerificationStateType
+        )
+    }
+
+    // ======== Utility Functions ========
+
+    /**
+     * Gets the human-readable name for an endpoint execution state
+     * @param state - The endpoint execution state enum value
+     * @returns Human-readable string representation of the execution state
+     */
+    static getExecutionStateName(state: EndpointExecutionStateType): string {
+        switch (state) {
+            case EndpointExecutionState.STATE_NOT_EXECUTABLE:
+                return 'NOT_EXECUTABLE'
+            case EndpointExecutionState.STATE_VERIFIED_BUT_NOT_EXECUTABLE:
+                return 'VERIFIED_BUT_NOT_EXECUTABLE'
+            case EndpointExecutionState.STATE_EXECUTABLE:
+                return 'EXECUTABLE'
+            case EndpointExecutionState.STATE_EXECUTED:
+                return 'EXECUTED'
+            default:
+                return 'UNKNOWN'
+        }
+    }
+
+    /**
+     * Gets the human-readable name for a ULN verification state
+     * @param state - The ULN verification state enum value
+     * @returns Human-readable string representation of the verification state
+     */
+    static getVerificationStateName(state: UlnVerificationStateType): string {
+        switch (state) {
+            case UlnVerificationState.STATE_VERIFYING:
+                return 'VERIFYING'
+            case UlnVerificationState.STATE_VERIFIABLE:
+                return 'VERIFIABLE'
+            case UlnVerificationState.STATE_VERIFIED:
+                return 'VERIFIED'
+            case UlnVerificationState.STATE_NOT_INITIALIZABLE:
+                return 'NOT_INITIALIZABLE'
+            default:
+                return 'UNKNOWN'
+        }
+    }
+
+    // ======== Private Helper Methods ========
+
+    /**
+     * Generate the full target path for endpoint view functions
+     * @param functionName - The function name to call
+     * @returns The full module path for the move call
+     */
+    #endpointViewsTarget(functionName: string): string {
+        return `${this.packageId}::${MODULE_NAME_ENDPOINT_VIEWS}::${functionName}`
+    }
+
+    /**
+     * Generate the full target path for ULN302 view functions
+     * @param functionName - The function name to call
+     * @returns The full module path for the move call
+     */
+    #uln302ViewsTarget(functionName: string): string {
+        return `${this.packageId}::${MODULE_NAME_ULN_302_VIEWS}::${functionName}`
+    }
+}

package/src/modules/message-libs/blocked-message-lib.ts

@@ -0,0 +1,112 @@
+import { bcs } from '@iota/iota-sdk/bcs'
+import { IotaClient } from '@iota/iota-sdk/client'
+import { Transaction, TransactionArgument, TransactionResult } from '@iota/iota-sdk/transactions'
+
+import { ModuleManager } from '../../module-manager'
+import { ObjectOptions } from '../../types'
+import { executeSimulate } from '../../utils'
+
+const MODULE_NAME = 'blocked_message_lib'
+
+export const BlockedMessageLibErrorCode = {
+    // BlockedMessageLib related errors (with BlockedMessageLib_ prefix)
+    BlockedMessageLib_ENotImplemented: 1,
+} as const
+
+export class BlockedMessageLib {
+    public packageId: string
+    public readonly client: IotaClient
+    private readonly objects: ObjectOptions
+
+    constructor(
+        packageId: string,
+        client: IotaClient,
+        objects: ObjectOptions,
+        private readonly moduleManager: ModuleManager
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.objects = objects
+    }
+
+    // === Set Functions ===
+
+    /**
+     * Quote messaging fees (always throws not implemented error)
+     * @param tx - The transaction to add the move call to
+     * @param call - The call transaction result or transaction argument
+     */
+    quoteMoveCall(tx: Transaction, call: TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('quote'),
+            arguments: [tx.object(this.objects.blockedMessageLib), call],
+        })
+    }
+
+    /**
+     * Send message (always throws not implemented error)
+     * @param tx - The transaction to add the move call to
+     * @param call - The call transaction result or transaction argument
+     */
+    sendMoveCall(tx: Transaction, call: TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('send'),
+            arguments: [tx.object(this.objects.blockedMessageLib), call],
+        })
+    }
+
+    /**
+     * Set configuration (always throws not implemented error)
+     * @param tx - The transaction to add the move call to
+     * @param call - The call transaction result or transaction argument
+     */
+    setConfigMoveCall(tx: Transaction, call: TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_config'),
+            arguments: [tx.object(this.objects.blockedMessageLib), call],
+        })
+    }
+
+    // === View Functions ===
+
+    /**
+     * Get blocked message library version
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the version information
+     */
+    versionMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('version'),
+            arguments: [],
+        })
+    }
+
+    /**
+     * Get blocked message library version
+     * @returns Promise<[string, string, string]> - Tuple of [major, minor, endpoint] version strings
+     */
+    async getVersion(): Promise<[string, string, string]> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.versionMoveCall(tx)
+            },
+            (result) => [
+                bcs.U64.parse(result[0].value).toString(),
+                bcs.U8.parse(result[1].value).toString(),
+                bcs.U8.parse(result[2].value).toString(),
+            ]
+        )
+    }
+
+    /**
+     * Generate the full target path for move calls
+     * @param name - The function name to call
+     * @param module_name - The module name (defaults to MODULE_NAME)
+     * @returns The full module path for the move call
+     * @private
+     */
+    #target(name: string, module_name: string = MODULE_NAME): string {
+        return `${this.packageId}::${module_name}::${name}`
+    }
+}

package/src/modules/message-libs/index.ts

@@ -0,0 +1,4 @@
+// Message library modules
+export * from './blocked-message-lib'
+export * from './simple-message-lib'
+export * from './uln302'

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

@@ -0,0 +1,270 @@
+import { bcs } from '@iota/iota-sdk/bcs'
+import { IotaClient } from '@iota/iota-sdk/client'
+import { Transaction, TransactionArgument, TransactionResult } from '@iota/iota-sdk/transactions'
+
+import { ModuleManager } from '../../module-manager'
+import { ObjectOptions } from '../../types'
+import { asAddress, asBytes, asBytes32, asObject, asU64, executeSimulate } from '../../utils'
+
+const MODULE_NAME = 'simple_message_lib'
+
+export const SimpleMessageLibErrorCode = {
+    // SimpleMessageLib related errors (matching simple_message_lib.move)
+    SimpleMessageLib_ENotImplemented: 1,
+    SimpleMessageLib_EZROFeeNotEnabled: 2,
+    SimpleMessageLib_EInvalidEid: 3,
+} as const
+
+export class SimpleMessageLib {
+    public packageId: string
+    public readonly client: IotaClient
+    private readonly objects: ObjectOptions
+
+    constructor(
+        packageId: string,
+        client: IotaClient,
+        objects: ObjectOptions,
+        private readonly moduleManager: ModuleManager
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.objects = objects
+    }
+
+    // === Set Functions ===
+
+    /**
+     * Set messaging fees for simple message library (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param zroFee - The ZRO token fee amount or transaction argument
+     * @param nativeFee - The native token fee amount or transaction argument
+     */
+    setMessagingFeeMoveCall(
+        tx: Transaction,
+        zroFee: number | TransactionArgument,
+        nativeFee: number | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_messaging_fee'),
+            arguments: [
+                tx.object(this.objects.simpleMessageLib),
+                tx.object(this.objects.simpleMessageLibAdminCap),
+                asU64(tx, zroFee),
+                asU64(tx, nativeFee),
+            ],
+        })
+    }
+
+    /**
+     * Set fee recipient address (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param feeRecipient - The new fee recipient address or transaction argument
+     */
+    setFeeRecipientMoveCall(tx: Transaction, feeRecipient: string | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_fee_recipient'),
+            arguments: [
+                tx.object(this.objects.simpleMessageLib),
+                tx.object(this.objects.endpointAdminCap),
+                asAddress(tx, feeRecipient),
+            ],
+        })
+    }
+
+    /**
+     * Validate packet for simple message processing
+     * @param tx - The transaction to add the move call to
+     * @param messagingChannel - The messaging channel object ID or transaction argument
+     * @param packetHeader - The packet header as bytes or transaction argument
+     * @param payloadHash - The payload hash as bytes or transaction argument
+     */
+    validatePacketMoveCall(
+        tx: Transaction,
+        messagingChannel: string | TransactionArgument,
+        packetHeader: Uint8Array | TransactionArgument,
+        payloadHash: Uint8Array | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('validate_packet'),
+            arguments: [
+                tx.object(this.objects.simpleMessageLib),
+                tx.object(this.objects.endpointV2),
+                tx.object(this.objects.simpleMessageLibAdminCap),
+                asObject(tx, messagingChannel),
+                asBytes(tx, packetHeader),
+                asBytes32(tx, payloadHash, this.moduleManager.getUtils()),
+                tx.object.clock(),
+            ],
+        })
+    }
+
+    /**
+     * Set configuration for simple message library
+     * @param tx - The transaction to add the move call to
+     * @param call - The call transaction result containing configuration or transaction argument
+     */
+    setConfigMoveCall(tx: Transaction, call: TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_config'),
+            arguments: [tx.object(this.objects.simpleMessageLib), call],
+        })
+    }
+
+    /**
+     * Quote messaging fees for simple message library
+     * @param tx - The transaction to add the move call to
+     * @param call - The call transaction result containing quote parameters or transaction argument
+     */
+    quoteMoveCall(tx: Transaction, call: TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('quote'),
+            arguments: [tx.object(this.objects.simpleMessageLib), call],
+        })
+    }
+
+    /**
+     * Send message through simple message library
+     * @param tx - The transaction to add the move call to
+     * @param messageChannel - The messaging channel object ID or transaction argument
+     * @param endpointCall - The endpoint call transaction result or transaction argument
+     * @param messageLibCall - The message library call transaction result or transaction argument
+     */
+    sendMoveCall(
+        tx: Transaction,
+        messageChannel: string | TransactionArgument,
+        endpointCall: TransactionArgument,
+        messageLibCall: TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('send'),
+            arguments: [
+                tx.object(this.objects.simpleMessageLib),
+                tx.object(this.objects.endpointV2),
+                asObject(tx, messageChannel),
+                endpointCall,
+                messageLibCall,
+            ],
+        })
+    }
+
+    // === View Functions ===
+
+    /**
+     * Get native token fee amount
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the native fee
+     */
+    getNativeFeeMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('get_native_fee'),
+            arguments: [tx.object(this.objects.simpleMessageLib)],
+        })
+    }
+
+    /**
+     * Get native token fee amount
+     * @returns Promise<string> - The native token fee as string
+     */
+    async getNativeFee(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getNativeFeeMoveCall(tx)
+            },
+            (result) => bcs.U64.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get ZRO token fee amount
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the ZRO fee
+     */
+    getZroFeeMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('get_zro_fee'),
+            arguments: [tx.object(this.objects.simpleMessageLib)],
+        })
+    }
+
+    /**
+     * Get ZRO token fee amount
+     * @returns Promise<string> - The ZRO token fee as string
+     */
+    async getZroFee(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getZroFeeMoveCall(tx)
+            },
+            (result) => bcs.U64.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get fee recipient address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the fee recipient address
+     */
+    getFeeRecipientMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('get_fee_recipient'),
+            arguments: [tx.object(this.objects.simpleMessageLib)],
+        })
+    }
+
+    /**
+     * Get fee recipient address
+     * @returns Promise<string> - The fee recipient address
+     */
+    async getFeeRecipient(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getFeeRecipientMoveCall(tx)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get simple message library version
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the version information
+     */
+    versionMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('version'),
+            arguments: [],
+        })
+    }
+
+    /**
+     * Get simple message library version
+     * @returns Promise<[string, string, string]> - Tuple of [major, minor, endpoint] version strings
+     */
+    async getVersion(): Promise<[string, string, string]> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.versionMoveCall(tx)
+            },
+            (result) => [
+                bcs.U64.parse(result[0].value).toString(),
+                bcs.U8.parse(result[1].value).toString(),
+                bcs.U8.parse(result[2].value).toString(),
+            ]
+        )
+    }
+
+    /**
+     * Generate the full target path for move calls
+     * @param name - The function name to call
+     * @param module_name - The module name (defaults to MODULE_NAME)
+     * @returns The full module path for the move call
+     * @private
+     */
+    #target(name: string, module_name: string = MODULE_NAME): string {
+        return `${this.packageId}::${module_name}::${name}`
+    }
+}