@across-protocol/contracts 0.1.0

package/contracts/oracle/interfaces/OptimisticOracleInterface.sol

@@ -0,0 +1,263 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/**
+ * @title Financial contract facing Oracle interface.
+ * @dev Interface used by financial contracts to interact with the Oracle. Voters will use a different interface.
+ */
+abstract contract OptimisticOracleInterface {
+    // Struct representing the state of a price request.
+    enum State {
+        Invalid, // Never requested.
+        Requested, // Requested, no other actions taken.
+        Proposed, // Proposed, but not expired or disputed yet.
+        Expired, // Proposed, not disputed, past liveness.
+        Disputed, // Disputed, but no DVM price returned yet.
+        Resolved, // Disputed and DVM price is available.
+        Settled // Final price has been set in the contract (can get here from Expired or Resolved).
+    }
+
+    // Struct representing a price request.
+    struct Request {
+        address proposer; // Address of the proposer.
+        address disputer; // Address of the disputer.
+        IERC20 currency; // ERC20 token used to pay rewards and fees.
+        bool settled; // True if the request is settled.
+        bool refundOnDispute; // True if the requester should be refunded their reward on dispute.
+        int256 proposedPrice; // Price that the proposer submitted.
+        int256 resolvedPrice; // Price resolved once the request is settled.
+        uint256 expirationTime; // Time at which the request auto-settles without a dispute.
+        uint256 reward; // Amount of the currency to pay to the proposer on settlement.
+        uint256 finalFee; // Final fee to pay to the Store upon request to the DVM.
+        uint256 bond; // Bond that the proposer and disputer must pay on top of the final fee.
+        uint256 customLiveness; // Custom liveness value set by the requester.
+    }
+
+    // This value must be <= the Voting contract's `ancillaryBytesLimit` value otherwise it is possible
+    // that a price can be requested to this contract successfully, but cannot be disputed because the DVM refuses
+    // to accept a price request made with ancillary data length over a certain size.
+    uint256 public constant ancillaryBytesLimit = 8192;
+
+    /**
+     * @notice Requests a new price.
+     * @param identifier price identifier being requested.
+     * @param timestamp timestamp of the price being requested.
+     * @param ancillaryData ancillary data representing additional args being passed with the price request.
+     * @param currency ERC20 token used for payment of rewards and fees. Must be approved for use with the DVM.
+     * @param reward reward offered to a successful proposer. Will be pulled from the caller. Note: this can be 0,
+     *               which could make sense if the contract requests and proposes the value in the same call or
+     *               provides its own reward system.
+     * @return totalBond default bond (final fee) + final fee that the proposer and disputer will be required to pay.
+     * This can be changed with a subsequent call to setBond().
+     */
+    function requestPrice(
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData,
+        IERC20 currency,
+        uint256 reward
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Set the proposal bond associated with a price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param bond custom bond amount to set.
+     * @return totalBond new bond + final fee that the proposer and disputer will be required to pay. This can be
+     * changed again with a subsequent call to setBond().
+     */
+    function setBond(
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData,
+        uint256 bond
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Sets the request to refund the reward if the proposal is disputed. This can help to "hedge" the caller
+     * in the event of a dispute-caused delay. Note: in the event of a dispute, the winner still receives the other's
+     * bond, so there is still profit to be made even if the reward is refunded.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     */
+    function setRefundOnDispute(
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) external virtual;
+
+    /**
+     * @notice Sets a custom liveness value for the request. Liveness is the amount of time a proposal must wait before
+     * being auto-resolved.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param customLiveness new custom liveness.
+     */
+    function setCustomLiveness(
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData,
+        uint256 customLiveness
+    ) external virtual;
+
+    /**
+     * @notice Proposes a price value on another address' behalf. Note: this address will receive any rewards that come
+     * from this proposal. However, any bonds are pulled from the caller.
+     * @param proposer address to set as the proposer.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param proposedPrice price being proposed.
+     * @return totalBond the amount that's pulled from the caller's wallet as a bond. The bond will be returned to
+     * the proposer once settled if the proposal is correct.
+     */
+    function proposePriceFor(
+        address proposer,
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData,
+        int256 proposedPrice
+    ) public virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Proposes a price value for an existing price request.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param proposedPrice price being proposed.
+     * @return totalBond the amount that's pulled from the proposer's wallet as a bond. The bond will be returned to
+     * the proposer once settled if the proposal is correct.
+     */
+    function proposePrice(
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData,
+        int256 proposedPrice
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Disputes a price request with an active proposal on another address' behalf. Note: this address will
+     * receive any rewards that come from this dispute. However, any bonds are pulled from the caller.
+     * @param disputer address to set as the disputer.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @return totalBond the amount that's pulled from the caller's wallet as a bond. The bond will be returned to
+     * the disputer once settled if the dispute was value (the proposal was incorrect).
+     */
+    function disputePriceFor(
+        address disputer,
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) public virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Disputes a price value for an existing price request with an active proposal.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @return totalBond the amount that's pulled from the disputer's wallet as a bond. The bond will be returned to
+     * the disputer once settled if the dispute was valid (the proposal was incorrect).
+     */
+    function disputePrice(
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Retrieves a price that was previously requested by a caller. Reverts if the request is not settled
+     * or settleable. Note: this method is not view so that this call may actually settle the price request if it
+     * hasn't been settled.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @return resolved price.
+     */
+    function settleAndGetPrice(
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) external virtual returns (int256);
+
+    /**
+     * @notice Attempts to settle an outstanding price request. Will revert if it isn't settleable.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @return payout the amount that the "winner" (proposer or disputer) receives on settlement. This amount includes
+     * the returned bonds as well as additional rewards.
+     */
+    function settle(
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) external virtual returns (uint256 payout);
+
+    /**
+     * @notice Gets the current data structure containing all information about a price request.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @return the Request data structure.
+     */
+    function getRequest(
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) public view virtual returns (Request memory);
+
+    /**
+     * @notice Returns the state of a price request.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @return the State enum value.
+     */
+    function getState(
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) public view virtual returns (State);
+
+    /**
+     * @notice Checks if a given request has resolved or been settled (i.e the optimistic oracle has a price).
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @return true if price has resolved or settled, false otherwise.
+     */
+    function hasPrice(
+        address requester,
+        bytes32 identifier,
+        uint256 timestamp,
+        bytes memory ancillaryData
+    ) public view virtual returns (bool);
+
+    function stampAncillaryData(bytes memory ancillaryData, address requester)
+        public
+        view
+        virtual
+        returns (bytes memory);
+}

package/contracts/oracle/interfaces/SkinnyOptimisticOracleInterface.sol

@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "../interfaces/OptimisticOracleInterface.sol";
+
+/**
+ * @title Interface for the gas-cost-reduced version of the OptimisticOracle.
+ * @notice Differences from normal OptimisticOracle:
+ * - refundOnDispute: flag is removed, by default there are no refunds on disputes.
+ * - customizing request parameters: In the OptimisticOracle, parameters like `bond` and `customLiveness` can be reset
+ *   after a request is already made via `requestPrice`. In the SkinnyOptimisticOracle, these parameters can only be
+ *   set in `requestPrice`, which has an expanded input set.
+ * - settleAndGetPrice: Replaced by `settle`, which can only be called once per settleable request. The resolved price
+ *   can be fetched via the `Settle` event or the return value of `settle`.
+ * - general changes to interface: Functions that interact with existing requests all require the parameters of the
+ *   request to modify to be passed as input. These parameters must match with the existing request parameters or the
+ *   function will revert. This change reflects the internal refactor to store hashed request parameters instead of the
+ *   full request struct.
+ * @dev Interface used by financial contracts to interact with the Oracle. Voters will use a different interface.
+ */
+abstract contract SkinnyOptimisticOracleInterface {
+    // Struct representing a price request. Note that this differs from the OptimisticOracleInterface's Request struct
+    // in that refundOnDispute is removed.
+    struct Request {
+        address proposer; // Address of the proposer.
+        address disputer; // Address of the disputer.
+        IERC20 currency; // ERC20 token used to pay rewards and fees.
+        bool settled; // True if the request is settled.
+        int256 proposedPrice; // Price that the proposer submitted.
+        int256 resolvedPrice; // Price resolved once the request is settled.
+        uint256 expirationTime; // Time at which the request auto-settles without a dispute.
+        uint256 reward; // Amount of the currency to pay to the proposer on settlement.
+        uint256 finalFee; // Final fee to pay to the Store upon request to the DVM.
+        uint256 bond; // Bond that the proposer and disputer must pay on top of the final fee.
+        uint256 customLiveness; // Custom liveness value set by the requester.
+    }
+
+    // This value must be <= the Voting contract's `ancillaryBytesLimit` value otherwise it is possible
+    // that a price can be requested to this contract successfully, but cannot be disputed because the DVM refuses
+    // to accept a price request made with ancillary data length over a certain size.
+    uint256 public constant ancillaryBytesLimit = 8192;
+
+    /**
+     * @notice Requests a new price.
+     * @param identifier price identifier being requested.
+     * @param timestamp timestamp of the price being requested.
+     * @param ancillaryData ancillary data representing additional args being passed with the price request.
+     * @param currency ERC20 token used for payment of rewards and fees. Must be approved for use with the DVM.
+     * @param reward reward offered to a successful proposer. Will be pulled from the caller. Note: this can be 0,
+     *               which could make sense if the contract requests and proposes the value in the same call or
+     *               provides its own reward system.
+     * @param bond custom proposal bond to set for request. If set to 0, defaults to the final fee.
+     * @param customLiveness custom proposal liveness to set for request.
+     * @return totalBond default bond + final fee that the proposer and disputer will be required to pay.
+     */
+    function requestPrice(
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        IERC20 currency,
+        uint256 reward,
+        uint256 bond,
+        uint256 customLiveness
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Proposes a price value on another address' behalf. Note: this address will receive any rewards that come
+     * from this proposal. However, any bonds are pulled from the caller.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param request price request parameters whose hash must match the request that the caller wants to
+     * propose a price for.
+     * @param proposer address to set as the proposer.
+     * @param proposedPrice price being proposed.
+     * @return totalBond the amount that's pulled from the caller's wallet as a bond. The bond will be returned to
+     * the proposer once settled if the proposal is correct.
+     */
+    function proposePriceFor(
+        address requester,
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        Request memory request,
+        address proposer,
+        int256 proposedPrice
+    ) public virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Proposes a price value where caller is the proposer.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param request price request parameters whose hash must match the request that the caller wants to
+     * propose a price for.
+     * @param proposedPrice price being proposed.
+     * @return totalBond the amount that's pulled from the caller's wallet as a bond. The bond will be returned to
+     * the proposer once settled if the proposal is correct.
+     */
+    function proposePrice(
+        address requester,
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        Request memory request,
+        int256 proposedPrice
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Combines logic of requestPrice and proposePrice while taking advantage of gas savings from not having to
+     * overwrite Request params that a normal requestPrice() => proposePrice() flow would entail. Note: The proposer
+     * will receive any rewards that come from this proposal. However, any bonds are pulled from the caller.
+     * @dev The caller is the requester, but the proposer can be customized.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param currency ERC20 token used for payment of rewards and fees. Must be approved for use with the DVM.
+     * @param reward reward offered to a successful proposer. Will be pulled from the caller. Note: this can be 0,
+     *               which could make sense if the contract requests and proposes the value in the same call or
+     *               provides its own reward system.
+     * @param bond custom proposal bond to set for request. If set to 0, defaults to the final fee.
+     * @param customLiveness custom proposal liveness to set for request.
+     * @param proposer address to set as the proposer.
+     * @param proposedPrice price being proposed.
+     * @return totalBond the amount that's pulled from the caller's wallet as a bond. The bond will be returned to
+     * the proposer once settled if the proposal is correct.
+     */
+    function requestAndProposePriceFor(
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        IERC20 currency,
+        uint256 reward,
+        uint256 bond,
+        uint256 customLiveness,
+        address proposer,
+        int256 proposedPrice
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Disputes a price request with an active proposal on another address' behalf. Note: this address will
+     * receive any rewards that come from this dispute. However, any bonds are pulled from the caller.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param request price request parameters whose hash must match the request that the caller wants to
+     * dispute.
+     * @param disputer address to set as the disputer.
+     * @param requester sender of the initial price request.
+     * @return totalBond the amount that's pulled from the caller's wallet as a bond. The bond will be returned to
+     * the disputer once settled if the dispute was valid (the proposal was incorrect).
+     */
+    function disputePriceFor(
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        Request memory request,
+        address disputer,
+        address requester
+    ) public virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Disputes a price request with an active proposal where caller is the disputer.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param request price request parameters whose hash must match the request that the caller wants to
+     * dispute.
+     * @return totalBond the amount that's pulled from the caller's wallet as a bond. The bond will be returned to
+     * the disputer once settled if the dispute was valid (the proposal was incorrect).
+     */
+    function disputePrice(
+        address requester,
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        Request memory request
+    ) external virtual returns (uint256 totalBond);
+
+    /**
+     * @notice Attempts to settle an outstanding price request. Will revert if it isn't settleable.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param request price request parameters whose hash must match the request that the caller wants to
+     * settle.
+     * @return payout the amount that the "winner" (proposer or disputer) receives on settlement. This amount includes
+     * the returned bonds as well as additional rewards.
+     * @return resolvedPrice the price that the request settled to.
+     */
+    function settle(
+        address requester,
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        Request memory request
+    ) external virtual returns (uint256 payout, int256 resolvedPrice);
+
+    /**
+     * @notice Computes the current state of a price request. See the State enum for more details.
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param request price request parameters.
+     * @return the State.
+     */
+    function getState(
+        address requester,
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        Request memory request
+    ) external virtual returns (OptimisticOracleInterface.State);
+
+    /**
+     * @notice Checks if a given request has resolved, expired or been settled (i.e the optimistic oracle has a price).
+     * @param requester sender of the initial price request.
+     * @param identifier price identifier to identify the existing request.
+     * @param timestamp timestamp to identify the existing request.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param request price request parameters. The hash of these parameters must match with the request hash that is
+     * associated with the price request unique ID {requester, identifier, timestamp, ancillaryData}, or this method
+     * will revert.
+     * @return boolean indicating true if price exists and false if not.
+     */
+    function hasPrice(
+        address requester,
+        bytes32 identifier,
+        uint32 timestamp,
+        bytes memory ancillaryData,
+        Request memory request
+    ) public virtual returns (bool);
+
+    /**
+     * @notice Generates stamped ancillary data in the format that it would be used in the case of a price dispute.
+     * @param ancillaryData ancillary data of the price being requested.
+     * @param requester sender of the initial price request.
+     * @return the stamped ancillary bytes.
+     */
+    function stampAncillaryData(bytes memory ancillaryData, address requester)
+        public
+        pure
+        virtual
+        returns (bytes memory);
+}

package/contracts/oracle/interfaces/StoreInterface.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "../../common/implementation/FixedPoint.sol";
+
+/**
+ * @title Interface that allows financial contracts to pay oracle fees for their use of the system.
+ */
+interface StoreInterface {
+    /**
+     * @notice Pays Oracle fees in ETH to the store.
+     * @dev To be used by contracts whose margin currency is ETH.
+     */
+    function payOracleFees() external payable;
+
+    /**
+     * @notice Pays oracle fees in the margin currency, erc20Address, to the store.
+     * @dev To be used if the margin currency is an ERC20 token rather than ETH.
+     * @param erc20Address address of the ERC20 token used to pay the fee.
+     * @param amount number of tokens to transfer. An approval for at least this amount must exist.
+     */
+    function payOracleFeesErc20(address erc20Address, FixedPoint.Unsigned calldata amount) external;
+
+    /**
+     * @notice Computes the regular oracle fees that a contract should pay for a period.
+     * @param startTime defines the beginning time from which the fee is paid.
+     * @param endTime end time until which the fee is paid.
+     * @param pfc "profit from corruption", or the maximum amount of margin currency that a
+     * token sponsor could extract from the contract through corrupting the price feed in their favor.
+     * @return regularFee amount owed for the duration from start to end time for the given pfc.
+     * @return latePenalty for paying the fee after the deadline.
+     */
+    function computeRegularFee(
+        uint256 startTime,
+        uint256 endTime,
+        FixedPoint.Unsigned calldata pfc
+    ) external view returns (FixedPoint.Unsigned memory regularFee, FixedPoint.Unsigned memory latePenalty);
+
+    /**
+     * @notice Computes the final oracle fees that a contract should pay at settlement.
+     * @param currency token used to pay the final fee.
+     * @return finalFee amount due.
+     */
+    function computeFinalFee(address currency) external view returns (FixedPoint.Unsigned memory);
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@across-protocol/contracts",
+  "version": "0.1.0",
+  "description": "Across smart contracts and tests",
+  "dependencies": {
+    "@eth-optimism/contracts": "^0.5.5",
+    "@openzeppelin/contracts": "4.1.0",
+    "@uma/core": "^2.18.0"
+  },
+  "devDependencies": {
+    "@eth-optimism/hardhat-ovm": "^0.2.2",
+    "@eth-optimism/smock": "1.1.9",
+    "@ethersproject/abi": "^5.5.0",
+    "@ethersproject/abstract-provider": "^5.5.1",
+    "@ethersproject/abstract-signer": "^5.5.0",
+    "@ethersproject/contracts": "^5.4.0",
+    "@ethersproject/providers": "^5.4.2",
+    "@nomiclabs/ethereumjs-vm": "^4.2.2",
+    "@nomiclabs/hardhat-ethers": "^2.0.2",
+    "@nomiclabs/hardhat-etherscan": "^2.1.6",
+    "@nomiclabs/hardhat-truffle5": "^2.0.0",
+    "@nomiclabs/hardhat-web3": "^2.0.0",
+    "@uma/common": "^2.14.0",
+    "@uma/contracts-node": "^0.1.15",
+    "@uniswap/v3-core": "^1.0.0-rc.2",
+    "arb-ts": "^1.0.2",
+    "decimal.js": "^10.3.1",
+    "ethers": "^5.5.2",
+    "glob": "^7.2.0",
+    "hardhat": "^2.6.8"
+  },
+  "homepage": "https://across.to",
+  "license": "AGPL-3.0-or-later",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.com/",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/across-protocol/across-smart-contracts.git"
+  },
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "/contracts/**/*.sol",
+    "/artifacts/**/*",
+    "/dist/**/*",
+    "/types/**/*"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "test": "mocha 'test/**/*.js'",
+    "build": "hardhat compile && yarn load-addresses",
+    "load-addresses": "yarn hardhat load-addresses",
+    "prepublish": "yarn build"
+  },
+  "bugs": {
+    "url": "https://github.com/across-protocol/across-smart-contracts/issues"
+  }
+}