@layerzerolabs/lz-iotal1-sdk-v2 3.0.143

package/src/types/options.ts

@@ -0,0 +1,333 @@
+import { IotaClient } from '@iota/iota-sdk/client'
+
+import { Chain, Stage } from '@layerzerolabs/lz-definitions'
+
+/**
+ * Type representing the options for packages.
+ */
+export interface PackageOptions {
+    /**
+     * The endpoint V2 address.
+     */
+    endpointV2: string
+
+    /**
+     * The zro address.
+     */
+    zro: string
+
+    /**
+     * The utils address.
+     */
+    utils: string
+
+    /**
+     * The call address.
+     */
+    call: string
+
+    /**
+     * The simple message library address.
+     */
+    simpleMessageLib: string
+
+    /**
+     * The ULN-302 address.
+     */
+    uln302: string
+
+    /**
+     * The treasury address.
+     */
+    treasury: string
+
+    /**
+     * The common DVN address.
+     */
+    dvn: string
+
+    /**
+     * The DVN fee lib address.
+     */
+    dvnFeeLib: string
+
+    /**
+     * The common executor address.
+     */
+    executor: string
+
+    /**
+     * The executor fee lib address.
+     */
+    executorFeeLib: string
+
+    /**
+     * The price feed address.
+     */
+    priceFeed: string
+
+    /**
+     * The common oapp address.
+     */
+    oapp: string
+
+    /**
+     * The LayerZero Views address.
+     */
+    layerzeroViews: string
+
+    /**
+     * The dvn layerzero address.
+     */
+    dvnLayerzero: string
+
+    /**
+     * The executor layerzero address.
+     */
+    executorLayerzero: string
+
+    /**
+     * The counter V2 address.
+     */
+    counterV2: string
+
+    /**
+     * The ptb move call address.
+     */
+    ptbMoveCall: string
+
+    /**
+     * The endpoint PTB builder address.
+     */
+    endpointPtbBuilder: string
+
+    /**
+     * The simple message lib PTB builder address.
+     */
+    simpleMessageLibPtbBuilder: string
+
+    /**
+     * The ULN-302 PTB builder address.
+     */
+    uln302PtbBuilder: string
+
+    /**
+     * The DVN PTB builder address.
+     */
+    dvnPtbBuilder: string
+
+    /**
+     * The executor PTB builder address.
+     */
+    executorPtbBuilder: string
+
+    /**
+     * The package whitelist validator address.
+     */
+    packageWhitelistValidator: string
+
+    /**
+     * The blocked message library object address.
+     */
+    blockedMessageLib: string
+
+    /**
+     * The blocked message library PTB builder object address.
+     */
+    blockedMessageLibPtbBuilder: string
+
+    /**
+     * The worker registry address.
+     */
+    workerRegistry: string
+
+    /**
+     * The worker common address.
+     */
+    workerCommon: string
+
+    /**
+     * Allow additional properties beyond the explicitly defined ones
+     */
+    [key: string]: any
+}
+
+/**
+ * Type representing the options for objects.
+ */
+export interface ObjectOptions {
+    /**
+     * The endpoint V2 object address.
+     */
+    endpointV2: string
+
+    /**
+     * The simple message library object address.
+     */
+    simpleMessageLib: string
+
+    /**
+     * The simple message library cap object address.
+     */
+    simpleMessageLibAdminCap: string
+
+    /**
+     * The simple message library PTB builder object address.
+     */
+    simpleMessageLibPtbBuilder: string
+
+    /**
+     * The ULN-302 message library object address.
+     */
+    uln302: string
+
+    /**
+     * The ULN-302 admin cap object address.
+     */
+    uln302AdminCap: string
+
+    /**
+     * The ULN-302 verification object address.
+     */
+    uln302Verification: string
+
+    /**
+     * The ULN-302 PTB builder object address.
+     */
+    uln302PtbBuilder: string
+
+    /**
+     * The treasury object address.
+     */
+    treasury: string
+
+    /**
+     * The treasury admin cap object address.
+     */
+    treasuryAdminCap: string
+
+    /**
+     * The blocked message library object address.
+     */
+    blockedMessageLib: string
+
+    /**
+     * The blocked message library PTB builder object address.
+     */
+    blockedMessageLibPtbBuilder: string
+
+    /**
+     * The counter admin cap object address.
+     */
+    counterAdminCap: string
+
+    /**
+     * The endpoint admin cap object address.
+     */
+    endpointAdminCap: string
+
+    /**
+     * The endpoint PTB builder object address.
+     */
+    endpointPtbBuilder: string
+
+    /**
+     * The endpoint PTB builder admin cap object address.
+     */
+    endpointPtbBuilderAdminCap: string
+
+    /**
+     * The default DVN object address.
+     */
+    dvn: string
+
+    /**
+     * The default DVN callCap object address, used in init_dvn move call
+     */
+    dvnCap: string
+
+    /**
+     * The default DVN fee lib object address.
+     */
+    dvnFeeLib: string
+
+    /**
+     * The default executor object address.
+     */
+    executor: string
+
+    /**
+     * The default executor callCap object address, used in init_executor move call
+     */
+    executorCap: string
+
+    /**
+     * The default executor owner cap object address.
+     */
+    executorOwnerCap: string
+
+    /**
+     * The default executor fee lib object address.
+     */
+    executorFeeLib: string
+
+    /**
+     * The default price feed object address.
+     */
+    priceFeed: string
+
+    /**
+     * The default price feed owner cap object address.
+     */
+    priceFeedOwnerCap: string
+
+    /**
+     * The counter OApp object address.
+     */
+    counter: string
+
+    /**
+     * The OApp core object address.
+     */
+    counterOapp: string
+    /**
+     * The default package whitelist validator object address.
+     */
+    packageWhitelistValidator: string
+
+    /**
+     * The worker registry object address.
+     */
+    workerRegistry: string
+
+    /**
+     * Allow additional properties beyond the explicitly defined ones
+     */
+    [key: string]: any
+}
+
+/**
+ * Module options for customizing module creation
+ */
+export interface ModuleOptions {
+    /** Custom package ID to use instead of default */
+    packageId: string
+    /** Custom objects configuration to use instead of default */
+    objects: Partial<ObjectOptions>
+}
+
+/**
+ * Options for initializing the SDK.
+ */
+export interface SdkOptions {
+    /** The chain for the SDK (default: Chain.IOTAL1) */
+    chain?: Chain
+    /** The Iota client for the SDK */
+    client: IotaClient
+    /** The stage of the SDK (default: Stage.MAINNET) */
+    stage?: Stage
+    /** Custom package addresses to override defaults */
+    packages?: Partial<PackageOptions>
+    /** Custom object addresses to override defaults */
+    objects?: Partial<ObjectOptions>
+}

