@layerzerolabs/lz-sui-sdk-v2 3.0.128 → 3.0.129-sui.0

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

@@ -29,6 +29,20 @@ export class ExecutorFeeLib {
         this.objects = objects
     }
 
+    // === Witness Functions ===
+
+    /**
+     * Create a LayerZero witness for Executor Fee Lib package whitelist registration
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the LayerZero witness
+     */
+    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::executor_fee_lib_witness::new`,
+            arguments: [],
+        })
+    }
+
     // === Set Functions ===
 
     /**

package/src/modules/workers/executor.ts

@@ -43,6 +43,20 @@ export class Executor {
         this.objects = objects
     }
 
+    // === Witness Functions ===
+
+    /**
+     * Create a LayerZero witness for Executor package whitelist registration
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the LayerZero witness
+     */
+    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::executor_witness::new`,
+            arguments: [],
+        })
+    }
+
     // Job Assignment and Fee Functions
 
     /**
@@ -104,8 +118,9 @@ export class Executor {
     // Execution Functions
 
     /**
-     * Execute LayerZero receive operation
+     * Execute LayerZero receive operation (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param messagingChannel - The messaging channel object ID
      * @param srcEid - Source endpoint ID
      * @param sender - Sender address as bytes
@@ -118,6 +133,7 @@ export class Executor {
      */
     executeLzReceiveMoveCall(
         tx: Transaction,
+        adminCap: string | TransactionArgument,
         messagingChannel: string | TransactionArgument,
         srcEid: number | TransactionArgument,
         sender: Uint8Array | TransactionArgument,
@@ -131,6 +147,7 @@ export class Executor {
             target: this.#target('execute_lz_receive'),
             arguments: [
                 tx.object(this.objects.executor),
+                asObject(tx, adminCap),
                 tx.object(this.objects.endpointV2),
                 asObject(tx, messagingChannel),
                 asU32(tx, srcEid),
@@ -145,8 +162,9 @@ export class Executor {
     }
 
     /**
-     * Execute LayerZero compose operation
+     * Execute LayerZero compose operation (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param composeQueue - The compose queue object ID
      * @param from - Source address
      * @param guid - Globally unique identifier as bytes
@@ -158,6 +176,7 @@ export class Executor {
      */
     executeLzComposeMoveCall(
         tx: Transaction,
+        adminCap: string | TransactionArgument,
         composeQueue: string | TransactionArgument,
         from: string | TransactionArgument,
         guid: Uint8Array | TransactionArgument,
@@ -170,6 +189,7 @@ export class Executor {
             target: this.#target('execute_lz_compose'),
             arguments: [
                 tx.object(this.objects.executor),
+                asObject(tx, adminCap),
                 tx.object(this.objects.endpointV2),
                 asObject(tx, composeQueue),
                 asAddress(tx, from),
@@ -182,12 +202,108 @@ export class Executor {
         })
     }
 
+    // Alert Functions
+
+    /**
+     * Record a failed lz_receive execution for off-chain processing (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
+     * @param srcEid - Source endpoint ID
+     * @param sender - Sender address as bytes
+     * @param nonce - Message nonce
+     * @param receiver - Receiver address
+     * @param guid - Globally unique identifier as bytes
+     * @param gas - Gas limit used for the execution attempt
+     * @param value - Native token value included with the message
+     * @param message - Message payload as bytes
+     * @param extraData - Additional execution data
+     * @param reason - Error message or failure reason
+     */
+    lzReceiveAlertMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        srcEid: number | TransactionArgument,
+        sender: Uint8Array | TransactionArgument,
+        nonce: bigint | number | string | TransactionArgument,
+        receiver: string | TransactionArgument,
+        guid: Uint8Array | TransactionArgument,
+        gas: bigint | number | string | TransactionArgument,
+        value: bigint | number | string | TransactionArgument,
+        message: Uint8Array | TransactionArgument,
+        extraData: Uint8Array | TransactionArgument,
+        reason: string | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('lz_receive_alert'),
+            arguments: [
+                tx.object(this.objects.executor),
+                asObject(tx, adminCap),
+                asU32(tx, srcEid),
+                asBytes32(tx, sender, this.moduleManager.getUtils()),
+                asU64(tx, nonce),
+                asAddress(tx, receiver),
+                asBytes32(tx, guid, this.moduleManager.getUtils()),
+                asU64(tx, gas),
+                asU64(tx, value),
+                asBytes(tx, message),
+                asBytes(tx, extraData),
+                asArgWithTx(tx, reason, (tx, val) => tx.pure.string(val)),
+            ],
+        })
+    }
+
+    /**
+     * Record a failed lz_compose execution for off-chain processing (admin only)
+     * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
+     * @param from - Source address
+     * @param to - Destination address
+     * @param guid - Globally unique identifier as bytes
+     * @param index - Compose message index
+     * @param gas - Gas limit used for the execution attempt
+     * @param value - Native token value included with the compose
+     * @param message - Compose message payload as bytes
+     * @param extraData - Additional execution data
+     * @param reason - Error message or failure reason
+     */
+    lzComposeAlertMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        from: string | TransactionArgument,
+        to: string | TransactionArgument,
+        guid: Uint8Array | TransactionArgument,
+        index: number | TransactionArgument,
+        gas: bigint | number | string | TransactionArgument,
+        value: bigint | number | string | TransactionArgument,
+        message: Uint8Array | TransactionArgument,
+        extraData: Uint8Array | TransactionArgument,
+        reason: string | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('lz_compose_alert'),
+            arguments: [
+                tx.object(this.objects.executor),
+                asObject(tx, adminCap),
+                asAddress(tx, from),
+                asAddress(tx, to),
+                asBytes32(tx, guid, this.moduleManager.getUtils()),
+                asU16(tx, index),
+                asU64(tx, gas),
+                asU64(tx, value),
+                asBytes(tx, message),
+                asBytes(tx, extraData),
+                asArgWithTx(tx, reason, (tx, val) => tx.pure.string(val)),
+            ],
+        })
+    }
+
     // Native Drop Functions
 
     /**
      * Native drop function (admin only)
      * Takes a Coin<SUI> from caller and distributes it to recipients according to params
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param srcEid - Source endpoint ID
      * @param sender - Sender address as bytes
      * @param dstEid - Destination endpoint ID
@@ -198,6 +314,7 @@ export class Executor {
      */
     nativeDropMoveCall(
         tx: Transaction,
+        adminCap: string | TransactionArgument,
         srcEid: number | TransactionArgument,
         sender: Uint8Array | TransactionArgument,
         dstEid: number | TransactionArgument,
@@ -218,6 +335,7 @@ export class Executor {
             target: this.#target('native_drop'),
             arguments: [
                 tx.object(this.objects.executor),
+                asObject(tx, adminCap),
                 asU32(tx, srcEid),
                 asBytes32(tx, sender, this.moduleManager.getUtils()),
                 asU32(tx, dstEid),
@@ -237,34 +355,50 @@ export class Executor {
     /**
      * Set default multiplier basis points for fee calculation (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param multiplierBps - The multiplier in basis points
      */
-    setDefaultMultiplierBpsMoveCall(tx: Transaction, multiplierBps: number | TransactionArgument): void {
+    setDefaultMultiplierBpsMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        multiplierBps: number | TransactionArgument
+    ): void {
         tx.moveCall({
             target: this.#target('set_default_multiplier_bps'),
-            arguments: [tx.object(this.objects.executor), asU16(tx, multiplierBps)],
+            arguments: [tx.object(this.objects.executor), asObject(tx, adminCap), asU16(tx, multiplierBps)],
         })
     }
 
     /**
      * Set deposit address for executor fees (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param depositAddress - The new deposit address
      */
-    setDepositAddressMoveCall(tx: Transaction, depositAddress: string | TransactionArgument): void {
+    setDepositAddressMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        depositAddress: string | TransactionArgument
+    ): void {
         tx.moveCall({
             target: this.#target('set_deposit_address'),
-            arguments: [tx.object(this.objects.executor), asAddress(tx, depositAddress)],
+            arguments: [tx.object(this.objects.executor), asObject(tx, adminCap), asAddress(tx, depositAddress)],
         })
     }
 
     /**
      * Set destination configuration for executor (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param dstEid - Destination endpoint ID
      * @param config - Destination configuration parameters
      */
-    setDstConfigMoveCall(tx: Transaction, dstEid: number | TransactionArgument, config: DstConfig): void {
+    setDstConfigMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        dstEid: number | TransactionArgument,
+        config: DstConfig
+    ): void {
         const configCall = tx.moveCall({
             target: this.#target('create_dst_config', 'executor_type'),
             arguments: [
@@ -277,25 +411,31 @@ export class Executor {
         })
         tx.moveCall({
             target: this.#target('set_dst_config'),
-            arguments: [tx.object(this.objects.executor), asU32(tx, dstEid), configCall],
+            arguments: [tx.object(this.objects.executor), asObject(tx, adminCap), asU32(tx, dstEid), configCall],
         })
     }
 
     /**
      * Set price feed for executor (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param priceFeed - The price feed address
      */
-    setPriceFeedMoveCall(tx: Transaction, priceFeed: string | TransactionArgument): void {
+    setPriceFeedMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        priceFeed: string | TransactionArgument
+    ): void {
         tx.moveCall({
             target: this.#target('set_price_feed'),
-            arguments: [tx.object(this.objects.executor), asAddress(tx, priceFeed)],
+            arguments: [tx.object(this.objects.executor), asObject(tx, adminCap), asAddress(tx, priceFeed)],
         })
     }
 
     /**
      * Set PTB builder move calls for executor worker operations (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param targetPtbBuilder - Target PTB builder address
      * @param getFeeMoveCalls - Get fee move calls transaction argument
      * @param assignJobMoveCalls - Assign job move calls transaction argument
@@ -311,6 +451,7 @@ export class Executor {
             target: this.#target('set_ptb_builder_move_calls'),
             arguments: [
                 tx.object(this.objects.executor),
+                asObject(tx, this.objects.executorOwnerCap),
                 asAddress(tx, targetPtbBuilder),
                 getFeeMoveCalls, // First element of Executor PTB result tuple
                 assignJobMoveCalls, // Second element of Executor PTB result tuple
@@ -321,11 +462,13 @@ export class Executor {
     /**
      * Set supported option types for a destination EID (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param dstEid - Destination endpoint ID
      * @param optionTypes - Array of supported option type values
      */
     setSupportedOptionTypesMoveCall(
         tx: Transaction,
+        adminCap: string | TransactionArgument,
         dstEid: number | TransactionArgument,
         optionTypes: number[]
     ): void {
@@ -333,6 +476,7 @@ export class Executor {
             target: this.#target('set_supported_option_types'),
             arguments: [
                 tx.object(this.objects.executor),
+                asObject(tx, adminCap),
                 asU32(tx, dstEid),
                 tx.pure(bcs.vector(bcs.u8()).serialize(optionTypes)),
             ],
@@ -342,12 +486,17 @@ export class Executor {
     /**
      * Set worker fee library for executor (admin only)
      * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
      * @param workerFeeLib - The worker fee library address
      */
-    setWorkerFeeLibMoveCall(tx: Transaction, workerFeeLib: string | TransactionArgument): void {
+    setWorkerFeeLibMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        workerFeeLib: string | TransactionArgument
+    ): void {
         tx.moveCall({
             target: this.#target('set_worker_fee_lib'),
-            arguments: [tx.object(this.objects.executor), asAddress(tx, workerFeeLib)],
+            arguments: [tx.object(this.objects.executor), asObject(tx, adminCap), asAddress(tx, workerFeeLib)],
         })
     }
 
@@ -606,28 +755,56 @@ export class Executor {
     }
 
     /**
-     * Check if an address is admin (sync Move call)
+     * Check if an admin cap is valid (sync Move call)
      * @param tx - The transaction to add the move call to
-     * @param account - The account address to check
+     * @param adminCap - The admin capability object ID to check
      * @returns TransactionResult - Result containing admin status
      */
-    isAdminMoveCall(tx: Transaction, account: string | TransactionArgument): TransactionResult {
+    isAdminMoveCall(tx: Transaction, adminCap: string | TransactionArgument): TransactionResult {
         return tx.moveCall({
             target: this.#target('is_admin'),
-            arguments: [tx.object(this.objects.executor), asAddress(tx, account)],
+            arguments: [tx.object(this.objects.executor), asObject(tx, adminCap)],
         })
     }
 
     /**
-     * Check if an address is admin (async simulation)
-     * @param account - The account address to check
-     * @returns Promise<boolean> - True if the address is admin
+     * Check if an admin cap is valid (async simulation)
+     * @param adminCap - The admin capability object ID to check
+     * @returns Promise<boolean> - True if the admin cap is valid
      */
-    async isAdmin(account: string): Promise<boolean> {
+    async isAdmin(adminCap: string): Promise<boolean> {
         return executeSimulate(
             this.client,
             (tx) => {
-                this.isAdminMoveCall(tx, account)
+                this.isAdminMoveCall(tx, adminCap)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Check if an address is an admin
+     * @param tx - The transaction to add the move call to
+     * @param admin - The admin address to check
+     * @returns Transaction result containing the admin status
+     */
+    isAdminAddressMoveCall(tx: Transaction, admin: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_admin_address'),
+            arguments: [tx.object(this.objects.executor), asAddress(tx, admin)],
+        })
+    }
+
+    /**
+     * Check if an address is an admin
+     * @param admin - The admin address to check
+     * @returns Promise<boolean> - True if the address is an admin
+     */
+    async isAdminAddress(admin: string): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isAdminAddressMoveCall(tx, admin)
             },
             (result) => bcs.Bool.parse(result[0].value)
         )
@@ -824,6 +1001,34 @@ export class Executor {
         )
     }
 
+    /**
+     * Get admin capability ID from admin address
+     * @param tx - The transaction to add the move call to
+     * @param admin - The admin address
+     * @returns Transaction result containing the admin capability ID
+     */
+    adminCapIdMoveCall(tx: Transaction, admin: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('admin_cap_id'),
+            arguments: [tx.object(this.objects.executor), asAddress(tx, admin)],
+        })
+    }
+
+    /**
+     * Get admin capability ID from admin address
+     * @param admin - The admin address
+     * @returns Promise<string> - The admin capability ID
+     */
+    async adminCapId(admin: string): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.adminCapIdMoveCall(tx, admin)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
     // === Private Helper Functions ===
 
     private parseDstConfig(data: Uint8Array): DstConfig {

package/src/modules/workers/price-feed.ts

@@ -5,15 +5,17 @@ import { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui
 import { ArbitrumPriceExtBcs, ModelTypeBcs, PriceBcs } from '../../bcs'
 import { ModuleManager } from '../../module-manager'
 import { ArbitrumPriceExt, ModelType, ObjectOptions, Price } from '../../types'
-import { asAddress, asBool, asU128, asU32, asU64, executeSimulate } from '../../utils'
+import { asAddress, asBool, asObject, asU128, asU32, asU64, executeSimulate } from '../../utils'
 
 const MODULE_NAME = 'price_feed'
 
 export const PriceFeedErrorCode = {
     // PriceFeed related errors
-    PRICE_FEED_EOnlyPriceUpdater: 1,
-    PRICE_FEED_ENotAnOPStack: 2,
-    PRICE_FEED_ENoPrice: 3,
+    PRICE_FEED_EInvalidDenominator: 1,
+    PRICE_FEED_ENoPrice: 2,
+    PRICE_FEED_ENotAnOPStack: 3,
+    PRICE_FEED_EOnlyPriceUpdater: 4,
+    PRICE_FEED_EPriceUpdaterCapNotFound: 5,
 } as const
 
 export class PriceFeed {
@@ -104,6 +106,7 @@ export class PriceFeed {
 
     /**
      * Set price updater role for an address (admin only)
+     * Note: This function will automatically create a price updater capability for new updaters
      * @param tx - The transaction to add the move call to
      * @param updater - The updater address or transaction argument
      * @param active - Whether to activate or deactivate the updater role or transaction argument
@@ -126,8 +129,9 @@ export class PriceFeed {
 
     /**
      * Set price ratio denominator for price calculations (admin only)
+     * Note: denominator must be greater than 0, otherwise the transaction will fail
      * @param tx - The transaction to add the move call to
-     * @param denominator - The price ratio denominator value or transaction argument
+     * @param denominator - The price ratio denominator value or transaction argument (must be > 0)
      */
     setPriceRatioDenominatorMoveCall(
         tx: Transaction,
@@ -183,29 +187,37 @@ export class PriceFeed {
     }
 
     /**
-     * Set price for a destination EID (price updater only)
+     * Set price for a destination EID (price updater capability required)
      * @param tx - The transaction to add the move call to
+     * @param updaterCap - The price updater capability object or transaction argument
      * @param dstEid - Destination endpoint ID or transaction argument
      * @param price - The price configuration to set
      */
-    setPriceMoveCall(tx: Transaction, dstEid: number | TransactionArgument, price: Price): void {
+    setPriceMoveCall(
+        tx: Transaction,
+        updaterCap: string | TransactionArgument,
+        dstEid: number | TransactionArgument,
+        price: Price
+    ): void {
         const priceCall = this.createPriceMoveCall(tx, price.priceRatio, price.gasPriceInUnit, price.gasPerByte)
 
         tx.moveCall({
             target: this.#target('set_price'),
-            arguments: [tx.object(this.objects.priceFeed), asU32(tx, dstEid), priceCall],
+            arguments: [tx.object(this.objects.priceFeed), asObject(tx, updaterCap), asU32(tx, dstEid), priceCall],
         })
     }
 
     /**
-     * Set price for Arbitrum with additional extension parameters (price updater only)
+     * Set price for Arbitrum with additional extension parameters (price updater capability required)
      * @param tx - The transaction to add the move call to
+     * @param updaterCap - The price updater capability object or transaction argument
      * @param dstEid - Destination endpoint ID
      * @param price - The base price configuration
      * @param arbitrumPriceExt - Additional Arbitrum-specific price parameters
      */
     setPriceForArbitrumMoveCall(
         tx: Transaction,
+        updaterCap: string | TransactionArgument,
         dstEid: number | TransactionArgument,
         price: Price,
         arbitrumPriceExt: ArbitrumPriceExt
@@ -219,22 +231,44 @@ export class PriceFeed {
 
         tx.moveCall({
             target: this.#target('set_price_for_arbitrum'),
-            arguments: [tx.object(this.objects.priceFeed), asU32(tx, dstEid), priceCall, arbitrumPriceExtCall],
+            arguments: [
+                tx.object(this.objects.priceFeed),
+                asObject(tx, updaterCap),
+                asU32(tx, dstEid),
+                priceCall,
+                arbitrumPriceExtCall,
+            ],
         })
     }
 
     /**
-     * Set native token price in USD (price updater only)
+     * Set native token price in USD (price updater capability required)
      * @param tx - The transaction to add the move call to
+     * @param updaterCap - The price updater capability object or transaction argument
      * @param nativeTokenPriceUsd - The native token price in USD
      */
     setNativeTokenPriceUsdMoveCall(
         tx: Transaction,
+        updaterCap: string | TransactionArgument,
         nativeTokenPriceUsd: bigint | number | string | TransactionArgument
     ): void {
         tx.moveCall({
             target: this.#target('set_native_token_price_usd'),
-            arguments: [tx.object(this.objects.priceFeed), asU128(tx, nativeTokenPriceUsd)],
+            arguments: [tx.object(this.objects.priceFeed), asObject(tx, updaterCap), asU128(tx, nativeTokenPriceUsd)],
+        })
+    }
+
+    // === Witness Functions ===
+
+    /**
+     * Create a LayerZero witness for PriceFeed package whitelist registration
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the LayerZero witness
+     */
+    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: `${this.packageId}::price_feed_witness::new`,
+            arguments: [],
         })
     }
 
@@ -266,6 +300,19 @@ export class PriceFeed {
         })
     }
 
+    /**
+     * Get price updater capability address for a specific updater
+     * @param tx - The transaction to add the move call to
+     * @param updater - The updater address to get capability for
+     * @returns Transaction result containing the price updater capability address
+     */
+    getPriceUpdaterCapMoveCall(tx: Transaction, updater: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('get_price_updater_cap'),
+            arguments: [tx.object(this.objects.priceFeed), asAddress(tx, updater)],
+        })
+    }
+
     /**
      * Get the owner capability address of this PriceFeed
      * @returns Promise<string> - The owner capability address
@@ -280,6 +327,21 @@ export class PriceFeed {
         )
     }
 
+    /**
+     * Get price updater capability address for a specific updater
+     * @param updater - The updater address to get capability for
+     * @returns Promise<string> - The price updater capability address
+     */
+    async priceUpdaterCap(updater: string): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getPriceUpdaterCapMoveCall(tx, updater)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
     /**
      * Check if an address is a price updater
      * @param tx - The transaction to add the move call to

package/src/resource.ts

@@ -30,6 +30,7 @@ const PACKAGE_ADDRESS_MAP: { [K in keyof PackageOptions]: Partial<{ [S in Stage]
     treasury: AddressConstants.PACKAGE_TREASURY_ADDRESS,
     oapp: AddressConstants.PACKAGE_OAPP_ADDRESS,
     layerzeroViews: AddressConstants.PACKAGE_LAYERZERO_VIEWS_ADDRESS,
+    packageWhitelistValidator: AddressConstants.PACKAGE_PACKAGE_WHITELIST_VALIDATOR_ADDRESS,
 }
 
 /**
@@ -62,6 +63,7 @@ const OBJECT_ADDRESS_MAP: { [K in keyof ObjectOptions]: Partial<{ [S in Stage]:
     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,
 }
 
 /**