Contract Overview
Contract Name:
RiscZeroGroth16Verifier
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 verify(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 verify(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 RiscZeroGroth16Verifier 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 verify(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 verify(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 verify(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 verify(seal, imageId, postStateDigest, sha256(journal));
}
function verifySnark(bytes memory seal, bytes32 imageId, bytes32 postStateDigest, bytes calldata journal)
public
view
returns (bool)
{
return verify(seal, imageId, postStateDigest, 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":[{"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":"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":"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":"verify","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":[{"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":"verifySnark","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.