@keep-network/tbtc-v2 1.6.0-dev.16 → 1.6.0-dev.18

package/contracts/test/LightRelayStub.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "../relay/LightRelay.sol";
+
+contract LightRelayStub is LightRelay {
+    // Gas-reporting version of validateChain
+    function validateChainGasReport(bytes memory headers)
+        external
+        returns (uint256, uint256)
+    {
+        return this.validateChain(headers);
+    }
+}

package/contracts/test/ReceiveApprovalStub.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "../token/TBTC.sol";
+
+contract ReceiveApprovalStub is IReceiveApproval {
+    bool public shouldRevert;
+
+    event ApprovalReceived(
+        address from,
+        uint256 value,
+        address token,
+        bytes extraData
+    );
+
+    function receiveApproval(
+        address from,
+        uint256 value,
+        address token,
+        bytes calldata extraData
+    ) external override {
+        if (shouldRevert) {
+            revert("i am your father luke");
+        }
+
+        emit ApprovalReceived(from, value, token, extraData);
+    }
+
+    function setShouldRevert(bool _shouldRevert) external {
+        shouldRevert = _shouldRevert;
+    }
+}

package/contracts/test/SepoliaLightRelay.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+// ██████████████     ▐████▌     ██████████████
+// ██████████████     ▐████▌     ██████████████
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+// ██████████████     ▐████▌     ██████████████
+// ██████████████     ▐████▌     ██████████████
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+
+pragma solidity 0.8.17;
+
+import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
+
+import "../relay/LightRelay.sol";
+
+/// @title Sepolia Light Relay
+/// @notice SepoliaLightRelay is a stub version of LightRelay intended to be
+///         used on the Sepolia test network. It allows to set the relay's
+///         difficulty based on arbitrary Bitcoin headers thus effectively
+///         bypass the validation of difficulties of Bitcoin testnet blocks.
+///         Since difficulty in Bitcoin testnet often falls to `1` it would not
+///         be possible to validate blocks with the real LightRelay.
+/// @dev Notice that SepoliaLightRelay is derived from LightRelay so that the two
+///      contracts have the same API and correct bindings can be generated.
+contract SepoliaLightRelay is LightRelay {
+    using BTCUtils for bytes;
+    using BTCUtils for uint256;
+
+    /// @notice Sets the current and previous difficulty based on the difficulty
+    ///         inferred from the provided Bitcoin headers.
+    function setDifficultyFromHeaders(bytes memory bitcoinHeaders)
+        external
+        onlyOwner
+    {
+        uint256 firstHeaderDiff = bitcoinHeaders
+            .extractTarget()
+            .calculateDifficulty();
+
+        currentEpochDifficulty = firstHeaderDiff;
+        prevEpochDifficulty = firstHeaderDiff;
+    }
+}

package/contracts/test/SystemTestRelay.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
+
+import "../bridge/Bridge.sol";
+
+/// @notice Used only for system tests.
+contract SystemTestRelay is IRelay {
+    using BTCUtils for bytes;
+    using BTCUtils for uint256;
+
+    uint256 private currentEpochDifficulty;
+    uint256 private prevEpochDifficulty;
+
+    function setCurrentEpochDifficulty(uint256 _difficulty) external {
+        currentEpochDifficulty = _difficulty;
+    }
+
+    function setPrevEpochDifficulty(uint256 _difficulty) external {
+        prevEpochDifficulty = _difficulty;
+    }
+
+    function setCurrentEpochDifficultyFromHeaders(bytes memory bitcoinHeaders)
+        external
+    {
+        uint256 firstHeaderDiff = bitcoinHeaders
+            .extractTarget()
+            .calculateDifficulty();
+
+        currentEpochDifficulty = firstHeaderDiff;
+    }
+
+    function setPrevEpochDifficultyFromHeaders(bytes memory bitcoinHeaders)
+        external
+    {
+        uint256 firstHeaderDiff = bitcoinHeaders
+            .extractTarget()
+            .calculateDifficulty();
+
+        prevEpochDifficulty = firstHeaderDiff;
+    }
+
+    function getCurrentEpochDifficulty()
+        external
+        view
+        override
+        returns (uint256)
+    {
+        return currentEpochDifficulty;
+    }
+
+    function getPrevEpochDifficulty() external view override returns (uint256) {
+        return prevEpochDifficulty;
+    }
+}

