Contract 0xbB66C7AB830024f0DFbf60ca9Af3BBD573b0790D

 
Txn Hash Method
Block
From
To
Value
0x686b8511f144d9dbbddebfcd2950f2096900292a8325f7de0b4a30bf45e8a4610x60a06040138253102022-07-04 15:13:16633 days 18 hrs agoFirn: Deployer IN  Create: DepositVerifier0 ETH0.0041469738820.001333333
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
DepositVerifier

Compiler Version
v0.8.15+commit.e14f2714

Optimization Enabled:
Yes with 10000 runs

Other Settings:
default evmVersion, Apache-2.0 license

Contract Source Code (Solidity Multiple files format)

File 1 of 4: DepositVerifier.sol
// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.15;

import "./IDepositVerifier.sol";
import "./InnerProductVerifier.sol";
import "./Utils.sol";

contract DepositVerifier is IDepositVerifier {
    using Utils for uint256;
    using Utils for Utils.Point;

    InnerProductVerifier immutable innerProductVerifier;

    constructor(address _innerProductVerifier) {
        innerProductVerifier = InnerProductVerifier(_innerProductVerifier);
    }

    function g() internal view returns (Utils.Point memory) {
        return Utils.Point(innerProductVerifier.gX(), innerProductVerifier.gY());
    }

    function h() internal view returns (Utils.Point memory) {
        return Utils.Point(innerProductVerifier.hX(), innerProductVerifier.hY());
    }

    function gs(uint256 i) internal view returns (Utils.Point memory) {
        (bytes32 x, bytes32 y) = innerProductVerifier.gs(i);
        return Utils.Point(x, y);
    }

    function hs(uint256 i) internal view returns (Utils.Point memory) {
        (bytes32 x, bytes32 y) = innerProductVerifier.hs(i);
        return Utils.Point(x, y);
    }

    struct Locals {
        uint256 v;
        uint256 w;
        uint256 vPow;
        uint256 wPow;
        uint256[n][2] f; // could just allocate extra space in the proof?
        uint256[N] r; // each poly is an array of length N. evaluations of prods
        Utils.Point temp;
        Utils.Point C_XR;
        Utils.Point y_XR;

        uint256 c;
        Utils.Point A_D;
        Utils.Point A_X;
    }

    function verify(uint256 amount, Utils.Statement calldata statement, Utils.DepositProof calldata proof) external view {
        Locals memory locals;
        locals.v = uint256(keccak256(abi.encode(amount, statement.Y, statement.C, statement.D, proof.A, proof.B))).mod();
        locals.w = uint256(keccak256(abi.encode(locals.v, proof.C_XG, proof.y_XG))).mod();
        for (uint256 k = 0; k < n; k++) {
            locals.f[1][k] = proof.f[k];
            locals.f[0][k] = locals.w.sub(proof.f[k]);

            locals.temp = locals.temp.add(gs(k).mul(locals.f[1][k]));
            locals.temp = locals.temp.add(hs(k).mul(locals.f[1][k].mul(locals.f[0][k])));
        }
        require(proof.B.mul(locals.w).add(proof.A).eq(locals.temp.add(h().mul(proof.z_A))), "Bit-proof verification failed.");

        locals.r = Utils.assemblePolynomials(locals.f);
        locals.wPow = 1;
        for (uint256 k = 0; k < n; k++) {
            locals.C_XR = locals.C_XR.add(proof.C_XG[k].mul(locals.wPow.neg()));
            locals.y_XR = locals.y_XR.add(proof.y_XG[k].mul(locals.wPow.neg()));

            locals.wPow = locals.wPow.mul(locals.w);
        }
        locals.vPow = locals.v; // used to be 1
        for (uint256 i = 0; i < N; i++) {
            uint256 multiplier = locals.r[i].add(locals.vPow.mul(locals.wPow.sub(locals.r[i]))); // locals. ?
            locals.C_XR = locals.C_XR.add(statement.C[i].mul(multiplier));
            locals.y_XR = locals.y_XR.add(statement.Y[i].mul(multiplier));
            locals.vPow = locals.vPow.mul(locals.v); // used to do this only if (i > 0)
        }
        locals.C_XR = locals.C_XR.add(g().mul(amount.neg().mul(locals.wPow))); // this line is new

        locals.A_D = g().mul(proof.s_r).add(statement.D.mul(proof.c.neg())); // add(mul(locals.gR, proof.s_r), mul(locals.DR, proof.c.neg()));
        locals.A_X = locals.y_XR.mul(proof.s_r).add(locals.C_XR.mul(proof.c.neg()));

        locals.c = uint256(keccak256(abi.encode(locals.v, locals.A_D, locals.A_X))).mod();
        require(locals.c == proof.c, "Sigma protocol failure.");
    }
}

