Contract
Contract Overview
Balance:
0 MATIC
My Name Tag:
Not Available
| Txn Hash |
Method
|
Block
|
From
|
To
|
Value | [Txn Fee] | |||
|---|---|---|---|---|---|---|---|---|---|
| 0x8527b6e9ea8a956c123b6fd0937ad25e1df5d6e108a79e9188759fff33cd1aa3 | 0x60806040 | 31504012 | 122 days 17 hrs ago | 0x1de72a1935df9b4e02315bda3c3cdbdf2a640583 | IN | Contract Creation | 0 MATIC | 0.00607115856 |
[ Download CSV Export ]
Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0xE38dD61363E87Bc3296FB3f5ac057100B3A2a684
Contract Name:
BitcoinRelay
Compiler Version
v0.8.2+commit.661d1103
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.8.4;
import "../libraries/TypedMemView.sol";
import "../libraries/BitcoinHelper.sol";
import "./interfaces/IBitcoinRelay.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract BitcoinRelay is IBitcoinRelay, Ownable, ReentrancyGuard, Pausable {
using TypedMemView for bytes;
using TypedMemView for bytes29;
using BitcoinHelper for bytes29;
using SafeERC20 for IERC20;
// Public variables
uint constant ONE_HUNDRED_PERCENT = 10000;
uint constant MAX_FINALIZATION_PARAMETER = 432; // roughly 3 days
uint public override initialHeight;
uint public override lastSubmittedHeight;
uint public override finalizationParameter;
uint public override rewardAmountInTDT;
uint public override relayerPercentageFee; // A number between [0, 10000)
uint public override submissionGasUsed; // Gas used for submitting a block header
uint public override epochLength;
uint public override baseQueries;
uint public override currentEpochQueries;
uint public override lastEpochQueries;
address public override TeleportDAOToken;
bytes32 public override relayGenesisHash; // Initial block header of relay
// Private and internal variables
mapping(uint => blockHeader[]) private chain; // height => list of block headers
mapping(bytes32 => bytes32) internal previousBlock; // block header hash => parent header hash
mapping(bytes32 => uint256) internal blockHeight; // block header hash => block height
/// @notice Gives a starting point for the relay
/// @param _genesisHeader The starting header
/// @param _height The starting height
/// @param _periodStart The hash of the first header in the genesis epoch
/// @param _TeleportDAOToken The address of the TeleportDAO ERC20 token contract
constructor(
bytes memory _genesisHeader,
uint256 _height,
bytes32 _periodStart,
address _TeleportDAOToken
) {
// Adds the initial block header to the chain
bytes29 _genesisView = _genesisHeader.ref(0).tryAsHeader();
require(_genesisView.notNull(), "BitcoinRelay: stop being dumb");
// genesis header and period start can be same
bytes32 _genesisHash = _genesisView.hash256();
relayGenesisHash = _genesisHash;
blockHeader memory newBlockHeader;
newBlockHeader.selfHash = _genesisHash;
newBlockHeader.parentHash = _genesisView.parent();
newBlockHeader.merkleRoot = _genesisView.merkleRoot();
newBlockHeader.relayer = _msgSender();
newBlockHeader.gasPrice = 0;
chain[_height].push(newBlockHeader);
require(
_periodStart & bytes32(0x0000000000000000000000000000000000000000000000000000000000ffffff) == bytes32(0),
"Period start hash does not have work. Hint: wrong byte order?");
blockHeight[_genesisHash] = _height;
blockHeight[_periodStart] = _height - (_height % BitcoinHelper.RETARGET_PERIOD_BLOCKS);
// Relay parameters
_setFinalizationParameter(3);
initialHeight = _height;
lastSubmittedHeight = _height;
_setTeleportDAOToken(_TeleportDAOToken);
_setRelayerPercentageFee(500);
_setEpochLength(BitcoinHelper.RETARGET_PERIOD_BLOCKS);
_setBaseQueries(epochLength);
lastEpochQueries = baseQueries;
currentEpochQueries = 0;
_setSubmissionGasUsed(300000); // in wei
}
function renounceOwnership() public virtual override onlyOwner {}
/// @notice Pause the relay
/// @dev Only functions with whenPaused modifier can be called
function pauseRelay() external override onlyOwner {
_pause();
}
/// @notice Unpause the relay
/// @dev Only functions with whenNotPaused modifier can be called
function unpauseRelay() external override onlyOwner {
_unpause();
}
/// @notice Getter for a specific block header's hash in the stored chain
/// @param _height The height of the desired block header
/// @param _index The index of the desired block header in that height
/// @return Block header's hash
function getBlockHeaderHash (uint _height, uint _index) external view override returns(bytes32) {
return chain[_height][_index].selfHash;
}
/// @notice Getter for a specific block header's fee price for a query
/// @param _height The height of the desired block header
/// @param _index The index of the desired block header in that height
/// @return Block header's fee price for a query
function getBlockHeaderFee (uint _height, uint _index) external view override returns(uint) {
return _calculateFee(chain[_height][_index].gasPrice);
}
/// @notice Getter for the number of block headers in the same height
/// @dev This shows the number of temporary forks in that specific height
/// @param _height The desired height of the blockchain
/// @return Number of block headers stored in the same height
function getNumberOfSubmittedHeaders (uint _height) external view override returns (uint) {
return chain[_height].length;
}
/// @notice Getter for available TDT in treasury
/// @return Amount of TDT available in Relay treasury
function availableTDT() external view override returns(uint) {
return IERC20(TeleportDAOToken).balanceOf(address(this));
}
/// @notice Getter for available target native token in treasury
/// @return Amount of target blockchain native token available in Relay treasury
function availableTNT() external view override returns(uint) {
return address(this).balance;
}
/// @notice Finds the height of a header by its hash
/// @dev Will fail if the header is unknown
/// @param _hash The header hash to search for
/// @return The height of the header, or error if unknown
function findHeight(bytes32 _hash) external view override returns (uint256) {
return _findHeight(_hash);
}
/// @notice Finds an ancestor for a block by its hash
/// @dev Will fail if the header is unknown
/// @param _hash The header hash to search for
/// @return The height of the header, or error if unknown
function findAncestor(bytes32 _hash, uint256 _offset) external view override returns (bytes32) {
return _findAncestor(_hash, _offset);
}
/// @notice Checks if a hash is an ancestor of the current one
/// @dev Limit the amount of lookups (and thus gas usage) with _limit
/// @param _ancestor The prospective ancestor
/// @param _descendant The descendant to check
/// @param _limit The maximum number of blocks to check
/// @return true if ancestor is at most limit blocks lower than descendant, otherwise false
function isAncestor(bytes32 _ancestor, bytes32 _descendant, uint256 _limit) external view override returns (bool) {
return _isAncestor(_ancestor, _descendant, _limit);
}
/// @notice External setter for rewardAmountInTDT
/// @dev This award is for the relayer who has a finalized block header
/// @param _rewardAmountInTDT The reward amount in TDT
function setRewardAmountInTDT(uint _rewardAmountInTDT) external override onlyOwner {
_setRewardAmountInTDT(_rewardAmountInTDT);
}
/// @notice External setter for finalizationParameter
/// @dev This might change if finalization rule of the source chain gets updated
/// @param _finalizationParameter The finalization parameter of the source chain
function setFinalizationParameter(uint _finalizationParameter) external override onlyOwner {
_setFinalizationParameter(_finalizationParameter);
}
/// @notice External setter for relayerPercentageFee
/// @dev This is updated when we want to change the Relayer reward
/// @param _relayerPercentageFee Ratio > 1 that determines percentage of reward to the Relayer
function setRelayerPercentageFee(uint _relayerPercentageFee) external override onlyOwner {
_setRelayerPercentageFee(_relayerPercentageFee);
}
/// @notice External setter for teleportDAO token
/// @dev This is updated when we want to change the teleportDAO token
/// @param _TeleportDAOToken The teleportDAO token address
function setTeleportDAOToken(address _TeleportDAOToken) external override onlyOwner {
_setTeleportDAOToken(_TeleportDAOToken);
}
/// @notice External setter for epochLength
/// @param _epochLength The length of epochs for estimating the user queries hence their fees
function setEpochLength(uint _epochLength) external override onlyOwner {
_setEpochLength(_epochLength);
}
/// @notice External setter for baseQueries
/// @param _baseQueries The base amount of queries we assume in each epoch
/// (This is for preventing user fees to grow significantly)
function setBaseQueries(uint _baseQueries) external override onlyOwner {
_setBaseQueries(_baseQueries);
}
/// @notice External setter for submissionGasUsed
/// @dev This is updated when the smart contract changes the way of getting block headers
/// @param _submissionGasUsed The gas used for submitting one block header
function setSubmissionGasUsed(uint _submissionGasUsed) external override onlyOwner {
_setSubmissionGasUsed(_submissionGasUsed);
}
/// @notice Internal setter for rewardAmountInTDT
/// @dev This award is for the relayer who has a finalized block header
/// @param _rewardAmountInTDT The reward amount in TDT
function _setRewardAmountInTDT(uint _rewardAmountInTDT) private {
emit NewRewardAmountInTDT(rewardAmountInTDT, _rewardAmountInTDT);
// this reward can be zero as well
rewardAmountInTDT = _rewardAmountInTDT;
}
/// @notice Internal setter for finalizationParameter
/// @dev This might change if finalization rule of the source chain gets updated
/// @param _finalizationParameter The finalization parameter of the source chain
function _setFinalizationParameter(uint _finalizationParameter) private {
emit NewFinalizationParameter(finalizationParameter, _finalizationParameter);
require(
_finalizationParameter > 0 && _finalizationParameter <= MAX_FINALIZATION_PARAMETER,
"BitcoinRelay: invalid finalization param"
);
finalizationParameter = _finalizationParameter;
}
/// @notice Internal setter for relayerPercentageFee
/// @dev This is updated when we want to change the Relayer reward
/// @param _relayerPercentageFee Ratio > 1 that determines percentage of reward to the Relayer
function _setRelayerPercentageFee(uint _relayerPercentageFee) private {
emit NewRelayerPercentageFee(relayerPercentageFee, _relayerPercentageFee);
require(
_relayerPercentageFee <= ONE_HUNDRED_PERCENT,
"BitcoinRelay: relay fee is above max"
);
relayerPercentageFee = _relayerPercentageFee;
}
/// @notice Internal setter for teleportDAO token
/// @dev This is updated when we want to change the teleportDAO token
/// @param _TeleportDAOToken The teleportDAO token address
function _setTeleportDAOToken(address _TeleportDAOToken) private {
emit NewTeleportDAOToken(TeleportDAOToken, _TeleportDAOToken);
TeleportDAOToken = _TeleportDAOToken;
}
/// @notice Internal setter for epochLength
/// @param _epochLength The length of epochs for estimating the user queries hence their fees
function _setEpochLength(uint _epochLength) private {
emit NewEpochLength(epochLength, _epochLength);
require(
_epochLength > 0,
"BitcoinRelay: zero epoch length"
);
epochLength = _epochLength;
}
/// @notice Internal setter for baseQueries
/// @param _baseQueries The base amount of queries we assume in each epoch
/// (This is for preventing user fees to grow significantly)
function _setBaseQueries(uint _baseQueries) private {
emit NewBaseQueries(baseQueries, _baseQueries);
require(
_baseQueries > 0,
"BitcoinRelay: zero base query"
);
baseQueries = _baseQueries;
}
/// @notice Internal setter for submissionGasUsed
/// @dev This is updated when the smart contract changes the way of getting block headers
/// @param _submissionGasUsed The gas used for submitting one block header
function _setSubmissionGasUsed(uint _submissionGasUsed) private {
emit NewSubmissionGasUsed(submissionGasUsed, _submissionGasUsed);
submissionGasUsed = _submissionGasUsed;
}
/// @notice Checks if a tx is included and finalized on the source blockchain
/// @dev Checks if the block is finalized, and Merkle proof is correct
/// @param _txid Desired tx Id in LE form
/// @param _blockHeight Block height of the desired tx
/// @param _intermediateNodes Part of the Merkle tree from the tx to the root (Merkle proof) in LE form
/// @param _index The index of the tx in Merkle tree
/// @return True if the provided tx is confirmed on the source blockchain, False otherwise
function checkTxProof (
bytes32 _txid, // In LE form
uint _blockHeight,
bytes calldata _intermediateNodes, // In LE form
uint _index
) external payable nonReentrant whenNotPaused override returns (bool) {
require(_txid != bytes32(0), "BitcoinRelay: txid should be non-zero");
// Revert if the block is not finalized
require(
_blockHeight + finalizationParameter < lastSubmittedHeight + 1,
"BitcoinRelay: block is not finalized on the relay"
);
// Block header exists on the relay
require(
_blockHeight >= initialHeight,
"BitcoinRelay: the requested height is not submitted on the relay (too old)"
);
// Count the query for next epoch fee calculation
currentEpochQueries += 1;
// Get the relay fee from the user
require(
_getFee(chain[_blockHeight][0].gasPrice),
"BitcoinRelay: getting fee was not successful"
);
// Check the inclusion of the transaction
bytes32 _merkleRoot = chain[_blockHeight][0].merkleRoot;
bytes29 intermediateNodes = _intermediateNodes.ref(0).tryAsMerkleArray(); // Check for errors if any
return BitcoinHelper.prove(_txid, _merkleRoot, intermediateNodes, _index);
}
/// @notice Adds headers to storage after validating
/// @dev We check integrity and consistency of the header chain
/// @param _anchor The header immediately preceeding the new chain
/// @param _headers A tightly-packed list of 80-byte Bitcoin headers
/// @return True if successfully written, error otherwise
function addHeaders(bytes calldata _anchor, bytes calldata _headers) external nonReentrant whenNotPaused override returns (bool) {
bytes29 _headersView = _headers.ref(0).tryAsHeaderArray();
bytes29 _anchorView = _anchor.ref(0).tryAsHeader();
_checkInputSizeAddHeaders(_headersView, _anchorView);
return _addHeaders(_anchorView, _headersView, false);
}
/// @notice Adds headers to storage, performs additional validation of retarget
/// @dev Checks the retarget, the heights, and the linkage
/// @param _oldPeriodStartHeader The first header in the difficulty period being closed
/// @param _oldPeriodEndHeader The last header in the difficulty period being closed (anchor of new headers)
/// @param _headers A tightly-packed list of 80-byte Bitcoin headers
/// @return True if successfully written, error otherwise
function addHeadersWithRetarget(
bytes calldata _oldPeriodStartHeader,
bytes calldata _oldPeriodEndHeader,
bytes calldata _headers
) external nonReentrant whenNotPaused override returns (bool) {
bytes29 _oldStart = _oldPeriodStartHeader.ref(0).tryAsHeader();
bytes29 _oldEnd = _oldPeriodEndHeader.ref(0).tryAsHeader();
bytes29 _headersView = _headers.ref(0).tryAsHeaderArray();
_checkInputSizeAddHeadersWithRetarget(_oldStart, _oldEnd, _headersView);
return _addHeadersWithRetarget(_oldStart, _oldEnd, _headersView);
}
/// @notice Adds headers to storage after validating
/// @dev Works like the other addHeaders; we use this function when relay is paused
/// then only owner can add the new blocks, like when a fork happens
/// @param _anchor The header immediately preceeding the new chain
/// @param _headers A tightly-packed list of 80-byte Bitcoin headers
/// @return True if successfully written, error otherwise
function ownerAddHeaders(bytes calldata _anchor, bytes calldata _headers) external nonReentrant onlyOwner override returns (bool) {
bytes29 _headersView = _headers.ref(0).tryAsHeaderArray();
bytes29 _anchorView = _anchor.ref(0).tryAsHeader();
_checkInputSizeAddHeaders(_headersView, _anchorView);
return _addHeaders(_anchorView, _headersView, false);
}
/// @notice Adds headers to storage, performs additional validation of retarget
/// @dev Works like the other addHeadersWithRetarget; we use this function when relay is paused
/// then only owner can add the new blocks, like when a fork happens
/// @param _oldPeriodStartHeader The first header in the difficulty period being closed
/// @param _oldPeriodEndHeader The last header in the difficulty period being closed (anchor of new headers)
/// @param _headers A tightly-packed list of 80-byte Bitcoin headers
/// @return True if successfully written, error otherwise
function ownerAddHeadersWithRetarget(
bytes calldata _oldPeriodStartHeader,
bytes calldata _oldPeriodEndHeader,
bytes calldata _headers
) external nonReentrant onlyOwner override returns (bool) {
bytes29 _oldStart = _oldPeriodStartHeader.ref(0).tryAsHeader();
bytes29 _oldEnd = _oldPeriodEndHeader.ref(0).tryAsHeader();
bytes29 _headersView = _headers.ref(0).tryAsHeaderArray();
_checkInputSizeAddHeadersWithRetarget(_oldStart, _oldEnd, _headersView);
return _addHeadersWithRetarget(_oldStart, _oldEnd, _headersView);
}
/// @notice Checks the size of addHeaders inputs
/// @param _headersView Input to the addHeaders and ownerAddHeaders functions
/// @param _anchorView Input to the addHeaders and ownerAddHeaders functions
function _checkInputSizeAddHeaders(bytes29 _headersView, bytes29 _anchorView) internal pure {
require(_headersView.notNull(), "BitcoinRelay: header array length must be divisible by 80");
require(_anchorView.notNull(), "BitcoinRelay: anchor must be 80 bytes");
}
/// @notice Checks the size of addHeadersWithRetarget inputs
/// @param _oldStart Input to the addHeadersWithRetarget and ownerAddHeadersWithRetarget functions
/// @param _oldEnd Input to the addHeadersWithRetarget and ownerAddHeadersWithRetarget functions
/// @param _headersView Input to the addHeadersWithRetarget functions
function _checkInputSizeAddHeadersWithRetarget(
bytes29 _oldStart,
bytes29 _oldEnd,
bytes29 _headersView
) internal pure {
require(
_oldStart.notNull() && _oldEnd.notNull() && _headersView.notNull(),
"BitcoinRelay: bad args. Check header and array byte lengths."
);
}
/// @notice Finds the height of a header by its hash
/// @dev Will fail if the header is unknown
/// @param _hash The header hash to search for
/// @return The height of the header
function _findHeight(bytes32 _hash) internal view returns (uint256) {
if (blockHeight[_hash] == 0) {
revert("BitcoinRelay: unknown block");
}
else {
return blockHeight[_hash];
}
}
/// @notice Finds an ancestor for a block by its hash
/// @dev Will fail if the header is unknown
/// @param _hash The header hash to search for
/// @param _offset The depth which is going to be searched
/// @return The height of the header, or error if unknown
function _findAncestor(bytes32 _hash, uint256 _offset) internal view returns (bytes32) {
bytes32 _current = _hash;
for (uint256 i = 0; i < _offset; i++) {
_current = previousBlock[_current];
}
require(_current != bytes32(0), "BitcoinRelay: unknown ancestor");
return _current;
}
/// @notice Checks if a hash is an ancestor of the current one
/// @dev Limit the amount of lookups (and thus gas usage) with _limit
/// @param _ancestor The prospective ancestor
/// @param _descendant The descendant to check
/// @param _limit The maximum number of blocks to check
/// @return true if ancestor is at most limit blocks lower than descendant, otherwise false
function _isAncestor(bytes32 _ancestor, bytes32 _descendant, uint256 _limit) internal view returns (bool) {
bytes32 _current = _descendant;
/* NB: 200 gas/read, so gas is capped at ~200 * limit */
for (uint256 i = 0; i < _limit; i++) {
if (_current == _ancestor) {
return true;
}
_current = previousBlock[_current];
}
return false;
}
// function _revertBytes32(bytes32 _input) internal pure returns(bytes32) {
// bytes memory temp;
// bytes32 result;
// for (uint256 i = 0; i < 32; i++) {
// temp = abi.encodePacked(temp, _input[31-i]);
// }
// assembly {
// result := mload(add(temp, 32))
// }
// return result;
// }
/// @notice Gets fee from the user
/// @dev Fee is paid in target blockchain native token
/// @param gasPrice The gas price had been used for adding the bitcoin block header
/// @return True if the fee payment was successful
function _getFee(uint gasPrice) internal returns (bool){
uint feeAmount;
feeAmount = _calculateFee(gasPrice);
require(msg.value >= feeAmount, "BitcoinRelay: fee is not enough");
Address.sendValue(payable(_msgSender()), msg.value - feeAmount);
return true;
}
/// @notice Calculates the fee amount
/// @dev Fee is paid in target blockchain native token
/// @param gasPrice The gas price had been used for adding the bitcoin block header
/// @return The fee amount
function _calculateFee(uint gasPrice) private view returns (uint) {
return (submissionGasUsed * gasPrice * (ONE_HUNDRED_PERCENT + relayerPercentageFee) * epochLength) / lastEpochQueries / ONE_HUNDRED_PERCENT;
}
/// @notice Adds headers to storage after validating
/// @dev We check integrity and consistency of the header chain
/// @param _anchor The header immediately preceeding the new chain
/// @param _headers A tightly-packed list of new 80-byte Bitcoin headers to record
/// @param _internal True if called internally from addHeadersWithRetarget, false otherwise
/// @return True if successfully written, error otherwise
function _addHeaders(bytes29 _anchor, bytes29 _headers, bool _internal) internal returns (bool) {
// Extract basic info
bytes32 _previousHash = _anchor.hash256();
uint256 _anchorHeight = _findHeight(_previousHash); // revert if the block is unknown
uint256 _target = _headers.indexHeaderArray(0).target();
// When calling addHeaders, no retargetting should happen
require(
_internal || _anchor.target() == _target,
"BitcoinRelay: unexpected retarget on external call"
);
// check the height on top of the anchor is not finalized
require(
_anchorHeight + 1 + finalizationParameter > lastSubmittedHeight,
"BitcoinRelay: block headers are too old"
);
/*
1. check that the blockheader is not a replica
2. check blocks are in the same epoch regarding difficulty
3. check that headers are in a coherent chain (no retargets, hash links good)
4. check that the header has sufficient work
5. Store the block connection
6. Store the height
7. store the block in the chain
*/
uint256 _height;
bytes32 _currentHash;
for (uint256 i = 0; i < _headers.len() / 80; i++) {
bytes29 _header = _headers.indexHeaderArray(i);
_height = _anchorHeight + i + 1;
_currentHash = _header.hash256();
// The below check prevents adding a replicated block header
require(
previousBlock[_currentHash] == bytes32(0),
"BitcoinRelay: the block header exists on the relay"
);
// Blocks that are multiplies of 2016 should be submitted using addHeadersWithRetarget
require(
_internal || _height % BitcoinHelper.RETARGET_PERIOD_BLOCKS != 0,
"BitcoinRelay: headers should be submitted by calling addHeadersWithRetarget"
);
require(_header.target() == _target, "BitcoinRelay: target changed unexpectedly");
require(_header.checkParent(_previousHash), "BitcoinRelay: headers do not form a consistent chain");
require(
TypedMemView.reverseUint256(uint256(_currentHash)) <= _target,
"BitcoinRelay: header work is insufficient"
);
previousBlock[_currentHash] = _previousHash;
blockHeight[_currentHash] = _height;
emit BlockAdded(_height, _currentHash, _previousHash, _msgSender());
_addToChain(_header, _height);
_previousHash = _currentHash;
}
return true;
}
/// @notice Sends reward and compensation to the relayer
/// @dev We pay the block submission cost in TNT and the extra reward in TDT
/// @param _relayer The relayer address
/// @param _height The height of the bitcoin block
/// @return Reward in native token
/// @return Reward in TDT token
function _sendReward(address _relayer, uint _height) internal returns (uint, uint) {
// Reward in TNT
uint rewardAmountInTNT = submissionGasUsed * chain[_height][0].gasPrice * (ONE_HUNDRED_PERCENT + relayerPercentageFee) / ONE_HUNDRED_PERCENT;
// Reward in TDT
uint contractTDTBalance = 0;
if (TeleportDAOToken != address(0)) {
contractTDTBalance = IERC20(TeleportDAOToken).balanceOf(address(this));
}
// Send reward in TDT
bool sentTDT;
if (rewardAmountInTDT <= contractTDTBalance && rewardAmountInTDT > 0) {
// Call ERC20 token contract to transfer reward tokens to the relayer
IERC20(TeleportDAOToken).safeTransfer(_relayer, rewardAmountInTDT);
sentTDT = true;
}
// Send reward in TNT
bool sentTNT;
if (address(this).balance > rewardAmountInTNT && rewardAmountInTNT > 0) {
// note: no need to revert if failed
(sentTNT,) = payable(_relayer).call{value: rewardAmountInTNT}("");
}
if (sentTNT) {
return sentTDT ? (rewardAmountInTNT, rewardAmountInTDT) : (rewardAmountInTNT, 0);
} else {
return sentTDT ? (0, rewardAmountInTDT) : (0, 0);
}
}
/// @notice Adds a header to the chain
/// @dev We prune the chain if the new header causes other block headers to get finalized
/// @param _header The new block header
/// @param _height The height of the new block header
function _addToChain(bytes29 _header, uint _height) internal {
// Prevent relayers to submit too old block headers
require(_height + finalizationParameter > lastSubmittedHeight, "BitcoinRelay: block header is too old");
blockHeader memory newBlockHeader;
newBlockHeader.selfHash = _header.hash256();
newBlockHeader.parentHash = _header.parent();
newBlockHeader.merkleRoot = _header.merkleRoot();
newBlockHeader.relayer = _msgSender();
newBlockHeader.gasPrice = tx.gasprice;
chain[_height].push(newBlockHeader);
if(_height > lastSubmittedHeight){
lastSubmittedHeight += 1;
_updateFee();
_pruneChain();
}
}
/// @notice Reset the number of users in an epoch when a new epoch starts
/// @dev This parameter is used when calculating the fee that relay gets from a user in the next epoch
function _updateFee() internal {
if (lastSubmittedHeight % epochLength == 0) {
lastEpochQueries = (currentEpochQueries < baseQueries) ? baseQueries : currentEpochQueries;
currentEpochQueries = 0;
}
}
/// @notice Finalizes a block header and removes all the other headers in the same height
/// @dev Note that when a chain gets pruned, it only deletes other blocks in the same
/// height as the finalized blocks. Other blocks on top of the non finalized blocks
/// of that height will exist until their height gets finalized.
function _pruneChain() internal {
// Make sure that we have at least finalizationParameter blocks on relay
if ((lastSubmittedHeight - initialHeight) >= finalizationParameter){
uint idx = finalizationParameter;
uint currentHeight = lastSubmittedHeight;
uint stableIdx = 0;
while (idx > 0) {
// bytes29 header = chain[currentHeight][stableIdx];
bytes32 parentHeaderHash = chain[currentHeight][stableIdx].parentHash;
stableIdx = _findIndex(parentHeaderHash, currentHeight-1);
idx--;
currentHeight--;
}
// Keep the finalized block header and delete rest of headers
chain[currentHeight][0] = chain[currentHeight][stableIdx];
if(chain[currentHeight].length > 1){
_pruneHeight(currentHeight);
}
// A new block has been finalized, we send its relayer's reward
uint rewardAmountTNT;
uint rewardAmountTDT;
(rewardAmountTNT, rewardAmountTDT) = _sendReward(chain[currentHeight][0].relayer, currentHeight);
emit BlockFinalized(
currentHeight,
chain[currentHeight][0].selfHash,
chain[currentHeight][0].parentHash,
chain[currentHeight][0].relayer,
rewardAmountTNT,
rewardAmountTDT
);
}
}
/// @notice Finds the index of a block header in a specific height
/// @dev
/// @param _headerHash The block header hash
/// @param _height The height of the block header
/// @return index Index of the block header
function _findIndex(bytes32 _headerHash, uint _height) internal view returns(uint index) {
for(uint256 _index = 0; _index < chain[_height].length; _index++) {
if(_headerHash == chain[_height][_index].selfHash) {
index = _index;
}
}
}
/// @notice Deletes all the block header in the same height except the first header
/// @dev The first header is the one that has gotten finalized
/// @param _height The height of the new block header
function _pruneHeight(uint _height) internal {
uint idx = chain[_height].length - 1;
while(idx > 0){
chain[_height].pop();
idx -= 1;
}
}
/// @notice Adds headers to storage, performs additional validation of retarget
/// @dev Checks the retarget, the heights, and the linkage
/// @param _oldStart The first header in the difficulty period being closed
/// @param _oldEnd The last header in the difficulty period being closed
/// @param _headers A tightly-packed list of 80-byte Bitcoin headers
/// @return True if successfully written, error otherwise
function _addHeadersWithRetarget(
bytes29 _oldStart,
bytes29 _oldEnd,
bytes29 _headers
) internal returns (bool) {
// requires that both blocks are known
uint256 _startHeight = _findHeight(_oldStart.hash256());
uint256 _endHeight = _findHeight(_oldEnd.hash256());
// retargets should happen at 2016 block intervals
require(
_endHeight % BitcoinHelper.RETARGET_PERIOD_BLOCKS == 2015,
"BitcoinRelay: must provide the last header of the closing difficulty period");
require(
_endHeight == _startHeight + 2015,
"BitcoinRelay: must provide exactly 1 difficulty period");
require(
_oldStart.diff() == _oldEnd.diff(),
"BitcoinRelay: period header difficulties do not match");
/* NB: This comparison looks weird because header nBits encoding truncates targets */
bytes29 _newStart = _headers.indexHeaderArray(0);
uint256 _actualTarget = _newStart.target();
uint256 _expectedTarget = BitcoinHelper.retargetAlgorithm(
_oldStart.target(),
_oldStart.time(),
_oldEnd.time()
);
require(
(_actualTarget & _expectedTarget) == _actualTarget,
"BitcoinRelay: invalid retarget provided"
);
// Pass all but the first through to be added
return _addHeaders(_oldEnd, _headers, true);
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.8.4;
/** @author Summa (https://summa.one) */
/*
Original version: https://github.com/summa-tx/memview-sol/blob/main/contracts/TypedMemView.sol
We made few changes to the original version:
1. Use solidity version 8 compiler
2. Remove SafeMath library
3. Add unchecked in line 522
*/
library TypedMemView {
// Why does this exist?
// the solidity `bytes memory` type has a few weaknesses.
// 1. You can't index ranges effectively
// 2. You can't slice without copying
// 3. The underlying data may represent any type
// 4. Solidity never deallocates memory, and memory costs grow
// superlinearly
// By using a memory view instead of a `bytes memory` we get the following
// advantages:
// 1. Slices are done on the stack, by manipulating the pointer
// 2. We can index arbitrary ranges and quickly convert them to stack types
// 3. We can insert type info into the pointer, and typecheck at runtime
// This makes `TypedMemView` a useful tool for efficient zero-copy
// algorithms.
// Why bytes29?
// We want to avoid confusion between views, digests, and other common
// types so we chose a large and uncommonly used odd number of bytes
//
// Note that while bytes are left-aligned in a word, integers and addresses
// are right-aligned. This means when working in assembly we have to
// account for the 3 unused bytes on the righthand side
//
// First 5 bytes are a type flag.
// - ff_ffff_fffe is reserved for unknown type.
// - ff_ffff_ffff is reserved for invalid types/errors.
// next 12 are memory address
// next 12 are len
// bottom 3 bytes are empty
// Assumptions:
// - non-modification of memory.
// - No Solidity updates
// - - wrt free mem point
// - - wrt bytes representation in memory
// - - wrt memory addressing in general
// Usage:
// - create type constants
// - use `assertType` for runtime type assertions
// - - unfortunately we can't do this at compile time yet :(
// - recommended: implement modifiers that perform type checking
// - - e.g.
// - - `uint40 constant MY_TYPE = 3;`
// - - ` modifer onlyMyType(bytes29 myView) { myView.assertType(MY_TYPE); }`
// - instantiate a typed view from a bytearray using `ref`
// - use `index` to inspect the contents of the view
// - use `slice` to create smaller views into the same memory
// - - `slice` can increase the offset
// - - `slice can decrease the length`
// - - must specify the output type of `slice`
// - - `slice` will return a null view if you try to overrun
// - - make sure to explicitly check for this with `notNull` or `assertType`
// - use `equal` for typed comparisons.
// The null view
bytes29 internal constant NULL = hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
uint256 constant LOW_12_MASK = 0xffffffffffffffffffffffff;
uint8 constant TWELVE_BYTES = 96;
/**
* @notice Returns the encoded hex character that represents the lower 4 bits of the argument.
* @param _b The byte
* @return char - The encoded hex character
*/
function nibbleHex(uint8 _b) internal pure returns (uint8 char) {
// This can probably be done more efficiently, but it's only in error
// paths, so we don't really care :)
uint8 _nibble = _b | 0xf0; // set top 4, keep bottom 4
if (_nibble == 0xf0) {return 0x30;} // 0
if (_nibble == 0xf1) {return 0x31;} // 1
if (_nibble == 0xf2) {return 0x32;} // 2
if (_nibble == 0xf3) {return 0x33;} // 3
if (_nibble == 0xf4) {return 0x34;} // 4
if (_nibble == 0xf5) {return 0x35;} // 5
if (_nibble == 0xf6) {return 0x36;} // 6
if (_nibble == 0xf7) {return 0x37;} // 7
if (_nibble == 0xf8) {return 0x38;} // 8
if (_nibble == 0xf9) {return 0x39;} // 9
if (_nibble == 0xfa) {return 0x61;} // a
if (_nibble == 0xfb) {return 0x62;} // b
if (_nibble == 0xfc) {return 0x63;} // c
if (_nibble == 0xfd) {return 0x64;} // d
if (_nibble == 0xfe) {return 0x65;} // e
if (_nibble == 0xff) {return 0x66;} // f
}
/**
* @notice Returns a uint16 containing the hex-encoded byte.
* `the first 8 bits of encoded is the nibbleHex of top 4 bits of _b`
* `the second 8 bits of encoded is the nibbleHex of lower 4 bits of _b`
* @param _b The byte
* @return encoded - The hex-encoded byte
*/
function byteHex(uint8 _b) internal pure returns (uint16 encoded) {
encoded |= nibbleHex(_b >> 4); // top 4 bits
encoded <<= 8;
encoded |= nibbleHex(_b); // lower 4 bits
}
/**
* @notice Encodes the uint256 to hex. `first` contains the encoded top 16 bytes.
* `second` contains the encoded lower 16 bytes.
*
* @param _b The 32 bytes as uint256
* @return first - The top 16 bytes
* @return second - The bottom 16 bytes
*/
function encodeHex(uint256 _b) internal pure returns (uint256 first, uint256 second) {
for (uint8 i = 31; i > 15; i -= 1) {
uint8 _byte = uint8(_b >> (i * 8));
first |= byteHex(_byte);
if (i != 16) {
first <<= 16;
}
}
unchecked {
// abusing underflow here =_=
for (uint8 i = 15; i < 255 ; i -= 1) {
uint8 _byte = uint8(_b >> (i * 8));
second |= byteHex(_byte);
if (i != 0) {
second <<= 16;
}
}
}
}
/**
* @notice Changes the endianness of a uint256.
* @dev https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel
* @param _b The unsigned integer to reverse
* @return v - The reversed value
*/
function reverseUint256(uint256 _b) internal pure returns (uint256 v) {
v = _b;
// swap bytes
v = ((v >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |
((v & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);
// swap 2-byte long pairs
v = ((v >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |
((v & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);
// swap 4-byte long pairs
v = ((v >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |
((v & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);
// swap 8-byte long pairs
v = ((v >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |
((v & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);
// swap 16-byte long pairs
v = (v >> 128) | (v << 128);
}
/**
* @notice Create a mask with the highest `_len` bits set.
* @param _len The length
* @return mask - The mask
*/
function leftMask(uint8 _len) private pure returns (uint256 mask) {
assembly {
// solium-disable-previous-line security/no-inline-assembly
mask := sar(
sub(_len, 1),
0x8000000000000000000000000000000000000000000000000000000000000000
)
}
}
/**
* @notice Return the null view.
* @return bytes29 - The null view
*/
function nullView() internal pure returns (bytes29) {
return NULL;
}
/**
* @notice Check if the view is null.
* @return bool - True if the view is null
*/
function isNull(bytes29 memView) internal pure returns (bool) {
return memView == NULL;
}
/**
* @notice Check if the view is not null.
* @return bool - True if the view is not null
*/
function notNull(bytes29 memView) internal pure returns (bool) {
return !isNull(memView);
}
/**
* @notice Check if the view is of a valid type and points to a valid location
* in memory.
* @dev We perform this check by examining solidity's unallocated memory
* pointer and ensuring that the view's upper bound is less than that.
* @param memView The view
* @return ret - True if the view is valid
*/
function isValid(bytes29 memView) internal pure returns (bool ret) {
if (typeOf(memView) == 0xffffffffff) {return false;}
uint256 _end = end(memView);
assembly {
// solium-disable-previous-line security/no-inline-assembly
ret := not(gt(_end, mload(0x40)))
}
}
/**
* @notice Require that a typed memory view be valid.
* @dev Returns the view for easy chaining.
* @param memView The view
* @return bytes29 - The validated view
*/
function assertValid(bytes29 memView) internal pure returns (bytes29) {
require(isValid(memView), "Validity assertion failed");
return memView;
}
/**
* @notice Return true if the memview is of the expected type. Otherwise false.
* @param memView The view
* @param _expected The expected type
* @return bool - True if the memview is of the expected type
*/
function isType(bytes29 memView, uint40 _expected) internal pure returns (bool) {
return typeOf(memView) == _expected;
}
/**
* @notice Require that a typed memory view has a specific type.
* @dev Returns the view for easy chaining.
* @param memView The view
* @param _expected The expected type
* @return bytes29 - The view with validated type
*/
function assertType(bytes29 memView, uint40 _expected) internal pure returns (bytes29) {
if (!isType(memView, _expected)) {
(, uint256 g) = encodeHex(uint256(typeOf(memView)));
(, uint256 e) = encodeHex(uint256(_expected));
string memory err = string(
abi.encodePacked(
"Type assertion failed. Got 0x",
uint80(g),
". Expected 0x",
uint80(e)
)
);
revert(err);
}
return memView;
}
/**
* @notice Return an identical view with a different type.
* @param memView The view
* @param _newType The new type
* @return newView - The new view with the specified type
*/
function castTo(bytes29 memView, uint40 _newType) internal pure returns (bytes29 newView) {
// then | in the new type
assembly {
// solium-disable-previous-line security/no-inline-assembly
// shift off the top 5 bytes
newView := or(newView, shr(40, shl(40, memView)))
newView := or(newView, shl(216, _newType))
}
}
/**
* @notice Unsafe raw pointer construction. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @dev Unsafe raw pointer construction. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @param _type The type
* @param _loc The memory address
* @param _len The length
* @return newView - The new view with the specified type, location and length
*/
function unsafeBuildUnchecked(uint256 _type, uint256 _loc, uint256 _len) private pure returns (bytes29 newView) {
assembly {
// solium-disable-previous-line security/no-inline-assembly
newView := shl(96, or(newView, _type)) // insert type
newView := shl(96, or(newView, _loc)) // insert loc
newView := shl(24, or(newView, _len)) // empty bottom 3 bytes
}
}
/**
* @notice Instantiate a new memory view. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @dev Instantiate a new memory view. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @param _type The type
* @param _loc The memory address
* @param _len The length
* @return newView - The new view with the specified type, location and length
*/
function build(uint256 _type, uint256 _loc, uint256 _len) internal pure returns (bytes29 newView) {
uint256 _end = _loc + _len;
assembly {
// solium-disable-previous-line security/no-inline-assembly
if gt(_end, mload(0x40)) {
_end := 0
}
}
if (_end == 0) {
return NULL;
}
newView = unsafeBuildUnchecked(_type, _loc, _len);
}
/**
* @notice Instantiate a memory view from a byte array.
* @dev Note that due to Solidity memory representation, it is not possible to
* implement a deref, as the `bytes` type stores its len in memory.
* @param arr The byte array
* @param newType The type
* @return bytes29 - The memory view
*/
function ref(bytes memory arr, uint40 newType) internal pure returns (bytes29) {
uint256 _len = arr.length;
uint256 _loc;
assembly {
// solium-disable-previous-line security/no-inline-assembly
_loc := add(arr, 0x20) // our view is of the data, not the struct
}
return build(newType, _loc, _len);
}
/**
* @notice Return the associated type information.
* @param memView The memory view
* @return _type - The type associated with the view
*/
function typeOf(bytes29 memView) internal pure returns (uint40 _type) {
assembly {
// solium-disable-previous-line security/no-inline-assembly
// 216 == 256 - 40
_type := shr(216, memView) // shift out lower (12 + 12 + 3) bytes
}
}
/**
* @notice Optimized type comparison. Checks that the 5-byte type flag is equal.
* @param left The first view
* @param right The second view
* @return bool - True if the 5-byte type flag is equal
*/
function sameType(bytes29 left, bytes29 right) internal pure returns (bool) {
// XOR the inputs to check their difference
return (left ^ right) >> (2 * TWELVE_BYTES) == 0;
}
/**
* @notice Return the memory address of the underlying bytes.
* @param memView The view
* @return _loc - The memory address
*/
function loc(bytes29 memView) internal pure returns (uint96 _loc) {
uint256 _mask = LOW_12_MASK; // assembly can't use globals
assembly {
// solium-disable-previous-line security/no-inline-assembly
// 120 bits = 12 bytes (the encoded loc) + 3 bytes (empty low space)
_loc := and(shr(120, memView), _mask)
}
}
/**
* @notice The number of memory words this memory view occupies, rounded up.
* @param memView The view
* @return uint256 - The number of memory words
*/
function words(bytes29 memView) internal pure returns (uint256) {
return (uint256(len(memView)) + 32) / 32;
}
/**
* @notice The in-memory footprint of a fresh copy of the view.
* @param memView The view
* @return uint256 - The in-memory footprint of a fresh copy of the view.
*/
function footprint(bytes29 memView) internal pure returns (uint256) {
return words(memView) * 32;
}
/**
* @notice The number of bytes of the view.
* @param memView The view
* @return _len - The length of the view
*/
function len(bytes29 memView) internal pure returns (uint96 _len) {
uint256 _mask = LOW_12_MASK; // assembly can't use globals
assembly {
// solium-disable-previous-line security/no-inline-assembly
_len := and(shr(24, memView), _mask)
}
}
/**
* @notice Returns the endpoint of `memView`.
* @param memView The view
* @return uint256 - The endpoint of `memView`
*/
function end(bytes29 memView) internal pure returns (uint256) {
return loc(memView) + len(memView);
}
/**
* @notice Safe slicing without memory modification.
* @param memView The view
* @param _index The start index
* @param _len The length
* @param newType The new type
* @return bytes29 - The new view
*/
function slice(bytes29 memView, uint256 _index, uint256 _len, uint40 newType) internal pure returns (bytes29) {
uint256 _loc = loc(memView);
// Ensure it doesn't overrun the view
if (_loc + _index + _len > end(memView)) {
return NULL;
}
_loc = _loc + _index;
return build(newType, _loc, _len);
}
/**
* @notice Shortcut to `slice`. Gets a view representing the first `_len` bytes.
* @param memView The view
* @param _len The length
* @param newType The new type
* @return bytes29 - The new view
*/
function prefix(bytes29 memView, uint256 _len, uint40 newType) internal pure returns (bytes29) {
return slice(memView, 0, _len, newType);
}
/**
* @notice Shortcut to `slice`. Gets a view representing the last `_len` bytes.
* @param memView The view
* @param _len The length
* @param newType The new type
* @return bytes29 - The new view
*/
function postfix(bytes29 memView, uint256 _len, uint40 newType) internal pure returns (bytes29) {
return slice(memView, uint256(len(memView)) - _len, _len, newType);
}
/**
* @notice Construct an error message for an indexing overrun.
* @param _loc The memory address
* @param _len The length
* @param _index The index
* @param _slice The slice where the overrun occurred
* @return err - The err
*/
function indexErrOverrun(
uint256 _loc,
uint256 _len,
uint256 _index,
uint256 _slice
) internal pure returns (string memory err) {
(, uint256 a) = encodeHex(_loc);
(, uint256 b) = encodeHex(_len);
(, uint256 c) = encodeHex(_index);
(, uint256 d) = encodeHex(_slice);
err = string(
abi.encodePacked(
"TypedMemView/index - Overran the view. Slice is at 0x",
uint48(a),
" with length 0x",
uint48(b),
". Attempted to index at offset 0x",
uint48(c),
" with length 0x",
uint48(d),
"."
)
);
}
/**
* @notice Load up to 32 bytes from the view onto the stack.
* @dev Returns a bytes32 with only the `_bytes` highest bytes set.
* This can be immediately cast to a smaller fixed-length byte array.
* To automatically cast to an integer, use `indexUint`.
* @param memView The view
* @param _index The index
* @param _bytes The bytes length
* @return result - The 32 byte result
*/
function index(bytes29 memView, uint256 _index, uint8 _bytes) internal pure returns (bytes32 result) {
if (_bytes == 0) {return bytes32(0);}
if (_index + _bytes > len(memView)) {
revert(indexErrOverrun(loc(memView), len(memView), _index, uint256(_bytes)));
}
require(_bytes <= 32, "TypedMemView/index - Attempted to index more than 32 bytes");
unchecked {
uint8 bitLength = _bytes * 8;
uint256 _loc = loc(memView);
uint256 _mask = leftMask(bitLength);
assembly {
// solium-disable-previous-line security/no-inline-assembly
result := and(mload(add(_loc, _index)), _mask)
}
}
}
/**
* @notice Parse an unsigned integer from the view at `_index`.
* @dev Requires that the view has >= `_bytes` bytes following that index.
* @param memView The view
* @param _index The index
* @param _bytes The bytes length
* @return result - The unsigned integer
*/
function indexUint(bytes29 memView, uint256 _index, uint8 _bytes) internal pure returns (uint256 result) {
return uint256(index(memView, _index, _bytes)) >> ((32 - _bytes) * 8);
}
/**
* @notice Parse an unsigned integer from LE bytes.
* @param memView The view
* @param _index The index
* @param _bytes The bytes length
* @return result - The unsigned integer
*/
function indexLEUint(bytes29 memView, uint256 _index, uint8 _bytes) internal pure returns (uint256 result) {
return reverseUint256(uint256(index(memView, _index, _bytes)));
}
/**
* @notice Parse an address from the view at `_index`. Requires that the view have >= 20 bytes
* following that index.
* @param memView The view
* @param _index The index
* @return address - The address
*/
function indexAddress(bytes29 memView, uint256 _index) internal pure returns (address) {
return address(uint160(indexUint(memView, _index, 20)));
}
/**
* @notice Return the keccak256 hash of the underlying memory
* @param memView The view
* @return digest - The keccak256 hash of the underlying memory
*/
function keccak(bytes29 memView) internal pure returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
// solium-disable-previous-line security/no-inline-assembly
digest := keccak256(_loc, _len)
}
}
/**
* @notice Return the sha2 digest of the underlying memory.
* @dev We explicitly deallocate memory afterwards.
* @param memView The view
* @return digest - The sha2 hash of the underlying memory
*/
function sha2(bytes29 memView) internal view returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
// solium-disable-previous-line security/no-inline-assembly
let ptr := mload(0x40)
pop(staticcall(gas(), 2, _loc, _len, ptr, 0x20)) // sha2 #1
digest := mload(ptr)
}
}
/**
* @notice Implements bitcoin's hash160 (rmd160(sha2()))
* @param memView The pre-image
* @return digest - the Digest
*/
function hash160(bytes29 memView) internal view returns (bytes20 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
// solium-disable-previous-line security/no-inline-assembly
let ptr := mload(0x40)
pop(staticcall(gas(), 2, _loc, _len, ptr, 0x20)) // sha2
pop(staticcall(gas(), 3, ptr, 0x20, ptr, 0x20)) // rmd160
digest := mload(add(ptr, 0xc)) // return value is 0-prefixed.
}
}
/**
* @notice Implements bitcoin's hash256 (double sha2)
* @param memView A view of the preimage
* @return digest - the Digest
*/
function hash256(bytes29 memView) internal view returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
// solium-disable-previous-line security/no-inline-assembly
let ptr := mload(0x40)
pop(staticcall(gas(), 2, _loc, _len, ptr, 0x20)) // sha2 #1
pop(staticcall(gas(), 2, ptr, 0x20, ptr, 0x20)) // sha2 #2
digest := mload(ptr)
}
}
/**
* @notice Return true if the underlying memory is equal. Else false.
* @param left The first view
* @param right The second view
* @return bool - True if the underlying memory is equal
*/
function untypedEqual(bytes29 left, bytes29 right) internal pure returns (bool) {
return (loc(left) == loc(right) && len(left) == len(right)) || keccak(left) == keccak(right);
}
/**
* @notice Return false if the underlying memory is equal. Else true.
* @param left The first view
* @param right The second view
* @return bool - False if the underlying memory is equal
*/
function untypedNotEqual(bytes29 left, bytes29 right) internal pure returns (bool) {
return !untypedEqual(left, right);
}
/**
* @notice Compares type equality.
* @dev Shortcuts if the pointers are identical, otherwise compares type and digest.
* @param left The first view
* @param right The second view
* @return bool - True if the types are the same
*/
function equal(bytes29 left, bytes29 right) internal pure returns (bool) {
return left == right || (typeOf(left) == typeOf(right) && keccak(left) == keccak(right));
}
/**
* @notice Compares type inequality.
* @dev Shortcuts if the pointers are identical, otherwise compares type and digest.
* @param left The first view
* @param right The second view
* @return bool - True if the types are not the same
*/
function notEqual(bytes29 left, bytes29 right) internal pure returns (bool) {
return !equal(left, right);
}
/**
* @notice Copy the view to a location, return an unsafe memory reference
* @dev Super Dangerous direct memory access.
*
* This reference can be overwritten if anything else modifies memory (!!!).
* As such it MUST be consumed IMMEDIATELY.
* This function is private to prevent unsafe usage by callers.
* @param memView The view
* @param _newLoc The new location
* @return written - the unsafe memory reference
*/
function unsafeCopyTo(bytes29 memView, uint256 _newLoc) private view returns (bytes29 written) {
require(notNull(memView), "TypedMemView/copyTo - Null pointer deref");
require(isValid(memView), "TypedMemView/copyTo - Invalid pointer deref");
uint256 _len = len(memView);
uint256 _oldLoc = loc(memView);
uint256 ptr;
assembly {
// solium-disable-previous-line security/no-inline-assembly
ptr := mload(0x40)
// revert if we're writing in occupied memory
if gt(ptr, _newLoc) {
revert(0x60, 0x20) // empty revert message
}
// use the identity precompile to copy
// guaranteed not to fail, so pop the success
pop(staticcall(gas(), 4, _oldLoc, _len, _newLoc, _len))
}
written = unsafeBuildUnchecked(typeOf(memView), _newLoc, _len);
}
/**
* @notice Copies the referenced memory to a new loc in memory, returning a `bytes` pointing to
* the new memory
* @dev Shortcuts if the pointers are identical, otherwise compares type and digest.
* @param memView The view
* @return ret - The view pointing to the new memory
*/
function clone(bytes29 memView) internal view returns (bytes memory ret) {
uint256 ptr;
uint256 _len = len(memView);
assembly {
// solium-disable-previous-line security/no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
ret := ptr
}
unsafeCopyTo(memView, ptr + 0x20);
assembly {
// solium-disable-previous-line security/no-inline-assembly
mstore(0x40, add(add(ptr, _len), 0x20)) // write new unused pointer
mstore(ptr, _len) // write len of new array (in bytes)
}
}
/**
* @notice Join the views in memory, return an unsafe reference to the memory.
* @dev Super Dangerous direct memory access.
*
* This reference can be overwritten if anything else modifies memory (!!!).
* As such it MUST be consumed IMMEDIATELY.
* This function is private to prevent unsafe usage by callers.
* @param memViews The views
* @return unsafeView - The conjoined view pointing to the new memory
*/
function unsafeJoin(bytes29[] memory memViews, uint256 _location) private view returns (bytes29 unsafeView) {
assembly {
// solium-disable-previous-line security/no-inline-assembly
let ptr := mload(0x40)
// revert if we're writing in occupied memory
if gt(ptr, _location) {
revert(0x60, 0x20) // empty revert message
}
}
uint256 _offset = 0;
for (uint256 i = 0; i < memViews.length; i ++) {
bytes29 memView = memViews[i];
unsafeCopyTo(memView, _location + _offset);
_offset += len(memView);
}
unsafeView = unsafeBuildUnchecked(0, _location, _offset);
}
/**
* @notice Produce the keccak256 digest of the concatenated contents of multiple views.
* @param memViews The views
* @return bytes32 - The keccak256 digest
*/
function joinKeccak(bytes29[] memory memViews) internal view returns (bytes32) {
uint256 ptr;
assembly {
// solium-disable-previous-line security/no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
}
return keccak(unsafeJoin(memViews, ptr));
}
/**
* @notice Produce the sha256 digest of the concatenated contents of multiple views.
* @param memViews The views
* @return bytes32 - The sha256 digest
*/
function joinSha2(bytes29[] memory memViews) internal view returns (bytes32) {
uint256 ptr;
assembly {
// solium-disable-previous-line security/no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
}
return sha2(unsafeJoin(memViews, ptr));
}
/**
* @notice copies all views, joins them into a new bytearray.
* @param memViews The views
* @return ret - The new byte array
*/
function join(bytes29[] memory memViews) internal view returns (bytes memory ret) {
uint256 ptr;
assembly {
// solium-disable-previous-line security/no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
}
bytes29 _newView = unsafeJoin(memViews, ptr + 0x20);
uint256 _written = len(_newView);
uint256 _footprint = footprint(_newView);
assembly {
// solium-disable-previous-line security/no-inline-assembly
// store the legnth
mstore(ptr, _written)
// new pointer is old + 0x20 + the footprint of the body
mstore(0x40, add(add(ptr, _footprint), 0x20))
ret := ptr
}
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.8.4;
import "./TypedMemView.sol";
import "../types/ScriptTypesEnum.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
library BitcoinHelper {
using SafeCast for uint96;
using SafeCast for uint256;
using TypedMemView for bytes;
using TypedMemView for bytes29;
// The target at minimum Difficulty. Also the target of the genesis block
uint256 internal constant DIFF1_TARGET = 0xffff0000000000000000000000000000000000000000000000000000;
uint256 internal constant RETARGET_PERIOD = 2 * 7 * 24 * 60 * 60; // 2 weeks in seconds
uint256 internal constant RETARGET_PERIOD_BLOCKS = 2016; // 2 weeks in blocks
enum BTCTypes {
Unknown, // 0x0
CompactInt, // 0x1
ScriptSig, // 0x2 - with length prefix
Outpoint, // 0x3
TxIn, // 0x4
IntermediateTxIns, // 0x5 - used in vin parsing
Vin, // 0x6
ScriptPubkey, // 0x7 - with length prefix
PKH, // 0x8 - the 20-byte payload digest
WPKH, // 0x9 - the 20-byte payload digest
WSH, // 0xa - the 32-byte payload digest
SH, // 0xb - the 20-byte payload digest
OpReturnPayload, // 0xc
TxOut, // 0xd
IntermediateTxOuts, // 0xe - used in vout parsing
Vout, // 0xf
Header, // 0x10
HeaderArray, // 0x11
MerkleNode, // 0x12
MerkleStep, // 0x13
MerkleArray // 0x14
}
/// @notice requires `memView` to be of a specified type
/// @dev passes if it is the correct type, errors if not
/// @param memView a 29-byte view with a 5-byte type
/// @param t the expected type (e.g. BTCTypes.Outpoint, BTCTypes.TxIn, etc)
modifier typeAssert(bytes29 memView, BTCTypes t) {
memView.assertType(uint40(t));
_;
}
// Revert with an error message re: non-minimal VarInts
function revertNonMinimal(bytes29 ref) private pure returns (string memory) {
(, uint256 g) = TypedMemView.encodeHex(ref.indexUint(0, ref.len().toUint8()));
string memory err = string(
abi.encodePacked(
"Non-minimal var int. Got 0x",
uint144(g)
)
);
revert(err);
}
/// @notice reads a compact int from the view at the specified index
/// @param memView a 29-byte view with a 5-byte type
/// @param _index the index
/// @return number returns the compact int at the specified index
function indexCompactInt(bytes29 memView, uint256 _index) internal pure returns (uint64 number) {
uint256 flag = memView.indexUint(_index, 1);
if (flag <= 0xfc) {
return flag.toUint64();
} else if (flag == 0xfd) {
number = memView.indexLEUint(_index + 1, 2).toUint64();
if (compactIntLength(number) != 3) {revertNonMinimal(memView.slice(_index, 3, 0));}
} else if (flag == 0xfe) {
number = memView.indexLEUint(_index + 1, 4).toUint64();
if (compactIntLength(number) != 5) {revertNonMinimal(memView.slice(_index, 5, 0));}
} else if (flag == 0xff) {
number = memView.indexLEUint(_index + 1, 8).toUint64();
if (compactIntLength(number) != 9) {revertNonMinimal(memView.slice(_index, 9, 0));}
}
}
/// @notice gives the total length (in bytes) of a CompactInt-encoded number
/// @param number the number as uint64
/// @return the compact integer length as uint8
function compactIntLength(uint64 number) private pure returns (uint8) {
if (number <= 0xfc) {
return 1;
} else if (number <= 0xffff) {
return 3;
} else if (number <= 0xffffffff) {
return 5;
} else {
return 9;
}
}
/// @notice extracts the LE txid from an outpoint
/// @param _outpoint the outpoint
/// @return the LE txid
function txidLE(bytes29 _outpoint) internal pure typeAssert(_outpoint, BTCTypes.Outpoint) returns (bytes32) {
return _outpoint.index(0, 32);
}
/// @notice Calculates the required transaction Id from the transaction details
/// @dev Calculates the hash of transaction details two consecutive times
/// @param _version Version of the transaction
/// @param _vin Inputs of the transaction
/// @param _vout Outputs of the transaction
/// @param _locktime Lock time of the transaction
/// @return Transaction Id of the transaction (in LE form)
function calculateTxId(
bytes4 _version,
bytes memory _vin,
bytes memory _vout,
bytes4 _locktime
) internal pure returns (bytes32) {
bytes32 inputHash1 = sha256(abi.encodePacked(_version, _vin, _vout, _locktime));
bytes32 inputHash2 = sha256(abi.encodePacked(inputHash1));
return inputHash2;
}
/// @notice Reverts a Bytes32 input
/// @param _input Bytes32 input that we want to revert
/// @return Reverted bytes32
function reverseBytes32(bytes32 _input) private pure returns (bytes32) {
bytes memory temp;
bytes32 result;
for (uint i = 0; i < 32; i++) {
temp = abi.encodePacked(temp, _input[31-i]);
}
assembly {
result := mload(add(temp, 32))
}
return result;
}
/// @notice Parses outpoint info from an input
/// @dev Reverts if vin is null
/// @param _vin The vin of a Bitcoin transaction
/// @param _index Index of the input that we are looking at
/// @return _txId Output tx id
/// @return _outputIndex Output tx index
function extractOutpoint(
bytes memory _vin,
uint _index
) internal pure returns (bytes32 _txId, uint _outputIndex) {
bytes29 vin = tryAsVin(_vin.ref(uint40(BTCTypes.Unknown)));
require(!vin.isNull(), "BitcoinHelper: vin is null");
bytes29 input = indexVin(vin, _index);
bytes29 _outpoint = outpoint(input);
_txId = txidLE(_outpoint);
_outputIndex = outpointIdx(_outpoint);
}
/// @notice extracts the index as an integer from the outpoint
/// @param _outpoint the outpoint
/// @return the index
function outpointIdx(bytes29 _outpoint) internal pure typeAssert(_outpoint, BTCTypes.Outpoint) returns (uint32) {
return _outpoint.indexLEUint(32, 4).toUint32();
}
/// @notice extracts the outpoint from an input
/// @param _input the input
/// @return the outpoint as a typed memory
function outpoint(bytes29 _input) internal pure typeAssert(_input, BTCTypes.TxIn) returns (bytes29) {
return _input.slice(0, 36, uint40(BTCTypes.Outpoint));
}
/// @notice extracts the script sig from an input
/// @param _input the input
/// @return the script sig as a typed memory
function scriptSig(bytes29 _input) internal pure typeAssert(_input, BTCTypes.TxIn) returns (bytes29) {
uint64 scriptLength = indexCompactInt(_input, 36);
return _input.slice(36, compactIntLength(scriptLength) + scriptLength, uint40(BTCTypes.ScriptSig));
}
/// @notice determines the length of the first input in an array of inputs
/// @param _inputs the vin without its length prefix
/// @return the input length
function inputLength(bytes29 _inputs) private pure typeAssert(_inputs, BTCTypes.IntermediateTxIns) returns (uint256) {
uint64 scriptLength = indexCompactInt(_inputs, 36);
return uint256(compactIntLength(scriptLength)) + uint256(scriptLength) + 36 + 4;
}
/// @notice extracts the input at a specified index
/// @param _vin the vin
/// @param _index the index of the desired input
/// @return the desired input
function indexVin(bytes29 _vin, uint256 _index) internal pure typeAssert(_vin, BTCTypes.Vin) returns (bytes29) {
uint256 _nIns = uint256(indexCompactInt(_vin, 0));
uint256 _viewLen = _vin.len();
require(_index < _nIns, "Vin read overrun");
uint256 _offset = uint256(compactIntLength(uint64(_nIns)));
bytes29 _remaining;
for (uint256 _i = 0; _i < _index; _i += 1) {
_remaining = _vin.postfix(_viewLen - _offset, uint40(BTCTypes.IntermediateTxIns));
_offset += inputLength(_remaining);
}
_remaining = _vin.postfix(_viewLen - _offset, uint40(BTCTypes.IntermediateTxIns));
uint256 _len = inputLength(_remaining);
return _vin.slice(_offset, _len, uint40(BTCTypes.TxIn));
}
/// @notice extracts the value from an output
/// @param _output the output
/// @return the value
function value(bytes29 _output) internal pure typeAssert(_output, BTCTypes.TxOut) returns (uint64) {
return _output.indexLEUint(0, 8).toUint64();
}
/// @notice Finds total outputs value
/// @dev Reverts if vout is null
/// @param _vout The vout of a Bitcoin transaction
/// @return _totalValue Total vout value
function parseOutputsTotalValue(bytes memory _vout) internal pure returns (uint64 _totalValue) {
bytes29 voutView = tryAsVout(_vout.ref(uint40(BTCTypes.Unknown)));
require(!voutView.isNull(), "BitcoinHelper: vout is null");
bytes29 output;
// Finds total number of outputs
uint _numberOfOutputs = uint256(indexCompactInt(voutView, 0));
for (uint index = 0; index < _numberOfOutputs; index++) {
output = indexVout(voutView, index);
_totalValue = _totalValue + value(output);
}
}
/// @notice Parses the BTC amount that has been sent to
/// a specific script in a specific output
/// @param _vout The vout of a Bitcoin transaction
/// @param _voutIndex Index of the output that we are looking at
/// @param _script Desired recipient script
/// @param _scriptType Type of the script (e.g. P2PK)
/// @return bitcoinAmount Amount of BTC have been sent to the _script
function parseValueFromSpecificOutputHavingScript(
bytes memory _vout,
uint _voutIndex,
bytes memory _script,
ScriptTypes _scriptType
) internal pure returns (uint64 bitcoinAmount) {
bytes29 voutView = tryAsVout(_vout.ref(uint40(BTCTypes.Unknown)));
require(!voutView.isNull(), "BitcoinHelper: vout is null");
bytes29 output = indexVout(voutView, _voutIndex);
bytes29 _scriptPubkey = scriptPubkey(output);
if (_scriptType == ScriptTypes.P2PK) {
// note: first byte is Pushdata Bytelength.
// note: public key length is 32.
bitcoinAmount = keccak256(_script) == keccak256(abi.encodePacked(_scriptPubkey.index(1, 32))) ? value(output) : 0;
} else if (_scriptType == ScriptTypes.P2PKH) {
// note: first three bytes are OP_DUP, OP_HASH160, Pushdata Bytelength.
// note: public key hash length is 20.
bitcoinAmount = keccak256(_script) == keccak256(abi.encodePacked(_scriptPubkey.indexAddress(3))) ? value(output) : 0;
} else if (_scriptType == ScriptTypes.P2SH) {
// note: first two bytes are OP_HASH160, Pushdata Bytelength
// note: script hash length is 20.
bitcoinAmount = keccak256(_script) == keccak256(abi.encodePacked(_scriptPubkey.indexAddress(2))) ? value(output) : 0;
} else if (_scriptType == ScriptTypes.P2WPKH) {
// note: first two bytes are OP_0, Pushdata Bytelength
// note: segwit public key hash length is 20.
bitcoinAmount = keccak256(_script) == keccak256(abi.encodePacked(_scriptPubkey.indexAddress(2))) ? value(output) : 0;
} else if (_scriptType == ScriptTypes.P2WSH) {
// note: first two bytes are OP_0, Pushdata Bytelength
// note: segwit script hash length is 32.
bitcoinAmount = keccak256(_script) == keccak256(abi.encodePacked(_scriptPubkey.index(2, 32))) ? value(output) : 0;
}
}
/// @notice Parses the BTC amount of a transaction
/// @dev Finds the BTC amount that has been sent to the locking script
/// Returns zero if no matching locking scrip is found
/// @param _vout The vout of a Bitcoin transaction
/// @param _lockingScript Desired locking script
/// @return bitcoinAmount Amount of BTC have been sent to the _lockingScript
function parseValueHavingLockingScript(
bytes memory _vout,
bytes memory _lockingScript
) internal view returns (uint64 bitcoinAmount) {
// Checks that vout is not null
bytes29 voutView = tryAsVout(_vout.ref(uint40(BTCTypes.Unknown)));
require(!voutView.isNull(), "BitcoinHelper: vout is null");
bytes29 output;
bytes29 _scriptPubkey;
// Finds total number of outputs
uint _numberOfOutputs = uint256(indexCompactInt(voutView, 0));
for (uint index = 0; index < _numberOfOutputs; index++) {
output = indexVout(voutView, index);
_scriptPubkey = scriptPubkey(output);
if (
keccak256(abi.encodePacked(_scriptPubkey.clone())) == keccak256(abi.encodePacked(_lockingScript))
) {
bitcoinAmount = value(output);
// Stops searching after finding the desired locking script
break;
}
}
}
/// @notice Parses the BTC amount and the op_return of a transaction
/// @dev Finds the BTC amount that has been sent to the locking script
/// Assumes that payload size is less than 76 bytes
/// @param _vout The vout of a Bitcoin transaction
/// @param _lockingScript Desired locking script
/// @return bitcoinAmount Amount of BTC have been sent to the _lockingScript
/// @return arbitraryData Opreturn data of the transaction
function parseValueAndDataHavingLockingScriptSmallPayload(
bytes memory _vout,
bytes memory _lockingScript
) internal view returns (uint64 bitcoinAmount, bytes memory arbitraryData) {
// Checks that vout is not null
bytes29 voutView = tryAsVout(_vout.ref(uint40(BTCTypes.Unknown)));
require(!voutView.isNull(), "BitcoinHelper: vout is null");
bytes29 output;
bytes29 _scriptPubkey;
bytes29 _scriptPubkeyWithLength;
bytes29 _arbitraryData;
// Finds total number of outputs
uint _numberOfOutputs = uint256(indexCompactInt(voutView, 0));
for (uint index = 0; index < _numberOfOutputs; index++) {
output = indexVout(voutView, index);
_scriptPubkey = scriptPubkey(output);
_scriptPubkeyWithLength = scriptPubkeyWithLength(output);
_arbitraryData = opReturnPayloadSmall(_scriptPubkeyWithLength);
// Checks whether the output is an arbitarary data or not
if(_arbitraryData == TypedMemView.NULL) {
// Output is not an arbitrary data
if (
keccak256(abi.encodePacked(_scriptPubkey.clone())) == keccak256(abi.encodePacked(_lockingScript))
) {
bitcoinAmount = value(output);
}
} else {
// Returns the whole bytes array
arbitraryData = _arbitraryData.clone();
}
}
}
/// @notice Parses the BTC amount and the op_return of a transaction
/// @dev Finds the BTC amount that has been sent to the locking script
/// Assumes that payload size is greater than 75 bytes
/// @param _vout The vout of a Bitcoin transaction
/// @param _lockingScript Desired locking script
/// @return bitcoinAmount Amount of BTC have been sent to the _lockingScript
/// @return arbitraryData Opreturn data of the transaction
function parseValueAndDataHavingLockingScriptBigPayload(
bytes memory _vout,
bytes memory _lockingScript
) internal view returns (uint64 bitcoinAmount, bytes memory arbitraryData) {
// Checks that vout is not null
bytes29 voutView = tryAsVout(_vout.ref(uint40(BTCTypes.Unknown)));
require(!voutView.isNull(), "BitcoinHelper: vout is null");
bytes29 output;
bytes29 _scriptPubkey;
bytes29 _scriptPubkeyWithLength;
bytes29 _arbitraryData;
// Finds total number of outputs
uint _numberOfOutputs = uint256(indexCompactInt(voutView, 0));
for (uint index = 0; index < _numberOfOutputs; index++) {
output = indexVout(voutView, index);
_scriptPubkey = scriptPubkey(output);
_scriptPubkeyWithLength = scriptPubkeyWithLength(output);
_arbitraryData = opReturnPayloadBig(_scriptPubkeyWithLength);
// Checks whether the output is an arbitarary data or not
if(_arbitraryData == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) {
// Output is not an arbitrary data
if (
keccak256(abi.encodePacked(_scriptPubkey.clone())) == keccak256(abi.encodePacked(_lockingScript))
) {
bitcoinAmount = value(output);
}
} else {
// Returns the whole bytes array
arbitraryData = _arbitraryData.clone();
}
}
}
/// @notice extracts the scriptPubkey from an output
/// @param _output the output
/// @return the scriptPubkey
function scriptPubkey(bytes29 _output) internal pure typeAssert(_output, BTCTypes.TxOut) returns (bytes29) {
uint64 scriptLength = indexCompactInt(_output, 8);
return _output.slice(8 + compactIntLength(scriptLength), scriptLength, uint40(BTCTypes.ScriptPubkey));
}
/// @notice extracts the scriptPubkey from an output
/// @param _output the output
/// @return the scriptPubkey
function scriptPubkeyWithLength(bytes29 _output) internal pure typeAssert(_output, BTCTypes.TxOut) returns (bytes29) {
uint64 scriptLength = indexCompactInt(_output, 8);
return _output.slice(8, compactIntLength(scriptLength) + scriptLength, uint40(BTCTypes.ScriptPubkey));
}
/// @notice Parses locking script from an output
/// @dev Reverts if vout is null
/// @param _vout The vout of a Bitcoin transaction
/// @param _index Index of the output that we are looking at
/// @return _lockingScript Parsed locking script
function getLockingScript(
bytes memory _vout,
uint _index
) internal view returns (bytes memory _lockingScript) {
bytes29 vout = tryAsVout(_vout.ref(uint40(BTCTypes.Unknown)));
require(!vout.isNull(), "BitcoinHelper: vout is null");
bytes29 output = indexVout(vout, _index);
bytes29 _lockingScriptBytes29 = scriptPubkey(output);
_lockingScript = _lockingScriptBytes29.clone();
}
/// @notice Returns number of outputs in a vout
/// @param _vout The vout of a Bitcoin transaction
function numberOfOutputs(bytes memory _vout) internal pure returns (uint _numberOfOutputs) {
bytes29 voutView = tryAsVout(_vout.ref(uint40(BTCTypes.Unknown)));
_numberOfOutputs = uint256(indexCompactInt(voutView, 0));
}
/// @notice determines the length of the first output in an array of outputs
/// @param _outputs the vout without its length prefix
/// @return the output length
function outputLength(bytes29 _outputs) private pure typeAssert(_outputs, BTCTypes.IntermediateTxOuts) returns (uint256) {
uint64 scriptLength = indexCompactInt(_outputs, 8);
return uint256(compactIntLength(scriptLength)) + uint256(scriptLength) + 8;
}
/// @notice extracts the output at a specified index
/// @param _vout the vout
/// @param _index the index of the desired output
/// @return the desired output
function indexVout(bytes29 _vout, uint256 _index) internal pure typeAssert(_vout, BTCTypes.Vout) returns (bytes29) {
uint256 _nOuts = uint256(indexCompactInt(_vout, 0));
uint256 _viewLen = _vout.len();
require(_index < _nOuts, "Vout read overrun");
uint256 _offset = uint256(compactIntLength(uint64(_nOuts)));
bytes29 _remaining;
for (uint256 _i = 0; _i < _index; _i += 1) {
_remaining = _vout.postfix(_viewLen - _offset, uint40(BTCTypes.IntermediateTxOuts));
_offset += outputLength(_remaining);
}
_remaining = _vout.postfix(_viewLen - _offset, uint40(BTCTypes.IntermediateTxOuts));
uint256 _len = outputLength(_remaining);
return _vout.slice(_offset, _len, uint40(BTCTypes.TxOut));
}
/// @notice extracts the Op Return Payload
/// @dev structure of the input is: 1 byte op return + 2 bytes indicating the length of payload + max length for op return payload is 80 bytes
/// @param _spk the scriptPubkey
/// @return the Op Return Payload (or null if not a valid Op Return output)
function opReturnPayloadBig(bytes29 _spk) internal pure typeAssert(_spk, BTCTypes.ScriptPubkey) returns (bytes29) {
uint64 _bodyLength = indexCompactInt(_spk, 0);
uint64 _payloadLen = _spk.indexUint(3, 1).toUint64();
if (_bodyLength > 83 || _bodyLength < 4 || _spk.indexUint(1, 1) != 0x6a || _spk.indexUint(3, 1) != _bodyLength - 3) {
return TypedMemView.nullView();
}
return _spk.slice(4, _payloadLen, uint40(BTCTypes.OpReturnPayload));
}
/// @notice extracts the Op Return Payload
/// @dev structure of the input is: 1 byte op return + 1 bytes indicating the length of payload + max length for op return payload is 75 bytes
/// @param _spk the scriptPubkey
/// @return the Op Return Payload (or null if not a valid Op Return output)
function opReturnPayloadSmall(bytes29 _spk) internal pure typeAssert(_spk, BTCTypes.ScriptPubkey) returns (bytes29) {
uint64 _bodyLength = indexCompactInt(_spk, 0);
uint64 _payloadLen = _spk.indexUint(2, 1).toUint64();
if (_bodyLength > 77 || _bodyLength < 4 || _spk.indexUint(1, 1) != 0x6a || _spk.indexUint(2, 1) != _bodyLength - 2) {
return TypedMemView.nullView();
}
return _spk.slice(3, _payloadLen, uint40(BTCTypes.OpReturnPayload));
}
/// @notice verifies the vin and converts to a typed memory
/// @dev will return null in error cases
/// @param _vin the vin
/// @return the typed vin (or null if error)
function tryAsVin(bytes29 _vin) internal pure typeAssert(_vin, BTCTypes.Unknown) returns (bytes29) {
if (_vin.len() == 0) {
return TypedMemView.nullView();
}
uint64 _nIns = indexCompactInt(_vin, 0);
uint256 _viewLen = _vin.len();
if (_nIns == 0) {
return TypedMemView.nullView();
}
uint256 _offset = uint256(compactIntLength(_nIns));
for (uint256 i = 0; i < _nIns; i++) {
if (_offset >= _viewLen) {
// We've reached the end, but are still trying to read more
return TypedMemView.nullView();
}
bytes29 _remaining = _vin.postfix(_viewLen - _offset, uint40(BTCTypes.IntermediateTxIns));
_offset += inputLength(_remaining);
}
if (_offset != _viewLen) {
return TypedMemView.nullView();
}
return _vin.castTo(uint40(BTCTypes.Vin));
}
/// @notice verifies the vout and converts to a typed memory
/// @dev will return null in error cases
/// @param _vout the vout
/// @return the typed vout (or null if error)
function tryAsVout(bytes29 _vout) internal pure typeAssert(_vout, BTCTypes.Unknown) returns (bytes29) {
if (_vout.len() == 0) {
return TypedMemView.nullView();
}
uint64 _nOuts = indexCompactInt(_vout, 0);
uint256 _viewLen = _vout.len();
if (_nOuts == 0) {
return TypedMemView.nullView();
}
uint256 _offset = uint256(compactIntLength(_nOuts));
for (uint256 i = 0; i < _nOuts; i++) {
if (_offset >= _viewLen) {
// We've reached the end, but are still trying to read more
return TypedMemView.nullView();
}
bytes29 _remaining = _vout.postfix(_viewLen - _offset, uint40(BTCTypes.IntermediateTxOuts));
_offset += outputLength(_remaining);
}
if (_offset != _viewLen) {
return TypedMemView.nullView();
}
return _vout.castTo(uint40(BTCTypes.Vout));
}
/// @notice verifies the header and converts to a typed memory
/// @dev will return null in error cases
/// @param _header the header
/// @return the typed header (or null if error)
function tryAsHeader(bytes29 _header) internal pure typeAssert(_header, BTCTypes.Unknown) returns (bytes29) {
if (_header.len() != 80) {
return TypedMemView.nullView();
}
return _header.castTo(uint40(BTCTypes.Header));
}
/// @notice Index a header array.
/// @dev Errors on overruns
/// @param _arr The header array
/// @param index The 0-indexed location of the header to get
/// @return the typed header at `index`
function indexHeaderArray(bytes29 _arr, uint256 index) internal pure typeAssert(_arr, BTCTypes.HeaderArray) returns (bytes29) {
uint256 _start = index * 80;
return _arr.slice(_start, 80, uint40(BTCTypes.Header));
}
/// @notice verifies the header array and converts to a typed memory
/// @dev will return null in error cases
/// @param _arr the header array
/// @return the typed header array (or null if error)
function tryAsHeaderArray(bytes29 _arr) internal pure typeAssert(_arr, BTCTypes.Unknown) returns (bytes29) {
if (_arr.len() % 80 != 0) {
return TypedMemView.nullView();
}
return _arr.castTo(uint40(BTCTypes.HeaderArray));
}
/// @notice verifies the merkle array and converts to a typed memory
/// @dev will return null in error cases
/// @param _arr the merkle array
/// @return the typed merkle array (or null if error)
function tryAsMerkleArray(bytes29 _arr) internal pure typeAssert(_arr, BTCTypes.Unknown) returns (bytes29) {
if (_arr.len() % 32 != 0) {
return TypedMemView.nullView();
}
return _arr.castTo(uint40(BTCTypes.MerkleArray));
}
/// @notice extracts the merkle root from the header
/// @param _header the header
/// @return the merkle root
function merkleRoot(bytes29 _header) internal pure typeAssert(_header, BTCTypes.Header) returns (bytes32) {
return _header.index(36, 32);
}
/// @notice extracts the target from the header
/// @param _header the header
/// @return the target
function target(bytes29 _header) internal pure typeAssert(_header, BTCTypes.Header) returns (uint256) {
uint256 _mantissa = _header.indexLEUint(72, 3);
require(_header.indexUint(75, 1) > 2, "ViewBTC: invalid target difficulty");
uint256 _exponent = _header.indexUint(75, 1) - 3;
return _mantissa * (256 ** _exponent);
}
/// @notice calculates the difficulty from a target
/// @param _target the target
/// @return the difficulty
function toDiff(uint256 _target) private pure returns (uint256) {
return DIFF1_TARGET / (_target);
}
/// @notice extracts the difficulty from the header
/// @param _header the header
/// @return the difficulty
function diff(bytes29 _header) internal pure typeAssert(_header, BTCTypes.Header) returns (uint256) {
return toDiff(target(_header));
}
/// @notice extracts the timestamp from the header
/// @param _header the header
/// @return the timestamp
function time(bytes29 _header) internal pure typeAssert(_header, BTCTypes.Header) returns (uint32) {
return uint32(_header.indexLEUint(68, 4));
}
/// @notice extracts the parent hash from the header
/// @param _header the header
/// @return the parent hash
function parent(bytes29 _header) internal pure typeAssert(_header, BTCTypes.Header) returns (bytes32) {
return _header.index(4, 32);
}
/// @notice Checks validity of header chain
/// @dev Compares current header parent to previous header's digest
/// @param _header The raw bytes header
/// @param _prevHeaderDigest The previous header's digest
/// @return true if the connect is valid, false otherwise
function checkParent(bytes29 _header, bytes32 _prevHeaderDigest) internal pure typeAssert(_header, BTCTypes.Header) returns (bool) {
return parent(_header) == _prevHeaderDigest;
}
/// @notice Validates a tx inclusion in the block
/// @dev `index` is not a reliable indicator of location within a block
/// @param _txid The txid (LE)
/// @param _merkleRoot The merkle root
/// @param _intermediateNodes The proof's intermediate nodes (digests between leaf and root)
/// @param _index The leaf's index in the tree (0-indexed)
/// @return true if fully valid, false otherwise
function prove(
bytes32 _txid,
bytes32 _merkleRoot,
bytes29 _intermediateNodes,
uint _index
) internal view typeAssert(_intermediateNodes, BTCTypes.MerkleArray) returns (bool) {
// Shortcut the empty-block case
if (
_txid == _merkleRoot &&
_index == 0 &&
_intermediateNodes.len() == 0
) {
return true;
}
return checkMerkle(_txid, _intermediateNodes, _merkleRoot, _index);
}
/// @notice verifies a merkle proof
/// @dev leaf, proof, and root are in LE format
/// @param _leaf the leaf
/// @param _proof the proof nodes
/// @param _root the merkle root
/// @param _index the index
/// @return true if valid, false if otherwise
function checkMerkle(
bytes32 _leaf,
bytes29 _proof,
bytes32 _root,
uint256 _index
) private view typeAssert(_proof, BTCTypes.MerkleArray) returns (bool) {
uint256 nodes = _proof.len() / 32;
if (nodes == 0) {
return _leaf == _root;
}
uint256 _idx = _index;
bytes32 _current = _leaf;
for (uint i = 0; i < nodes; i++) {
bytes32 _next = _proof.index(i * 32, 32);
if (_idx % 2 == 1) {
_current = merkleStep(_next, _current);
} else {
_current = merkleStep(_current, _next);
}
_idx >>= 1;
}
return _current == _root;
}
/// @notice Concatenates and hashes two inputs for merkle proving
/// @dev Not recommended to call directly.
/// @param _a The first hash
/// @param _b The second hash
/// @return digest The double-sha256 of the concatenated hashes
function merkleStep(bytes32 _a, bytes32 _b) private view returns (bytes32 digest) {
assembly {
// solium-disable-previous-line security/no-inline-assembly
let ptr := mload(0x40)
mstore(ptr, _a)
mstore(add(ptr, 0x20), _b)
pop(staticcall(gas(), 2, ptr, 0x40, ptr, 0x20)) // sha256 #1
pop(staticcall(gas(), 2, ptr, 0x20, ptr, 0x20)) // sha256 #2
digest := mload(ptr)
}
}
/// @notice performs the bitcoin difficulty retarget
/// @dev implements the Bitcoin algorithm precisely
/// @param _previousTarget the target of the previous period
/// @param _firstTimestamp the timestamp of the first block in the difficulty period
/// @param _secondTimestamp the timestamp of the last block in the difficulty period
/// @return the new period's target threshold
function retargetAlgorithm(
uint256 _previousTarget,
uint256 _firstTimestamp,
uint256 _secondTimestamp
) internal pure returns (uint256) {
uint256 _elapsedTime = _secondTimestamp - _firstTimestamp;
// Normalize ratio to factor of 4 if very long or very short
if (_elapsedTime < RETARGET_PERIOD / 4) {
_elapsedTime = RETARGET_PERIOD / 4;
}
if (_elapsedTime > RETARGET_PERIOD * 4) {
_elapsedTime = RETARGET_PERIOD * 4;
}
/*
NB: high targets e.g. ffff0020 can cause overflows here
so we divide it by 256**2, then multiply by 256**2 later
we know the target is evenly divisible by 256**2, so this isn't an issue
*/
uint256 _adjusted = _previousTarget / 65536 * _elapsedTime;
return _adjusted / RETARGET_PERIOD * 65536;
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.8.4;
interface IBitcoinRelay {
// Structures
/// @notice Structure for recording block header
/// @param selfHash Hash of block header
/// @param parentHash Hash of parent block header
/// @param merkleRoot Merkle root of transactions in the block
/// @param relayer Address of relayer who submitted the block header
/// @param gasPrice Gas price of tx that relayer submitted the block header
struct blockHeader {
bytes32 selfHash;
bytes32 parentHash;
bytes32 merkleRoot;
address relayer;
uint gasPrice;
}
// Events
/// @notice Emits when a block header is added
/// @param height Height of submitted header
/// @param selfHash Hash of submitted header
/// @param parentHash Parent hash of submitted header
/// @param relayer Address of relayer who submitted the block header
event BlockAdded(
uint indexed height,
bytes32 selfHash,
bytes32 indexed parentHash,
address indexed relayer
);
/// @notice Emits when a block header gets finalized
/// @param height Height of the header
/// @param selfHash Hash of the header
/// @param parentHash Parent hash of the header
/// @param relayer Address of relayer who submitted the block header
/// @param rewardAmountTNT Amount of reward that the relayer receives in target native token
/// @param rewardAmountTDT Amount of reward that the relayer receives in TDT
event BlockFinalized(
uint indexed height,
bytes32 selfHash,
bytes32 parentHash,
address indexed relayer,
uint rewardAmountTNT,
uint rewardAmountTDT
);
/// @notice Emits when changes made to reward amount in TDT
event NewRewardAmountInTDT (
uint oldRewardAmountInTDT,
uint newRewardAmountInTDT
);
/// @notice Emits when changes made to finalization parameter
event NewFinalizationParameter (
uint oldFinalizationParameter,
uint newFinalizationParameter
);
/// @notice Emits when changes made to relayer percentage fee
event NewRelayerPercentageFee (
uint oldRelayerPercentageFee,
uint newRelayerPercentageFee
);
/// @notice Emits when changes made to teleportDAO token
event NewTeleportDAOToken (
address oldTeleportDAOToken,
address newTeleportDAOToken
);
/// @notice Emits when changes made to epoch length
event NewEpochLength(
uint oldEpochLength,
uint newEpochLength
);
/// @notice Emits when changes made to base queries
event NewBaseQueries(
uint oldBaseQueries,
uint newBaseQueries
);
/// @notice Emits when changes made to submission gas used
event NewSubmissionGasUsed(
uint oldSubmissionGasUsed,
uint newSubmissionGasUsed
);
// Read-only functions
function relayGenesisHash() external view returns (bytes32);
function initialHeight() external view returns(uint);
function lastSubmittedHeight() external view returns(uint);
function finalizationParameter() external view returns(uint);
function TeleportDAOToken() external view returns(address);
function relayerPercentageFee() external view returns(uint);
function epochLength() external view returns(uint);
function lastEpochQueries() external view returns(uint);
function currentEpochQueries() external view returns(uint);
function baseQueries() external view returns(uint);
function submissionGasUsed() external view returns(uint);
function getBlockHeaderHash(uint height, uint index) external view returns(bytes32);
function getBlockHeaderFee(uint _height, uint _index) external view returns(uint);
function getNumberOfSubmittedHeaders(uint height) external view returns (uint);
function availableTDT() external view returns(uint);
function availableTNT() external view returns(uint);
function findHeight(bytes32 _hash) external view returns (uint256);
function findAncestor(bytes32 _hash, uint256 _offset) external view returns (bytes32);
function isAncestor(bytes32 _ancestor, bytes32 _descendant, uint256 _limit) external view returns (bool);
function rewardAmountInTDT() external view returns (uint);
// State-changing functions
function pauseRelay() external;
function unpauseRelay() external;
function setRewardAmountInTDT(uint _rewardAmountInTDT) external;
function setFinalizationParameter(uint _finalizationParameter) external;
function setRelayerPercentageFee(uint _relayerPercentageFee) external;
function setTeleportDAOToken(address _TeleportDAOToken) external;
function setEpochLength(uint _epochLength) external;
function setBaseQueries(uint _baseQueries) external;
function setSubmissionGasUsed(uint _submissionGasUsed) external;
function checkTxProof(
bytes32 txid,
uint blockHeight,
bytes calldata intermediateNodes,
uint index
) external payable returns (bool);
function addHeaders(bytes calldata _anchor, bytes calldata _headers) external returns (bool);
function addHeadersWithRetarget(
bytes calldata _oldPeriodStartHeader,
bytes calldata _oldPeriodEndHeader,
bytes calldata _headers
) external returns (bool);
function ownerAddHeaders(bytes calldata _anchor, bytes calldata _headers) external returns (bool);
function ownerAddHeadersWithRetarget(
bytes calldata _oldPeriodStartHeader,
bytes calldata _oldPeriodEndHeader,
bytes calldata _headers
) external returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor() {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.8.4;
enum ScriptTypes {
P2PK, // 32 bytes
P2PKH, // 20 bytes
P2SH, // 20 bytes
P2WPKH, // 20 bytes
P2WSH // 32 bytes
}// SPDX-License-Identifier: MIT
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 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
*/
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 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
*/
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 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
*/
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 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
*/
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 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
*/
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 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
*/
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.
*/
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.
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
/**
* @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) {
require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
return int128(value);
}
/**
* @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) {
require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
return int64(value);
}
/**
* @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) {
require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
return int32(value);
}
/**
* @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) {
require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
return int16(value);
}
/**
* @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) {
require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
return int8(value);
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
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);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}{
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"metadata": {
"useLiteralContent": true
},
"libraries": {}
}[{"inputs":[{"internalType":"bytes","name":"_genesisHeader","type":"bytes"},{"internalType":"uint256","name":"_height","type":"uint256"},{"internalType":"bytes32","name":"_periodStart","type":"bytes32"},{"internalType":"address","name":"_TeleportDAOToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"height","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"selfHash","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"parentHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"relayer","type":"address"}],"name":"BlockAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"height","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"selfHash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"parentHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"relayer","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardAmountTNT","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardAmountTDT","type":"uint256"}],"name":"BlockFinalized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldBaseQueries","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBaseQueries","type":"uint256"}],"name":"NewBaseQueries","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldEpochLength","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newEpochLength","type":"uint256"}],"name":"NewEpochLength","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldFinalizationParameter","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newFinalizationParameter","type":"uint256"}],"name":"NewFinalizationParameter","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldRelayerPercentageFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newRelayerPercentageFee","type":"uint256"}],"name":"NewRelayerPercentageFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldRewardAmountInTDT","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newRewardAmountInTDT","type":"uint256"}],"name":"NewRewardAmountInTDT","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldSubmissionGasUsed","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newSubmissionGasUsed","type":"uint256"}],"name":"NewSubmissionGasUsed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldTeleportDAOToken","type":"address"},{"indexed":false,"internalType":"address","name":"newTeleportDAOToken","type":"address"}],"name":"NewTeleportDAOToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"TeleportDAOToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_anchor","type":"bytes"},{"internalType":"bytes","name":"_headers","type":"bytes"}],"name":"addHeaders","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_oldPeriodStartHeader","type":"bytes"},{"internalType":"bytes","name":"_oldPeriodEndHeader","type":"bytes"},{"internalType":"bytes","name":"_headers","type":"bytes"}],"name":"addHeadersWithRetarget","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"availableTDT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"availableTNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseQueries","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_txid","type":"bytes32"},{"internalType":"uint256","name":"_blockHeight","type":"uint256"},{"internalType":"bytes","name":"_intermediateNodes","type":"bytes"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"checkTxProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"currentEpochQueries","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finalizationParameter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_hash","type":"bytes32"},{"internalType":"uint256","name":"_offset","type":"uint256"}],"name":"findAncestor","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_hash","type":"bytes32"}],"name":"findHeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_height","type":"uint256"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getBlockHeaderFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_height","type":"uint256"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getBlockHeaderHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_height","type":"uint256"}],"name":"getNumberOfSubmittedHeaders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialHeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_ancestor","type":"bytes32"},{"internalType":"bytes32","name":"_descendant","type":"bytes32"},{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"isAncestor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastEpochQueries","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastSubmittedHeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_anchor","type":"bytes"},{"internalType":"bytes","name":"_headers","type":"bytes"}],"name":"ownerAddHeaders","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_oldPeriodStartHeader","type":"bytes"},{"internalType":"bytes","name":"_oldPeriodEndHeader","type":"bytes"},{"internalType":"bytes","name":"_headers","type":"bytes"}],"name":"ownerAddHeadersWithRetarget","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pauseRelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"relayGenesisHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"relayerPercentageFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardAmountInTDT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_baseQueries","type":"uint256"}],"name":"setBaseQueries","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_epochLength","type":"uint256"}],"name":"setEpochLength","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_finalizationParameter","type":"uint256"}],"name":"setFinalizationParameter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_relayerPercentageFee","type":"uint256"}],"name":"setRelayerPercentageFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardAmountInTDT","type":"uint256"}],"name":"setRewardAmountInTDT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_submissionGasUsed","type":"uint256"}],"name":"setSubmissionGasUsed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_TeleportDAOToken","type":"address"}],"name":"setTeleportDAOToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"submissionGasUsed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpauseRelay","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
| Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
|---|