package/contracts/test/TestBitcoinTx.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "../bridge/BitcoinTx.sol";
+import "../bridge/BridgeState.sol";
+import "../bridge/IRelay.sol";
+
+contract TestBitcoinTx {
+    BridgeState.Storage internal self;
+
+    event ProofValidated(bytes32 txHash);
+
+    constructor(address _relay) {
+        self.relay = IRelay(_relay);
+    }
+
+    function validateProof(
+        BitcoinTx.Info calldata txInfo,
+        BitcoinTx.Proof calldata proof
+    ) external {
+        emit ProofValidated(BitcoinTx.validateProof(self, txInfo, proof));
+    }
+}

package/contracts/test/TestERC20.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol";
+
+contract TestERC20 is ERC20WithPermit {
+    string public constant NAME = "Test ERC20 Token";
+    string public constant SYMBOL = "TT";
+
+    constructor() ERC20WithPermit(NAME, SYMBOL) {}
+}

package/contracts/test/TestERC721.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+contract TestERC721 is ERC721 {
+    string public constant NAME = "Test ERC721 Token";
+    string public constant SYMBOL = "TT";
+
+    constructor() ERC721(NAME, SYMBOL) {}
+
+    function mint(address to, uint256 tokenId) public {
+        _mint(to, tokenId);
+    }
+}

package/contracts/test/TestEcdsaLib.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "../bridge/EcdsaLib.sol";
+
+// TODO: Rename to EcdsLibStub
+/// @dev This is a contract implemented to test EcdsaLib library directly.
+contract TestEcdsaLib {
+    function compressPublicKey(bytes32 x, bytes32 y)
+        public
+        pure
+        returns (bytes memory)
+    {
+        return EcdsaLib.compressPublicKey(x, y);
+    }
+}

