@hyperlane-xyz/core 3.9.0 → 3.10.1-beta0

package/contracts/client/MailboxClient.sol

@@ -92,6 +92,10 @@ abstract contract MailboxClient is OwnableUpgradeable {
         return mailbox.latestDispatchedId() == id;
     }
 
+    function _isDelivered(bytes32 id) internal view returns (bool) {
+        return mailbox.delivered(id);
+    }
+
     function _metadata(
         uint32 /*_destinationDomain*/
     ) internal view virtual returns (bytes memory) {
@@ -123,6 +127,24 @@ abstract contract MailboxClient is OwnableUpgradeable {
             );
     }
 
+    function _dispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipient,
+        uint256 _value,
+        bytes memory _messageBody,
+        bytes memory _hookMetadata,
+        IPostDispatchHook _hook
+    ) internal virtual returns (bytes32) {
+        return
+            mailbox.dispatch{value: _value}(
+                _destinationDomain,
+                _recipient,
+                _messageBody,
+                _hookMetadata,
+                _hook
+            );
+    }
+
     function _quoteDispatch(
         uint32 _destinationDomain,
         bytes32 _recipient,
@@ -137,4 +159,21 @@ abstract contract MailboxClient is OwnableUpgradeable {
                 hook
             );
     }
+
+    function _quoteDispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipient,
+        bytes memory _messageBody,
+        bytes calldata _hookMetadata,
+        IPostDispatchHook _hook
+    ) internal view virtual returns (uint256) {
+        return
+            mailbox.quoteDispatch(
+                _destinationDomain,
+                _recipient,
+                _messageBody,
+                _hookMetadata,
+                _hook
+            );
+    }
 }

package/contracts/hooks/warp-route/RateLimitedHook.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+import {MailboxClient} from "contracts/client/MailboxClient.sol";
+import {IPostDispatchHook} from "contracts/interfaces/hooks/IPostDispatchHook.sol";
+import {Message} from "contracts/libs/Message.sol";
+import {TokenMessage} from "contracts/token/libs/TokenMessage.sol";
+import {RateLimited} from "contracts/libs/RateLimited.sol";
+
+contract RateLimitedHook is IPostDispatchHook, MailboxClient, RateLimited {
+    using Message for bytes;
+    using TokenMessage for bytes;
+
+    mapping(bytes32 messageId => bool validated) public messageValidated;
+
+    modifier validateMessageOnce(bytes calldata _message) {
+        bytes32 messageId = _message.id();
+        require(!messageValidated[messageId], "MessageAlreadyValidated");
+        _;
+        messageValidated[messageId] = true;
+    }
+
+    constructor(
+        address _mailbox,
+        uint256 _maxCapacity
+    ) MailboxClient(_mailbox) RateLimited(_maxCapacity) {}
+
+    /// @inheritdoc IPostDispatchHook
+    function hookType() external pure returns (uint8) {
+        return uint8(IPostDispatchHook.Types.Rate_Limited_Hook);
+    }
+
+    /// @inheritdoc IPostDispatchHook
+    function supportsMetadata(bytes calldata) external pure returns (bool) {
+        return false;
+    }
+
+    /**
+     * Verify a message, rate limit, and increment the sender's limit.
+     * @dev ensures that this gets called by the Mailbox
+     */
+    function postDispatch(
+        bytes calldata,
+        bytes calldata _message
+    ) external payable validateMessageOnce(_message) {
+        require(_isLatestDispatched(_message.id()), "InvalidDispatchedMessage");
+
+        uint256 newAmount = _message.body().amount();
+        validateAndConsumeFilledLevel(newAmount);
+    }
+
+    /// @inheritdoc IPostDispatchHook
+    function quoteDispatch(
+        bytes calldata,
+        bytes calldata
+    ) external pure returns (uint256) {
+        return 0;
+    }
+}

package/contracts/interfaces/hooks/IPostDispatchHook.sol

