Skip to content

Commit

Permalink
Revert "Chore/doc"
Browse files Browse the repository at this point in the history
  • Loading branch information
@yu23ki14
yu23ki14 authored Mar 16, 2023
1 parent 2addd90 commit 9232872
Show file tree
Hide file tree
Showing 22 changed files with 778 additions and 768 deletions.
12 changes: 9 additions & 3 deletions .env.example
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
LOCAL_PRIVATE_KEY=0000000000000000000000000000000000000000000000000000000000000000
TEST_PRIVATE_KEY=0000000000000000000000000000000000000000000000000000000000000000
MAIN_PRIVATE_KEY=0000000000000000000000000000000000000000000000000000000000000000
LOCAL_PRIVATE_KEY=
TEST_PRIVATE_KEY=
MAIN_PRIVATE_KEY=

LOCAL_USERS_ADDRESSES=
TESTNET_USERS_ADDRESSES=
Expand All @@ -15,4 +15,10 @@ ETHERSCAN_API_KEY=
HENKAKU_V2_ADDRESS=
POOL_WALLET_ADDRESS=

RELAYER_API_KEY=
RELAYER_API_SECRET=
MUMBAI_AUTOTASK_ID=
TEAM_API_KEY=
TEAM_API_SECRET=

REPORT_GAS=false
2 changes: 1 addition & 1 deletion .gitignore
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,6 @@ typechain-types
cache
artifacts

scripts/ticket_argument.ts
scripts/nengajo_argument.ts

build
10 changes: 5 additions & 5 deletions README.md
View file
Original file line number Diff line number Diff line change
@@ -1,11 +1,11 @@
# henkaku-ticket-contract
# henkaku-nengajo-contract

## 概要

これはチケットの NFT を発行するコントラクトです。
これは年賀状の NFT を発行するコントラクトです。

このチケット NFT ではオンライン、オフライン問わずイベントチケットをコントラクトに登録し、それを欲しい人が HENKAKU トークンで Mint するようになっています。
チケットの登録時には供給量（MaxSupply）、価格（HENKAKU）、収益受け取りアドレスなどを設定できるようになっています。また、NFT を持っている人しか見ることのできないシークレットメッセージを画像として登録できるので、会場の情報などを渡すこともできます。
年賀状は通常、書いたものを住所を知っているひとたちに向けて送るものですが、この年賀状 NFT では書いたものをコントラクトに登録し、それを欲しい人が自分で Mint するようになっています。
年賀状の登録時には供給量（MaxSupply）を設定できるようになっています。

## 開発について

Expand All @@ -14,7 +14,7 @@
- Node.js: v16.x
- Hardhat