package/src/types/price-feed.ts

@@ -0,0 +1,21 @@
+// PriceFeed configuration and data interfaces
+
+// Model Types enum - matches Move contract ModelType
+export enum ModelType {
+    DEFAULT = 0,
+    ARB_STACK = 1,
+    OP_STACK = 2,
+}
+
+// Price struct interface - matches Move contract Price struct
+export interface Price {
+    priceRatio: bigint // u128 in Move (price_ratio)
+    gasPriceInUnit: bigint // u64 in Move (gas_price_in_unit)
+    gasPerByte: number // u32 in Move (gas_per_byte)
+}
+
+// ArbitrumPriceExt struct interface - matches Move contract ArbitrumPriceExt struct
+export interface ArbitrumPriceExt {
+    gasPerL2Tx: bigint // u64 in Move (gas_per_l2_tx)
+    gasPerL1CallDataByte: number // u32 in Move (gas_per_l1_call_data_byte)
+}

package/src/types/ptb-builder.ts

@@ -0,0 +1,29 @@
+// TypeScript interfaces matching the Move structs in move_call.move
+export interface MoveCall {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    function: Function
+    arguments: Argument[]
+    type_arguments: string[] // TypeName as string
+    result_ids: Uint8Array[]
+    is_builder_call: boolean
+}
+
+export interface Function {
+    package: string
+    module_name: string
+    name: string
+}
+
+export type Argument =
+    | { ID: Uint8Array }
+    | { Object: string }
+    | { Pure: Uint8Array }
+    | { NestedResult: [number, number] } // [call_index, result_index]
+
+export const MAX_BATCH_SIZE = 50
+export const DEFAULT_SIMULATION_TIMES = 5
+
+export interface BuilderPlaceholderInfo {
+    index: number
+    moveCallCount: number
+}

package/src/types/simulation.ts

@@ -0,0 +1,8 @@
+/**
+ * Simulation-related type definitions
+ */
+
+export interface SimulateResult {
+    value: Uint8Array
+    type: string
+}

package/src/utils/argument.ts

