@layerzerolabs/lz-iotal1-sdk-v2 3.0.143

package/src/modules/workers/treasury.ts

@@ -0,0 +1,295 @@
+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, asBool, asU64, executeSimulate } from '../../utils'
+
+const MODULE_NAME = 'treasury'
+
+export const TreasuryErrorCode = {
+    // Treasury related errors (matching treasury.move)
+    TREASURY_EInvalidFeeRecipient: 1,
+    TREASURY_EInvalidNativeFeeBp: 2,
+    TREASURY_EZroNotEnabled: 3,
+} as const
+
+export class Treasury {
+    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 fee recipient address for treasury (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.treasury),
+                tx.object(this.objects.treasuryAdminCap),
+                asAddress(tx, feeRecipient),
+            ],
+        })
+    }
+
+    /**
+     * Set native fee basis points for treasury (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param nativeFeeBp - The native fee in basis points or transaction argument
+     */
+    setNativeFeeBpMoveCall(tx: Transaction, nativeFeeBp: bigint | number | string | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_native_fee_bp'),
+            arguments: [
+                tx.object(this.objects.treasury),
+                tx.object(this.objects.treasuryAdminCap),
+                asU64(tx, nativeFeeBp),
+            ],
+        })
+    }
+
+    /**
+     * Set ZRO token fee for treasury (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param zroFee - The ZRO token fee amount or transaction argument
+     */
+    setZroFeeMoveCall(tx: Transaction, zroFee: bigint | number | string | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_zro_fee'),
+            arguments: [tx.object(this.objects.treasury), tx.object(this.objects.treasuryAdminCap), asU64(tx, zroFee)],
+        })
+    }
+
+    /**
+     * Enable or disable ZRO token fees (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param zroEnabled - Whether ZRO token fees are enabled or transaction argument
+     */
+    setZroEnabledMoveCall(tx: Transaction, zroEnabled: boolean | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_zro_enabled'),
+            arguments: [
+                tx.object(this.objects.treasury),
+                tx.object(this.objects.treasuryAdminCap),
+                asBool(tx, zroEnabled),
+            ],
+        })
+    }
+
+    /**
+     * Enable or disable treasury fees (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param feeEnabled - Whether treasury fees are enabled or transaction argument
+     */
+    setFeeEnabledMoveCall(tx: Transaction, feeEnabled: boolean | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_fee_enabled'),
+            arguments: [
+                tx.object(this.objects.treasury),
+                tx.object(this.objects.treasuryAdminCap),
+                asBool(tx, feeEnabled),
+            ],
+        })
+    }
+
+    // === View Functions ===
+
+    /**
+     * Calculate treasury fees for a transaction
+     * @param tx - The transaction to add the move call to
+     * @param totalNativeFee - Total native fee amount or transaction argument
+     * @param payInZro - Whether to pay in ZRO tokens or transaction argument
+     * @returns Transaction result containing calculated fees
+     */
+    getFeeMoveCall(
+        tx: Transaction,
+        totalNativeFee: bigint | number | string | TransactionArgument,
+        payInZro: boolean | TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('get_fee'),
+            arguments: [tx.object(this.objects.treasury), asU64(tx, totalNativeFee), asBool(tx, payInZro)],
+        })
+    }
+
+    /**
+     * Calculate treasury fees for a transaction
+     * @param totalNativeFee - Total native fee amount
+     * @param payInZro - Whether to pay in ZRO tokens
+     * @returns Promise<[bigint, bigint]> - Tuple of [nativeFee, zroFee]
+     */
+    async getFee(totalNativeFee: bigint, payInZro: boolean): Promise<[bigint, bigint]> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getFeeMoveCall(tx, totalNativeFee, payInZro)
+            },
+            (result) => {
+                // Parse the tuple (u64, u64) returned by get_fee
+                const nativeFee = BigInt(bcs.U64.parse(result[0].value))
+                const zroFee = BigInt(bcs.U64.parse(result[1].value))
+                return [nativeFee, zroFee]
+            }
+        )
+    }
+
+    /**
+     * Get treasury fee recipient address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the fee recipient address
+     */
+    feeRecipientMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('fee_recipient'),
+            arguments: [tx.object(this.objects.treasury)],
+        })
+    }
+
+    /**
+     * Get treasury fee recipient address
+     * @returns Promise<string> - The fee recipient address
+     */
+    async feeRecipient(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.feeRecipientMoveCall(tx)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get native fee basis points
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the native fee basis points
+     */
+    nativeFeeBpMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('native_fee_bp'),
+            arguments: [tx.object(this.objects.treasury)],
+        })
+    }
+
+    /**
+     * Get native fee basis points
+     * @returns Promise<bigint> - The native fee in basis points
+     */
+    async nativeFeeBp(): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.nativeFeeBpMoveCall(tx)
+            },
+            (result) => BigInt(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
+     */
+    zroFeeMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('zro_fee'),
+            arguments: [tx.object(this.objects.treasury)],
+        })
+    }
+
+    /**
+     * Get ZRO token fee amount
+     * @returns Promise<bigint> - The ZRO token fee
+     */
+    async zroFee(): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.zroFeeMoveCall(tx)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
+    /**
+     * Check if ZRO token fees are enabled
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the ZRO enabled status
+     */
+    zroEnabledMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('zro_enabled'),
+            arguments: [tx.object(this.objects.treasury)],
+        })
+    }
+
+    /**
+     * Check if ZRO token fees are enabled
+     * @returns Promise<boolean> - True if ZRO fees are enabled
+     */
+    async zroEnabled(): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.zroEnabledMoveCall(tx)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Check if treasury fees are enabled
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the fee enabled status
+     */
+    feeEnabledMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('fee_enabled'),
+            arguments: [tx.object(this.objects.treasury)],
+        })
+    }
+
+    /**
+     * Check if treasury fees are enabled
+     * @returns Promise<boolean> - True if treasury fees are enabled
+     */
+    async feeEnabled(): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.feeEnabledMoveCall(tx)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    // === Private Functions ===
+
+    /**
+     * 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/workers/worker-registry.ts

@@ -0,0 +1,110 @@
+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, executeSimulate } from '../../utils'
+
+const MODULE_NAME = 'worker_registry'
+
+export const WorkerRegistryErrorCode = {
+    // WorkerRegistry related errors (matching worker_registry.move)
+    EWorkerInfoInvalid: 1,
+    EWorkerInfoNotFound: 2,
+} as const
+
+/**
+ * WorkerRegistry provides access to the worker registry contract functionality
+ * This module maintains mappings between worker addresses and their associated information.
+ */
+export class WorkerRegistry {
+    public packageId: string
+    public readonly client: IotaClient
+    private readonly objects: ObjectOptions
+
+    /**
+     * Create a new WorkerRegistry instance
+     * @param packageId - The package ID of the worker registry contract
+     * @param client - The Iota client instance
+     * @param objects - Object options containing contract object IDs
+     * @param moduleManager - Module manager for handling dependencies
+     */
+    constructor(
+        packageId: string,
+        client: IotaClient,
+        objects: ObjectOptions,
+        private readonly moduleManager: ModuleManager
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.objects = objects
+    }
+
+    // === View Functions ===
+
+    /**
+     * Get worker info for a specific worker address (as a move call)
+     * This creates a move call that can be used in a PTB (Programmable Transaction Block)
+     * @param tx - The transaction to add the move call to
+     * @param worker - The worker address or transaction argument
+     * @returns TransactionResult - The move call result containing worker info bytes
+     * @throws Will throw an error if worker info is not found (EWorkerInfoNotFound)
+     */
+    getWorkerInfoMoveCall(tx: Transaction, worker: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('get_worker_info'),
+            arguments: [tx.object(this.objects.workerRegistry), asAddress(tx, worker)],
+        })
+    }
+
+    /**
+     * Get worker info for a specific worker address
+     * Executes the get_worker_info function and returns the worker information bytes
+     * @param worker - The worker address to get info for
+     * @returns Promise<Uint8Array> - The worker information bytes containing encoded worker data
+     * @throws Will throw an error if worker info is not found (EWorkerInfoNotFound)
+     */
+    async getWorkerInfo(worker: string): Promise<Uint8Array> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getWorkerInfoMoveCall(tx, worker)
+            },
+            (result) => {
+                return result[0].value
+            }
+        )
+    }
+
+    /**
+     * Check if worker info exists for a specific worker address
+     * This is a convenience method that catches EWorkerInfoNotFound errors
+     * @param worker - The worker address to check
+     * @returns Promise<boolean> - True if worker info exists, false if not found
+     * @throws Will re-throw any errors other than EWorkerInfoNotFound
+     */
+    async hasWorkerInfo(worker: string): Promise<boolean> {
+        try {
+            await this.getWorkerInfo(worker)
+            return true
+        } catch (error) {
+            // If the error is EWorkerInfoNotFound, return false
+            if (error instanceof Error && error.message.includes('EWorkerInfoNotFound')) {
+                return false
+            }
+            // Re-throw other errors
+            throw error
+        }
+    }
+
+    // === Private Functions ===
+
+    /**
+     * Generate the target string for move calls
+     * @param functionName - The function name to call
+     * @returns The fully qualified target string for the move call
+     */
+    #target(functionName: string): string {
+        return `${this.packageId}::${MODULE_NAME}::${functionName}`
+    }
+}