@@ -24,7 +24,8 @@ interface IPostDispatchHook {
         ID_AUTH_ISM,
         PAUSABLE,
         PROTOCOL_FEE,
-        LAYER_ZERO_V1
+        LAYER_ZERO_V1,
+        Rate_Limited_Hook
     }
 
     /**

package/contracts/isms/TrustedRelayerIsm.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
+import {Message} from "../libs/Message.sol";
+import {Mailbox} from "../Mailbox.sol";
+
+contract TrustedRelayerIsm is IInterchainSecurityModule {
+    using Message for bytes;
+
+    uint8 public immutable moduleType = uint8(Types.NULL);
+    Mailbox public immutable mailbox;
+    address public immutable trustedRelayer;
+
+    constructor(address _mailbox, address _trustedRelayer) {
+        mailbox = Mailbox(_mailbox);
+        trustedRelayer = _trustedRelayer;
+    }
+
+    function verify(
+        bytes calldata,
+        bytes calldata message
+    ) external view returns (bool) {
+        return mailbox.processor(message.id()) == trustedRelayer;
+    }
+}

package/contracts/isms/warp-route/RateLimitedIsm.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMailbox} from "contracts/interfaces/IMailbox.sol";
+import {MailboxClient} from "contracts/client/MailboxClient.sol";
+import {RateLimited} from "contracts/libs/RateLimited.sol";
+import {IInterchainSecurityModule} from "contracts/interfaces/IInterchainSecurityModule.sol";
+import {Message} from "contracts/libs/Message.sol";
+import {TokenMessage} from "contracts/token/libs/TokenMessage.sol";
+
+contract RateLimitedIsm is
+    MailboxClient,
+    RateLimited,
+    IInterchainSecurityModule
+{
+    using Message for bytes;
+    using TokenMessage for bytes;
+
+    mapping(bytes32 messageId => bool validated) public messageValidated;
+
+    modifier validateMessageOnce(bytes calldata _message) {
+        bytes32 messageId = _message.id();
+        require(!messageValidated[messageId], "MessageAlreadyValidated");
+        messageValidated[messageId] = true;
+        _;
+    }
+
+    constructor(
+        address _mailbox,
+        uint256 _maxCapacity
+    ) MailboxClient(_mailbox) RateLimited(_maxCapacity) {}
+
+    /// @inheritdoc IInterchainSecurityModule
+    function moduleType() external pure returns (uint8) {
+        return uint8(IInterchainSecurityModule.Types.UNUSED);
+    }
+
+    /**
+     * Verify a message, rate limit, and increment the sender's limit.
+     * @dev ensures that this gets called by the Mailbox
+     */
+    function verify(
+        bytes calldata,
+        bytes calldata _message
+    ) external validateMessageOnce(_message) returns (bool) {
+        require(_isDelivered(_message.id()), "InvalidDeliveredMessage");
+
+        uint256 newAmount = _message.body().amount();
+        validateAndConsumeFilledLevel(newAmount);
+
+        return true;
+    }
+}