@@ -0,0 +1,198 @@
+import { bcs } from '@iota/iota-sdk/bcs'
+import { Transaction, TransactionArgument } from '@iota/iota-sdk/transactions'
+
+import { Utils } from '../modules'
+
+/**
+ * Type guard to check if a value is already a TransactionArgument
+ * TransactionArgument can be:
+ * 1. Argument object with $kind property
+ * 2. Synchronous function: (tx: Transaction) => Argument
+ * 3. Asynchronous function: AsyncTransactionThunk
+ */
+export function isTransactionArgument(value: unknown): value is TransactionArgument {
+    // Check if it's a function (sync or async)
+    if (typeof value === 'function') {
+        return true
+    }
+
+    // Check if it's an Argument object
+    if (value !== null && typeof value === 'object' && '$kind' in value) {
+        const obj = value as { $kind: string }
+        return (
+            obj.$kind === 'GasCoin' || obj.$kind === 'Input' || obj.$kind === 'Result' || obj.$kind === 'NestedResult'
+        )
+    }
+
+    return false
+}
+
+/**
+ * Convert value to TransactionArgument using a simple converter function
+ * @param value - The value to convert (primitive type or TransactionArgument)
+ * @param converter - Function to convert primitive type to TransactionArgument
+ * @returns TransactionArgument
+ */
+export function asArg<T>(
+    value: T | TransactionArgument,
+    converter: (val: T) => TransactionArgument
+): TransactionArgument {
+    if (isTransactionArgument(value)) {
+        return value
+    }
+    return converter(value)
+}
+
+/**
+ * Convert value to TransactionArgument using a converter that requires Transaction
+ * @param tx - The transaction
+ * @param value - The value to convert
+ * @param converter - Function to convert value using transaction
+ * @returns TransactionArgument
+ */
+export function asArgWithTx<T>(
+    tx: Transaction,
+    value: T | TransactionArgument,
+    converter: (tx: Transaction, val: T) => TransactionArgument
+): TransactionArgument {
+    if (isTransactionArgument(value)) {
+        return value
+    }
+    return converter(tx, value)
+}
+
+/**
+ * Async version: Convert value to TransactionArgument using an async converter that requires Transaction
+ * @param tx - The transaction
+ * @param value - The value to convert
+ * @param converter - Async function to convert value using transaction
+ * @returns Promise<TransactionArgument>
+ */
+export async function asArgWithTxAsync<T>(
+    tx: Transaction,
+    value: T | TransactionArgument,
+    converter: (tx: Transaction, val: T) => Promise<TransactionArgument>
+): Promise<TransactionArgument> {
+    if (isTransactionArgument(value)) {
+        return value
+    }
+    return converter(tx, value)
+}
+
+// ===== Simplified conversion methods =====
+
+/**
+ * Convert to object reference TransactionArgument
+ */
+export function asObject(tx: Transaction, value: string | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.object(val))
+}
+
+/**
+ * Convert to address TransactionArgument
+ */
+export function asAddress(tx: Transaction, value: string | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.address(val))
+}
+
+/**
+ * Convert to u8 TransactionArgument
+ */
+export function asU8(tx: Transaction, value: number | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.u8(val))
+}
+
+/**
+ * Convert to u16 TransactionArgument
+ */
+export function asU16(tx: Transaction, value: number | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.u16(val))
+}
+
+/**
+ * Convert to u32 TransactionArgument
+ */
+export function asU32(tx: Transaction, value: number | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.u32(val))
+}
+
+/**
+ * Convert to u64 TransactionArgument (supports bigint, number, or string)
+ */
+export function asU64(tx: Transaction, value: bigint | number | string | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.u64(val))
+}
+
+/**
+ * Convert to u128 TransactionArgument (supports bigint, number, or string)
+ */
+export function asU128(tx: Transaction, value: bigint | number | string | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.u128(val))
+}
+
+/**
+ * Convert to u256 TransactionArgument (supports bigint, number, or string)
+ */
+export function asU256(tx: Transaction, value: bigint | number | string | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.u256(val))
+}
+
+/**
+ * Convert Uint8Array to Bytes32 using moduleManager's fromBytesMoveCall
+ * @param tx - The transaction
+ * @param value - Uint8Array or TransactionArgument
+ * @param utils - utils Module
+ * @returns TransactionArgument
+ */
+export function asBytes32(tx: Transaction, value: Uint8Array | TransactionArgument, utils: Utils): TransactionArgument {
+    return asArgWithTx(tx, value, (tx, bytes) => utils.fromBytesMoveCall(tx, bytes))
+}
+
+/**
+ * Convert Uint8Array to serialized bytes vector TransactionArgument
+ * @param tx - The transaction
+ * @param value - Uint8Array or TransactionArgument
+ * @returns TransactionArgument
+ */
+export function asBytes(tx: Transaction, value: Uint8Array | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure(bcs.vector(bcs.u8()).serialize(val)))
+}
+/**
+ * Convert Uint8Array Vector to serialized bytes vector TransactionArgument
+ * @param tx - The transaction
+ * @param value - Uint8Array or TransactionArgument
+ * @returns TransactionArgument
+ */
+export function asBytesVector(tx: Transaction, value: Uint8Array[] | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure(bcs.vector(bcs.vector(bcs.u8())).serialize(val)))
+}
+
+/**
+ * Convert string to string TransactionArgument
+ * @param tx - The transaction
+ * @param value - string or TransactionArgument
+ * @returns TransactionArgument
+ */
+export function asString(tx: Transaction, value: string | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.string(val))
+}
+
+/**
+ * Convert address array to serialized vector<address> TransactionArgument
+ * @param tx - The transaction
+ * @param value - string[] or TransactionArgument
+ * @returns TransactionArgument
+ */
+export function asAddressVector(tx: Transaction, value: string[] | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure(bcs.vector(bcs.Address).serialize(val)))
+}
+
+/**
+ * Convert boolean to boolean TransactionArgument
+ * @param tx - The transaction
+ * @param value - boolean or TransactionArgument
+ * @returns TransactionArgument
+ */
+export function asBool(tx: Transaction, value: boolean | TransactionArgument): TransactionArgument {
+    return asArg(value, (val) => tx.pure.bool(val))
+}

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+// Utils unified exports
+export * from './argument'
+export * from './transaction'
+export * from './ptb-validator'
+export * from './package-allowlist-validator'
+export * from './non-sender-object-validator'
+export * from './share-object-validator'
+export * from './validate-with-details'

