ETH Price: $3,383.10 (-1.65%)
Gas: 2 Gwei

Contract

0xFD14567eaf9ba941cB8c8a94eEC14831ca7fD1b4
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Token Holdings

Multichain Info

1 address found via
Transaction Hash
Method
Block
From
To
Value
Register Continu...193107232024-02-26 9:03:23123 days ago1708938203IN
StarkEx: SHARP
0 ETH0.014716431.96577864
Register Continu...193107232024-02-26 9:03:23123 days ago1708938203IN
StarkEx: SHARP
0 ETH0.0017095631.96577864
Register Continu...193107232024-02-26 9:03:23123 days ago1708938203IN
StarkEx: SHARP
0 ETH0.012956431.96577864
Register Continu...193107222024-02-26 9:03:11123 days ago1708938191IN
StarkEx: SHARP
0 ETH0.0017050431.8884276
Register Continu...193107222024-02-26 9:03:11123 days ago1708938191IN
StarkEx: SHARP
0 ETH0.0126682531.8884276
Register Continu...193107222024-02-26 9:03:11123 days ago1708938191IN
StarkEx: SHARP
0 ETH0.0017042731.8884276
Register Continu...193107222024-02-26 9:03:11123 days ago1708938191IN
StarkEx: SHARP
0 ETH0.0197808631.8884276
Register Continu...193107212024-02-26 9:02:59123 days ago1708938179IN
StarkEx: SHARP
0 ETH0.0017782233.25710884
Register Continu...193107212024-02-26 9:02:59123 days ago1708938179IN
StarkEx: SHARP
0 ETH0.0117119233.25710884
Register Continu...193107212024-02-26 9:02:59123 days ago1708938179IN
StarkEx: SHARP
0 ETH0.0017786233.25710884
Register Continu...193107212024-02-26 9:02:59123 days ago1708938179IN
StarkEx: SHARP
0 ETH0.0108292733.25710884
Register Continu...193107202024-02-26 9:02:47123 days ago1708938167IN
StarkEx: SHARP
0 ETH0.0019045833.49139007
Register Continu...193107202024-02-26 9:02:47123 days ago1708938167IN
StarkEx: SHARP
0 ETH0.0128995733.49139007
Register Continu...193107202024-02-26 9:02:47123 days ago1708938167IN
StarkEx: SHARP
0 ETH0.0017907533.49139007
Register Continu...193107202024-02-26 9:02:47123 days ago1708938167IN
StarkEx: SHARP
0 ETH0.0231214133.49139007
Register Continu...193107192024-02-26 9:02:35123 days ago1708938155IN
StarkEx: SHARP
0 ETH0.0017921833.51811621
Register Continu...193107192024-02-26 9:02:35123 days ago1708938155IN
StarkEx: SHARP
0 ETH0.009796533.51811621
Register Continu...193107192024-02-26 9:02:35123 days ago1708938155IN
StarkEx: SHARP
0 ETH0.0017921833.51811621
Register Continu...193107192024-02-26 9:02:35123 days ago1708938155IN
StarkEx: SHARP
0 ETH0.0187363933.51811621
Register Continu...193107182024-02-26 9:02:23123 days ago1708938143IN
StarkEx: SHARP
0 ETH0.0018340234.30836974
Register Continu...193107182024-02-26 9:02:23123 days ago1708938143IN
StarkEx: SHARP
0 ETH0.0088025334.30836974
Register Continu...193107182024-02-26 9:02:23123 days ago1708938143IN
StarkEx: SHARP
0 ETH0.0018340234.30836974
Register Continu...193107182024-02-26 9:02:23123 days ago1708938143IN
StarkEx: SHARP
0 ETH0.019141834.30836974
Register Continu...193107172024-02-26 9:02:11123 days ago1708938131IN
StarkEx: SHARP
0 ETH0.0018716934.99741483
Register Continu...193107172024-02-26 9:02:11123 days ago1708938131IN
StarkEx: SHARP
0 ETH0.0108267634.99741483
View all transactions

View more zero value Internal Transactions in Advanced View mode

