@layerzerolabs/lz-sui-sdk-v2 3.0.134 → 3.0.135

package/src/modules/ptb-builders/endpoint-ptb-builder.ts

@@ -6,9 +6,15 @@ import { ModuleManager } from '../../module-manager'
 import { ObjectOptions } from '../../types'
 import { asAddress, asBool, asU32, executeSimulate } from '../../utils'
 
-export const LibBuilderManagerErrorCode = {
-    // LibBuilderManager related errors (with LibBuilderManager_ prefix)
-    LibBuilderManager_EBuilderNotFound: 1,
+export const EndpointPtbBuilderErrorCode = {
+    // EndpointPtbBuilder related errors (matching endpoint_ptb_builder.move)
+    EndpointPtbBuilder_EBuilderNotFound: 1,
+    EndpointPtbBuilder_EBuilderRegistered: 2,
+    EndpointPtbBuilder_EBuilderUnsupported: 3,
+    EndpointPtbBuilder_EInvalidBounds: 4,
+    EndpointPtbBuilder_EInvalidBuilderAddress: 5,
+    EndpointPtbBuilder_EInvalidLibrary: 6,
+    EndpointPtbBuilder_EUnauthorized: 7,
 } as const
 
 const ModuleName = 'endpoint_ptb_builder'

package/src/modules/ptb-builders/ptb-builder.ts

@@ -2,14 +2,14 @@ import { bcs } from '@mysten/sui/bcs'
 import { SuiClient } from '@mysten/sui/client'
 import { Transaction, TransactionResult } from '@mysten/sui/transactions'
 
-import { VectorMoveCallBCS } from '../../bcs'
+import { OAppInfoV1Bcs, VectorMoveCallBCS } from '../../bcs'
 import {
     Argument,
     BuilderPlaceholderInfo,
     DEFAULT_SIMULATION_TIMES,
     LzComposeVersion,
-    LzReceiveVersion,
     MoveCall,
+    OAppInfoVersion,
     SimulateResult,
 } from '../../types'
 import { simulateTransaction } from '../../utils/transaction'
@@ -17,6 +17,15 @@ import { normalizeSuiPackageId } from '../../utils/type-name'
 
 const MOVE_CALL_MODULE_NAME = 'move_call'
 
+export const PtbBuilderErrorCode = {
+    // MoveCallsBuilder related errors (matching move_calls_builder.move)
+    MoveCallsBuilder_EInvalidMoveCallResult: 1,
+    MoveCallsBuilder_EResultIDNotFound: 2,
+
+    // Argument related errors (matching argument.move)
+    Argument_EInvalidArgument: 1,
+} as const
+
 export class PtbBuilder {
     public packageId: string
     public readonly client: SuiClient
@@ -48,9 +57,10 @@ export class PtbBuilder {
     async simulateLzReceivePtb(tx: Transaction, sender?: string): Promise<MoveCall[]> {
         const ptbCallsResult = await simulateTransaction(this.client, tx, sender)
         const buffer = Buffer.from(bcs.vector(bcs.u8()).parse(ptbCallsResult[0].value))
+
         const version = buffer.readInt16BE()
-        if (version === LzReceiveVersion.VERSION_1) {
-            return this.#decodeMoveCallsBytes(new Uint8Array(buffer.subarray(2)))
+        if (version === OAppInfoVersion.VERSION_1) {
+            return this.#decodeMoveCallsFromOAppInfoV1(new Uint8Array(buffer.subarray(2)))
         }
         throw new Error(`Unknown version: ${version}`)
     }
@@ -285,6 +295,11 @@ export class PtbBuilder {
         return this.#decodeMoveCallsBytes(value)
     }
 
+    #decodeMoveCallsFromOAppInfoV1(bytes: Uint8Array): MoveCall[] {
+        const oappInfo = OAppInfoV1Bcs.parse(bytes)
+        return this.#decodeMoveCallsBytes(new Uint8Array(oappInfo.lz_receive_info).subarray(2)) // remove the version prefix
+    }
+
     /**
      * Decode move calls from raw bytes
      * @param bytes - The raw bytes containing encoded move calls

package/src/modules/ptb-builders/uln302-ptb-builder.ts

@@ -8,6 +8,11 @@ import { asAddress, executeSimulate } from '../../utils'
 
 const MODULE_NAME = 'uln_302_ptb_builder'
 
+export const Uln302PtbBuilderErrorCode = {
+    // ULN302 PTB Builder related errors (matching uln_302_ptb_builder.move)
+    Uln302PtbBuilder_EWorkerPtbsNotFound: 1,
+} as const
+
 export class Uln302PtbBuilder {
     public packageId: string
     public readonly client: SuiClient

package/src/modules/workers/dvn-layerzero.ts

@@ -6,6 +6,11 @@ import { asAddress, asAddressVector, asBytesVector, asObject, asU16, asU32, asU6
 
 const MODULE_NAME = 'dvn_layerzero'
 
+export const DVNLayerzeroErrorCode = {
+    // DVNLayerzero related errors (matching dvn_layerzero.move)
+    DVNLayerzero_EWorkerCapNotFromPackage: 1,
+} as const
+
 export class DvnLayerZero {
     public packageId: string
     public readonly client: SuiClient
@@ -28,6 +33,7 @@ export class DvnLayerZero {
      * @param workerCap - Worker capability object ID or transaction argument
      * @param vid - Verifier ID for the DVN or transaction argument
      * @param depositAddress - Address for fee deposits or transaction argument
+     * @param supportedMessageLibs - Array of supported message library addresses or transaction argument
      * @param priceFeed - Price feed object address or transaction argument
      * @param workerFeeLib - Worker fee library address or transaction argument
      * @param defaultMultiplierBps - Default multiplier in basis points or transaction argument
@@ -40,6 +46,7 @@ export class DvnLayerZero {
         workerCap: string | TransactionArgument,
         vid: number | TransactionArgument,
         depositAddress: string | TransactionArgument,
+        supportedMessageLibs: string[] | TransactionArgument,
         priceFeed: string | TransactionArgument,
         workerFeeLib: string | TransactionArgument,
         defaultMultiplierBps: number | TransactionArgument,
@@ -53,12 +60,14 @@ export class DvnLayerZero {
                 asObject(tx, workerCap),
                 asU32(tx, vid),
                 asAddress(tx, depositAddress),
+                asAddressVector(tx, supportedMessageLibs),
                 asAddress(tx, priceFeed),
                 asAddress(tx, workerFeeLib),
                 asU16(tx, defaultMultiplierBps),
                 asAddressVector(tx, admins),
                 asBytesVector(tx, signers),
                 asU64(tx, quorum),
+                tx.object(this.moduleManager.objects.workerRegistry),
             ],
         })
     }

package/src/modules/workers/dvn.ts

@@ -27,6 +27,21 @@ export const DVNErrorCode = {
     DVN_EEidNotSupported: 2,
     DVN_EHashAlreadyUsed: 3,
     DVN_EPtbBuilderAlreadyInitialized: 4,
+
+    // Multisig related errors (matching multisig.move)
+    Multisig_EDuplicatedSigner: 1,
+    Multisig_EInvalidSignatureLength: 2,
+    Multisig_EInvalidSignerLength: 3,
+    Multisig_EQuorumIsZero: 4,
+    Multisig_ESignaturesLessThanQuorum: 5,
+    Multisig_ESignerAlreadyExists: 6,
+    Multisig_ESignerNotFound: 7,
+    Multisig_ESignerNotInCommittee: 8,
+    Multisig_ESignersSizeIsLessThanQuorum: 9,
+
+    // DVNInfoV1 related errors (matching dvn_info_v1.move)
+    DVNInfoV1_EInvalidData: 1,
+    DVNInfoV1_EInvalidVersion: 2,
 } as const
 
 export class DVN {
@@ -253,6 +268,37 @@ export class DVN {
 
     // === Set Functions with Signatures ===
 
+    /**
+     * Set supported message library (admin with signatures)
+     * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
+     * @param messageLib - The message library address
+     * @param supported - Whether to support or remove support for the message library
+     * @param expiration - Signature expiration timestamp
+     * @param signatures - Multisig signatures for authorization
+     */
+    setSupportedMessageLibMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        messageLib: string | TransactionArgument,
+        supported: boolean | TransactionArgument,
+        expiration: bigint | number | string | TransactionArgument,
+        signatures: Uint8Array | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_supported_message_lib'),
+            arguments: [
+                tx.object(this.objects.dvn),
+                asObject(tx, adminCap),
+                asAddress(tx, messageLib),
+                asBool(tx, supported),
+                asU64(tx, expiration),
+                asBytes(tx, signatures),
+                tx.object.clock(),
+            ],
+        })
+    }
+
     /**
      * Set allowlist status for an OApp sender (admin with signatures)
      * @param tx - The transaction to add the move call to
@@ -433,32 +479,33 @@ export class DVN {
     // Verification Functions
 
     /**
-     * Verify a packet with DVN signatures (admin with signatures)
+     * Verify a packet with DVN signatures (admin with signatures) - returns Call object for ULN302
      * @param tx - The transaction to add the move call to
      * @param adminCap - The admin capability object ID
-     * @param verification - The verification object address
+     * @param targetMessageLib - The target message library address (usually ULN302)
      * @param packetHeader - The packet header as bytes
      * @param payloadHash - The payload hash as bytes
      * @param confirmations - Required confirmations count
      * @param expiration - Signature expiration timestamp
      * @param signatures - DVN multisig signatures
+     * @returns Transaction result containing the verification Call object
      */
     verifyMoveCall(
         tx: Transaction,
         adminCap: string | TransactionArgument,
-        verification: string | TransactionArgument,
+        targetMessageLib: string | TransactionArgument,
         packetHeader: Uint8Array | TransactionArgument,
         payloadHash: Uint8Array | TransactionArgument,
         confirmations: bigint | number | string | TransactionArgument,
         expiration: bigint | number | string | TransactionArgument,
         signatures: Uint8Array | TransactionArgument
-    ): void {
-        tx.moveCall({
+    ): TransactionResult {
+        return tx.moveCall({
             target: this.#target('verify'),
             arguments: [
                 tx.object(this.objects.dvn),
                 asObject(tx, adminCap),
-                asObject(tx, verification),
+                asAddress(tx, targetMessageLib),
                 asBytes(tx, packetHeader),
                 asBytes32(tx, payloadHash, this.moduleManager.getUtils()),
                 asU64(tx, confirmations),
@@ -755,6 +802,34 @@ export class DVN {
         )
     }
 
+    /**
+     * Check if a message library is supported by this DVN
+     * @param tx - The transaction to add the move call to
+     * @param messageLib - The message library address to check
+     * @returns Transaction result containing the support status
+     */
+    isSupportedMessageLibMoveCall(tx: Transaction, messageLib: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_supported_message_lib'),
+            arguments: [tx.object(this.objects.dvn), asAddress(tx, messageLib)],
+        })
+    }
+
+    /**
+     * Check if a message library is supported by this DVN
+     * @param messageLib - The message library address to check
+     * @returns Promise<boolean> - True if the message library is supported
+     */
+    async isSupportedMessageLib(messageLib: string): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isSupportedMessageLibMoveCall(tx, messageLib)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
     /**
      * Check if an address is allowlisted
      * @param tx - The transaction to add the move call to
@@ -1135,6 +1210,65 @@ export class DVN {
         )
     }
 
+    /**
+     * Get DVN object address from worker registry using this DVN's worker capability (as a move call)
+     * This function chains Move calls to decode worker info and extract the DVN object address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the DVN object address
+     */
+    getDvnObjectAddressMoveCall(tx: Transaction): TransactionResult {
+        // Step 1: Get this DVN's worker capability address
+        const workerCapAddress = this.workerCapAddressMoveCall(tx)
+
+        // Step 2: Get worker info bytes from registry
+        const workerInfoBytes = this.moduleManager
+            .getWorkerRegistry(this.client)
+            .getWorkerInfoMoveCall(tx, workerCapAddress)
+
+        // Step 3: Decode worker info using worker_common::worker_info_v1::decode
+        const workerInfo = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::decode`,
+            arguments: [workerInfoBytes],
+        })
+
+        // Step 4: Extract worker_info field from decoded WorkerInfoV1
+        const dvnInfoBytes = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::worker_info`,
+            arguments: [workerInfo],
+        })
+
+        // Step 5: Decode DVN info using dvn::dvn_info_v1::decode
+        const dvnInfo = tx.moveCall({
+            target: `${this.packageId}::dvn_info_v1::decode`,
+            arguments: [dvnInfoBytes],
+        })
+
+        // Step 6: Extract dvn_object address from decoded DVNInfoV1
+        return tx.moveCall({
+            target: `${this.packageId}::dvn_info_v1::dvn_object`,
+            arguments: [dvnInfo],
+        })
+    }
+
+    /**
+     * Get DVN object address from worker registry using this DVN's worker capability
+     * This function uses Move calls to decode worker info and extract the DVN object address
+     * @returns Promise<string> - The DVN object address
+     * @throws Will throw an error if worker info is not found or if decoding fails
+     */
+    async getDvnObjectAddress(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getDvnObjectAddressMoveCall(tx)
+            },
+            (result) => {
+                // The result is the DVN object address directly from the Move call chain
+                return bcs.Address.parse(result[0].value)
+            }
+        )
+    }
+
     // === Witness Functions ===
 
     /**
@@ -1506,6 +1640,80 @@ export class DVN {
         })
     }
 
+    /**
+     * Populate verify with DVN verification and ULN verify call
+     * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
+     * @param targetMessageLib - The target message library address (usually ULN302)
+     * @param targetVerification - The verification object address for the target message library
+     * @param packetHeader - The packet header as bytes
+     * @param payloadHash - The payload hash as bytes
+     * @param confirmations - Required confirmations count
+     * @param expiration - Signature expiration timestamp
+     * @param signatures - DVN multisig signatures
+     */
+    populateVerify(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        targetMessageLib: string,
+        targetVerification: string,
+        packetHeader: Uint8Array | TransactionArgument,
+        payloadHash: Uint8Array | TransactionArgument,
+        confirmations: bigint | number | string | TransactionArgument,
+        expiration: bigint | number | string | TransactionArgument,
+        signatures: Uint8Array | TransactionArgument
+    ): void {
+        // Step 1: Call DVN's verifyMoveCall to get the verification call
+        const dvnCall = this.verifyMoveCall(
+            tx,
+            adminCap,
+            targetMessageLib,
+            packetHeader,
+            payloadHash,
+            confirmations,
+            expiration,
+            signatures
+        )
+
+        // Step 2: Get the message library object address based on targetMessageLib
+        const messageLibObjectAddress = this.#getUlnObjectAddress(targetMessageLib)
+
+        tx.moveCall({
+            target: this.#getUlnVerifyTarget(targetMessageLib),
+            arguments: [tx.object(messageLibObjectAddress), asObject(tx, targetVerification), dvnCall],
+        })
+    }
+
+    /**
+     * Get message library object address based on targetMessageLib package address
+     * @param targetMessageLib - The target message library package address
+     * @returns Message library object address
+     * @throws Error if targetMessageLib doesn't match any known message library
+     * @private
+     */
+    #getUlnObjectAddress(targetMessageLib: string): string {
+        // Check if targetMessageLib equals ULN302 package address
+        if (targetMessageLib === this.moduleManager.packages.uln302) {
+            return this.objects.uln302
+        }
+
+        throw new Error('Target message library not match objects')
+    }
+
+    /**
+     * Get ULN verify target path based on targetMessageLib package address
+     * @param targetMessageLib - The target message library package address
+     * @returns Message library verify target path
+     * @throws Error if targetMessageLib doesn't match any known message library
+     * @private
+     */
+    #getUlnVerifyTarget(targetMessageLib: string): string {
+        if (targetMessageLib === this.moduleManager.packages.uln302) {
+            return `${targetMessageLib}::uln_302::verify`
+        }
+
+        throw new Error('Target message library not match any target')
+    }
     /**
      * Generate the full target path for move calls
      * @param name - The function name to call

package/src/modules/workers/executor-fee-lib.ts

@@ -7,10 +7,18 @@ import { ObjectOptions } from '../../types'
 const MODULE_NAME = 'executor_fee_lib'
 
 export const ExecutorFeeLibErrorCode = {
-    // Executor Fee Lib related errors (with ExecutorFeeLib_ prefix)
+    // Executor Fee Lib related errors (matching executor_fee_lib.move)
     ExecutorFeeLib_EEidNotSupported: 1,
-    ExecutorFeeLib_EInvalidExecutor: 2,
-    ExecutorFeeLib_EExecutorAlreadySet: 3,
+
+    // ExecutorOption related errors (matching executor_option.move)
+    ExecutorOption_ENoOptions: 1,
+    ExecutorOption_EUnsupportedOptionType: 2,
+    ExecutorOption_EZeroLzReceiveGasProvided: 3,
+    ExecutorOption_EZeroLzComposeGasProvided: 4,
+    ExecutorOption_ENativeAmountExceedsCap: 5,
+    ExecutorOption_EInvalidLzReceiveOption: 6,
+    ExecutorOption_EInvalidNativeDropOption: 7,
+    ExecutorOption_EInvalidLzComposeOption: 8,
 } as const
 
 export class ExecutorFeeLib {

package/src/modules/workers/executor-layerzero.ts

@@ -6,6 +6,11 @@ import { asAddress, asAddressVector, asObject, asU16 } from '../../utils'
 
 const MODULE_NAME = 'executor_layerzero'
 
+export const ExecutorLayerzeroErrorCode = {
+    // ExecutorLayerzero related errors (matching executor_layerzero.move)
+    ExecutorLayerzero_EWorkerCapNotFromPackage: 1,
+} as const
+
 export class ExecutorLayerZero {
     public packageId: string
     public readonly client: SuiClient
@@ -27,6 +32,7 @@ export class ExecutorLayerZero {
      * @param tx - The transaction to add the move call to
      * @param workerCap - Worker capability object ID or transaction argument
      * @param depositAddress - Address for fee deposits or transaction argument
+     * @param supportedMessageLibs - Array of supported message library addresses or transaction argument
      * @param priceFeed - Price feed object address or transaction argument
      * @param workerFeeLib - Worker fee library address or transaction argument
      * @param defaultMultiplierBps - Default multiplier in basis points or transaction argument
@@ -37,6 +43,7 @@ export class ExecutorLayerZero {
         tx: Transaction,
         workerCap: string | TransactionArgument,
         depositAddress: string | TransactionArgument,
+        supportedMessageLibs: string[] | TransactionArgument,
         priceFeed: string | TransactionArgument,
         workerFeeLib: string | TransactionArgument,
         defaultMultiplierBps: number | TransactionArgument,
@@ -48,11 +55,13 @@ export class ExecutorLayerZero {
             arguments: [
                 asObject(tx, workerCap),
                 asAddress(tx, depositAddress),
+                asAddressVector(tx, supportedMessageLibs),
                 asAddress(tx, priceFeed),
                 asAddress(tx, workerFeeLib),
                 asU16(tx, defaultMultiplierBps),
                 asAddress(tx, owner),
                 asAddressVector(tx, admins),
+                tx.object(this.moduleManager.objects.workerRegistry),
             ],
         })
     }

package/src/modules/workers/executor.ts

@@ -25,6 +25,10 @@ export const ExecutorErrorCode = {
     // Executor related errors (with Executor_ prefix)
     Executor_EEidNotSupported: 1,
     Executor_EInvalidNativeDropAmount: 2,
+
+    // ExecutorInfoV1 related errors (matching executor_info_v1.move)
+    ExecutorInfoV1_EInvalidData: 1,
+    ExecutorInfoV1_EInvalidVersion: 2,
 } as const
 
 export class Executor {
@@ -524,6 +528,30 @@ export class Executor {
         })
     }
 
+    /**
+     * Set supported message library (owner only)
+     * @param tx - The transaction to add the move call to
+     * @param ownerCap - The owner capability object ID
+     * @param messageLib - The message library address
+     * @param supported - Whether to support or remove support for the message library
+     */
+    setSupportedMessageLibMoveCall(
+        tx: Transaction,
+        ownerCap: string | TransactionArgument,
+        messageLib: string | TransactionArgument,
+        supported: boolean | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_supported_message_lib'),
+            arguments: [
+                tx.object(this.objects.executor),
+                asObject(tx, ownerCap),
+                asAddress(tx, messageLib),
+                asBool(tx, supported),
+            ],
+        })
+    }
+
     /**
      * Set allowlist status for an OApp sender (owner only)
      * @param tx - The transaction to add the move call to
@@ -810,6 +838,34 @@ export class Executor {
         )
     }
 
+    /**
+     * Check if a message library is supported by this executor
+     * @param tx - The transaction to add the move call to
+     * @param messageLib - The message library address to check
+     * @returns Transaction result containing the support status
+     */
+    isSupportedMessageLibMoveCall(tx: Transaction, messageLib: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_supported_message_lib'),
+            arguments: [tx.object(this.objects.executor), asAddress(tx, messageLib)],
+        })
+    }
+
+    /**
+     * Check if a message library is supported by this executor
+     * @param messageLib - The message library address to check
+     * @returns Promise<boolean> - True if the message library is supported
+     */
+    async isSupportedMessageLib(messageLib: string): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isSupportedMessageLibMoveCall(tx, messageLib)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
     /**
      * Check if an address is allowlisted
      * @param tx - The transaction to add the move call to
@@ -1029,6 +1085,65 @@ export class Executor {
         )
     }
 
+    /**
+     * Get Executor object address from worker registry using this Executor's worker capability (as a move call)
+     * This function chains Move calls to decode worker info and extract the Executor object address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the Executor object address
+     */
+    getExecutorObjectAddressMoveCall(tx: Transaction): TransactionResult {
+        // Step 1: Get this Executor's worker capability address
+        const workerCapAddress = this.workerCapAddressMoveCall(tx)
+
+        // Step 2: Get worker info bytes from registry
+        const workerInfoBytes = this.moduleManager
+            .getWorkerRegistry(this.client)
+            .getWorkerInfoMoveCall(tx, workerCapAddress)
+
+        // Step 3: Decode worker info using worker_common::worker_info_v1::decode
+        const workerInfo = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::decode`,
+            arguments: [workerInfoBytes],
+        })
+
+        // Step 4: Extract worker_info field from decoded WorkerInfoV1
+        const executorInfoBytes = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::worker_info`,
+            arguments: [workerInfo],
+        })
+
+        // Step 5: Decode Executor info using executor::executor_info_v1::decode
+        const executorInfo = tx.moveCall({
+            target: `${this.packageId}::executor_info_v1::decode`,
+            arguments: [executorInfoBytes],
+        })
+
+        // Step 6: Extract executor_object address from decoded ExecutorInfoV1
+        return tx.moveCall({
+            target: `${this.packageId}::executor_info_v1::executor_object`,
+            arguments: [executorInfo],
+        })
+    }
+
+    /**
+     * Get Executor object address from worker registry using this Executor's worker capability
+     * This function uses Move calls to decode worker info and extract the Executor object address
+     * @returns Promise<string> - The Executor object address
+     * @throws Will throw an error if worker info is not found or if decoding fails
+     */
+    async getExecutorObjectAddress(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getExecutorObjectAddressMoveCall(tx)
+            },
+            (result) => {
+                // The result is the Executor object address directly from the Move call chain
+                return bcs.Address.parse(result[0].value)
+            }
+        )
+    }
+
     // === Private Helper Functions ===
 
     private parseDstConfig(data: Uint8Array): DstConfig {

package/src/modules/workers/index.ts

@@ -7,3 +7,4 @@ export * from './executor-fee-lib'
 export * from './executor-layerzero'
 export * from './price-feed'
 export * from './treasury'
+export * from './worker-registry'

package/src/modules/workers/treasury.ts

@@ -9,10 +9,10 @@ import { asAddress, asBool, asU64, executeSimulate } from '../../utils'
 const MODULE_NAME = 'treasury'
 
 export const TreasuryErrorCode = {
-    // Treasury related errors
-    TREASURY_EZroNotEnabled: 1,
-    TREASURY_EInvalidFeeRecipient: 2,
-    TREASURY_EInvalidNativeFeeBp: 3,
+    // Treasury related errors (matching treasury.move)
+    TREASURY_EInvalidFeeRecipient: 1,
+    TREASURY_EInvalidNativeFeeBp: 2,
+    TREASURY_EZroNotEnabled: 3,
 } as const
 
 export class Treasury {