File 2 of 4: IDepositVerifier.sol
// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.15;

import "./Utils.sol";

interface IDepositVerifier {
    function verify(uint256 amount, Utils.Statement calldata statement, Utils.DepositProof calldata proof) external view;
}

File 3 of 4: InnerProductVerifier.sol
// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.15;

import "./Utils.sol";

contract InnerProductVerifier {
    using Utils for uint256;
    using Utils for Utils.Point;

    bytes32 public immutable gX;
    bytes32 public immutable gY;
    bytes32 public immutable hX;
    bytes32 public immutable hY;
    // above, emulating immutable `Utils.Point`s using raw `bytes32`s. save some sloads later.
    Utils.Point[M << 1] public gs;
    Utils.Point[M << 1] public hs;
    // have to use storage, not immutable, because solidity doesn't support non-primitive immutable types

    constructor() {
        Utils.Point memory gTemp = Utils.mapInto("g");
        gX = gTemp.x;
        gY = gTemp.y;
        Utils.Point memory hTemp = Utils.mapInto("h");
        hX = hTemp.x;
        hY = hTemp.y;
        for (uint256 i = 0; i < M << 1; i++) {
            gs[i] = Utils.mapInto("g", i);
            hs[i] = Utils.mapInto("h", i);
        }
    }

    struct Locals {
        uint256 o;
        Utils.Point P;
        uint256[m + 1] challenges;
        uint256[M << 1] s;
    }

    function verify(Utils.InnerProductStatement calldata statement, Utils.InnerProductProof calldata proof, bool transfer) external view {
        Locals memory locals;
        locals.o = statement.salt;
        locals.P = statement.P;
        uint256 M_ = M << (transfer ? 1 : 0);
        uint256 m_ = m + (transfer ? 1 : 0);

        for (uint256 i = 0; i < m_; i++) {
            locals.o = uint256(keccak256(abi.encode(locals.o, proof.L[i], proof.R[i]))).mod(); // overwrites
            locals.challenges[i] = locals.o;
            uint256 inverse = locals.o.inv();
            locals.P = locals.P.add(proof.L[i].mul(locals.o.mul(locals.o))).add(proof.R[i].mul(inverse.mul(inverse)));
        }

        locals.s[0] = 1;
        for (uint256 i = 0; i < m_; i++) locals.s[0] = locals.s[0].mul(locals.challenges[i]);
        locals.s[0] = locals.s[0].inv();
        for (uint256 i = 0; i < m_; i++) {
            for (uint256 j = 0; j < M_; j += 1 << m_ - i) {
                locals.s[j + (1 << m_ - i - 1)] = locals.s[j].mul(locals.challenges[i]).mul(locals.challenges[i]);
            }
        }

        Utils.Point memory temp = statement.u.mul(proof.a.mul(proof.b));
        for (uint256 i = 0; i < M_; i++) {
            temp = temp.add(gs[i].mul(locals.s[i].mul(proof.a)));
            temp = temp.add(statement.hs[i].mul(locals.s[M_ - 1 - i].mul(proof.b)));
        }
        require(temp.eq(locals.P), "Inner product proof failed.");
    }
}

File 4 of 4: Utils.sol
// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.15;

uint256 constant n = 4;
uint256 constant N = 1 << n;
uint256 constant m = 5;
uint256 constant M = 1 << m;