package/contracts/libs/RateLimited.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+/**
+ * @title RateLimited
+ * @notice A contract used to keep track of an address sender's token amount limits.
+ * @dev Implements a modified token bucket algorithm where the bucket is full in the beginning and gradually refills
+ * See: https://dev.to/satrobit/rate-limiting-using-the-token-bucket-algorithm-3cjh
+ **/
+contract RateLimited is OwnableUpgradeable {
+    uint256 public constant DURATION = 1 days; // 86400
+    uint256 public filledLevel; /// @notice Current filled level
+    uint256 public refillRate; /// @notice Tokens per second refill rate
+    uint256 public lastUpdated; /// @notice Timestamp of the last time an action has been taken TODO prob can be uint40
+
+    event RateLimitSet(uint256 _oldCapacity, uint256 _newCapacity);
+
+    constructor(uint256 _capacity) {
+        _transferOwnership(msg.sender);
+        setRefillRate(_capacity);
+        filledLevel = _capacity;
+    }
+
+    error RateLimitExceeded(uint256 newLimit, uint256 targetLimit);
+
+    /**
+     * @return The max capacity where the bucket will no longer refill
+     */
+    function maxCapacity() public view returns (uint256) {
+        return refillRate * DURATION;
+    }
+
+    /**
+     * Calculates the refilled amount based on time and refill rate
+     *
+     * Consider an example where there is a 1e18 max token limit per day (86400s)
+     * If half of the tokens has been used, and half a day (43200s) has passed,
+     * then there should be a refill of 0.5e18
+     *
+     * To calculate:
+     *   Refilled = Elapsed * RefilledRate
+     *   Elapsed = timestamp - Limit.lastUpdated
+     *   RefilledRate = Capacity / DURATION
+     *
+     *   If half of the day (43200) has passed, then
+     *   (86400 - 43200) * (1e18 / 86400)  = 0.5e18
+     */
+    function calculateRefilledAmount() internal view returns (uint256) {
+        uint256 elapsed = block.timestamp - lastUpdated;
+        return elapsed * refillRate;
+    }
+
+    /**
+     * Calculates the adjusted fill level based on time
+     */
+    function calculateCurrentLevel() public view returns (uint256) {
+        uint256 _capacity = maxCapacity();
+        require(_capacity > 0, "RateLimitNotSet");
+
+        if (block.timestamp > lastUpdated + DURATION) {
+            // If last update is in the previous window, return the max capacity
+            return _capacity;
+        } else {
+            // If within the window, refill the capacity
+            uint256 replenishedLevel = filledLevel + calculateRefilledAmount();
+
+            // Only return _capacity, in the case where newCurrentCapcacity overflows
+            return replenishedLevel > _capacity ? _capacity : replenishedLevel;
+        }
+    }
+
+    /**
+     * Sets the refill rate by giving a capacity
+     * @param _capacity new maximum capacity to set
+     */
+    function setRefillRate(
+        uint256 _capacity
+    ) public onlyOwner returns (uint256) {
+        uint256 _oldRefillRate = refillRate;
+        uint256 _newRefillRate = _capacity / DURATION;
+        refillRate = _newRefillRate;
+
+        emit RateLimitSet(_oldRefillRate, _newRefillRate);
+
+        return _newRefillRate;
+    }
+
+    /**
+     * Validate an amount and decreases the currentCapacity
+     * @param _newAmount The amount to consume the fill level
+     * @return The new filled level
+     */
+    function validateAndConsumeFilledLevel(
+        uint256 _newAmount
+    ) public returns (uint256) {
+        uint256 adjustedFilledLevel = calculateCurrentLevel();
+        require(_newAmount <= adjustedFilledLevel, "RateLimitExceeded");
+
+        // Reduce the filledLevel and update lastUpdated
+        uint256 _filledLevel = adjustedFilledLevel - _newAmount;
+        filledLevel = _filledLevel;
+        lastUpdated = block.timestamp;
+
+        return _filledLevel;
+    }
+}

package/contracts/middleware/InterchainAccountRouter.sol

@@ -656,4 +656,36 @@ contract InterchainAccountRouter is Router {
     ) private view returns (address payable) {
         return payable(Create2.computeAddress(_salt, bytecodeHash));
     }
+
+    /**
+     * @notice Returns the gas payment required to dispatch a message to the given domain's router.
+     * @param _destination The domain of the destination router.
+     * @return _gasPayment Payment computed by the registered hooks via MailboxClient.
+     */
+    function quoteGasPayment(
+        uint32 _destination
+    ) external view returns (uint256 _gasPayment) {
+        return _quoteDispatch(_destination, "");
+    }
+
+    /**
+     * @notice Returns the gas payment required to dispatch a given messageBody to the given domain's router with gas limit override.
+     * @param _destination The domain of the destination router.
+     * @param _messageBody The message body to be dispatched.
+     * @param gasLimit The gas limit to override with.
+     */
+    function quoteGasPayment(
+        uint32 _destination,
+        bytes calldata _messageBody,
+        uint256 gasLimit
+    ) external view returns (uint256 _gasPayment) {
+        bytes32 _router = _mustHaveRemoteRouter(_destination);
+        return
+            mailbox.quoteDispatch(
+                _destination,
+                _router,
+                _messageBody,
+                StandardHookMetadata.overrideGasLimit(gasLimit)
+            );
+    }
 }

