Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import {ERC2771Context} from "../../lib/relay-context-contracts/contracts/vendor/ERC2771Context.sol";
import {LyraForwarderBase} from "./LyraForwarderBase.sol";
import {IL1StandardBridge} from "../interfaces/IL1StandardBridge.sol";
import {ISocketVault} from "../interfaces/ISocketVault.sol";
import {IERC3009} from "../interfaces/IERC3009.sol";

/**
 * @title   LyraForwarder
 * @notice  Use this contract when we want to sponsor gas for users
 * @dev     Someone need to fund this contract with ETH to use Socket Bridge
 * @dev     All functions are public, EOAs can also use this contract to use receiveWithAuthorization to deposit USDC
 */
contract LyraSponsoredForwarder is LyraForwarderBase, ERC2771Context {
    /**
     * @dev GelatoRelay1BalanceERC2771 forwarder (0xd8253782c45a12053594b9deB72d8e8aB2Fca54c) is used for all non-zkSync-EVM
     */
    constructor(
        address _usdcLocal,
        address _socketVault
    )
        payable
        LyraForwarderBase(_usdcLocal, _socketVault)
        ERC2771Context(0xd8253782c45a12053594b9deB72d8e8aB2Fca54c)
    {}

    /**
     * @notice  Deposit user USDC to L2 through Socket fast bridge
     * @dev     Users never have to approve USDC to this contract, we use receiveWithAuthorization to save gas
     *
     * @param isScwWallet   True if user wants to deposit to default LightAccount on L2
     * @param minGasLimit   Minimum gas limit for the L2 execution
     * @param connector     Socket Connector
     * @param authData      Data and signatures for receiveWithAuthorization
     */
    function depositUSDCSocketBridge(bool isScwWallet, uint32 minGasLimit, address connector, ReceiveWithAuthData calldata authData)
        external
    {
        address msgSender = _msgSender();

        IERC3009(usdcLocal).receiveWithAuthorization(
            msgSender,
            address(this),
            authData.value,
            authData.validAfter,
            authData.validBefore,
            authData.nonce,
            authData.v,
            authData.r,
            authData.s
        );

        uint256 feeInWei = ISocketVault(socketVault).getMinFees(connector, minGasLimit);

        ISocketVault(socketVault).depositToAppChain{value: feeInWei}(
            _getL2Receiver(msgSender, isScwWallet), authData.value, minGasLimit, connector
        );
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (metatx/ERC2771Context.sol)

pragma solidity ^0.8.1;

/**
 * @dev Context variant with ERC2771 support.
 */
// based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/metatx/ERC2771Context.sol
abstract contract ERC2771Context {
    address private immutable _trustedForwarder;

    constructor(address trustedForwarder) {
        _trustedForwarder = trustedForwarder;
    }

    function isTrustedForwarder(address forwarder)
        public
        view
        virtual
        returns (bool)
    {
        return forwarder == _trustedForwarder;
    }

    function _msgSender() internal view virtual returns (address sender) {
        if (isTrustedForwarder(msg.sender)) {
            // The assembly code is more direct than the Solidity version using `abi.decode`.
            /// @solidity memory-safe-assembly
            assembly {
                sender := shr(96, calldataload(sub(calldatasize(), 20)))
            }
        } else {
            return msg.sender;
        }
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        if (isTrustedForwarder(msg.sender)) {
            return msg.data[:msg.data.length - 20];
        } else {
            return msg.data;
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import {IERC20} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {ILightAccountFactory} from "../interfaces/ILightAccountFactory.sol";

/**
 * @title  LyraForwarderBase
 * @notice Shared logic for both self-paying and sponsored forwarder
 */
abstract contract LyraForwarderBase {
    // keccak256("ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)")
    bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH =
        0xd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8;

    ///@dev L1 USDC address.
    address public immutable usdcLocal;

    ///@dev SocketVault address.
    address public immutable socketVault;

    ///@dev Light Account factory address.
    ///     See this script for more info https://github.com/alchemyplatform/light-account/blob/main/script/Deploy_LightAccountFactory.s.sol
    address public constant lightAccountFactory = 0x000000893A26168158fbeaDD9335Be5bC96592E2;

    struct ReceiveWithAuthData {
        uint256 value;
        uint256 validAfter;
        uint256 validBefore;
        bytes32 nonce;
        uint8 v;
        bytes32 r;
        bytes32 s;
    }

    constructor(
        address _usdcLocal,
        address _socketVault
    ) {
        usdcLocal = _usdcLocal;
        socketVault = _socketVault;
        
        IERC20(_usdcLocal).approve(_socketVault, type(uint256).max);
    }

    /**
     * @dev Get the recipient address based on isSCW flag
     * @param sender The real sender of the transaction
     * @param isSCW  True if the sender wants to deposit to smart contract wallet
     */
    function _getL2Receiver(address sender, bool isSCW) internal view returns (address) {
        if (isSCW) {
            return ILightAccountFactory(lightAccountFactory).getAddress(sender, 0);
        } else {
            return sender;
        }
    }
}

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.9;

interface IL1StandardBridge {
    /**
     * @custom:legacy
     * @notice Deposits some amount of ETH into a target account on L2.
     *         Note that if ETH is sent to a contract on L2 and the call fails, then that ETH will
     *         be locked in the L2StandardBridge. ETH may be recoverable if the call can be
     *         successfully replayed by increasing the amount of gas supplied to the call. If the
     *         call will fail for any amount of gas, then the ETH will be locked permanently.
     *
     * @param _to          Address of the recipient on L2.
     * @param _minGasLimit Minimum gas limit for the deposit message on L2.
     * @param _extraData   Optional data to forward to L2. Data supplied here will not be used to
     *                     execute any code on L2 and is only emitted as extra data for the
     *                     convenience of off-chain tooling.
     */
    function depositETHTo(address _to, uint32 _minGasLimit, bytes calldata _extraData) external;

    /**
     * @custom:legacy
     * @notice Deposits some amount of ERC20 tokens into the sender's account on L2.
     *
     * @param _l1Token     Address of the L1 token being deposited.
     * @param _l2Token     Address of the corresponding token on L2.
     * @param _amount      Amount of the ERC20 to deposit.
     * @param _minGasLimit Minimum gas limit for the deposit message on L2.
     * @param _extraData   Optional data to forward to L2. Data supplied here will not be used to
     *                     execute any code on L2 and is only emitted as extra data for the
     *                     convenience of off-chain tooling.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _minGasLimit,
        bytes calldata _extraData
    ) external;

    /**
     * @custom:legacy
     * @notice Deposits some amount of ERC20 tokens into a target account on L2.
     *
     * @param _l1Token     Address of the L1 token being deposited.
     * @param _l2Token     Address of the corresponding token on L2.
     * @param _to          Address of the recipient on L2.
     * @param _amount      Amount of the ERC20 to deposit.
     * @param _minGasLimit Minimum gas limit for the deposit message on L2.
     * @param _extraData   Optional data to forward to L2. Data supplied here will not be used to
     *                     execute any code on L2 and is only emitted as extra data for the
     *                     convenience of off-chain tooling.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _minGasLimit,
        bytes calldata _extraData
    ) external;

    /**
     * @custom:legacy
     * @notice Finalizes a withdrawal of ETH from L2.
     *
     * @param _from      Address of the withdrawer on L2.
     * @param _to        Address of the recipient on L1.
     * @param _amount    Amount of ETH to withdraw.
     * @param _extraData Optional data forwarded from L2.
     */
    function finalizeETHWithdrawal(address _from, address _to, uint256 _amount, bytes calldata _extraData)
        external
        payable;

    /**
     * @custom:legacy
     * @notice Finalizes a withdrawal of ERC20 tokens from L2.
     *
     * @param _l1Token   Address of the token on L1.
     * @param _l2Token   Address of the corresponding token on L2.
     * @param _from      Address of the withdrawer on L2.
     * @param _to        Address of the recipient on L1.
     * @param _amount    Amount of the ERC20 to withdraw.
     * @param _extraData Optional data forwarded from L2.
     */
    function finalizeERC20Withdrawal(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _extraData
    ) external;

    /**
     * @notice Sends ERC20 tokens to a receiver's address on the other chain. Note that if the
     *         ERC20 token on the other chain does not recognize the local token as the correct
     *         pair token, the ERC20 bridge will fail and the tokens will be returned to sender on
     *         this chain.
     *
     * @param localToken  Address of the ERC20 on this chain.
     * @param remoteToken Address of the corresponding token on the remote chain.
     * @param to          Address of the receiver.
     * @param amount      Amount of local tokens to deposit.
     * @param minGasLimit Minimum amount of gas that the bridge can be relayed with.
     * @param extraData   Extra data to be sent with the transaction. Note that the recipient will
     *                     not be triggered with this data, but it will be emitted and can be used
     *                     to identify the transaction.
     */
    function bridgeERC20To(
        address localToken,
        address remoteToken,
        address to,
        uint256 amount,
        uint32 minGasLimit,
        bytes calldata extraData
    ) external;
}

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.9;

interface ISocketVault {
    function depositToAppChain(address receiver_, uint256 amount_, uint256 msgGasLimit_, address connector_)
        external
        payable;

    function __token() external view returns (address);

    function getMinFees(address connector, uint256 minGasLimit) external view returns (uint256);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

interface IERC3009 {
    /**
     * @notice Execute a transfer with a signed authorization
     * @param from          Payer's address (Authorizer)
     * @param to            Payee's address
     * @param value         Amount to be transferred
     * @param validAfter    The time after which this is valid (unix time)
     * @param validBefore   The time before which this is valid (unix time)
     * @param nonce         Unique nonce
     * @param v             v of the signature
     * @param r             r of the signature
     * @param s             s of the signature
     */
    function transferWithAuthorization(
        address from,
        address to,
        uint256 value,
        uint256 validAfter,
        uint256 validBefore,
        bytes32 nonce,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @notice Receive a transfer with a signed authorization from the payer
     * @dev This has an additional check to ensure that the payee's address matches
     * the caller of this function to prevent front-running attacks. (See security
     * considerations)
     * @param from          Payer's address (Authorizer)
     * @param to            Payee's address
     * @param value         Amount to be transferred
     * @param validAfter    The time after which this is valid (unix time)
     * @param validBefore   The time before which this is valid (unix time)
     * @param nonce         Unique nonce
     * @param v             v of the signature
     * @param r             r of the signature
     * @param s             s of the signature
     */
    function receiveWithAuthorization(
        address from,
        address to,
        uint256 value,
        uint256 validAfter,
        uint256 validBefore,
        bytes32 nonce,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

interface ILightAccountFactory {
    /**
     * @notice Create an account, and return its address.
     * Returns the address even if the account is already deployed.
     * @dev During UserOperation execution, this method is called only if the account is not deployed.
     * This method returns an existing account address so that entryPoint.getSenderAddress() would work even after account creation.
     * @param owner The owner of the account to be created
     * @param salt A salt, which can be changed to create multiple accounts with the same owner
     * @return ret The address of either the newly deployed account or an existing account with this owner and salt
     */
    function createAccount(address owner, uint256 salt) external returns (address ret);

    /**
     * @notice Calculate the counterfactual address of this account as it would be returned by createAccount()
     * @param owner The owner of the account to be created
     * @param salt A salt, which can be changed to create multiple accounts with the same owner
     * @return The address of the account that would be created with createAccount()
     */
    function getAddress(address owner, uint256 salt) external view returns (address);
}

{
  "remappings": [
    "account-abstraction/=lib/account-abstraction/contracts/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "account-abstraction/=lib/account-abstraction/contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts/contracts/",
    "relay-context-contracts/=lib/relay-context-contracts/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 2000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_usdcLocal","type":"address"},{"internalType":"address","name":"_socketVault","type":"address"}],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"RECEIVE_WITH_AUTHORIZATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"isScwWallet","type":"bool"},{"internalType":"uint32","name":"minGasLimit","type":"uint32"},{"internalType":"address","name":"connector","type":"address"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct LyraForwarderBase.ReceiveWithAuthData","name":"authData","type":"tuple"}],"name":"depositUSDCSocketBridge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lightAccountFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"socketVault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"usdcLocal","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000006d303cee7959f814042d31e0624fb88ec6fbcc1d

-----Decoded View---------------
Arg [0] : _usdcLocal (address): 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
Arg [1] : _socketVault (address): 0x6D303CEE7959f814042D31E0624fB88Ec6fbcC1d

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [1] : 0000000000000000000000006d303cee7959f814042d31e0624fb88ec6fbcc1d

701:1726:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;756:36:2;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;178:55:8;;;160:74;;148:2;133:18;756:36:2;;;;;;;;1618:772:3;;;;;;;;;;-1:-1:-1;1618:772:3;;;;;:::i;:::-;;:::i;:::-;;489:172:1;;;;;;;;;;-1:-1:-1;489:172:1;;;;;:::i;:::-;637:17;-1:-1:-1;;;;;624:30:1;;;;;;;489:172;;;;1640:14:8;;1633:22;1615:41;;1603:2;1588:18;489:172:1;1475:187:8;983:88:2;;;;;;;;;;;;1029:42;983:88;;510:136;;;;;;;;;;-1:-1:-1;510:136:2;580:66;510:136;;;;;1813:25:8;;;1801:2;1786:18;510:136:2;1667:177:8;682:34:2;;;;;;;;;;;;;;;1618:772:3;1778:17;1798:12;:10;:12::i;:::-;1778:32;-1:-1:-1;;;;;;1830:9:3;1821:44;;1778:32;1910:4;1929:14;;1957:19;;;;1990:20;;;;2024:14;;;;2052:10;;;;;;;;:::i;:::-;1821:299;;;;;;;;;;-1:-1:-1;;;;;2569:15:8;;;1821:299:3;;;2551:34:8;2621:15;;;;2601:18;;;2594:43;2653:18;;;2646:34;;;;2696:18;;;2689:34;;;;2739:19;;;2732:35;2783:19;;;2776:35;2860:4;2848:17;2827:19;;;2820:46;2076:10:3;;;;2882:19:8;;;2875:35;2100:10:3;;;;2926:19:8;;;2919:35;2462:19;;1821:299:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2150:60:3;;;;;-1:-1:-1;;;;;3156:55:8;;;2150:60:3;;;3138:74:8;3260:10;3248:23;;3228:18;;;3221:51;2131:16:3;;-1:-1:-1;2163:11:3;2150:36;;-1:-1:-1;2150:36:3;;3111:18:8;;2150:60:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2131:79;;2234:11;-1:-1:-1;;;;;2221:43:3;;2272:8;2295:38;2310:9;2321:11;2295:14;:38::i;:::-;2221:162;;;;;;;;;;-1:-1:-1;;;;;3781:15:8;;;2221:162:3;;;3763:34:8;2335:14:3;;3813:18:8;;;3806:34;3888:10;3876:23;;3856:18;;;3849:51;3936:15;;;3916:18;;;3909:43;3674:19;;2221:162:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1768:622;;1618:772;;;;:::o;667:431:1:-;720:14;637:17;-1:-1:-1;;;;;624:30:1;769:10;624:30;746:346;;-1:-1:-1;995:23:1;999:14;995:23;982:37;978:2;974:46;667:431;:::o;746:346::-;-1:-1:-1;1071:10:1;;667:431::o;1723:250:2:-;1798:7;1821:5;1817:150;;;1849:63;;;;;-1:-1:-1;;;;;4163:55:8;;1849:63:2;;;4145:74:8;1910:1:2;4235:18:8;;;4228:34;1029:42:2;;1849:52;;4118:18:8;;1849:63:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1842:70;;;;1817:150;-1:-1:-1;1950:6:2;1817:150;1723:250;;;;:::o;245:154:8:-;-1:-1:-1;;;;;324:5:8;320:54;313:5;310:65;300:93;;389:1;386;379:12;300:93;245:154;:::o;404:814::-;524:6;532;540;548;592:9;583:7;579:23;622:3;618:2;614:12;611:32;;;639:1;636;629:12;611:32;678:9;665:23;731:5;724:13;717:21;710:5;707:32;697:60;;753:1;750;743:12;697:60;776:5;-1:-1:-1;833:2:8;818:18;;805:32;881:10;868:24;;856:37;;846:65;;907:1;904;897:12;846:65;930:7;-1:-1:-1;989:2:8;974:18;;961:32;1002:33;961:32;1002:33;:::i;:::-;1054:7;-1:-1:-1;1154:3:8;1085:66;1077:75;;1073:85;1070:105;;;1171:1;1168;1161:12;1070:105;-1:-1:-1;404:814:8;;;;-1:-1:-1;404:814:8;1209:2;1194:18;;-1:-1:-1;404:814:8:o;1223:247::-;1282:6;1335:2;1323:9;1314:7;1310:23;1306:32;1303:52;;;1351:1;1348;1341:12;1303:52;1390:9;1377:23;1409:31;1434:5;1409:31;:::i;:::-;1459:5;1223:247;-1:-1:-1;;;1223:247:8:o;1849:269::-;1906:6;1959:2;1947:9;1938:7;1934:23;1930:32;1927:52;;;1975:1;1972;1965:12;1927:52;2014:9;2001:23;2064:4;2057:5;2053:16;2046:5;2043:27;2033:55;;2084:1;2081;2074:12;3283:184;3353:6;3406:2;3394:9;3385:7;3381:23;3377:32;3374:52;;;3422:1;3419;3412:12;3374:52;-1:-1:-1;3445:16:8;;3283:184;-1:-1:-1;3283:184:8:o;4273:251::-;4343:6;4396:2;4384:9;4375:7;4371:23;4367:32;4364:52;;;4412:1;4409;4402:12;4364:52;4444:9;4438:16;4463:31;4488:5;4463:31;:::i

ipfs://985cf73a34e016bd3e5a983636d6d5222164277af4b3db33fa02291503c2707c