Contract Overview
Contract Name:
RiscZeroGroth16VerifierName
Compiler Version
v0.8.9+commit.e5eed63a
// SPDX-License-Identifier: GPL-3.0 /* Copyright 2021 0KIMS association. This file is generated with [snarkJS](https://github.com/iden3/snarkjs). snarkJS is a free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. snarkJS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with snarkJS. If not, see <https://www.gnu.org/licenses/>. */ pragma solidity >=0.7.0 <0.9.0; contract Groth16Verifier { // Scalar field size uint256 constant r = 21888242871839275222246405745257275088548364400416034343698204186575808495617; // Base field size uint256 constant q = 21888242871839275222246405745257275088696311157297823662689037894645226208583; // Verification Key data uint256 constant alphax = 20491192805390485299153009773594534940189261866228447918068658471970481763042; uint256 constant alphay = 9383485363053290200918347156157836566562967994039712273449902621266178545958; uint256 constant betax1 = 4252822878758300859123897981450591353533073413197771768651442665752259397132; uint256 constant betax2 = 6375614351688725206403948262868962793625744043794305715222011528459656738731; uint256 constant betay1 = 21847035105528745403288232691147584728191162732299865338377159692350059136679; uint256 constant betay2 = 10505242626370262277552901082094356697409835680220590971873171140371331206856; uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634; uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781; uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531; uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930; uint256 constant deltax1 = 18518940221910320856687047018635785128750837022059566906616608708313475199865; uint256 constant deltax2 = 9492326610711013918333865133991413442330971822743127449106067493230447878125; uint256 constant deltay1 = 19483644759748826533215810634368877792922012485854314246298395665859158607201; uint256 constant deltay2 = 21375251776817431660251933179512026180139877181625068362970095925425149918084; uint256 constant IC0x = 5283414572476013565779278723585415063371186194506872223482170607932178811733; uint256 constant IC0y = 18704069070102836155408936676819275373965966640372164023392964533091458933020; uint256 constant IC1x = 4204832149120840018317309580010992142700029278901617154852760187580780425598; uint256 constant IC1y = 12454324579480242399557363837918019584959512625719173397955145140913291575910; uint256 constant IC2x = 14956117485756386823219519866025248834283088288522682527835557402788427995664; uint256 constant IC2y = 6968527870554016879785099818512699922114301060378071349626144898778340839382; uint256 constant IC3x = 6512168907754184210144919576616764035747139382744482291187821746087116094329; uint256 constant IC3y = 17156131719875889332084290091263207055049222677188492681713268727972722760739; uint256 constant IC4x = 5195346330747727606774560791771406703229046454464300598774280139349802276261; uint256 constant IC4y = 16279160127031959334335024858510026085227931356896384961436876214395869945425; // Memory data uint16 constant pVk = 0; uint16 constant pPairing = 128; uint16 constant pLastMem = 896; function verifyProof( uint256[2] calldata _pA, uint256[2][2] calldata _pB, uint256[2] calldata _pC, uint256[4] calldata _pubSignals ) public view returns (bool) { assembly { function checkField(v) { if iszero(lt(v, q)) { mstore(0, 0) return(0, 0x20) } } // G1 function to multiply a G1 value(x,y) to value in an address function g1_mulAccC(pR, x, y, s) { let success let mIn := mload(0x40) mstore(mIn, x) mstore(add(mIn, 32), y) mstore(add(mIn, 64), s) success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64) if iszero(success) { mstore(0, 0) return(0, 0x20) } mstore(add(mIn, 64), mload(pR)) mstore(add(mIn, 96), mload(add(pR, 32))) success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64) if iszero(success) { mstore(0, 0) return(0, 0x20) } } function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk { let _pPairing := add(pMem, pPairing) let _pVk := add(pMem, pVk) mstore(_pVk, IC0x) mstore(add(_pVk, 32), IC0y) // Compute the linear combination vk_x g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0))) g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32))) g1_mulAccC(_pVk, IC3x, IC3y, calldataload(add(pubSignals, 64))) g1_mulAccC(_pVk, IC4x, IC4y, calldataload(add(pubSignals, 96))) // -A mstore(_pPairing, calldataload(pA)) mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q)) // B mstore(add(_pPairing, 64), calldataload(pB)) mstore(add(_pPairing, 96), calldataload(add(pB, 32))) mstore(add(_pPairing, 128), calldataload(add(pB, 64))) mstore(add(_pPairing, 160), calldataload(add(pB, 96))) // alpha1 mstore(add(_pPairing, 192), alphax) mstore(add(_pPairing, 224), alphay) // beta2 mstore(add(_pPairing, 256), betax1) mstore(add(_pPairing, 288), betax2) mstore(add(_pPairing, 320), betay1) mstore(add(_pPairing, 352), betay2) // vk_x mstore(add(_pPairing, 384), mload(add(pMem, pVk))) mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32)))) // gamma2 mstore(add(_pPairing, 448), gammax1) mstore(add(_pPairing, 480), gammax2) mstore(add(_pPairing, 512), gammay1) mstore(add(_pPairing, 544), gammay2) // C mstore(add(_pPairing, 576), calldataload(pC)) mstore(add(_pPairing, 608), calldataload(add(pC, 32))) // delta2 mstore(add(_pPairing, 640), deltax1) mstore(add(_pPairing, 672), deltax2) mstore(add(_pPairing, 704), deltay1) mstore(add(_pPairing, 736), deltay2) let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20) isOk := and(success, mload(_pPairing)) } let pMem := mload(0x40) mstore(0x40, add(pMem, pLastMem)) // Validate that all evaluations ∈ F checkField(calldataload(add(_pubSignals, 0))) checkField(calldataload(add(_pubSignals, 32))) checkField(calldataload(add(_pubSignals, 64))) checkField(calldataload(add(_pubSignals, 96))) checkField(calldataload(add(_pubSignals, 128))) // Validate all evaluations let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem) mstore(0, isValid) return(0, 0x20) } } }
// Copyright 2023 RISC Zero, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // // SPDX-License-Identifier: Apache-2.0 pragma solidity ^0.8.9; /// @notice Indicator for the overall system at the end of execution covered by this proof. enum SystemExitCode { Halted, Paused, SystemSplit } /// @notice Combination of system and user exit codes. /// @dev If system exit code is SystemSplit, the user exit code must be zero. struct ExitCode { SystemExitCode system; uint8 user; } /// @notice Data associated with a receipt which is used for both input and /// output of global state. struct ReceiptMetadata { /// Digest of the SystemState of a segment just before execution has begun. bytes32 preStateDigest; /// Digest of the SystemState of a segment just after execution has completed. bytes32 postStateDigest; /// The exit code for a segment ExitCode exitCode; /// A digest of the input, from the viewpoint of the guest. bytes32 input; /// A digest of the journal, from the viewpoint of the guest. bytes32 output; } library ReceiptMetadataLib { bytes32 constant TAG_DIGEST = sha256("risc0.ReceiptMeta"); function digest(ReceiptMetadata memory meta) internal pure returns (bytes32) { return sha256( abi.encodePacked( TAG_DIGEST, // down meta.input, meta.preStateDigest, meta.postStateDigest, meta.output, // data uint32(meta.exitCode.system) << 24, uint32(meta.exitCode.user) << 24, // down.length uint16(4) << 8 ) ); } } struct Receipt { bytes seal; ReceiptMetadata meta; } interface IRiscZeroVerifier { /// @notice verify that the given receipt is a valid Groth16 RISC Zero recursion receipt. /// @return true if the receipt passes the verification checks. function verifyProof(Receipt calldata receipt) external view returns (bool); /// @notice verifies that the given seal is a valid Groth16 RISC Zero proof of execution over the /// given image ID, post-state digest, and journal. Asserts that the input hash // is all-zeros (i.e. no committed input) and the exit code is (Halted, 0). /// @return true if the receipt passes the verification checks. function verifyBytes32(bytes calldata seal, bytes32 imageId, bytes32 postStateDigest, bytes32 journalHash) external view returns (bool); /// @notice verifies that the given seal is a valid Groth16 RISC Zero proof of execution over the /// given image ID, post-state digest, and full journal. Asserts that the input hash // is all-zeros (i.e. no committed input) and the exit code is (Halted, 0). /// @return true if the receipt passes the verification checks. function verify(bytes memory seal, bytes32 imageId, bytes32 postStateDigest, bytes calldata journal) external view returns (bool); }
// Copyright 2023 RISC Zero, Inc. // // The RiscZeroGroth16Verifier is a free software: you can redistribute it // and/or modify it under the terms of the GNU General Public License as // published by the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // The RiscZeroGroth16Verifier is distributed in the hope that it will be // useful, but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General // Public License for more details. // // You should have received a copy of the GNU General Public License along with // the RiscZeroGroth16Verifier. If not, see <https://www.gnu.org/licenses/>. // // SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.9; import {SafeCast} from "./SafeCast.sol"; import {Groth16Verifier} from "./Groth16Verifier.sol"; import { IRiscZeroVerifier, Receipt, ReceiptMetadata, ReceiptMetadataLib, ExitCode, SystemExitCode } from "../IRiscZeroVerifier.sol"; /// @notice reverse the byte order of the uint256 value. /// @dev Soldity uses a big-endian ABI encoding. Reversing the byte order before encoding /// ensure that the encoded value will be little-endian. /// Written by k06a. https://ethereum.stackexchange.com/a/83627 function reverseByteOrderUint256(uint256 input) pure returns (uint256 v) { v = input; // swap bytes v = ((v & 0xFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00) >> 8) | ((v & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8); // swap 2-byte long pairs v = ((v & 0xFFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000) >> 16) | ((v & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16); // swap 4-byte long pairs v = ((v & 0xFFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000) >> 32) | ((v & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32); // swap 8-byte long pairs v = ((v & 0xFFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF0000000000000000) >> 64) | ((v & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64); // swap 16-byte long pairs v = (v >> 128) | (v << 128); } /// @notice reverse the byte order of the uint32 value. /// @dev Soldity uses a big-endian ABI encoding. Reversing the byte order before encoding /// ensure that the encoded value will be little-endian. /// Written by k06a. https://ethereum.stackexchange.com/a/83627 function reverseByteOrderUint32(uint32 input) pure returns (uint32 v) { v = input; // swap bytes v = ((v & 0xFF00FF00) >> 8) | ((v & 0x00FF00FF) << 8); // swap 2-byte long pairs v = (v >> 16) | (v << 16); } /// @notice A Groth16 seal over the claimed receipt metadata. struct Seal { uint256[2] a; uint256[2][2] b; uint256[2] c; } contract RiscZeroGroth16VerifierName is IRiscZeroVerifier, Groth16Verifier { using ReceiptMetadataLib for ReceiptMetadata; using SafeCast for uint256; // Control ID hash for the identity_p254 predicate decomposed as implemented by splitDigest. uint256 internal constant CONTROL_ID_0 = uint256(0x68e42d8b3ddc499f4e1799a767052ab3); uint256 internal constant CONTROL_ID_1 = uint256(0x3802684f1645e0a028585b0445d39231); /// @notice splits a digest into two 128-bit words to use as public signal inputs. /// @dev RISC Zero's Circom verifier circuit takes each of two hash digests in two 128-bit /// chunks. These values can be derived from the digest by splitting the digest in half and /// then reversing the bytes of each. function splitDigest(bytes32 digest) internal pure returns (uint256, uint256) { uint256 reversed = reverseByteOrderUint256(uint256(digest)); return (uint256(uint128(uint256(reversed))), uint256(reversed >> 128)); } /// @notice verify that the given receipt is a valid Groth16 RISC Zero recursion receipt. /// @return true if the receipt passes the verification checks. function verifyProof(Receipt memory receipt) public view returns (bool) { (uint256 meta0, uint256 meta1) = splitDigest(receipt.meta.digest()); Seal memory seal = abi.decode(receipt.seal, (Seal)); return this.verifyProof(seal.a, seal.b, seal.c, [CONTROL_ID_0, CONTROL_ID_1, meta0, meta1]); } /// @notice verifies that the given seal is a valid Groth16 RISC Zero proof of execution over the /// given image ID, post-state digest, and journal hash. Asserts that the input hash // is all-zeros (i.e. no committed input) and the exit code is (Halted, 0). /// @return true if the receipt passes the verification checks. function verifyBytes32(bytes memory seal, bytes32 imageId, bytes32 postStateDigest, bytes32 journalHash) public view returns (bool) { Receipt memory receipt = Receipt( seal, ReceiptMetadata(imageId, postStateDigest, ExitCode(SystemExitCode.Halted, 0), bytes32(0), journalHash) ); return verifyProof(receipt); } /// @notice verifies that the given seal is a valid Groth16 RISC Zero proof of execution over the /// given image ID, post-state digest, and full journal. Asserts that the input hash // is all-zeros (i.e. no committed input) and the exit code is (Halted, 0). /// @return true if the receipt passes the verification checks. function verify(bytes memory seal, bytes32 imageId, bytes32 postStateDigest, bytes calldata journal) public view returns (bool) { return verifyBytes32(seal, imageId, postStateDigest, sha256(journal)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
[{"inputs":[{"internalType":"bytes","name":"seal","type":"bytes"},{"internalType":"bytes32","name":"imageId","type":"bytes32"},{"internalType":"bytes32","name":"postStateDigest","type":"bytes32"},{"internalType":"bytes","name":"journal","type":"bytes"}],"name":"verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"seal","type":"bytes"},{"internalType":"bytes32","name":"imageId","type":"bytes32"},{"internalType":"bytes32","name":"postStateDigest","type":"bytes32"},{"internalType":"bytes32","name":"journalHash","type":"bytes32"}],"name":"verifyBytes32","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[2]","name":"_pA","type":"uint256[2]"},{"internalType":"uint256[2][2]","name":"_pB","type":"uint256[2][2]"},{"internalType":"uint256[2]","name":"_pC","type":"uint256[2]"},{"internalType":"uint256[4]","name":"_pubSignals","type":"uint256[4]"}],"name":"verifyProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"seal","type":"bytes"},{"components":[{"internalType":"bytes32","name":"preStateDigest","type":"bytes32"},{"internalType":"bytes32","name":"postStateDigest","type":"bytes32"},{"components":[{"internalType":"enum SystemExitCode","name":"system","type":"uint8"},{"internalType":"uint8","name":"user","type":"uint8"}],"internalType":"struct ExitCode","name":"exitCode","type":"tuple"},{"internalType":"bytes32","name":"input","type":"bytes32"},{"internalType":"bytes32","name":"output","type":"bytes32"}],"internalType":"struct ReceiptMetadata","name":"meta","type":"tuple"}],"internalType":"struct Receipt","name":"receipt","type":"tuple"}],"name":"verifyProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for
interesting conversations.