package/src/utils/move-call-object-fetcher.ts

@@ -0,0 +1,105 @@
+import { IotaClient, IotaObjectResponse } from '@iota/iota-sdk/client'
+
+import { MAX_BATCH_SIZE, MoveCall } from '../types'
+
+/**
+ * Represents a move call with its associated object details
+ */
+export interface MoveCallWithObjectDetails {
+    moveCall: MoveCall
+    objectDetails: Map<string, IotaObjectResponse>
+}
+
+/**
+ * MoveCallObjectFetcher fetches object details for move calls once
+ * and provides them to validators to avoid multiple API calls
+ */
+export class MoveCallObjectFetcher {
+    private client: IotaClient
+    private batchSize: number
+
+    constructor(client: IotaClient, batchSize: number = MAX_BATCH_SIZE) {
+        this.client = client
+        this.batchSize = batchSize
+    }
+
+    /**
+     * Fetches object details for all objects referenced in move calls
+     * @param moveCalls - Array of move calls to fetch object details for
+     * @param options - Options for what object data to fetch
+     * @returns Array of move calls with their associated object details
+     */
+    async fetchObjectDetails(
+        moveCalls: MoveCall[],
+        options: {
+            showOwner?: boolean
+            showType?: boolean
+            showContent?: boolean
+            showBcs?: boolean
+            showDisplay?: boolean
+            showStorageRebate?: boolean
+        } = {}
+    ): Promise<MoveCallWithObjectDetails[]> {
+        // Extract all unique object IDs from move calls
+        const objectIdSet = new Set<string>()
+        for (const moveCall of moveCalls) {
+            for (const arg of moveCall.arguments) {
+                if ('Object' in arg) {
+                    objectIdSet.add(arg.Object)
+                }
+            }
+        }
+
+        const objectIds = Array.from(objectIdSet)
+        if (objectIds.length === 0) {
+            // No objects to fetch, return move calls with empty object details
+            return moveCalls.map((moveCall) => ({
+                moveCall,
+                objectDetails: new Map<string, IotaObjectResponse>(),
+            }))
+        }
+
+        // Validate batch size
+        if (this.batchSize > MAX_BATCH_SIZE || this.batchSize < 1) {
+            throw new Error(`batchSize must be between 1 and ${MAX_BATCH_SIZE}`)
+        }
+
+        // Fetch all objects in batches
+        const objectDetailsMap = new Map<string, IotaObjectResponse>()
+
+        for (let i = 0; i < objectIds.length; i += this.batchSize) {
+            const batch = objectIds.slice(i, i + this.batchSize)
+            const objects = await this.client.multiGetObjects({
+                ids: batch,
+                options,
+            })
+
+            // Map object responses to their IDs
+            objects.forEach((object, index) => {
+                const objectId = batch[index]
+                objectDetailsMap.set(objectId, object)
+            })
+        }
+
+        // Create move calls with object details
+        return moveCalls.map((moveCall) => {
+            // Get object details for this specific move call
+            const moveCallObjectDetails = new Map<string, IotaObjectResponse>()
+
+            for (const arg of moveCall.arguments) {
+                if ('Object' in arg) {
+                    const objectId = arg.Object
+                    const objectDetail = objectDetailsMap.get(objectId)
+                    if (objectDetail) {
+                        moveCallObjectDetails.set(objectId, objectDetail)
+                    }
+                }
+            }
+
+            return {
+                moveCall,
+                objectDetails: moveCallObjectDetails,
+            }
+        })
+    }
+}