package/contracts/test/TestPostDispatchHook.sol

@@ -1,15 +1,21 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
+import {Message} from "../libs/Message.sol";
 
 import {IPostDispatchHook} from "../interfaces/hooks/IPostDispatchHook.sol";
 import {AbstractPostDispatchHook} from "../hooks/libs/AbstractPostDispatchHook.sol";
 
 contract TestPostDispatchHook is AbstractPostDispatchHook {
+    using Message for bytes;
+
     // ============ Public Storage ============
 
     // test fees for quoteDispatch
     uint256 public fee = 0;
 
+    // used to keep track of dispatched message
+    mapping(bytes32 messageId => bool dispatched) public messageDispatched;
+
     // ============ External Functions ============
 
     /// @inheritdoc IPostDispatchHook
@@ -29,16 +35,14 @@ contract TestPostDispatchHook is AbstractPostDispatchHook {
 
     // ============ Internal functions ============
     function _postDispatch(
-        bytes calldata,
-        /*metadata*/
-        bytes calldata /*message*/
-    ) internal pure override {
-        // test - empty
+        bytes calldata /*metadata*/,
+        bytes calldata message
+    ) internal override {
+        messageDispatched[message.id()] = true;
     }
 
     function _quoteDispatch(
-        bytes calldata,
-        /*metadata*/
+        bytes calldata /*metadata*/,
         bytes calldata /*message*/
     ) internal view override returns (uint256) {
         return fee;

package/contracts/token/HypERC20.sol

@@ -26,11 +26,15 @@ contract HypERC20 is ERC20Upgradeable, TokenRouter {
     function initialize(
         uint256 _totalSupply,
         string memory _name,
-        string memory _symbol
+        string memory _symbol,
+        address _hook,
+        address _interchainSecurityModule,
+        address _owner
     ) external initializer {
         // Initialize ERC20 metadata
         __ERC20_init(_name, _symbol);
         _mint(msg.sender, _totalSupply);
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
     }
 
     function decimals() public view override returns (uint8) {

package/contracts/token/HypERC20Collateral.sol

@@ -25,6 +25,14 @@ contract HypERC20Collateral is TokenRouter {
         wrappedToken = IERC20(erc20);
     }
 
+    function initialize(
+        address _hook,
+        address _interchainSecurityModule,
+        address _owner
+    ) public virtual initializer {
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
+    }
+
     function balanceOf(
         address _account
     ) external view override returns (uint256) {

package/contracts/token/HypERC20CollateralVaultDeposit.sol

@@ -21,7 +21,15 @@ contract HypERC20CollateralVaultDeposit is HypERC20Collateral {
         address _mailbox
     ) HypERC20Collateral(_vault.asset(), _mailbox) {
         vault = _vault;
+    }
+
+    function initialize(
+        address _hook,
+        address _interchainSecurityModule,
+        address _owner
+    ) public override initializer {
         wrappedToken.approve(address(vault), type(uint256).max);
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
     }
 
     /**

package/contracts/token/HypERC721.sol

@@ -19,18 +19,22 @@ contract HypERC721 is ERC721EnumerableUpgradeable, TokenRouter {
      * @param _mintAmount The amount of NFTs to mint to `msg.sender`.
      * @param _name The name of the token.
      * @param _symbol The symbol of the token.
+     * @param _hook The post-dispatch hook contract.
+       @param _interchainSecurityModule The interchain security module contract.
+       @param _owner The this contract.
      */
     function initialize(
         uint256 _mintAmount,
         string memory _name,
-        string memory _symbol
+        string memory _symbol,
+        address _hook,
+        address _interchainSecurityModule,
+        address _owner
     ) external initializer {
-        address owner = msg.sender;
-        _transferOwnership(owner);
-
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
         __ERC721_init(_name, _symbol);
         for (uint256 i = 0; i < _mintAmount; i++) {
-            _safeMint(owner, i);
+            _safeMint(msg.sender, i);
         }
     }
 

package/contracts/token/HypERC721Collateral.sol

@@ -21,6 +21,20 @@ contract HypERC721Collateral is TokenRouter {
         wrappedToken = IERC721(erc721);
     }
 
+    /**
+     * @notice Initializes the Hyperlane router
+     * @param _hook The post-dispatch hook contract.
+       @param _interchainSecurityModule The interchain security module contract.
+       @param _owner The this contract.
+     */
+    function initialize(
+        address _hook,
+        address _interchainSecurityModule,
+        address _owner
+    ) public virtual initializer {
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
+    }
+
     function ownerOf(uint256 _tokenId) external view returns (address) {
         return IERC721(wrappedToken).ownerOf(_tokenId);
     }

package/contracts/token/HypNative.sol

@@ -20,6 +20,20 @@ contract HypNative is TokenRouter {
 
     constructor(address _mailbox) TokenRouter(_mailbox) {}
 
+    /**
+     * @notice Initializes the Hyperlane router
+     * @param _hook The post-dispatch hook contract.
+       @param _interchainSecurityModule The interchain security module contract.
+       @param _owner The this contract.
+     */
+    function initialize(
+        address _hook,
+        address _interchainSecurityModule,
+        address _owner
+    ) public initializer {
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
+    }
+
     /**
      * @inheritdoc TokenRouter
      * @dev uses (`msg.value` - `_amount`) as interchain gas payment and `msg.sender` as refund address.
@@ -31,7 +45,15 @@ contract HypNative is TokenRouter {
     ) public payable virtual override returns (bytes32 messageId) {
         require(msg.value >= _amount, "Native: amount exceeds msg.value");
         uint256 gasPayment = msg.value - _amount;
-        return _transferRemote(_destination, _recipient, _amount, gasPayment);
+        return
+            _transferRemote(
+                _destination,
+                _recipient,
+                _amount,
+                gasPayment,
+                bytes(""),
+                address(0)
+            );
     }
 
     function balanceOf(

package/contracts/token/extensions/HypNativeScaled.sol

@@ -30,7 +30,14 @@ contract HypNativeScaled is HypNative {
         uint256 gasPayment = msg.value - _amount;
         uint256 scaledAmount = _amount / scale;
         return
-            _transferRemote(_destination, _recipient, scaledAmount, gasPayment);
+            _transferRemote(
+                _destination,
+                _recipient,
+                scaledAmount,
+                gasPayment,
+                bytes(""),
+                address(0)
+            );
     }
 
     /**

package/contracts/token/libs/TokenRouter.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity >=0.8.0;
 
+import {IPostDispatchHook} from "../../interfaces/hooks/IPostDispatchHook.sol";
 import {GasRouter} from "../../client/GasRouter.sol";
 import {MailboxClient} from "../../client/MailboxClient.sol";
 import {TypeCasts} from "../../libs/TypeCasts.sol";
@@ -56,31 +57,86 @@ abstract contract TokenRouter is GasRouter {
         uint256 _amountOrId
     ) external payable virtual returns (bytes32 messageId) {
         return
-            _transferRemote(_destination, _recipient, _amountOrId, msg.value);
+            _transferRemote(
+                _destination,
+                _recipient,
+                _amountOrId,
+                msg.value,
+                bytes(""),
+                address(0)
+            );
+    }
+
+    /**
+     * @notice Transfers `_amountOrId` token to `_recipient` on `_destination` domain with a specified hook
+     * @dev Delegates transfer logic to `_transferFromSender` implementation.
+     * @dev The metadata is the token metadata, and is DIFFERENT than the hook metadata.
+     * @dev Emits `SentTransferRemote` event on the origin chain.
+     * @param _destination The identifier of the destination chain.
+     * @param _recipient The address of the recipient on the destination chain.
+     * @param _amountOrId The amount or identifier of tokens to be sent to the remote recipient.
+     * @param _hookMetadata The metadata passed into the hook
+     * @param _hook The post dispatch hook to be called by the Mailbox
+     * @return messageId The identifier of the dispatched message.
+     */
+    function transferRemote(
+        uint32 _destination,
+        bytes32 _recipient,
+        uint256 _amountOrId,
+        bytes calldata _hookMetadata,
+        address _hook
+    ) external payable virtual returns (bytes32 messageId) {
+        return
+            _transferRemote(
+                _destination,
+                _recipient,
+                _amountOrId,
+                msg.value,
+                _hookMetadata,
+                _hook
+            );
     }
 
     /**
      * @notice Transfers `_amountOrId` token to `_recipient` on `_destination` domain.
      * @dev Delegates transfer logic to `_transferFromSender` implementation.
+     * @dev The metadata is the token metadata, and is DIFFERENT than the hook metadata.
      * @dev Emits `SentTransferRemote` event on the origin chain.
      * @param _destination The identifier of the destination chain.
      * @param _recipient The address of the recipient on the destination chain.
      * @param _amountOrId The amount or identifier of tokens to be sent to the remote recipient.
      * @param _gasPayment The amount of native token to pay for interchain gas.
+     * @param _hookMetadata The metadata passed into the hook
+     * @param _hook The post dispatch hook to be called by the Mailbox
      * @return messageId The identifier of the dispatched message.
      */
     function _transferRemote(
         uint32 _destination,
         bytes32 _recipient,
         uint256 _amountOrId,
-        uint256 _gasPayment
+        uint256 _gasPayment,
+        bytes memory _hookMetadata,
+        address _hook
     ) internal returns (bytes32 messageId) {
         bytes memory metadata = _transferFromSender(_amountOrId);
-        messageId = _dispatch(
-            _destination,
-            _gasPayment,
-            TokenMessage.format(_recipient, _amountOrId, metadata)
-        );
+
+        if (address(_hook) == address(0)) {
+            messageId = _dispatch(
+                _destination,
+                _gasPayment,
+                TokenMessage.format(_recipient, _amountOrId, metadata)
+            );
+        } else {
+            messageId = _dispatch(
+                _destination,
+                _recipient,
+                _gasPayment,
+                TokenMessage.format(_recipient, _amountOrId, metadata),
+                _hookMetadata,
+                IPostDispatchHook(_hook)
+            );
+        }
+
         emit SentTransferRemote(_destination, _recipient, _amountOrId);
     }
 

package/dist/@layerzerolabs/index.d.ts

@@ -1,5 +1,5 @@
-import type * as lzEvmProtocolV2 from "./lz-evm-protocol-v2";
+import type * as lzEvmProtocolV2 from "./lz-evm-protocol-v2/index.js";
 export type { lzEvmProtocolV2 };
-import type * as lzEvmV107 from "./lz-evm-v1-0.7";
+import type * as lzEvmV107 from "./lz-evm-v1-0.7/index.js";
 export type { lzEvmV107 };
 //# sourceMappingURL=index.d.ts.map

package/dist/@layerzerolabs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../types/@layerzerolabs/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,eAAe,MAAM,sBAAsB,CAAC;AAC7D,YAAY,EAAE,eAAe,EAAE,CAAC;AAChC,OAAO,KAAK,KAAK,SAAS,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../types/@layerzerolabs/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,eAAe,MAAM,+BAA+B,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,CAAC;AAChC,OAAO,KAAK,KAAK,SAAS,MAAM,0BAA0B,CAAC;AAC3D,YAAY,EAAE,SAAS,EAAE,CAAC"}

package/dist/@layerzerolabs/index.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=index.js.map