package/src/modules/zro.ts

@@ -0,0 +1,94 @@
+import { IotaClient } from '@iota/iota-sdk/client'
+import { Transaction, TransactionArgument, TransactionResult } from '@iota/iota-sdk/transactions'
+
+import { ModuleManager } from '../module-manager'
+
+export class Zro {
+    public packageId: string
+    public readonly client: IotaClient
+    public zroType: string
+
+    constructor(
+        packageId: string,
+        client: IotaClient,
+        private readonly moduleManager: ModuleManager
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.zroType = `${this.packageId}::zro::ZRO`
+    }
+
+    // === Utils function ===
+
+    /**
+     * Split ZRO tokens and wrap in an Option type for use in LayerZero operations
+     * If value is 0, returns Option::None, otherwise returns Option::Some with the split tokens
+     * @param tx - The transaction to add the move call to
+     * @param userAddress - Address of the user whose ZRO tokens to split
+     * @param value - Amount of ZRO tokens to split (0 for None option)
+     * @param maxCoins - Maximum total number of coins to collect across all pages (default: 200)
+     * @param maxCoinsPerPage - Maximum number of coins to fetch per page (default: 50)
+     * @returns Promise resolving to transaction result containing Option<Coin<ZRO>>
+     * @throws Error if insufficient ZRO balance
+     */
+    async splitOptionZroTokenMoveCall(
+        tx: Transaction,
+        userAddress: string,
+        value: bigint,
+        maxCoins = 200,
+        maxCoinsPerPage = 50
+    ): Promise<TransactionResult> {
+        if (value === 0n) {
+            return this.noneOptionMoveCall(tx)
+        }
+        const zroCoin = await this.splitZroTokenMoveCall(tx, userAddress, value, maxCoins, maxCoinsPerPage)
+        return this.someOptionMoveCall(tx, zroCoin)
+    }
+
+    /**
+     * Splits specified amount of ZRO tokens from user's wallet
+     * This method fetches coins and merges them as needed to get sufficient balance
+     * @param tx - The transaction to add the move call to
+     * @param owner - Address of the user whose ZRO coins to split
+     * @param amount - Amount of ZRO tokens to split (in smallest units, considering 9 decimals)
+     * @param limit - Maximum total number of coins to collect across all pages (default: 200)
+     * @param pageSize - Maximum number of coins to fetch per page (default: 50)
+     * @returns Promise resolving to split ZRO coin as TransactionResult
+     * @throws Error if insufficient ZRO balance or no coins found
+     */
+    async splitZroTokenMoveCall(
+        tx: Transaction,
+        owner: string,
+        amount: bigint,
+        limit = 200,
+        pageSize = 50
+    ): Promise<TransactionResult> {
+        return this.moduleManager.getUtils().splitCoinMoveCall(tx, this.zroType, owner, amount, limit, pageSize)
+    }
+
+    /**
+     * Creates an Option::Some moveCall containing a ZRO coin
+     * @param tx - The transaction to add the move call to
+     * @param zroCoin - ZRO coin to wrap in Option or transaction argument
+     * @returns Transaction result containing Option<Coin<ZRO>> type with Some value
+     */
+    someOptionMoveCall(tx: Transaction, zroCoin: TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: `0x1::option::some`,
+            typeArguments: [`0x2::coin::Coin<${this.zroType}>`],
+            arguments: [zroCoin],
+        })
+    }
+
+    /**
+     * Creates an Option::None moveCall for ZRO coin type
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing Option<Coin<ZRO>> type with None value
+     */
+    noneOptionMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `0x1::option::none`,
+            typeArguments: [`0x2::coin::Coin<${this.zroType}>`],
+        })
+    }
+}