package/contracts/test/TestTBTCDepositor.sol

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity ^0.8.0;
+
+import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
+
+import "../integrator/AbstractTBTCDepositor.sol";
+import "../integrator/IBridge.sol";
+import "../integrator/ITBTCVault.sol";
+
+contract TestTBTCDepositor is AbstractTBTCDepositor {
+    event InitializeDepositReturned(uint256 depositKey);
+
+    event FinalizeDepositReturned(
+        uint256 initialDepositAmount,
+        uint256 tbtcAmount,
+        bytes32 extraData
+    );
+
+    function initialize(address _bridge, address _tbtcVault) external {
+        __AbstractTBTCDepositor_initialize(_bridge, _tbtcVault);
+    }
+
+    function initializeDepositPublic(
+        IBridgeTypes.BitcoinTxInfo calldata fundingTx,
+        IBridgeTypes.DepositRevealInfo calldata reveal,
+        bytes32 extraData
+    ) external {
+        uint256 depositKey = _initializeDeposit(fundingTx, reveal, extraData);
+        emit InitializeDepositReturned(depositKey);
+    }
+
+    function finalizeDepositPublic(uint256 depositKey) external {
+        (
+            uint256 initialDepositAmount,
+            uint256 tbtcAmount,
+            bytes32 extraData
+        ) = _finalizeDeposit(depositKey);
+        emit FinalizeDepositReturned(
+            initialDepositAmount,
+            tbtcAmount,
+            extraData
+        );
+    }
+
+    function calculateTbtcAmountPublic(
+        uint64 depositAmountSat,
+        uint64 depositTreasuryFeeSat
+    ) external view returns (uint256) {
+        return _calculateTbtcAmount(depositAmountSat, depositTreasuryFeeSat);
+    }
+}
+
+contract MockBridge is IBridge {
+    using BTCUtils for bytes;
+
+    mapping(uint256 => IBridgeTypes.DepositRequest) internal _deposits;
+
+    uint64 internal _depositTreasuryFeeDivisor = 50; // 1/50 == 100 bps == 2% == 0.02
+    uint64 internal _depositTxMaxFee = 1000; // 1000 satoshi = 0.00001 BTC
+
+    event DepositRevealed(uint256 depositKey);
+
+    function revealDepositWithExtraData(
+        IBridgeTypes.BitcoinTxInfo calldata fundingTx,
+        IBridgeTypes.DepositRevealInfo calldata reveal,
+        bytes32 extraData
+    ) external {
+        bytes32 fundingTxHash = abi
+            .encodePacked(
+                fundingTx.version,
+                fundingTx.inputVector,
+                fundingTx.outputVector,
+                fundingTx.locktime
+            )
+            .hash256View();
+
+        uint256 depositKey = uint256(
+            keccak256(
+                abi.encodePacked(fundingTxHash, reveal.fundingOutputIndex)
+            )
+        );
+
+        require(
+            _deposits[depositKey].revealedAt == 0,
+            "Deposit already revealed"
+        );
+
+        bytes memory fundingOutput = fundingTx
+            .outputVector
+            .extractOutputAtIndex(reveal.fundingOutputIndex);
+
+        uint64 fundingOutputAmount = fundingOutput.extractValue();
+
+        IBridgeTypes.DepositRequest memory request;
+
+        request.depositor = msg.sender;
+        request.amount = fundingOutputAmount;
+        /* solhint-disable-next-line not-rely-on-time */
+        request.revealedAt = uint32(block.timestamp);
+        request.vault = reveal.vault;
+        request.treasuryFee = _depositTreasuryFeeDivisor > 0
+            ? fundingOutputAmount / _depositTreasuryFeeDivisor
+            : 0;
+        request.sweptAt = 0;
+        request.extraData = extraData;
+
+        _deposits[depositKey] = request;
+
+        emit DepositRevealed(depositKey);
+    }
+
+    function sweepDeposit(uint256 depositKey) public {
+        require(_deposits[depositKey].revealedAt != 0, "Deposit not revealed");
+        require(_deposits[depositKey].sweptAt == 0, "Deposit already swept");
+        /* solhint-disable-next-line not-rely-on-time */
+        _deposits[depositKey].sweptAt = uint32(block.timestamp);
+    }
+
+    function deposits(uint256 depositKey)
+        external
+        view
+        returns (IBridgeTypes.DepositRequest memory)
+    {
+        return _deposits[depositKey];
+    }
+
+    function depositParameters()
+        external
+        view
+        returns (
+            uint64 depositDustThreshold,
+            uint64 depositTreasuryFeeDivisor,
+            uint64 depositTxMaxFee,
+            uint32 depositRevealAheadPeriod
+        )
+    {
+        depositDustThreshold = 0;
+        depositTreasuryFeeDivisor = 0;
+        depositTxMaxFee = _depositTxMaxFee;
+        depositRevealAheadPeriod = 0;
+    }
+
+    function setDepositTreasuryFeeDivisor(uint64 value) external {
+        _depositTreasuryFeeDivisor = value;
+    }
+
+    function setDepositTxMaxFee(uint64 value) external {
+        _depositTxMaxFee = value;
+    }
+}
+
+contract MockTBTCVault is ITBTCVault {
+    struct Request {
+        uint64 requestedAt;
+        uint64 finalizedAt;
+    }
+
+    mapping(uint256 => Request) internal _requests;
+
+    uint32 public optimisticMintingFeeDivisor = 100; // 1%
+
+    function optimisticMintingRequests(uint256 depositKey)
+        external
+        returns (uint64 requestedAt, uint64 finalizedAt)
+    {
+        Request memory request = _requests[depositKey];
+        return (request.requestedAt, request.finalizedAt);
+    }
+
+    function createOptimisticMintingRequest(uint256 depositKey) external {
+        require(
+            _requests[depositKey].requestedAt == 0,
+            "Request already exists"
+        );
+        /* solhint-disable-next-line not-rely-on-time */
+        _requests[depositKey].requestedAt = uint64(block.timestamp);
+    }
+
+    function finalizeOptimisticMintingRequest(uint256 depositKey) public {
+        require(
+            _requests[depositKey].requestedAt != 0,
+            "Request does not exist"
+        );
+        require(
+            _requests[depositKey].finalizedAt == 0,
+            "Request already finalized"
+        );
+        /* solhint-disable-next-line not-rely-on-time */
+        _requests[depositKey].finalizedAt = uint64(block.timestamp);
+    }
+
+    function setOptimisticMintingFeeDivisor(uint32 value) external {
+        optimisticMintingFeeDivisor = value;
+    }
+}