Advanced mode:
Loading...
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x43f42173...81e9C86E2
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
MemoryPageFactRegistry

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 1000000 runs

Other Settings:
default evmVersion, Apache-2.0 license
File 1 of 4 : MemoryPageFactRegistry.sol
/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  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

  https://www.starkware.co/open-source-license/

  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.6.12;

import "FactRegistry.sol";

contract MemoryPageFactRegistryConstants {
    // A page based on a list of pairs (address, value).
    // In this case, memoryHash = hash(address, value, address, value, address, value, ...).
    uint256 internal constant REGULAR_PAGE = 0;
    // A page based on adjacent memory cells, starting from a given address.
    // In this case, memoryHash = hash(value, value, value, ...).
    uint256 internal constant CONTINUOUS_PAGE = 1;
}

/*
  A fact registry for the claim:
    I know n pairs (addr, value) for which the hash of the pairs is memoryHash, and the cumulative
    product: \prod_i( z - (addr_i + alpha * value_i) ) is prod.
  The exact format of the hash depends on the type of the page
  (see MemoryPageFactRegistryConstants).
  The fact consists of (pageType, prime, n, z, alpha, prod, memoryHash, address).
  Note that address is only available for CONTINUOUS_PAGE, and otherwise it is 0.
*/
contract MemoryPageFactRegistry is FactRegistry, MemoryPageFactRegistryConstants {
    event LogMemoryPageFactRegular(bytes32 factHash, uint256 memoryHash, uint256 prod);
    event LogMemoryPageFactContinuous(bytes32 factHash, uint256 memoryHash, uint256 prod);

    /*
      Registers a fact based of the given memory (address, value) pairs (REGULAR_PAGE).
    */
    function registerRegularMemoryPage(
        uint256[] calldata memoryPairs,
        uint256 z,
        uint256 alpha,
        uint256 prime
    )
        external
        returns (
            bytes32 factHash,
            uint256 memoryHash,
            uint256 prod
        )
    {
        // Ensure 'memoryPairs.length' is bounded as a sanity check (the bound is somewhat arbitrary).
        require(memoryPairs.length < 2**20, "Too many memory values.");
        require(memoryPairs.length % 2 == 0, "Size of memoryPairs must be even.");
        require(z < prime, "Invalid value of z.");
        require(alpha < prime, "Invalid value of alpha.");
        (factHash, memoryHash, prod) = computeFactHash(memoryPairs, z, alpha, prime);
        emit LogMemoryPageFactRegular(factHash, memoryHash, prod);

        registerFact(factHash);
    }

    function computeFactHash(
        uint256[] memory memoryPairs,
        uint256 z,
        uint256 alpha,
        uint256 prime
    )
        private
        pure
        returns (
            bytes32 factHash,
            uint256 memoryHash,
            uint256 prod
        )
    {
        uint256 memorySize = memoryPairs.length / 2; // NOLINT: divide-before-multiply.

        prod = 1;

        assembly {
            let memoryPtr := add(memoryPairs, 0x20)

            // Each value of memoryPairs is a pair: (address, value).
            let lastPtr := add(memoryPtr, mul(memorySize, 0x40))
            for {
                let ptr := memoryPtr
            } lt(ptr, lastPtr) {
                ptr := add(ptr, 0x40)
            } {
                // Compute address + alpha * value.
                let address_value_lin_comb := addmod(
                    // address=
                    mload(ptr),
                    mulmod(
                        // value=
                        mload(add(ptr, 0x20)),
                        alpha,
                        prime
                    ),
                    prime
                )
                prod := mulmod(prod, add(z, sub(prime, address_value_lin_comb)), prime)
            }

            memoryHash := keccak256(
                memoryPtr,
                mul(
                    // 0x20 * 2.
                    0x40,
                    memorySize
                )
            )
        }

        factHash = keccak256(
            abi.encodePacked(
                REGULAR_PAGE,
                prime,
                memorySize,
                z,
                alpha,
                prod,
                memoryHash,
                uint256(0)
            )
        );
    }

    /*
      Registers a fact based on the given values, assuming continuous addresses.
      values should be [value at startAddr, value at (startAddr + 1), ...].
    */
    function registerContinuousMemoryPage(
        // NOLINT: external-function.
        uint256 startAddr,
        uint256[] memory values,
        uint256 z,
        uint256 alpha,
        uint256 prime
    )
        public
        returns (
            bytes32 factHash,
            uint256 memoryHash,
            uint256 prod
        )
    {
        require(values.length < 2**20, "Too many memory values.");
        require(prime < 2**254, "prime is too big for the optimizations in this function.");
        require(z < prime, "Invalid value of z.");
        require(alpha < prime, "Invalid value of alpha.");
        // Ensure 'startAddr' less then prime and bounded as a sanity check (the bound is somewhat arbitrary).
        require((startAddr < prime) && (startAddr < 2**64), "Invalid value of startAddr.");

        uint256 nValues = values.length;

        assembly {
            // Initialize prod to 1.
            prod := 1
            // Initialize valuesPtr to point to the first value in the array.
            let valuesPtr := add(values, 0x20)

            let minus_z := mod(sub(prime, z), prime)

            // Start by processing full batches of 8 cells, addr represents the last address in each
            // batch.
            let addr := add(startAddr, 7)
            let lastAddr := add(startAddr, nValues)
            for {

            } lt(addr, lastAddr) {
                addr := add(addr, 8)
            } {
                // Compute the product of (lin_comb - z) instead of (z - lin_comb), since we're
                // doing an even number of iterations, the result is the same.
                prod := mulmod(
                    prod,
                    mulmod(
                        add(add(sub(addr, 7), mulmod(mload(valuesPtr), alpha, prime)), minus_z),
                        add(
                            add(sub(addr, 6), mulmod(mload(add(valuesPtr, 0x20)), alpha, prime)),
                            minus_z
                        ),
                        prime
                    ),
                    prime
                )

                prod := mulmod(
                    prod,
                    mulmod(
                        add(
                            add(sub(addr, 5), mulmod(mload(add(valuesPtr, 0x40)), alpha, prime)),
                            minus_z
                        ),
                        add(
                            add(sub(addr, 4), mulmod(mload(add(valuesPtr, 0x60)), alpha, prime)),
                            minus_z
                        ),
                        prime
                    ),
                    prime
                )

                prod := mulmod(
                    prod,
                    mulmod(
                        add(
                            add(sub(addr, 3), mulmod(mload(add(valuesPtr, 0x80)), alpha, prime)),
                            minus_z
                        ),
                        add(
                            add(sub(addr, 2), mulmod(mload(add(valuesPtr, 0xa0)), alpha, prime)),
                            minus_z
                        ),
                        prime
                    ),
                    prime
                )

                prod := mulmod(
                    prod,
                    mulmod(
                        add(
                            add(sub(addr, 1), mulmod(mload(add(valuesPtr, 0xc0)), alpha, prime)),
                            minus_z
                        ),
                        add(add(addr, mulmod(mload(add(valuesPtr, 0xe0)), alpha, prime)), minus_z),
                        prime
                    ),
                    prime
                )

                valuesPtr := add(valuesPtr, 0x100)
            }

            // Handle leftover.
            // Translate addr to the beginning of the last incomplete batch.
            addr := sub(addr, 7)
            for {

            } lt(addr, lastAddr) {
                addr := add(addr, 1)
            } {
                let address_value_lin_comb := addmod(
                    addr,
                    mulmod(mload(valuesPtr), alpha, prime),
                    prime
                )
                prod := mulmod(prod, add(z, sub(prime, address_value_lin_comb)), prime)
                valuesPtr := add(valuesPtr, 0x20)
            }

            memoryHash := keccak256(add(values, 0x20), mul(0x20, nValues))
        }

        factHash = keccak256(
            abi.encodePacked(CONTINUOUS_PAGE, prime, nValues, z, alpha, prod, memoryHash, startAddr)
        );

        emit LogMemoryPageFactContinuous(factHash, memoryHash, prod);

        registerFact(factHash);
    }
}