library Utils {
    uint256 constant GROUP_ORDER = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001;
    uint256 constant FIELD_ORDER = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47;
    uint256 constant PPLUS1DIV4 = 0x0c19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52;

    function add(uint256 x, uint256 y) internal pure returns (uint256) {
        return addmod(x, y, GROUP_ORDER);
    }

    function mul(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulmod(x, y, GROUP_ORDER);
    }

    function inv(uint256 x) internal view returns (uint256) {
        return exp(x, GROUP_ORDER - 2);
    }

    function mod(uint256 x) internal pure returns (uint256) {
        return x % GROUP_ORDER;
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256) {
        return x >= y ? x - y : GROUP_ORDER - y + x;
    }

    function neg(uint256 x) internal pure returns (uint256) {
        return GROUP_ORDER - x;
    }

    function exp(uint256 base, uint256 exponent) internal view returns (uint256 output) {
        uint256 order = GROUP_ORDER;
        assembly {
            let location := mload(0x40)
            mstore(location, 0x20)
            mstore(add(location, 0x20), 0x20)
            mstore(add(location, 0x40), 0x20)
            mstore(add(location, 0x60), base)
            mstore(add(location, 0x80), exponent)
            mstore(add(location, 0xa0), order)
            if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) {
                revert(0, 0)
            }
            output := mload(location)
        }
    }

    function fieldExp(uint256 base, uint256 exponent) internal view returns (uint256 output) { // warning: mod p, not q
        uint256 order = FIELD_ORDER;
        assembly {
            let location := mload(0x40)
            mstore(location, 0x20)
            mstore(add(location, 0x20), 0x20)
            mstore(add(location, 0x40), 0x20)
            mstore(add(location, 0x60), base)
            mstore(add(location, 0x80), exponent)
            mstore(add(location, 0xa0), order)
            if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) {
                revert(0, 0)
            }
            output := mload(location)
        }
    }

    struct Point {
        bytes32 x;
        bytes32 y;
    }

    function add(Point memory p1, Point memory p2) internal view returns (Point memory r) {
        assembly {
            let location := mload(0x40)
            mstore(location, mload(p1))
            mstore(add(location, 0x20), mload(add(p1, 0x20)))
            mstore(add(location, 0x40), mload(p2))
            mstore(add(location, 0x60), mload(add(p2, 0x20)))
            if iszero(staticcall(gas(), 0x06, location, 0x80, r, 0x40)) {
                revert(0, 0)
            }
        }
    }

    function mul(Point memory p, uint256 s) internal view returns (Point memory r) {
        assembly {
            let location := mload(0x40)
            mstore(location, mload(p))
            mstore(add(location, 0x20), mload(add(p, 0x20)))
            mstore(add(location, 0x40), s)
            if iszero(staticcall(gas(), 0x07, location, 0x60, r, 0x40)) {
                revert(0, 0)
            }
        }
    }

    function neg(Point memory p) internal pure returns (Point memory) {
        return Point(p.x, bytes32(FIELD_ORDER - uint256(p.y))); // p.y should already be reduced mod P?
    }

    function eq(Point memory p1, Point memory p2) internal pure returns (bool) {
        return p1.x == p2.x && p1.y == p2.y;
    }

    function decompress(bytes32 input) internal view returns (Point memory) {
        if (input == 0x00) return Point(0x00, 0x00);
        uint256 x = uint256(input);
        uint256 sign = (x & 0x8000000000000000000000000000000000000000000000000000000000000000) >> 255;
        x &= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
        uint256 ySquared = fieldExp(x, 3) + 3;
        uint256 y = fieldExp(ySquared, PPLUS1DIV4);
        Point memory result = Point(bytes32(x), bytes32(y));
        if (sign != y & 0x01) return neg(result);
        return result;
    }

    function compress(Point memory input) internal pure returns (bytes32) {
        uint256 result = uint256(input.x);
        if (uint256(input.y) & 0x01 == 0x01) result |= 0x8000000000000000000000000000000000000000000000000000000000000000;
        return bytes32(result);
    }

    function mapInto(uint256 seed) internal view returns (Point memory) {
        uint256 y;
        while (true) {
            uint256 ySquared = fieldExp(seed, 3) + 3; // addmod instead of add: waste of gas, plus function overhead cost
            y = fieldExp(ySquared, PPLUS1DIV4);
            if (fieldExp(y, 2) == ySquared) {
                break;
            }
            seed += 1;
        }
        return Point(bytes32(seed), bytes32(y));
    }

    function mapInto(string memory input) internal view returns (Point memory) {
        return mapInto(uint256(keccak256(abi.encodePacked(input))) % FIELD_ORDER);
    }

    function mapInto(string memory input, uint256 i) internal view returns (Point memory) {
        return mapInto(uint256(keccak256(abi.encodePacked(input, i))) % FIELD_ORDER);
    }

    function slice(bytes memory input, uint256 start) internal pure returns (bytes32 result) {
        assembly {
            result := mload(add(add(input, 0x20), start))
        }
    }

    struct Statement {
        Point[N] Y;
        Point[N] CLn;
        Point[N] CRn;
        Point[N] C;
        Point D;
        uint256 epoch;
        Point u;
        uint256 fee;
    }

    struct DepositProof {
        Point A;
        Point B;

        Point[n] C_XG;
        Point[n] y_XG;

        uint256[n] f;
        uint256 z_A;

        uint256 c;
        uint256 s_r;
    }

    function deserializeDeposit(bytes memory arr) internal view returns (DepositProof memory proof) {
        proof.A = decompress(slice(arr, 0));
        proof.B = decompress(slice(arr, 32));

        for (uint256 k = 0; k < n; k++) {
            proof.C_XG[k] = decompress(slice(arr, 64 + k * 32));
            proof.y_XG[k] = decompress(slice(arr, 64 + (k + n) * 32));
            proof.f[k] = uint256(slice(arr, 64 + n * 64 + k * 32));
        }
        uint256 starting = n * 96;
        proof.z_A = uint256(slice(arr, 64 + starting));

        proof.c = uint256(slice(arr, 96 + starting));
        proof.s_r = uint256(slice(arr, 128 + starting));

        return proof;
    }

    struct TransferProof {
        Point BA;
        Point BS;
        Point A;
        Point B;

        Point[n] CLnG;
        Point[n] CRnG;
        Point[n] C_0G;
        Point[n] DG;
        Point[n] y_0G;
        Point[n] gG;
        Point[n] C_XG;
        Point[n] y_XG;

        uint256[n][2] f;
        uint256 z_A;

        Point T_1;
        Point T_2;
        uint256 tHat;
        uint256 mu;

        uint256 c;
        uint256 s_sk;
        uint256 s_r;
        uint256 s_b;
        uint256 s_tau;

        InnerProductProof ip;
    }

    function deserializeTransfer(bytes memory arr) internal view returns (TransferProof memory proof) {
        proof.BA = decompress(slice(arr, 0));
        proof.BS = decompress(slice(arr, 32));
        proof.A = decompress(slice(arr, 64));
        proof.B = decompress(slice(arr, 96));

        for (uint256 k = 0; k < n; k++) {
            proof.CLnG[k] = decompress(slice(arr, 128 + k * 32));
            proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32));
            proof.C_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32));
            proof.DG[k] = decompress(slice(arr, 128 + n * 96 + k * 32));
            proof.y_0G[k] = decompress(slice(arr, 128 + n * 128 + k * 32));
            proof.gG[k] = decompress(slice(arr, 128 + n * 160 + k * 32));
            proof.C_XG[k] = decompress(slice(arr, 128 + n * 192 + k * 32));
            proof.y_XG[k] = decompress(slice(arr, 128 + n * 224 + k * 32));
            proof.f[0][k] = uint256(slice(arr, 128 + n * 256 + k * 32));
            proof.f[1][k] = uint256(slice(arr, 128 + n * 288 + k * 32));
        }

        uint256 starting = n * 320;
        proof.z_A = uint256(slice(arr, 128 + starting));

        proof.T_1 = decompress(slice(arr, 160 + starting));
        proof.T_2 = decompress(slice(arr, 192 + starting));
        proof.tHat = uint256(slice(arr, 224 + starting));
        proof.mu = uint256(slice(arr, 256 + starting));

        proof.c = uint256(slice(arr, 288 + starting));
        proof.s_sk = uint256(slice(arr, 320 + starting));
        proof.s_r = uint256(slice(arr, 352 + starting));
        proof.s_b = uint256(slice(arr, 384 + starting));
        proof.s_tau = uint256(slice(arr, 416 + starting));

        for (uint256 i = 0; i < m + 1; i++) {
            proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32));
            proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m + 1) * 32));
        }
        proof.ip.a = uint256(slice(arr, 448 + starting + (m + 1) * 64));
        proof.ip.b = uint256(slice(arr, 480 + starting + (m + 1) * 64));

        return proof;
    }

    struct WithdrawalProof {
        Point BA;
        Point BS;
        Point A;
        Point B;

        Point[n] CLnG;
        Point[n] CRnG;
        Point[n] y_0G;
        Point[n] gG;
        Point[n] C_XG;
        Point[n] y_XG;

        uint256[n] f;
        uint256 z_A;

        Point T_1;
        Point T_2;
        uint256 tHat;
        uint256 mu;

        uint256 c;
        uint256 s_sk;
        uint256 s_r;
        uint256 s_b;
        uint256 s_tau;

        InnerProductProof ip;
    }

    function deserializeWithdrawal(bytes memory arr) internal view returns (WithdrawalProof memory proof) {
        proof.BA = decompress(slice(arr, 0));
        proof.BS = decompress(slice(arr, 32));
        proof.A = decompress(slice(arr, 64));
        proof.B = decompress(slice(arr, 96));

        for (uint256 k = 0; k < n; k++) {
            proof.CLnG[k] = decompress(slice(arr, 128 + k * 32));
            proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32));
            proof.y_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32));
            proof.gG[k] = decompress(slice(arr, 128 + n * 96 + k * 32));
            proof.C_XG[k] = decompress(slice(arr, 128 + n * 128 + k * 32));
            proof.y_XG[k] = decompress(slice(arr, 128 + n * 160 + k * 32));
            proof.f[k] = uint256(slice(arr, 128 + n * 192 + k * 32));
        }
        uint256 starting = n * 224;
        proof.z_A = uint256(slice(arr, 128 + starting));

        proof.T_1 = decompress(slice(arr, 160 + starting));
        proof.T_2 = decompress(slice(arr, 192 + starting));
        proof.tHat = uint256(slice(arr, 224 + starting));
        proof.mu = uint256(slice(arr, 256 + starting));

        proof.c = uint256(slice(arr, 288 + starting));
        proof.s_sk = uint256(slice(arr, 320 + starting));
        proof.s_r = uint256(slice(arr, 352 + starting));
        proof.s_b = uint256(slice(arr, 384 + starting));
        proof.s_tau = uint256(slice(arr, 416 + starting));

        for (uint256 i = 0; i < m; i++) { // will leave the `m`th element empty
            proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32));
            proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m) * 32));
        }
        proof.ip.a = uint256(slice(arr, 448 + starting + m * 64));
        proof.ip.b = uint256(slice(arr, 480 + starting + m * 64));

        return proof;
    }

    struct InnerProductStatement {
        uint256 salt;
        Point[M << 1] hs; // "overridden" parameters.
        Point u;
        Point P;
    }

    struct InnerProductProof {
        Point[m + 1] L;
        Point[m + 1] R;
        uint256 a;
        uint256 b;
    }

    function assemblePolynomials(uint256[n][2] memory f) internal pure returns (uint256[N] memory result) {
        // f is a 2m-by-2 array... containing the f's and x - f's, twice (i.e., concatenated).
        // output contains two "rows", each of length N.
        result[0] = 1;
        for (uint256 k = 0; k < n; k++) {
            for (uint256 i = 0; i < N; i += 1 << n - k) {
                result[i + (1 << n - 1 - k)] = mul(result[i], f[1][n - 1 - k]);
                result[i] = mul(result[i], f[0][n - 1 - k]);
            }
        }
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_innerProductVerifier","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"components":[{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"Y","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"CLn","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"CRn","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"C","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"D","type":"tuple"},{"internalType":"uint256","name":"epoch","type":"uint256"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"u","type":"tuple"},{"internalType":"uint256","name":"fee","type":"uint256"}],"internalType":"struct Utils.Statement","name":"statement","type":"tuple"},{"components":[{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"A","type":"tuple"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"B","type":"tuple"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[4]","name":"C_XG","type":"tuple[4]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[4]","name":"y_XG","type":"tuple[4]"},{"internalType":"uint256[4]","name":"f","type":"uint256[4]"},{"internalType":"uint256","name":"z_A","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"},{"internalType":"uint256","name":"s_r","type":"uint256"}],"internalType":"struct Utils.DepositProof","name":"proof","type":"tuple"}],"name":"verify","outputs":[],"stateMutability":"view","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000cef468199f67ea54cd326d6470defd69378ea92b

-----Decoded View---------------
Arg [0] : _innerProductVerifier (address): 0xcef468199f67EA54CD326D6470DefD69378Ea92B

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000cef468199f67ea54cd326d6470defd69378ea92b


Deployed ByteCode Sourcemap

158:3454:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1524:2086;;;;;;:::i;:::-;;:::i;:::-;;;1651:20;;:::i;:::-;1777:7;1710:75;;1692:101;;1710:75;;1721:6;;1729:9;;1742:11;;;;1755;;;;1768:5;;1777:7;;;1710:75;;;:::i;:::-;;;;;;;;;;;;;1700:86;;;;;;1692:95;;:99;:101::i;:::-;1681:112;;;1832:44;;1814:70;;1832:44;;1853:10;;;;1865;;;;1832:44;;;:::i;1814:70::-;1803:8;;;:81;1899:9;1894:300;86:1:3;1914::0;:5;1894:300;;;1957:5;:7;;1965:1;1957:10;;;;;;;:::i;:::-;;;;;1940:6;:8;;;1949:1;1940:11;;;;;;;:::i;:::-;;;;;1952:1;1940:14;;;;;;;:::i;:::-;;;;:27;1998:24;2011:7;;;2019:1;2011:10;;;;;;;:::i;:::-;;1998:8;;;;;2011:10;;;;1998:12;:24::i;:::-;1981:8;;;;:11;1993:1;1981:14;;;;;;;:::i;:::-;;;;:41;2077:8;;;;2051:42;;2067:25;;2086:1;2077:11;;;;2089:1;2077:14;;;;;;;:::i;:::-;;;;;2067:5;2070:1;2067:2;:5::i;:::-;:9;;:25::i;:::-;2051:11;;;;;:15;:42::i;:::-;2037:11;;;:56;2166:8;;;;:11;2121:62;;2137:45;;2147:34;;2178:1;2166:14;;;;;;;:::i;:::-;;;;;2147:8;;;;2156:1;2147:11;;;;2159:1;2147:14;;;;;;;:::i;:::-;;;;;;:18;:34::i;:::-;2137:5;2140:1;2137:2;:5::i;2121:62::-;2107:11;;;:76;1921:3;;;;:::i;:::-;;;;1894:300;;;;2211:74;2249:35;2265:18;2273:5;:9;;;2265:3;:1;:3::i;2249:35::-;2211:34;;;;;;;;2237:5;2211:34;:::i;:::-;2223:8;;;;2211:21;;:11;;;;;;;:7;;;:11;:::i;:21::-;:25;;:34::i;:::-;:37;;:74::i;:::-;2203:117;;;;;;;4654:2:4;2203:117:0;;;4636:21:4;4693:2;4673:18;;;4666:30;4732:32;4712:18;;;4705:60;4782:18;;2203:117:0;;;;;;;;;2342:35;2368:6;:8;;;2342:25;:35::i;:::-;2331:8;;;:46;2401:1;2387:11;;;:15;-1:-1:-1;2412:259:0;86:1:3;2432::0;:5;2412:259;;;2472:53;2488:36;2506:17;:6;:11;;;:15;:17::i;:::-;2488:5;:10;;2499:1;2488:13;;;;;;;:::i;:::-;;;;:17;;;;;;;;;;:::i;:36::-;2472:11;;;;;:15;:53::i;:::-;2458:6;:11;;:67;;;;2553:53;2569:36;2587:17;:6;:11;;;:15;:17::i;:::-;2569:5;:10;;2580:1;2569:13;;;;;;;:::i;:36::-;2553:11;;;;;:15;:53::i;:::-;2539:11;;;:67;2651:8;;;;2635:11;;;;:25;;:15;:25::i;:::-;2621:11;;;:39;2439:3;;;;:::i;:::-;;;;2412:259;;;-1:-1:-1;2694:8:0;;2680:11;;;:22;2694:8;2728:391;110:6:3;2748:5:0;;2728:391;;;2774:18;2795:62;2811:45;2827:28;2843:6;:8;;;2852:1;2843:11;;;;;;;:::i;:::-;;;;;2827;;;;;:15;:28::i;:::-;2811:11;;;;;:15;:45::i;:::-;2795:6;:8;;;2804:1;2795:11;;;;;;;:::i;:::-;;;;;;:15;:62::i;:::-;2774:83;;2898:47;2914:30;2933:10;2914:9;:11;;2926:1;2914:14;;;;;;;:::i;:30::-;2898:11;;;;;:15;:47::i;:::-;2884:11;;;:61;2973:47;2989:30;3008:10;2989:9;3001:1;2989:14;;;;;;;:::i;:30::-;2973:11;;;;;:15;:47::i;:::-;2959:11;;;:61;3064:8;;3048:11;;;;:25;;:15;:25::i;:::-;3034:11;;;:39;-1:-1:-1;2755:3:0;;;;:::i;:::-;;;;2728:391;;;;3142:55;3158:38;3166:29;3183:6;:11;;;3166:12;:6;:10;:12::i;:::-;:16;;:29::i;:::-;3158:3;:1;:3::i;:38::-;3142:11;;;;;:15;:55::i;:::-;3128:11;;;:69;3241:54;3264:30;3280:13;:7;;;;:11;:13::i;:::-;3264:15;;;;;;;:11;;;:15;:::i;:30::-;3241:18;3249:5;:9;;;3241:3;:1;:3::i;:54::-;3228:10;;;:67;3384:62;3415:30;3431:13;:7;;;;:11;:13::i;:::-;3415:11;;;;;:15;:30::i;:::-;3384:11;;;;:26;;3400:9;;;;3384:15;:26::i;:62::-;3371:10;;;:75;;;3497:8;;3507:10;;;;3486:44;;3468:70;;3486:44;;3497:8;3507:10;3486:44;;;:::i;3468:70::-;3457:8;;;:81;;;3568:7;;;;3556:19;3548:55;;;;;;;5615:2:4;3548:55:0;;;5597:21:4;5654:2;5634:18;;;5627:30;5693:25;5673:18;;;5666:53;5736:18;;3548:55:0;5413:347:4;3548:55:0;1641:1969;1524:2086;;;:::o;854:95:3:-;901:7;927:15;223:66;927:1;:15;:::i;:::-;920:22;854:95;-1:-1:-1;;854:95:3:o;955:127::-;1013:7;1044:1;1039;:6;;:36;;1074:1;1056:15;1070:1;223:66;1056:15;:::i;:::-;:19;;;;:::i;:::-;1039:36;;;1048:5;1052:1;1048;:5;:::i;:::-;1032:43;955:127;-1:-1:-1;;;955:127:3:o;764:168:0:-;-1:-1:-1;;;;;;;;;;;;;;;;;865:26:0;;;;;;;;6634:25:4;;;841:9:0;;;;865:23;:20;:23;;;;6607:18:4;;865:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;908:17;;;;;;;;;;;;;;;;;764:168;-1:-1:-1;;;;764:168:0:o;3053:415:3:-;-1:-1:-1;;;;;;;;;;;;;;;;;3187:4:3;3181:11;3228:1;3222:8;3212;3205:26;3285:4;3282:1;3278:12;3272:19;3265:4;3255:8;3251:19;3244:48;3333:1;3326:4;3316:8;3312:19;3305:30;3401:4;3398:1;3392:4;3382:8;3376:4;3369:5;3358:48;3348:104;;3436:1;3433;3426:12;3348:104;;3053:415;;;;:::o;2553:494::-;-1:-1:-1;;;;;;;;;;;;;;;;;2694:4:3;2688:11;2735:2;2729:9;2719:8;2712:27;2794:4;2790:2;2786:13;2780:20;2773:4;2763:8;2759:19;2752:49;2848:2;2842:9;2835:4;2825:8;2821:19;2814:38;2907:4;2903:2;2899:13;2893:20;2886:4;2876:8;2872:19;2865:49;2980:4;2977:1;2971:4;2961:8;2955:4;2948:5;2937:48;2927:104;;3015:1;3012;3005:12;623:116;681:7;223:66;717:1;714;707:25;700:32;623:116;-1:-1:-1;;;623:116:3:o;938:168:0:-;-1:-1:-1;;;;;;;;;;;;;;;;;1039:26:0;;;;;;;;6634:25:4;;;1015:9:0;;;;1039:23;:20;:23;;;;6607:18:4;;1039:26:0;6488:177:4;613:145:0;-1:-1:-1;;;;;;;;;;;;;;;;;686:65:0;;;;;;;;698:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;686:65;;;;725:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;686:65;;679:72;613:145;-1:-1:-1;613:145:0:o;3657:127:3:-;3757:4;;3749;;3726;;3749:12;:28;;;;-1:-1:-1;;3773:4:3;;;;;3765;;;:12;;3657:127::o;12046:549::-;12122:24;;:::i;:::-;12322:1;12310:13;;12317:1;12333:256;86:1;12353;:5;12333:256;;;12384:9;12379:200;110:6;12399:5;;12379:200;;;12472:31;12476:6;12483:1;12476:9;;;;;;;:::i;:::-;;;;;12487:1;12489;12487:4;;;;;12500:1;12492:5;12496:1;86;12492:5;:::i;:::-;:9;;;;:::i;:::-;12487:15;;;;;;;:::i;:::-;;;;;12472:3;:31::i;:::-;12441:6;12466:1;12458:5;12462:1;86;12458:5;:::i;:::-;:9;;;;:::i;:::-;12448:20;;12453:1;:14;;12448:1;:20;:::i;:::-;12441:28;;;;;;;:::i;:::-;;;;:62;12533:31;12537:6;12544:1;12537:9;;;;;;;:::i;:::-;;;;;12548:1;12550;12548:4;;12533:31;12521:6;12528:1;12521:9;;;;;;;:::i;:::-;;;;:43;12416:5;12420:1;86;12416:5;:::i;:::-;12406:15;;12411:1;:10;;12406:15;;:::i;:::-;;;12379:200;;;-1:-1:-1;12360:3:3;;;;:::i;:::-;;;;12333:256;;;;12046:549;;;:::o;1088:95::-;1135:7;1161:15;1175:1;223:66;1161:15;:::i;501:116::-;559:7;223:66;595:1;592;585:25;578:32;501:116;-1:-1:-1;;;501:116:3:o;462:145:0:-;-1:-1:-1;;;;;;;;;;;;;;;;;535:65:0;;;;;;;;547:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;535:65;;;;574:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:603:4:-;152:6;160;168;212:9;203:7;199:23;242:4;238:2;234:13;231:33;;;260:1;257;250:12;231:33;296:9;283:23;273:33;;399:4;330:66;326:2;322:75;318:86;315:106;;;417:1;414;407:12;315:106;455:2;444:9;440:18;430:28;;551:3;482:66;478:2;474:75;470:85;467:105;;;568:1;565;558:12;467:105;;606:4;595:9;591:20;581:30;;14:603;;;;;:::o;796:368::-;912:5;935:1;945:213;959:4;956:1;953:11;945:213;;;702:19;;690:32;;778:4;767:16;;;754:30;738:14;;;731:54;1074:4;1098:12;;;;1133:15;;;;979:1;972:9;945:213;;1169:1042;1797:25;;;1783:4;1768:20;;1831:75;1902:2;1887:18;;1879:6;1831:75;:::i;:::-;1915:77;1986:4;1975:9;1971:20;1963:6;1915:77;:::i;:::-;702:19;;2057:4;2042:20;;690:32;778:4;767:16;;754:30;738:14;;;731:54;702:19;;2128:4;2113:20;;690:32;778:4;767:16;;754:30;738:14;;;731:54;702:19;;2199:4;2184:20;;690:32;778:4;767:16;;754:30;738:14;;;731:54;1169:1042;;;;;;;;;:::o;2216:376::-;2340:5;2363:1;2373:213;2387:4;2384:1;2381:11;2373:213;;;702:19;;690:32;;778:4;767:16;;;754:30;738:14;;;731:54;2502:4;2526:12;;;;2561:15;;;;2407:1;2400:9;2373:213;;2597:611;2992:25;;;2979:3;2964:19;;3026:83;3105:2;3090:18;;3082:6;3026:83;:::i;:::-;3118:84;3197:3;3186:9;3182:19;3174:6;3118:84;:::i;:::-;2597:611;;;;;;:::o;3213:184::-;3265:77;3262:1;3255:88;3362:4;3359:1;3352:15;3386:4;3383:1;3376:15;3402:184;3454:77;3451:1;3444:88;3551:4;3548:1;3541:15;3575:4;3572:1;3565:15;3591:195;3630:3;3661:66;3654:5;3651:77;3648:103;;3731:18;;:::i;:::-;-1:-1:-1;3778:1:4;3767:13;;3591:195::o;3791:656::-;3873:6;3926:2;3914:9;3905:7;3901:23;3897:32;3894:52;;;3942:1;3939;3932:12;3894:52;3975:2;3969:9;4017:2;4009:6;4005:15;4086:6;4074:10;4071:22;4050:18;4038:10;4035:34;4032:62;4029:242;;;4127:77;4124:1;4117:88;4228:4;4225:1;4218:15;4256:4;4253:1;4246:15;4029:242;4287:2;4280:22;4326:23;;4311:39;;4411:2;4396:18;;;4383:32;4366:15;;;4359:57;;;;-1:-1:-1;4318:6:4;3791:656;-1:-1:-1;3791:656:4:o;4962:446::-;5257:25;;;5244:3;5229:19;;5291:51;5338:2;5323:18;;5315:6;4882:12;;4870:25;;4944:4;4933:16;;;4927:23;4911:14;;4904:47;4811:146;5291:51;4882:12;;5398:2;5383:18;;4870:25;4944:4;4933:16;;4927:23;4911:14;;;4904:47;5351:51;4811:146;5954:266;5986:1;6012;6002:189;;6047:77;6044:1;6037:88;6148:4;6145:1;6138:15;6176:4;6173:1;6166:15;6002:189;-1:-1:-1;6205:9:4;;5954:266::o;6225:125::-;6265:4;6293:1;6290;6287:8;6284:34;;;6298:18;;:::i;:::-;-1:-1:-1;6335:9:4;;6225:125::o;6355:128::-;6395:3;6426:1;6422:6;6419:1;6416:13;6413:39;;;6432:18;;:::i;:::-;-1:-1:-1;6468:9:4;;6355:128::o;6670:245::-;6749:6;6757;6810:2;6798:9;6789:7;6785:23;6781:32;6778:52;;;6826:1;6823;6816:12;6778:52;-1:-1:-1;;6849:16:4;;6905:2;6890:18;;;6884:25;6849:16;;6884:25;;-1:-1:-1;6670:245:4:o;6920:184::-;6990:6;7043:2;7031:9;7022:7;7018:23;7014:32;7011:52;;;7059:1;7056;7049:12;7011:52;-1:-1:-1;7082:16:4;;6920:184;-1:-1:-1;6920:184:4:o

Swarm Source

ipfs://16104808c532418261a4ee51d08126c04f39883537bf11bcfdd55cbe932cf8e5
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.