package/contracts/test/WormholeBridgeStub.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "./TestERC20.sol";
+import "../l2/L2WormholeGateway.sol";
+
+/// @dev Stub contract used in L2WormholeGateway unit tests.
+///      Stub contract is used instead of a smock because of the token transfer
+///      that needs to happen in completeTransferWithPayload function.
+contract WormholeBridgeStub is IWormholeTokenBridge {
+    TestERC20 public wormholeToken;
+
+    uint256 public transferAmount;
+    bytes32 public receiverAddress;
+
+    // Two simple events allowing to assert Wormhole bridge functions are
+    // called.
+    event WormholeBridgeStub_completeTransferWithPayload(bytes encodedVm);
+    event WormholeBridgeStub_transferTokens(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint256 arbiterFee,
+        uint32 nonce
+    );
+    event WormholeBridgeStub_transferTokensWithPayload(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint32 nonce,
+        bytes payload
+    );
+
+    constructor(TestERC20 _wormholeToken) {
+        wormholeToken = _wormholeToken;
+    }
+
+    function completeTransferWithPayload(bytes memory encodedVm)
+        external
+        returns (bytes memory)
+    {
+        emit WormholeBridgeStub_completeTransferWithPayload(encodedVm);
+        wormholeToken.mint(msg.sender, transferAmount);
+
+        // In a real implementation, encodedVm is parsed. To avoid copy-pasting
+        // Wormhole code to this contract and then encoding parmaters in unit
+        // tests, we allow to set the receiver address on the stub contract and
+        // we return it here. The rest of the parameters does not matter.
+        IWormholeTokenBridge.TransferWithPayload memory transfer = IWormholeTokenBridge
+            .TransferWithPayload(
+                1, // payloadID
+                2, // amount
+                0x3000000000000000000000000000000000000000000000000000000000000000, // tokenAddress
+                4, // tokenChain
+                0x5000000000000000000000000000000000000000000000000000000000000000, // to
+                6, // toChain
+                0x7000000000000000000000000000000000000000000000000000000000000000, // fromAddress
+                abi.encode(receiverAddress) // payload
+            );
+
+        return abi.encode(transfer);
+    }
+
+    function transferTokens(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint256 arbiterFee,
+        uint32 nonce
+    ) external payable returns (uint64 sequence) {
+        emit WormholeBridgeStub_transferTokens(
+            token,
+            amount,
+            recipientChain,
+            recipient,
+            arbiterFee,
+            nonce
+        );
+        return 777;
+    }
+
+    function transferTokensWithPayload(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint32 nonce,
+        bytes memory payload
+    ) external payable returns (uint64 sequence) {
+        emit WormholeBridgeStub_transferTokensWithPayload(
+            token,
+            amount,
+            recipientChain,
+            recipient,
+            nonce,
+            payload
+        );
+        return 888;
+    }
+
+    function parseTransferWithPayload(bytes memory encoded)
+        external
+        pure
+        returns (IWormholeTokenBridge.TransferWithPayload memory transfer)
+    {
+        return abi.decode(encoded, (IWormholeTokenBridge.TransferWithPayload));
+    }
+
+    function setTransferAmount(uint256 _transferAmount) external {
+        transferAmount = _transferAmount;
+    }
+
+    function setReceiverAddress(bytes32 _receiverAddress) external {
+        receiverAddress = _receiverAddress;
+    }
+
+    // Allows to mint Wormhole tBTC for depositWormholeTbtc unit tests.
+    function mintWormholeToken(address to, uint256 amount) external {
+        wormholeToken.mint(to, amount);
+    }
+}

package/export/artifacts/contracts/bridge/VendingMachine.sol/VendingMachine.json

@@ -601,7 +601,7 @@
           "parameterSlots": 1,
           "returnSlots": 0
         },
-        "abi_decode_tuple_t_contract$_IERC20_$18228t_contract$_TBTC_$42134t_uint256_fromMemory": {
+        "abi_decode_tuple_t_contract$_IERC20_$18228t_contract$_TBTC_$42171t_uint256_fromMemory": {
           "entryPoint": 230,
           "id": null,
           "parameterSlots": 2,
@@ -1045,7 +1045,7 @@
                     }
                   ]
                 },
-                "name": "abi_decode_tuple_t_contract$_IERC20_$18228t_contract$_TBTC_$42134t_uint256_fromMemory",
+                "name": "abi_decode_tuple_t_contract$_IERC20_$18228t_contract$_TBTC_$42171t_uint256_fromMemory",
                 "nodeType": "YulFunctionDefinition",
                 "parameters": [
                   {
@@ -1085,7 +1085,7 @@
               }
             ]
           },
