File size: 2,690 Bytes
f998fcd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.17;
import "./Utils.sol";
contract InnerProductVerifier {
using Utils for uint256;
using Utils for Utils.Point;
bytes32 public immutable gX;
bytes32 public immutable gY;
bytes32 public immutable hX;
bytes32 public immutable hY;
// above, emulating immutable `Utils.Point`s using raw `bytes32`s. save some sloads later.
Utils.Point[M << 1] public gs;
Utils.Point[M << 1] public hs;
// have to use storage, not immutable, because solidity doesn't support non-primitive immutable types
constructor() {
Utils.Point memory gTemp = Utils.mapInto("g");
gX = gTemp.x;
gY = gTemp.y;
Utils.Point memory hTemp = Utils.mapInto("h");
hX = hTemp.x;
hY = hTemp.y;
for (uint256 i = 0; i < M << 1; i++) {
gs[i] = Utils.mapInto("g", i);
hs[i] = Utils.mapInto("h", i);
}
}
struct Locals {
uint256 o;
Utils.Point P;
uint256[m + 1] challenges;
uint256[M << 1] s;
}
function verify(Utils.InnerProductStatement calldata statement, Utils.InnerProductProof calldata proof, bool transfer) external view {
Locals memory locals;
locals.o = statement.salt;
locals.P = statement.P;
uint256 M_ = M << (transfer ? 1 : 0);
uint256 m_ = m + (transfer ? 1 : 0);
for (uint256 i = 0; i < m_; i++) {
locals.o = uint256(keccak256(abi.encode(locals.o, proof.L[i], proof.R[i]))).mod(); // overwrites
locals.challenges[i] = locals.o;
uint256 inverse = locals.o.inv();
locals.P = locals.P.add(proof.L[i].mul(locals.o.mul(locals.o))).add(proof.R[i].mul(inverse.mul(inverse)));
}
locals.s[0] = 1;
for (uint256 i = 0; i < m_; i++) locals.s[0] = locals.s[0].mul(locals.challenges[i]);
locals.s[0] = locals.s[0].inv();
for (uint256 i = 0; i < m_; i++) {
for (uint256 j = 0; j < M_; j += 1 << m_ - i) {
locals.s[j + (1 << m_ - i - 1)] = locals.s[j].mul(locals.challenges[i]).mul(locals.challenges[i]);
}
}
Utils.Point memory temp = statement.u.mul(proof.a.mul(proof.b));
for (uint256 i = 0; i < M_; i++) {
temp = temp.add(gs[i].mul(locals.s[i].mul(proof.a)));
temp = temp.add(statement.hs[i].mul(locals.s[M_ - 1 - i].mul(proof.b)));
}
require(temp.eq(locals.P), "Inner product proof failed.");
}
} |