File 2 of 4 : FactRegistry.sol
/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  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

  https://www.starkware.co/open-source-license/

  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.6.12;

import "IQueryableFactRegistry.sol";

contract FactRegistry is IQueryableFactRegistry {
    // Mapping: fact hash -> true.
    mapping(bytes32 => bool) private verifiedFact;

    // Indicates whether the Fact Registry has at least one fact registered.
    bool anyFactRegistered = false;

    /*
      Checks if a fact has been verified.
    */
    function isValid(bytes32 fact) external view override returns (bool) {
        return _factCheck(fact);
    }

    /*
      This is an internal method to check if the fact is already registered.
      In current implementation of FactRegistry it's identical to isValid().
      But the check is against the local fact registry,
      So for a derived referral fact registry, it's not the same.
    */
    function _factCheck(bytes32 fact) internal view returns (bool) {
        return verifiedFact[fact];
    }

    function registerFact(bytes32 factHash) internal {
        // This function stores the fact hash in the mapping.
        verifiedFact[factHash] = true;

        // Mark first time off.
        if (!anyFactRegistered) {
            anyFactRegistered = true;
        }
    }

    /*
      Indicates whether at least one fact was registered.
    */
    function hasRegisteredFact() external view override returns (bool) {
        return anyFactRegistered;
    }
}