-          "contents": "{\n    { }\n    function validator_revert_contract_IERC20(value)\n    {\n        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }\n    }\n    function abi_decode_tuple_t_contract$_IERC20_$18228t_contract$_TBTC_$42134t_uint256_fromMemory(headStart, dataEnd) -> value0, value1, value2\n    {\n        if slt(sub(dataEnd, headStart), 96) { revert(0, 0) }\n        let value := mload(headStart)\n        validator_revert_contract_IERC20(value)\n        value0 := value\n        let value_1 := mload(add(headStart, 32))\n        validator_revert_contract_IERC20(value_1)\n        value1 := value_1\n        value2 := mload(add(headStart, 64))\n    }\n}",
+          "contents": "{\n    { }\n    function validator_revert_contract_IERC20(value)\n    {\n        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }\n    }\n    function abi_decode_tuple_t_contract$_IERC20_$18228t_contract$_TBTC_$42171t_uint256_fromMemory(headStart, dataEnd) -> value0, value1, value2\n    {\n        if slt(sub(dataEnd, headStart), 96) { revert(0, 0) }\n        let value := mload(headStart)\n        validator_revert_contract_IERC20(value)\n        value0 := value\n        let value_1 := mload(add(headStart, 32))\n        validator_revert_contract_IERC20(value_1)\n        value1 := value_1\n        value2 := mload(add(headStart, 64))\n    }\n}",
           "id": 130,
           "language": "Yul",
           "name": "#utility.yul"
@@ -1415,7 +1415,7 @@
           "parameterSlots": 2,
           "returnSlots": 1
         },
-        "abi_encode_tuple_t_contract$_TBTC_$42134__to_t_address__fromStack_reversed": {
+        "abi_encode_tuple_t_contract$_TBTC_$42171__to_t_address__fromStack_reversed": {
           "entryPoint": null,
           "id": null,
           "parameterSlots": 2,
@@ -3111,7 +3111,7 @@
                     }
                   ]
                 },
-                "name": "abi_encode_tuple_t_contract$_TBTC_$42134__to_t_address__fromStack_reversed",
+                "name": "abi_encode_tuple_t_contract$_TBTC_$42171__to_t_address__fromStack_reversed",
                 "nodeType": "YulFunctionDefinition",
                 "parameters": [
                   {
@@ -8190,7 +8190,7 @@
               }
             ]
           },