package/src/resource.ts

@@ -0,0 +1,104 @@
+import { Stage } from '@layerzerolabs/lz-definitions'
+
+import * as AddressConstants from './generated/addresses'
+import { ObjectOptions, PackageOptions } from './types'
+
+/**
+ * Address mapping configuration for packages
+ */
+const PACKAGE_ADDRESS_MAP: { [K in keyof PackageOptions]: Partial<{ [S in Stage]: string }> } = {
+    utils: AddressConstants.PACKAGE_UTILS_ADDRESS,
+    endpointV2: AddressConstants.PACKAGE_ENDPOINT_V2_ADDRESS,
+    counterV2: AddressConstants.PACKAGE_COUNTER_V2_ADDRESS,
+    simpleMessageLib: AddressConstants.PACKAGE_SIMPLE_MESSAGE_LIB_ADDRESS,
+    uln302: AddressConstants.PACKAGE_ULN_302_ADDRESS,
+    uln302PtbBuilder: AddressConstants.PACKAGE_ULN_302_PTB_BUILDER_ADDRESS,
+    blockedMessageLib: AddressConstants.PACKAGE_BLOCKED_MESSAGE_LIB_ADDRESS,
+    blockedMessageLibPtbBuilder: AddressConstants.PACKAGE_BLOCKED_MESSAGE_LIB_PTB_BUILDER_ADDRESS,
+    dvnPtbBuilder: AddressConstants.PACKAGE_DVN_PTB_BUILDER_ADDRESS,
+    executorPtbBuilder: AddressConstants.PACKAGE_EXECUTOR_PTB_BUILDER_ADDRESS,
+    executor: AddressConstants.PACKAGE_EXECUTOR_ADDRESS,
+    zro: AddressConstants.PACKAGE_ZRO_ADDRESS,
+    call: AddressConstants.PACKAGE_CALL_ADDRESS,
+    endpointPtbBuilder: AddressConstants.PACKAGE_ENDPOINT_PTB_BUILDER_ADDRESS,
+    simpleMessageLibPtbBuilder: AddressConstants.PACKAGE_SIMPLE_MESSAGE_LIB_PTB_BUILDER_ADDRESS,
+    ptbMoveCall: AddressConstants.PACKAGE_PTB_MOVE_CALL_ADDRESS,
+    dvn: AddressConstants.PACKAGE_DVN_ADDRESS,
+    dvnFeeLib: AddressConstants.PACKAGE_DVN_FEE_LIB_ADDRESS,
+    dvnLayerzero: AddressConstants.PACKAGE_DVN_LAYERZERO_ADDRESS,
+    executorFeeLib: AddressConstants.PACKAGE_EXECUTOR_FEE_LIB_ADDRESS,
+    executorLayerzero: AddressConstants.PACKAGE_EXECUTOR_LAYERZERO_ADDRESS,
+    priceFeed: AddressConstants.PACKAGE_PRICE_FEED_ADDRESS,
+    treasury: AddressConstants.PACKAGE_TREASURY_ADDRESS,
+    oapp: AddressConstants.PACKAGE_OAPP_ADDRESS,
+    layerzeroViews: AddressConstants.PACKAGE_LAYERZERO_VIEWS_ADDRESS,
+    packageWhitelistValidator: AddressConstants.PACKAGE_PACKAGE_WHITELIST_VALIDATOR_ADDRESS,
+    workerRegistry: AddressConstants.PACKAGE_WORKER_REGISTRY_ADDRESS,
+    workerCommon: AddressConstants.PACKAGE_WORKER_COMMON_ADDRESS,
+}
+
+/**
+ * Address mapping configuration for objects
+ */
+const OBJECT_ADDRESS_MAP: { [K in keyof ObjectOptions]: Partial<{ [S in Stage]: string }> } = {
+    endpointV2: AddressConstants.OBJECT_ENDPOINT_V2_ADDRESS,
+    simpleMessageLib: AddressConstants.OBJECT_SIMPLE_MESSAGE_LIB_ADDRESS,
+    simpleMessageLibAdminCap: AddressConstants.OBJECT_SIMPLE_MESSAGE_LIB_ADMIN_CAP_ADDRESS,
+    simpleMessageLibPtbBuilder: AddressConstants.OBJECT_SIMPLE_MESSAGE_LIB_PTB_BUILDER_ADDRESS,
+    uln302: AddressConstants.OBJECT_ULN_302_ADDRESS,
+    uln302AdminCap: AddressConstants.OBJECT_ULN_302_ADMIN_CAP_ADDRESS,
+    uln302PtbBuilder: AddressConstants.OBJECT_ULN_302_PTB_BUILDER_ADDRESS,
+    uln302Verification: AddressConstants.OBJECT_ULN_302_VERIFICATION_ADDRESS,
+    treasury: AddressConstants.OBJECT_TREASURY_ADDRESS,
+    treasuryAdminCap: AddressConstants.OBJECT_TREASURY_ADMIN_CAP_ADDRESS,
+    blockedMessageLib: AddressConstants.OBJECT_BLOCKED_MESSAGE_LIB_ADDRESS,
+    blockedMessageLibPtbBuilder: AddressConstants.OBJECT_BLOCKED_MESSAGE_LIB_PTB_BUILDER_ADDRESS,
+    counter: AddressConstants.OBJECT_COUNTER_ADDRESS,
+    counterOapp: AddressConstants.OBJECT_COUNTER_OAPP_ADDRESS,
+    counterAdminCap: AddressConstants.OBJECT_COUNTER_ADMIN_CAP_ADDRESS,
+    endpointAdminCap: AddressConstants.OBJECT_ENDPOINT_ADMIN_CAP_ADDRESS,
+    endpointPtbBuilder: AddressConstants.OBJECT_ENDPOINT_PTB_BUILDER_ADDRESS,
+    endpointPtbBuilderAdminCap: AddressConstants.OBJECT_ENDPOINT_PTB_BUILDER_ADMIN_CAP_ADDRESS,
+    dvn: AddressConstants.OBJECT_DVN_ADDRESS,
+    dvnCap: AddressConstants.OBJECT_DVN_CAP_ADDRESS,
+    dvnFeeLib: AddressConstants.OBJECT_DVN_FEE_LIB_ADDRESS,
+    executor: AddressConstants.OBJECT_EXECUTOR_ADDRESS,
+    executorCap: AddressConstants.OBJECT_EXECUTOR_CAP_ADDRESS,
+    executorOwnerCap: AddressConstants.OBJECT_EXECUTOR_OWNER_CAP_ADDRESS,
+    executorFeeLib: AddressConstants.OBJECT_EXECUTOR_FEE_LIB_ADDRESS,
+    priceFeed: AddressConstants.OBJECT_PRICE_FEED_ADDRESS,
+    priceFeedOwnerCap: AddressConstants.OBJECT_PRICE_FEED_OWNER_CAP_ADDRESS,
+    packageWhitelistValidator: AddressConstants.OBJECT_PACKAGE_WHITELIST_VALIDATOR_ADDRESS,
+    workerRegistry: AddressConstants.OBJECT_WORKER_REGISTRY_ADDRESS,
+}
+
+/**
+ * Simple Resource Manager for address resolution
+ */
+export class ResourceManager {
+    /**
+     * Build package configuration with address mappings for a given stage
+     */
+    static mergeDefaultPackageConfig(stage: Stage, customPackages?: Partial<PackageOptions>): PackageOptions {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const config = {} as PackageOptions
+        for (const [key, stageMap] of Object.entries(PACKAGE_ADDRESS_MAP)) {
+            const typedKey = key as keyof PackageOptions
+            config[typedKey] = stageMap[stage] ?? ''
+        }
+        return { ...config, ...customPackages }
+    }
+
+    /**
+     * Build object configuration with address mappings for a given stage
+     */
+    static mergeDefaultObjectConfig(stage: Stage, customObjects?: Partial<ObjectOptions>): ObjectOptions {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const config = {} as ObjectOptions
+        for (const [key, stageMap] of Object.entries(OBJECT_ADDRESS_MAP)) {
+            const typedKey = key as keyof ObjectOptions
+            config[typedKey] = stageMap[stage] ?? ''
+        }
+        return { ...config, ...customObjects }
+    }
+}