文件 1 的 1：Arbscriptions.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
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");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
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");
}
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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1);
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256,
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
}
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
pragma solidity ^0.8.0;
contract ARC20 is ERC20 {
uint256 public _maxSupply;
uint256 public _amountPerMint;
uint256 public _totalMinted;
address public _factory;
constructor(
string memory tick,
uint256 maxSupply,
uint256 amountPerMint,
address factory
) ERC20("ARC-20 Token", tick) {
_maxSupply = maxSupply * 1e18;
_amountPerMint = amountPerMint * 1e18;
_factory = factory;
_totalMinted = 0;
}
function mint(address to, uint256 amount) external {
require(msg.sender == _factory, "only factory can mint");
uint256 mintAmount = amount * 1e18;
require(mintAmount <= _amountPerMint, "amount exceeds limit");
require(_totalMinted + mintAmount <= _maxSupply, "max supply exceeded");
_mint(to, mintAmount);
_totalMinted += mintAmount;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
}
pragma solidity ^0.8.0;
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function encode(bytes memory data) internal pure returns (string memory) {
uint256 len = data.length;
if (len == 0) return "";
uint256 encodedLen = 4 * ((len + 2) / 3);
bytes memory result = new bytes(encodedLen + 32);
bytes memory table = TABLE;
assembly {
let tablePtr := add(table, 1)
let resultPtr := add(result, 32)
for {
let i := 0
} lt(i, len) {
} {
i := add(i, 3)
let input := and(mload(add(data, i)), 0xffffff)
let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(input, 0x3F))), 0xFF))
out := shl(224, out)
mstore(resultPtr, out)
resultPtr := add(resultPtr, 4)
}
switch mod(len, 3)
case 1 {
mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
}
case 2 {
mstore(sub(resultPtr, 1), shl(248, 0x3d))
}
mstore(result, encodedLen)
}
return string(result);
}
}
pragma solidity ^0.8.1;
library JsmnSolLib {
enum JsmnType { UNDEFINED, OBJECT, ARRAY, STRING, PRIMITIVE }
uint constant RETURN_SUCCESS = 0;
uint constant RETURN_ERROR_INVALID_JSON = 1;
uint constant RETURN_ERROR_PART = 2;
uint constant RETURN_ERROR_NO_MEM = 3;
struct Token {
JsmnType jsmnType;
uint start;
bool startSet;
uint end;
bool endSet;
uint8 size;
}
struct Parser {
uint pos;
uint toknext;
int toksuper;
}
function init(uint length) internal pure returns (Parser memory, Token[] memory) {
Parser memory p = Parser(0, 0, -1);
Token[] memory t = new Token[](length);
return (p, t);
}
function allocateToken(Parser memory parser, Token[] memory tokens) internal pure returns (bool, Token memory) {
if (parser.toknext >= tokens.length) {
return (false, tokens[tokens.length-1]);
}
Token memory token = Token(JsmnType.UNDEFINED, 0, false, 0, false, 0);
tokens[parser.toknext] = token;
parser.toknext++;
return (true, token);
}
function fillToken(Token memory token, JsmnType jsmnType, uint start, uint end) internal pure {
token.jsmnType = jsmnType;
token.start = start;
token.startSet = true;
token.end = end;
token.endSet = true;
token.size = 0;
}
function parseString(Parser memory parser, Token[] memory tokens, bytes memory s) internal pure returns (uint) {
uint start = parser.pos;
bool success;
Token memory token;
parser.pos++;
for (; parser.pos<s.length; parser.pos++) {
bytes1 c = s[parser.pos];
if (c == '"') {
(success, token) = allocateToken(parser, tokens);
if (!success) {
parser.pos = start;
return RETURN_ERROR_NO_MEM;
}
fillToken(token, JsmnType.STRING, start+1, parser.pos);
return RETURN_SUCCESS;
}
if (uint8(c) == 92 && parser.pos + 1 < s.length) {
parser.pos++;
if (s[parser.pos] == '\"' || s[parser.pos] == '/' || s[parser.pos] == '\\'
|| s[parser.pos] == 'f' || s[parser.pos] == 'r' || s[parser.pos] == 'n'
|| s[parser.pos] == 'b' || s[parser.pos] == 't') {
continue;
} else {
parser.pos = start;
return(RETURN_ERROR_INVALID_JSON);
}
}
}
parser.pos = start;
return RETURN_ERROR_PART;
}
function parsePrimitive(Parser memory parser, Token[] memory tokens, bytes memory s) internal pure returns (uint) {
bool found = false;
uint start = parser.pos;
bytes1 c;
bool success;
Token memory token;
for (; parser.pos < s.length; parser.pos++) {
c = s[parser.pos];
if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == ','
|| c == 0x7d || c == 0x5d) {
found = true;
break;
}
if (uint8(c) < 32 || uint8(c) > 127) {
parser.pos = start;
return RETURN_ERROR_INVALID_JSON;
}
}
if (!found) {
parser.pos = start;
return RETURN_ERROR_PART;
}
(success, token) = allocateToken(parser, tokens);
if (!success) {
parser.pos = start;
return RETURN_ERROR_NO_MEM;
}
fillToken(token, JsmnType.PRIMITIVE, start, parser.pos);
parser.pos--;
return RETURN_SUCCESS;
}
function parse(string memory json, uint numberElements) internal pure returns (uint, Token[] memory tokens, uint) {
bytes memory s = bytes(json);
bool success;
Parser memory parser;
(parser, tokens) = init(numberElements);
uint r;
uint count = parser.toknext;
uint i;
Token memory token;
for (; parser.pos<s.length; parser.pos++) {
bytes1 c = s[parser.pos];
if (c == 0x7b || c == 0x5b) {
count++;
(success, token) = allocateToken(parser, tokens);
if (!success) {
return (RETURN_ERROR_NO_MEM, tokens, 0);
}
if (parser.toksuper != -1) {
tokens[uint(parser.toksuper)].size++;
}
token.jsmnType = (c == 0x7b ? JsmnType.OBJECT : JsmnType.ARRAY);
token.start = parser.pos;
token.startSet = true;
parser.toksuper = int(parser.toknext - 1);
continue;
}
if (c == 0x7d || c == 0x5d) {
JsmnType tokenType = (c == 0x7d ? JsmnType.OBJECT : JsmnType.ARRAY);
bool isUpdated = false;
for (i=parser.toknext-1; i>=0; i--) {
token = tokens[i];
if (token.startSet && !token.endSet) {
if (token.jsmnType != tokenType) {
return (RETURN_ERROR_INVALID_JSON, tokens, 0);
}
parser.toksuper = -1;
tokens[i].end = parser.pos + 1;
tokens[i].endSet = true;
isUpdated = true;
break;
}
}
if (!isUpdated) {
return (RETURN_ERROR_INVALID_JSON, tokens, 0);
}
for (; i>0; i--) {
token = tokens[i];
if (token.startSet && !token.endSet) {
parser.toksuper = int(i);
break;
}
}
if (i==0) {
token = tokens[i];
if (token.startSet && !token.endSet) {
parser.toksuper = int128(uint128(i));
}
}
continue;
}
if (c == '"') {
r = parseString(parser, tokens, s);
if (r != RETURN_SUCCESS) {
return (r, tokens, 0);
}
count++;
if (parser.toksuper != -1)
tokens[uint(parser.toksuper)].size++;
continue;
}
if (c == ' ' || c == 0x11 || c == 0x12 || c == 0x14) {
continue;
}
if (c == ':') {
parser.toksuper = int(parser.toknext -1);
continue;
}
if (c == ',') {
if (parser.toksuper != -1
&& tokens[uint(parser.toksuper)].jsmnType != JsmnType.ARRAY
&& tokens[uint(parser.toksuper)].jsmnType != JsmnType.OBJECT) {
for(i = parser.toknext-1; i>=0; i--) {
if (tokens[i].jsmnType == JsmnType.ARRAY || tokens[i].jsmnType == JsmnType.OBJECT) {
if (tokens[i].startSet && !tokens[i].endSet) {
parser.toksuper = int(i);
break;
}
}
}
}
continue;
}
if ((c >= '0' && c <= '9') || c == '-' || c == 'f' || c == 't' || c == 'n') {
if (parser.toksuper != -1) {
token = tokens[uint(parser.toksuper)];
if (token.jsmnType == JsmnType.OBJECT
|| (token.jsmnType == JsmnType.STRING && token.size != 0)) {
return (RETURN_ERROR_INVALID_JSON, tokens, 0);
}
}
r = parsePrimitive(parser, tokens, s);
if (r != RETURN_SUCCESS) {
return (r, tokens, 0);
}
count++;
if (parser.toksuper != -1) {
tokens[uint(parser.toksuper)].size++;
}
continue;
}
if (c >= 0x20 && c <= 0x7e) {
return (RETURN_ERROR_INVALID_JSON, tokens, 0);
}
}
return (RETURN_SUCCESS, tokens, parser.toknext);
}
function getBytes(string memory json, uint start, uint end) internal pure returns (string memory) {
bytes memory s = bytes(json);
bytes memory result = new bytes(end-start);
for (uint i=start; i<end; i++) {
result[i-start] = s[i];
}
return string(result);
}
function parseInt(string memory _a) internal pure returns (int) {
return parseInt(_a, 0);
}
function parseInt(string memory _a, uint _b) internal pure returns (int) {
bytes memory bresult = bytes(_a);
int mint = 0;
bool decimals = false;
bool negative = false;
for (uint i=0; i<bresult.length; i++){
if ((i == 0) && (bresult[i] == '-')) {
negative = true;
}
if ((uint8(bresult[i]) >= 48) && (uint8(bresult[i]) <= 57)) {
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += int256(uint256(uint8(bresult[i]) - 48));
} else if (uint8(bresult[i]) == 46) decimals = true;
}
if (_b > 0) mint *= int(10**_b);
if (negative) mint *= -1;
return mint;
}
function uint2str(uint i) internal pure returns (string memory){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = bytes1(uint8(48 + i % 10));
i /= 10;
}
return string(bstr);
}
function parseBool(string memory _a) internal pure returns (bool) {
if (strCompare(_a, 'true') == 0) {
return true;
} else {
return false;
}
}
function strCompare(string memory _a, string memory _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
}
pragma solidity ^0.8.0;
contract Arbscriptions is ERC721, Ownable {
using Counters for Counters.Counter;
string public constant ARBS_HEAER = "arb";
bytes32 public constant ARBS_HEAER_HASH = keccak256(abi.encodePacked(ARBS_HEAER));
uint8 public constant ARBS_VER = 1;
uint256 public constant ARBS_ARBSCRIBE_FEE = 0.0003 ether;
bytes32 public constant CT_TEXT_HASH = keccak256(abi.encodePacked("text/plain;charset=utf-8"));
bytes32 public constant CT_JSON_HASH = keccak256(abi.encodePacked("application/json"));
uint256 public constant ARC20_MAX_JSON_LENGTH = 100;
uint256 public constant ARC20_MAX_JSON_TOKEN = 10;
bytes32 public constant ARC20_P_HASH = keccak256(abi.encodePacked("p"));
bytes32 public constant ARC20_OP_HASH = keccak256(abi.encodePacked("op"));
bytes32 public constant ARC20_TICK_HASH = keccak256(abi.encodePacked("tick"));
bytes32 public constant ARC20_MAX_HASH = keccak256(abi.encodePacked("max"));
bytes32 public constant ARC20_LIM_HASH = keccak256(abi.encodePacked("lim"));
bytes32 public constant ARC20_AMT_HASH = keccak256(abi.encodePacked("amt"));
bytes32 public constant ARC20_P_HASH_ARC20 = keccak256(abi.encodePacked("arc-20"));
bytes32 public constant ARC20_OP_HASH_DEPLOY = keccak256(abi.encodePacked("deploy"));
bytes32 public constant ARC20_OP_HASH_MINT = keccak256(abi.encodePacked("mint"));
address public Dev;
string private baseURL;
Counters.Counter private _inscriptionIdTracker;
mapping(string => address) private arc20Contracts;
mapping(address => uint256) private arc20TokenIndex;
struct ARC20Token {
address tokenAddress;
string tick;
uint256 maxSupply;
uint256 amountPerMint;
uint256 deployId;
address deployer;
}
ARC20Token[] public arc20Tokens;
event TokenCreated(
address indexed tokenAddress,
string tick,
uint256 maxSupply,
uint256 amountPerMint,
address factoryContract,
uint256 deployId,
address deployer
);
constructor(
string memory _baseURL,
address _dev
) ERC721("Arbitrum Inscriptions", "ARBSCRIPTION") {
baseURL = _baseURL;
Dev = _dev;
_inscriptionIdTracker.increment();
}
fallback(bytes calldata input) external payable returns (bytes memory) {
require(msg.sender == tx.origin, "only EOA");
require(msg.value >= ARBS_ARBSCRIBE_FEE, "insufficient fee");
require(keccak256(abi.encodePacked(string(input[0:3]))) == ARBS_HEAER_HASH, "invalid header");
require(uint8(input[3]) == ARBS_VER, "invalid version");
uint16 ctlen = uint16(bytes2(input[4:6]));
uint32 clen = uint32(bytes4(input[6:10]));
require(ctlen > 0 && clen > 0 && input.length == 10 + ctlen + clen, "invalid calldata length");
uint256 id = _inscriptionIdTracker.current();
_inscriptionIdTracker.increment();
_safeMint(msg.sender, id, new bytes(0));
if(clen <= ARC20_MAX_JSON_LENGTH) {
bytes memory contentType = input[10:10+ctlen];
bytes32 cthash = keccak256(contentType);
if ((cthash == CT_TEXT_HASH || cthash == CT_JSON_HASH)) {
string memory content = string(input[10+ctlen:10+ctlen+clen]);
parseJsonAndExecute(id, content);
}
}
return abi.encode(id);
}
function parseJsonAndExecute(uint256 scriptionId, string memory content) internal {
uint returnValue;
JsmnSolLib.Token[] memory tokens;
uint actualNum;
(returnValue, tokens, actualNum) = JsmnSolLib.parse(content, ARC20_MAX_JSON_TOKEN + 1);
if (returnValue != JsmnSolLib.RETURN_SUCCESS) return;
{
string memory p = JsmnSolLib.getBytes(content, tokens[1].start, tokens[1].end);
string memory pVal = JsmnSolLib.getBytes(content, tokens[2].start, tokens[2].end);
string memory op = JsmnSolLib.getBytes(content, tokens[3].start, tokens[3].end);
string memory tick = JsmnSolLib.getBytes(content, tokens[5].start, tokens[5].end);
if (keccak256(abi.encodePacked(p)) != ARC20_P_HASH || keccak256(abi.encodePacked(op)) != ARC20_OP_HASH
|| keccak256(abi.encodePacked(tick)) != ARC20_TICK_HASH || keccak256(abi.encodePacked(pVal)) != ARC20_P_HASH_ARC20 ) {
return;
}
}
{
string memory opVal = JsmnSolLib.getBytes(content, tokens[4].start, tokens[4].end);
string memory tickVal = JsmnSolLib.getBytes(content, tokens[6].start, tokens[6].end);
string memory key = JsmnSolLib.getBytes(content, tokens[7].start, tokens[7].end);
string memory keyVal = JsmnSolLib.getBytes(content, tokens[8].start, tokens[8].end);
bytes32 opValHash = keccak256(abi.encodePacked(opVal));
if (opValHash == ARC20_OP_HASH_DEPLOY) {
if (arc20Contracts[tickVal] != address(0)) return;
string memory lim = JsmnSolLib.getBytes(content, tokens[9].start, tokens[9].end);
if (keccak256(abi.encodePacked(key)) != ARC20_MAX_HASH || keccak256(abi.encodePacked(lim)) != ARC20_LIM_HASH ) return;
string memory limVal = JsmnSolLib.getBytes(content, tokens[10].start, tokens[10].end);
if (!isDigit(keyVal) || !isDigit(limVal)) return;
createARC20(tickVal, toUint(keyVal), toUint(limVal), scriptionId);
} else if (opValHash == ARC20_OP_HASH_MINT) {
address tokenAddr = arc20Contracts[tickVal];
if (tokenAddr == address(0)) return;
if (keccak256(abi.encodePacked(key)) != ARC20_AMT_HASH) return;
if (!isDigit(keyVal)) return;
try ARC20(tokenAddr).mint( msg.sender, toUint(keyVal)) {
address deployer = arc20Tokens[arc20TokenIndex[tokenAddr]].deployer;
payable(deployer).transfer(ARBS_ARBSCRIBE_FEE * 5 / 100);
} catch {}
}
}
}
function createARC20(
string memory tick,
uint256 maxSupply,
uint256 amountPerMint,
uint256 scriptionId
) internal {
require(bytes(tick).length == 4, "invalid tick");
require(maxSupply > 0, "maxSupply must be greater than 0");
require(amountPerMint > 0, "amountPerMint must be greater than 0");
require(maxSupply >= amountPerMint, "maxSupply must be greater than amountPerMint");
require(arc20Contracts[tick] == address(0), "token deployed");
ARC20 token = new ARC20(tick, maxSupply, amountPerMint, address(this));
arc20Contracts[tick] = address(token);
ARC20Token memory tokenInfo = ARC20Token(
address(token),
tick,
maxSupply,
amountPerMint,
scriptionId,
msg.sender
);
arc20Tokens.push(tokenInfo);
arc20TokenIndex[address(token)] = arc20Tokens.length-1;
emit TokenCreated(
address(token),
tick,
maxSupply,
amountPerMint,
address(this),
scriptionId,
msg.sender
);
}
function withdraw() external {
require(msg.sender == Dev, "not dev");
require(address(this).balance > 0, "no balance");
uint256 balance = address(this).balance;
payable(Dev).transfer(balance);
}
receive() external payable {
revert();
}
function getTokensByPage(uint256 page, uint256 pageSize) external view returns (ARC20Token[] memory tokens, uint256[] memory totalSupplies) {
require(page > 0, "Invalid page number");
require(pageSize > 0, "Invalid page size");
uint256 start = (page - 1) * pageSize;
uint256 end = start + pageSize;
if (end > arc20Tokens.length) {
end = arc20Tokens.length;
}
tokens = new ARC20Token[](end - start);
totalSupplies = new uint256[](end - start);
for (uint256 i = start; i < end; i++) {
tokens[i - start] = arc20Tokens[i];
totalSupplies[i - start] = ARC20(arc20Tokens[i].tokenAddress).totalSupply();
}
}
function getTokenByTick(string memory tick) external view returns (ARC20Token memory tokenInfo, uint256 totalSupply) {
address tokenAddr = arc20Contracts[tick];
if (tokenAddr != address(0)) {
tokenInfo = arc20Tokens[arc20TokenIndex[tokenAddr]];
totalSupply = ARC20(tokenAddr).totalSupply();
}
}
function getTokenCount() external view returns (uint256) {
return arc20Tokens.length;
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
string[17] memory parts;
parts[0] = '<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet" viewBox="0 0 300 300"><style>.base { fill: white; font-family: serif; font-size: 14px; }</style><rect width="100%" height="100%" fill="black" /><text x="10" y="30" class="base">';
parts[1] = string(abi.encodePacked('Arbscription #', toString(tokenId)));
parts[2] = '</text><text x="10" y="60" class="base">';
parts[3] = string(abi.encodePacked(baseURL, '/arbscriptions/', toString(tokenId)));
parts[4] = '</text></svg>';
string memory output = string(abi.encodePacked(parts[0], parts[1], parts[2], parts[3], parts[4]));
string memory json = Base64.encode(bytes(string(abi.encodePacked('{"name": "Arbscription #', toString(tokenId), '", "description": "Arbscriptions are a new way of creating digital artifacts on Arbitrum using transaction calldata.", "image": "data:image/svg+xml;base64,', Base64.encode(bytes(output)), '"}'))));
output = string(abi.encodePacked('data:application/json;base64,', json));
return output;
}
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toUint(string memory s) internal pure returns (uint) {
bytes memory b = bytes(s);
uint result = 0;
for (uint256 i = 0; i < b.length; i++) {
uint256 c = uint256(uint8(b[i]));
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
}
}
return result;
}
function isDigit(string memory s) internal pure returns (bool) {
bytes memory b = bytes(s);
for (uint i = 0; i < b.length; i++) {
uint256 c = uint256(uint8(b[i]));
if (c < 48 || c > 57) {
return false;
}
}
return true;
}
}