-          "contents": "{\n    { }\n    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, value0)\n    }\n    function abi_encode_tuple_t_address__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function abi_decode_address(offset) -> value\n    {\n        value := calldataload(offset)\n        if iszero(eq(value, and(value, 0xffffffffffffffffffffffffffffffffffffffff))) { revert(0, 0) }\n    }\n    function abi_decode_tuple_t_address(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n    }\n    function abi_encode_tuple_t_contract$_IERC20_$18228__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := calldataload(headStart)\n    }\n    function abi_decode_tuple_t_addresst_uint256t_addresst_bytes_calldata_ptr(headStart, dataEnd) -> value0, value1, value2, value3, value4\n    {\n        if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n        value2 := abi_decode_address(add(headStart, 64))\n        let offset := calldataload(add(headStart, 96))\n        let _1 := 0xffffffffffffffff\n        if gt(offset, _1) { revert(0, 0) }\n        let _2 := add(headStart, offset)\n        if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }\n        let length := calldataload(_2)\n        if gt(length, _1) { revert(0, 0) }\n        if gt(add(add(_2, length), 32), dataEnd) { revert(0, 0) }\n        value3 := add(_2, 32)\n        value4 := length\n    }\n    function abi_encode_tuple_t_contract$_TBTC_$42134__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function abi_decode_tuple_t_addresst_uint256(headStart, dataEnd) -> value0, value1\n    {\n        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n    }\n    function abi_encode_tuple_t_stringliteral_9e5d6ee1ae898a2df1a30570594add9e68ad8b6af4a57d7f5f0cb2842bacfb92__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 24)\n        mstore(add(headStart, 64), \"Caller is not authorized\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_stringliteral_df41f55d800b6607edb1865fb30b4ab33d723889d164c99cca8fee73ff0a30ba__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 38)\n        mstore(add(headStart, 64), \"New initiator must not be zero a\")\n        mstore(add(headStart, 96), \"ddress\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_uint256_t_uint256__to_t_uint256_t_uint256__fromStack_reversed(headStart, value1, value0) -> tail\n    {\n        tail := add(headStart, 64)\n        mstore(headStart, value0)\n        mstore(add(headStart, 32), value1)\n    }\n    function abi_encode_tuple_t_stringliteral_b1549855d8fed0f683c741615955b3e3f5ac1fbe3fc645d4559c62450ecc9620__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 41)\n        mstore(add(headStart, 64), \"New VendingMachine cannot be zer\")\n        mstore(add(headStart, 96), \"o address\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_address_t_uint256__to_t_address_t_uint256__fromStack_reversed(headStart, value1, value0) -> tail\n    {\n        tail := add(headStart, 64)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n    }\n    function panic_error_0x11()\n    {\n        mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)\n        mstore(4, 0x11)\n        revert(0, 0x24)\n    }\n    function checked_add_t_uint256(x, y) -> sum\n    {\n        sum := add(x, y)\n        if gt(x, sum) { panic_error_0x11() }\n    }\n    function abi_decode_tuple_t_uint256_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := mload(headStart)\n    }\n    function abi_encode_tuple_t_stringliteral_1a06921938f9f63c056c578e8a5f166d5d113ae30837c6c39a7741ed0e1467eb__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 36)\n        mstore(add(headStart, 64), \"Amount + fee exceeds TBTC v2 bal\")\n        mstore(add(headStart, 96), \"ance\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_stringliteral_ea12df8d4a8fcefc5cad59efc2d58b797f642582ed766ffab36a121e023bc406__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 20)\n        mstore(add(headStart, 64), \"Token is not TBTC v1\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_stringliteral_fd4966bd1bdd27d0ab34b8489f15fc58fd6abfe9ed90887e0c2e4963267e6422__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 27)\n        mstore(add(headStart, 64), \"Only TBTC v1 caller allowed\")\n        tail := add(headStart, 96)\n    }\n    function checked_mul_t_uint256(x, y) -> product\n    {\n        product := mul(x, y)\n        if iszero(or(iszero(x), eq(y, div(product, x)))) { panic_error_0x11() }\n    }\n    function checked_div_t_uint256(x, y) -> r\n    {\n        if iszero(y)\n        {\n            mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)\n            mstore(4, 0x12)\n            revert(0, 0x24)\n        }\n        r := div(x, y)\n    }\n    function abi_encode_tuple_t_stringliteral_245f15ff17f551913a7a18385165551503906a406f905ac1c2437281a7cd0cfe__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 38)\n        mstore(add(headStart, 64), \"Ownable: new owner is the zero a\")\n        mstore(add(headStart, 96), \"ddress\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_stringliteral_61334796e55ed72efd746c0931e2d3cac4c97d3130d7bb275d5f0f57af1f045e__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 20)\n        mstore(add(headStart, 64), \"Change not initiated\")\n        tail := add(headStart, 96)\n    }\n    function checked_sub_t_uint256(x, y) -> diff\n    {\n        diff := sub(x, y)\n        if gt(diff, x) { panic_error_0x11() }\n    }\n    function abi_encode_tuple_t_stringliteral_9924ebdf1add33d25d4ef888e16131f0a5687b0580a36c21b5c301a6c462effe__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 32)\n        mstore(add(headStart, 64), \"Ownable: caller is not the owner\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_stringliteral_92dde2c37d5ac1c8388fee9c21ec0fe0c957aca7e978d56c81b848f962f0a8ba__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 32)\n        mstore(add(headStart, 64), \"Governance delay has not elapsed\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_address_t_address_t_uint256__to_t_address_t_address_t_uint256__fromStack_reversed(headStart, value2, value1, value0) -> tail\n    {\n        tail := add(headStart, 96)\n        let _1 := 0xffffffffffffffffffffffffffffffffffffffff\n        mstore(headStart, and(value0, _1))\n        mstore(add(headStart, 32), and(value1, _1))\n        mstore(add(headStart, 64), value2)\n    }\n    function abi_decode_tuple_t_bool_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let value := mload(headStart)\n        if iszero(eq(value, iszero(iszero(value)))) { revert(0, 0) }\n        value0 := value\n    }\n    function abi_encode_tuple_t_stringliteral_e11ad79d1e4a7f2e5f376964cb99e8e8f7904e3fc16a109f7a7ecb9aa7956dcd__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 42)\n        mstore(add(headStart, 64), \"SafeERC20: ERC20 operation did n\")\n        mstore(add(headStart, 96), \"ot succeed\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_stringliteral_565f1a77334fc4792800921178c71e4521acffab18ff9e7885b49377ee80ab4c__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 38)\n        mstore(add(headStart, 64), \"Address: insufficient balance fo\")\n        mstore(add(headStart, 96), \"r call\")\n        tail := add(headStart, 128)\n    }\n    function copy_memory_to_memory_with_cleanup(src, dst, length)\n    {\n        let i := 0\n        for { } lt(i, length) { i := add(i, 32) }\n        {\n            mstore(add(dst, i), mload(add(src, i)))\n        }\n        mstore(add(dst, length), 0)\n    }\n    function abi_encode_tuple_packed_t_bytes_memory_ptr__to_t_bytes_memory_ptr__nonPadded_inplace_fromStack_reversed(pos, value0) -> end\n    {\n        let length := mload(value0)\n        copy_memory_to_memory_with_cleanup(add(value0, 0x20), pos, length)\n        end := add(pos, length)\n    }\n    function abi_encode_tuple_t_stringliteral_cc2e4e38850b7c0a3e942cfed89b71c77302df25bcb2ec297a0c4ff9ff6b90ad__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 29)\n        mstore(add(headStart, 64), \"Address: call to non-contract\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack_reversed(headStart, value0) -> tail\n    {\n        mstore(headStart, 32)\n        let length := mload(value0)\n        mstore(add(headStart, 32), length)\n        copy_memory_to_memory_with_cleanup(add(value0, 32), add(headStart, 64), length)\n        tail := add(add(headStart, and(add(length, 31), not(31))), 64)\n    }\n}",
+          "contents": "{\n    { }\n    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, value0)\n    }\n    function abi_encode_tuple_t_address__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function abi_decode_address(offset) -> value\n    {\n        value := calldataload(offset)\n        if iszero(eq(value, and(value, 0xffffffffffffffffffffffffffffffffffffffff))) { revert(0, 0) }\n    }\n    function abi_decode_tuple_t_address(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n    }\n    function abi_encode_tuple_t_contract$_IERC20_$18228__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := calldataload(headStart)\n    }\n    function abi_decode_tuple_t_addresst_uint256t_addresst_bytes_calldata_ptr(headStart, dataEnd) -> value0, value1, value2, value3, value4\n    {\n        if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n        value2 := abi_decode_address(add(headStart, 64))\n        let offset := calldataload(add(headStart, 96))\n        let _1 := 0xffffffffffffffff\n        if gt(offset, _1) { revert(0, 0) }\n        let _2 := add(headStart, offset)\n        if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }\n        let length := calldataload(_2)\n        if gt(length, _1) { revert(0, 0) }\n        if gt(add(add(_2, length), 32), dataEnd) { revert(0, 0) }\n        value3 := add(_2, 32)\n        value4 := length\n    }\n    function abi_encode_tuple_t_contract$_TBTC_$42171__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function abi_decode_tuple_t_addresst_uint256(headStart, dataEnd) -> value0, value1\n    {\n        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n    }\n    function abi_encode_tuple_t_stringliteral_9e5d6ee1ae898a2df1a30570594add9e68ad8b6af4a57d7f5f0cb2842bacfb92__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 24)\n        mstore(add(headStart, 64), \"Caller is not authorized\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_stringliteral_df41f55d800b6607edb1865fb30b4ab33d723889d164c99cca8fee73ff0a30ba__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 38)\n        mstore(add(headStart, 64), \"New initiator must not be zero a\")\n        mstore(add(headStart, 96), \"ddress\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_uint256_t_uint256__to_t_uint256_t_uint256__fromStack_reversed(headStart, value1, value0) -> tail\n    {\n        tail := add(headStart, 64)\n        mstore(headStart, value0)\n        mstore(add(headStart, 32), value1)\n    }\n    function abi_encode_tuple_t_stringliteral_b1549855d8fed0f683c741615955b3e3f5ac1fbe3fc645d4559c62450ecc9620__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 41)\n        mstore(add(headStart, 64), \"New VendingMachine cannot be zer\")\n        mstore(add(headStart, 96), \"o address\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_address_t_uint256__to_t_address_t_uint256__fromStack_reversed(headStart, value1, value0) -> tail\n    {\n        tail := add(headStart, 64)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n    }\n    function panic_error_0x11()\n    {\n        mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)\n        mstore(4, 0x11)\n        revert(0, 0x24)\n    }\n    function checked_add_t_uint256(x, y) -> sum\n    {\n        sum := add(x, y)\n        if gt(x, sum) { panic_error_0x11() }\n    }\n    function abi_decode_tuple_t_uint256_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := mload(headStart)\n    }\n    function abi_encode_tuple_t_stringliteral_1a06921938f9f63c056c578e8a5f166d5d113ae30837c6c39a7741ed0e1467eb__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 36)\n        mstore(add(headStart, 64), \"Amount + fee exceeds TBTC v2 bal\")\n        mstore(add(headStart, 96), \"ance\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_stringliteral_ea12df8d4a8fcefc5cad59efc2d58b797f642582ed766ffab36a121e023bc406__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 20)\n        mstore(add(headStart, 64), \"Token is not TBTC v1\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_stringliteral_fd4966bd1bdd27d0ab34b8489f15fc58fd6abfe9ed90887e0c2e4963267e6422__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 27)\n        mstore(add(headStart, 64), \"Only TBTC v1 caller allowed\")\n        tail := add(headStart, 96)\n    }\n    function checked_mul_t_uint256(x, y) -> product\n    {\n        product := mul(x, y)\n        if iszero(or(iszero(x), eq(y, div(product, x)))) { panic_error_0x11() }\n    }\n    function checked_div_t_uint256(x, y) -> r\n    {\n        if iszero(y)\n        {\n            mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)\n            mstore(4, 0x12)\n            revert(0, 0x24)\n        }\n        r := div(x, y)\n    }\n    function abi_encode_tuple_t_stringliteral_245f15ff17f551913a7a18385165551503906a406f905ac1c2437281a7cd0cfe__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 38)\n        mstore(add(headStart, 64), \"Ownable: new owner is the zero a\")\n        mstore(add(headStart, 96), \"ddress\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_stringliteral_61334796e55ed72efd746c0931e2d3cac4c97d3130d7bb275d5f0f57af1f045e__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 20)\n        mstore(add(headStart, 64), \"Change not initiated\")\n        tail := add(headStart, 96)\n    }\n    function checked_sub_t_uint256(x, y) -> diff\n    {\n        diff := sub(x, y)\n        if gt(diff, x) { panic_error_0x11() }\n    }\n    function abi_encode_tuple_t_stringliteral_9924ebdf1add33d25d4ef888e16131f0a5687b0580a36c21b5c301a6c462effe__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 32)\n        mstore(add(headStart, 64), \"Ownable: caller is not the owner\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_stringliteral_92dde2c37d5ac1c8388fee9c21ec0fe0c957aca7e978d56c81b848f962f0a8ba__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 32)\n        mstore(add(headStart, 64), \"Governance delay has not elapsed\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_address_t_address_t_uint256__to_t_address_t_address_t_uint256__fromStack_reversed(headStart, value2, value1, value0) -> tail\n    {\n        tail := add(headStart, 96)\n        let _1 := 0xffffffffffffffffffffffffffffffffffffffff\n        mstore(headStart, and(value0, _1))\n        mstore(add(headStart, 32), and(value1, _1))\n        mstore(add(headStart, 64), value2)\n    }\n    function abi_decode_tuple_t_bool_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let value := mload(headStart)\n        if iszero(eq(value, iszero(iszero(value)))) { revert(0, 0) }\n        value0 := value\n    }\n    function abi_encode_tuple_t_stringliteral_e11ad79d1e4a7f2e5f376964cb99e8e8f7904e3fc16a109f7a7ecb9aa7956dcd__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 42)\n        mstore(add(headStart, 64), \"SafeERC20: ERC20 operation did n\")\n        mstore(add(headStart, 96), \"ot succeed\")\n        tail := add(headStart, 128)\n    }\n    function abi_encode_tuple_t_stringliteral_565f1a77334fc4792800921178c71e4521acffab18ff9e7885b49377ee80ab4c__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 38)\n        mstore(add(headStart, 64), \"Address: insufficient balance fo\")\n        mstore(add(headStart, 96), \"r call\")\n        tail := add(headStart, 128)\n    }\n    function copy_memory_to_memory_with_cleanup(src, dst, length)\n    {\n        let i := 0\n        for { } lt(i, length) { i := add(i, 32) }\n        {\n            mstore(add(dst, i), mload(add(src, i)))\n        }\n        mstore(add(dst, length), 0)\n    }\n    function abi_encode_tuple_packed_t_bytes_memory_ptr__to_t_bytes_memory_ptr__nonPadded_inplace_fromStack_reversed(pos, value0) -> end\n    {\n        let length := mload(value0)\n        copy_memory_to_memory_with_cleanup(add(value0, 0x20), pos, length)\n        end := add(pos, length)\n    }\n    function abi_encode_tuple_t_stringliteral_cc2e4e38850b7c0a3e942cfed89b71c77302df25bcb2ec297a0c4ff9ff6b90ad__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), 29)\n        mstore(add(headStart, 64), \"Address: call to non-contract\")\n        tail := add(headStart, 96)\n    }\n    function abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack_reversed(headStart, value0) -> tail\n    {\n        mstore(headStart, 32)\n        let length := mload(value0)\n        mstore(add(headStart, 32), length)\n        copy_memory_to_memory_with_cleanup(add(value0, 32), add(headStart, 64), length)\n        tail := add(add(headStart, and(add(length, 31), not(31))), 64)\n    }\n}",
           "id": 130,
           "language": "Yul",
           "name": "#utility.yul"