File 3 of 4 : IFactRegistry.sol
/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  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

  https://www.starkware.co/open-source-license/

  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.6.12;

/*
  The Fact Registry design pattern is a way to separate cryptographic verification from the
  business logic of the contract flow.

  A fact registry holds a hash table of verified "facts" which are represented by a hash of claims
  that the registry hash check and found valid. This table may be queried by accessing the
  isValid() function of the registry with a given hash.

  In addition, each fact registry exposes a registry specific function for submitting new claims
  together with their proofs. The information submitted varies from one registry to the other
  depending of the type of fact requiring verification.

  For further reading on the Fact Registry design pattern see this
  `StarkWare blog post <https://medium.com/starkware/the-fact-registry-a64aafb598b6>`_.
*/
interface IFactRegistry {
    /*
      Returns true if the given fact was previously registered in the contract.
    */
    function isValid(bytes32 fact) external view returns (bool);
}

File 4 of 4 : IQueryableFactRegistry.sol
/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  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

  https://www.starkware.co/open-source-license/

  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.6.12;

import "IFactRegistry.sol";

/*
  Extends the IFactRegistry interface with a query method that indicates
  whether the fact registry has successfully registered any fact or is still empty of such facts.
*/
interface IQueryableFactRegistry is IFactRegistry {
    /*
      Returns true if at least one fact has been registered.
    */
    function hasRegisteredFact() external view returns (bool);
}

Settings
{
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {},
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "evmVersion": "istanbul",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"factHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"memoryHash","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"prod","type":"uint256"}],"name":"LogMemoryPageFactContinuous","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"factHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"memoryHash","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"prod","type":"uint256"}],"name":"LogMemoryPageFactRegular","type":"event"},{"inputs":[],"name":"hasRegisteredFact","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fact","type":"bytes32"}],"name":"isValid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"startAddr","type":"uint256"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"uint256","name":"z","type":"uint256"},{"internalType":"uint256","name":"alpha","type":"uint256"},{"internalType":"uint256","name":"prime","type":"uint256"}],"name":"registerContinuousMemoryPage","outputs":[{"internalType":"bytes32","name":"factHash","type":"bytes32"},{"internalType":"uint256","name":"memoryHash","type":"uint256"},{"internalType":"uint256","name":"prod","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"memoryPairs","type":"uint256[]"},{"internalType":"uint256","name":"z","type":"uint256"},{"internalType":"uint256","name":"alpha","type":"uint256"},{"internalType":"uint256","name":"prime","type":"uint256"}],"name":"registerRegularMemoryPage","outputs":[{"internalType":"bytes32","name":"factHash","type":"bytes32"},{"internalType":"uint256","name":"memoryHash","type":"uint256"},{"internalType":"uint256","name":"prod","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

Deployed Bytecode

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

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.