ローカルノードでの立ち上げ方法　([リンク](docs/local_node.md))
ローカルノードでの立ち上げ方法　(https://github.com/henkaku-center/henkaku-nengajo-contract/blob/main/docs/local_node.md)

## ライセンス

Expand Down
4 changes: 2 additions & 2 deletions contracts/community/InteractHenkakuToken.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,9 +16,9 @@ abstract contract InteractHenakuToken is Administration, MintManager {
}

function transferHenkakuV2(uint256 _amount) internal {
require(checkHenkakuV2Balance(_amount), "Ticket: Insufficient HenkakuV2 token");
require(checkHenkakuV2Balance(_amount), "Nengajo: Insufficient HenkakuV2 token");
bool sent = IHenkakuToken(henkakuV2).transferFrom(msg.sender, henkakuPoolWallet, _amount);
require(sent, "Ticket: Henkaku transfer failed");
require(sent, "Nengajo: Henkaku transfer failed");
}

function checkHenkakuV2Balance(uint256 _requiredAmount) internal view returns (bool) {
Expand Down
84 changes: 42 additions & 42 deletions contracts/community/Ticket.sol → contracts/community/Nengajo.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@ import "./Administration.sol";
import "./InteractHenkakuToken.sol";
import "./MintManager.sol";

contract Ticket is ERC1155, ERC1155Supply, Administration, MintManager, InteractHenakuToken {
contract Nengajo is ERC1155, ERC1155Supply, Administration, MintManager, InteractHenakuToken {
//@dev count up tokenId from 0
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
Expand All @@ -19,7 +19,7 @@ contract Ticket is ERC1155, ERC1155Supply, Administration, MintManager, Interact
mapping(address => uint256[]) private ownerOfMintedIds;

//@dev Declare Event to emit
event RegisterTicket(address indexed creator, uint256 tokenId, string metaDataURL, uint256 maxSupply);
event RegisterNengajo(address indexed creator, uint256 tokenId, string metaDataURL, uint256 maxSupply);
event Mint(address indexed minter, uint256 indexed tokenId);
event MintBatch(address indexed minter, uint256[] tokenIds);

Expand All @@ -28,14 +28,14 @@ contract Ticket is ERC1155, ERC1155Supply, Administration, MintManager, Interact
* @param creator: creator's wallet address
* @param maxSupply: max supply number of token
*/
struct TicketInfo {
struct NengajoInfo {
uint256 id;
string uri;
address creator;
uint256 maxSupply;
}

TicketInfo[] private registeredTickets;
NengajoInfo[] private registeredNengajoes;

constructor(
string memory _name,
Expand All @@ -52,41 +52,41 @@ contract Ticket is ERC1155, ERC1155Supply, Administration, MintManager, Interact
name = _name;
symbol = _symbol;

registeredTickets.push(TicketInfo(0, "", address(0), 0));
registeredNengajoes.push(NengajoInfo(0, "", address(0), 0));
_tokenIds.increment();
}

modifier whenMintable() {
require(
(block.timestamp > open_blockTimestamp && close_blockTimestamp > block.timestamp) || mintable,
"Ticket: Not mintable"
"Nengajo: Not mintable"
);
require(checkHenkakuV2Balance(1), "Ticket: Insufficient Henkaku Token Balance");
require(checkHenkakuV2Balance(1), "Nengajo: Insufficient Henkaku Token Balance");
_;
}

function registerTicket(uint256 _maxSupply, string memory _metaDataURL) public {
require(_maxSupply != 0 || keccak256(bytes(_metaDataURL)) != keccak256(bytes("")), "Ticket: invalid params");
function registerNengajo(uint256 _maxSupply, string memory _metaDataURL) public {
require(_maxSupply != 0 || keccak256(bytes(_metaDataURL)) != keccak256(bytes("")), "Nengajo: invalid params");
uint256 amount = calcPrice(_maxSupply);

uint256 tokenId = _tokenIds.current();
ownerOfRegisteredIds[msg.sender].push(tokenId);
registeredTickets.push(TicketInfo(tokenId, _metaDataURL, msg.sender, _maxSupply));
registeredNengajoes.push(NengajoInfo(tokenId, _metaDataURL, msg.sender, _maxSupply));
_tokenIds.increment();

transferHenkakuV2(amount);

// @dev Emit registeredTicket
// @dev Emit registeredNengajo
// @param address, tokenId, URL of meta data, max supply
emit RegisterTicket(msg.sender, tokenId, _metaDataURL, _maxSupply);
emit RegisterNengajo(msg.sender, tokenId, _metaDataURL, _maxSupply);
}

function calcPrice(uint256 _maxSupply) public view returns (uint256) {
TicketInfo[] memory _registeredTickets = registeredTickets;
NengajoInfo[] memory _registeredNengajoes = registeredNengajoes;
uint256[] memory _ownerOfRegisteredIds = ownerOfRegisteredIds[msg.sender];
uint256 registeredCount;
for (uint256 i = 0; i < _ownerOfRegisteredIds.length; ) {
registeredCount += _registeredTickets[_ownerOfRegisteredIds[i]].maxSupply;
registeredCount += _registeredNengajoes[_ownerOfRegisteredIds[i]].maxSupply;
unchecked {
++i;
}
Expand All @@ -103,44 +103,44 @@ contract Ticket is ERC1155, ERC1155Supply, Administration, MintManager, Interact
return amount;
}

// @return all registered TicketInfo
function retrieveAllTickets() external view returns (TicketInfo[] memory) {
return registeredTickets;
// @return all registered NengajoInfo
function retrieveAllNengajoes() external view returns (NengajoInfo[] memory) {
return registeredNengajoes;
}

// @return registered TicketInfo by tokenId
function retrieveRegisteredTicket(uint256 _tokenId) public view returns (TicketInfo memory) {
TicketInfo[] memory _registeredTickets = registeredTickets;
require(_registeredTickets.length > _tokenId, "Ticket: not available");
return _registeredTickets[_tokenId];
// @return registered NengajoInfo by tokenId
function retrieveRegisteredNengajo(uint256 _tokenId) public view returns (NengajoInfo memory) {
NengajoInfo[] memory _registeredNengajoes = registeredNengajoes;
require(_registeredNengajoes.length > _tokenId, "Nengajo: not available");
return _registeredNengajoes[_tokenId];
}

// @return registered TicketInfo by address
function retrieveRegisteredTickets(address _address) public view returns (TicketInfo[] memory) {
TicketInfo[] memory _registeredTickets = registeredTickets;
// @return registered NengajoInfo by address
function retrieveRegisteredNengajoes(address _address) public view returns (NengajoInfo[] memory) {
NengajoInfo[] memory _registeredNengajoes = registeredNengajoes;
uint256[] memory _ownerOfRegisteredIds = ownerOfRegisteredIds[_address];
TicketInfo[] memory _ownerOfRegisteredTickets = new TicketInfo[](_ownerOfRegisteredIds.length);
NengajoInfo[] memory _ownerOfRegisteredNengajoes = new NengajoInfo[](_ownerOfRegisteredIds.length);

for (uint256 i = 0; i < _ownerOfRegisteredIds.length; ) {
TicketInfo memory _registeredTicket = _registeredTickets[_ownerOfRegisteredIds[i]];
if (_registeredTicket.creator == _address) {
_ownerOfRegisteredTickets[i] = _registeredTicket;
NengajoInfo memory _registeredNengajo = _registeredNengajoes[_ownerOfRegisteredIds[i]];
if (_registeredNengajo.creator == _address) {
_ownerOfRegisteredNengajoes[i] = _registeredNengajo;
}
unchecked {
++i;
}
}
return _ownerOfRegisteredTickets;
return _ownerOfRegisteredNengajoes;
}

function checkTicketAmount(uint256 _tokenId) private view {
require(balanceOf(msg.sender, _tokenId) == 0, "Ticket: You already have this ticket");
require(retrieveRegisteredTicket(_tokenId).maxSupply > totalSupply(_tokenId), "Ticket: Mint limit reached");
function checkNengajoAmount(uint256 _tokenId) private view {
require(balanceOf(msg.sender, _tokenId) == 0, "Nengajo: You already have this nengajo");
require(retrieveRegisteredNengajo(_tokenId).maxSupply > totalSupply(_tokenId), "Nengajo: Mint limit reached");
}

// @dev mint function
function mint(uint256 _tokenId) public whenMintable {
checkTicketAmount(_tokenId);
checkNengajoAmount(_tokenId);
_mint(msg.sender, _tokenId, 1, "");
ownerOfMintedIds[msg.sender].push(_tokenId);

Expand All @@ -155,7 +155,7 @@ contract Ticket is ERC1155, ERC1155Supply, Administration, MintManager, Interact
uint256[] memory amountList = new uint256[](tokenIdsLength);

for (uint256 i = 0; i < tokenIdsLength; ) {
checkTicketAmount(_tokenIdsList[i]);
checkNengajoAmount(_tokenIdsList[i]);
amountList[i] = 1;
ownerOfMintedIds[msg.sender].push(_tokenIdsList[i]);
unchecked {
Expand All @@ -171,29 +171,29 @@ contract Ticket is ERC1155, ERC1155Supply, Administration, MintManager, Interact
}

// @return holding tokenIds with address
function retrieveMintedTickets(address _address) public view returns (TicketInfo[] memory) {
TicketInfo[] memory _registeredTickets = registeredTickets;
function retrieveMintedNengajoes(address _address) public view returns (NengajoInfo[] memory) {
NengajoInfo[] memory _registeredNengajoes = registeredNengajoes;
uint256[] memory _ownerOfMintedIds = ownerOfMintedIds[_address];
TicketInfo[] memory _ownerOfMintedTickets = new TicketInfo[](_ownerOfMintedIds.length);
NengajoInfo[] memory _ownerOfMintedNengajoes = new NengajoInfo[](_ownerOfMintedIds.length);

for (uint256 i = 0; i < _ownerOfMintedIds.length; ) {
_ownerOfMintedTickets[i] = _registeredTickets[_ownerOfMintedIds[i]];
_ownerOfMintedNengajoes[i] = _registeredNengajoes[_ownerOfMintedIds[i]];
unchecked {
++i;
}
}

return _ownerOfMintedTickets;
return _ownerOfMintedNengajoes;
}

// @return token metadata uri
function uri(uint256 _tokenId) public view override(ERC1155) returns (string memory) {
return retrieveRegisteredTicket(_tokenId).uri;
return retrieveRegisteredNengajo(_tokenId).uri;
}

// @return token metadata uri
function tokenURI(uint256 _tokenId) public view returns (string memory) {
return retrieveRegisteredTicket(_tokenId).uri;
return retrieveRegisteredNengajo(_tokenId).uri;
}

function _beforeTokenTransfer(
Expand Down
Loading

0 comments on commit 9232872

Please sign in to comment.