0xfacet-contracts 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9fac7c3c3df979bc789b4b300cf331972a368edb51fd2c8646654564ecd25e81
+  data.tar.gz: 696b46279ae0a4b54c26249ae879c4514f80e0720aaeada490874d90bacb7d53
+SHA512:
+  metadata.gz: 580db8d5ab28967cc8b3886de2f2bedc53efe5ba83b6c87d2786c08c3e4e716223fc570b9eb84a4f7b346755a67a9552e87f6bbf22da7296028c20f67e7c2659
+  data.tar.gz: 6e2f3120f2978f4b9e29c1e80f17bff93380400d956c9b436679ee0abd4a90f9992bdd7e63d97ebecf3d85ea975a7d7a7bcd0b062ab78fdfe0afe47d6eccd415

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2023-11-16
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,15 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/0xfacet/contracts.rb
+lib/0xfacet/contracts/ERC20.rb
+lib/0xfacet/contracts/ERC721.rb
+lib/0xfacet/contracts/EtherBridge.rb
+lib/0xfacet/contracts/EtherBridgeV2.rb
+lib/0xfacet/contracts/EthscriptionERC20Bridge.rb
+lib/0xfacet/contracts/GenerativeERC721.rb
+lib/0xfacet/contracts/OpenEditionERC721.rb
+lib/0xfacet/contracts/PublicMintERC20.rb
+lib/0xfacet/contracts/UnsafeNoApprovalERC20.rb
+lib/0xfacet/contracts/Upgradeable.rb

data/README.md

@@ -0,0 +1,24 @@
+# 0xFacet Rubidity O.G. Standard Contracts
+
+0xfacet-contracts - rubidity o.g. standard contracts (incl. ERC20,  PublicMintERC20, ERC721, GenerativeERC721, etc.)
+
+* home  :: [github.com/s6ruby/rubidity.review](https://github.com/s6ruby/rubidity.review)
+* bugs  :: [github.com/s6ruby/rubidity.review/issues](https://github.com/s6ruby/rubidity/issues)
+* gem   :: [rubygems.org/gems/0xfacet-contracts](https://rubygems.org/gems/0xfacet-contracts)
+* rdoc  :: [rubydoc.info/gems/0xfacet-contracts](http://rubydoc.info/gems/0xfacet-contracts)
+
+
+
+## About
+
+What's happening herè?
+
+The idea is to look at the facet vm code as-is (that is, NOT suggesting new or alternate syntax and semantics) in the review / commentary 
+and start to (re)package / modular-ize 
+code in "place holder" gems (waiting for adoption by the founders) such as 0xfacet and 0xfacet-typed and 0xfacet-rubidity.
+
+See [Rubidity O.G. (Dumb Contracts) Public Code Review / (More) Tests / Gems & More »](https://github.com/s6ruby/rubidity.review)
+
+
+
+

data/Rakefile

@@ -0,0 +1,32 @@
+require 'hoe'
+
+# require './lib/0xfacet/version.rb'
+
+
+Hoe.spec '0xfacet-contracts' do
+
+  self.version =   '0.0.1'
+
+  self.summary = '0xfacet-contracts - rubidity o.g. standard contracts (incl. ERC20, PublicMintERC20, ERC721, GenerativeERC721, etc.)'
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/s6ruby/rubidity.review' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'gerald.bauer@gmail.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+    ['0xfacet-rubidity', '>= 0.0.1'],
+  ]
+
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+end

data/lib/0xfacet/contracts/ERC20.rb

@@ -0,0 +1,76 @@
+pragma :rubidity, "1.0.0"
+
+contract :ERC20, abstract: true do
+  event :Transfer, { from: :address, to: :address, amount: :uint256 }
+  event :Approval, { owner: :address, spender: :address, amount: :uint256 }
+
+  string :public, :name
+  string :public, :symbol
+  uint8 :public, :decimals
+  
+  uint256 :public, :totalSupply
+
+  mapping ({ address: :uint256 }), :public, :balanceOf
+  mapping ({ address: mapping(address: :uint256) }), :public, :allowance
+  
+  constructor(name: :string, symbol: :string, decimals: :uint8) {
+    s.name = name
+    s.symbol = symbol
+    s.decimals = decimals
+  }
+
+  function :approve, { spender: :address, amount: :uint256 }, :public, :virtual, returns: :bool do
+    s.allowance[msg.sender][spender] = amount
+    
+    emit :Approval, owner: msg.sender, spender: spender, amount: amount
+    
+    return true
+  end
+  
+  function :transfer, { to: :address, amount: :uint256 }, :public, :virtual, returns: :bool do
+    require(s.balanceOf[msg.sender] >= amount, "Insufficient balance")
+    
+    s.balanceOf[msg.sender] -= amount
+    s.balanceOf[to] += amount
+
+    emit :Transfer, from: msg.sender, to: to, amount: amount
+    
+    return true
+  end
+  
+  function :transferFrom, {
+    from: :address,
+    to: :address,
+    amount: :uint256
+  }, :public, :virtual, returns: :bool do
+    allowed = s.allowance[from][msg.sender]
+    
+    require(s.balanceOf[from] >= amount, "Insufficient balance")
+    require(allowed >= amount, "Insufficient allowance")
+    
+    s.allowance[from][msg.sender] = allowed - amount
+    
+    s.balanceOf[from] -= amount
+    s.balanceOf[to] += amount
+    
+    emit :Transfer, from: from, to: to, amount: amount
+    
+    return true
+  end
+  
+  function :_mint, { to: :address, amount: :uint256 }, :internal, :virtual do
+    s.totalSupply += amount
+    s.balanceOf[to] += amount
+    
+    emit :Transfer, from: address(0), to: to, amount: amount
+  end
+  
+  function :_burn, { from: :address, amount: :uint256 }, :internal, :virtual do
+    require(s.balanceOf[from] >= amount, "Insufficient balance")
+    
+    s.balanceOf[from] -= amount
+    s.totalSupply -= amount
+    
+    emit :Transfer, from: from, to: address(0), amount: amount
+  end
+end

data/lib/0xfacet/contracts/ERC721.rb

@@ -0,0 +1,103 @@
+pragma :rubidity, "1.0.0"
+
+contract :ERC721, abstract: true do
+  event :Transfer, { from: :address, to: :address, id: :uint256 }
+  event :Approval, { owner: :address, spender: :address, id: :uint256 }
+  event :ApprovalForAll, { owner: :address, operator: :address, approved: :bool }
+
+  string :public, :name
+  string :public, :symbol
+  
+  mapping ({ uint256: :address }), :internal, :_ownerOf
+  mapping ({ address: :uint256 }), :internal, :_balanceOf
+  
+  mapping ({ uint256: :address }), :public, :getApproved
+  mapping ({ address: mapping(address: :bool) }), :public, :isApprovedForAll
+
+  constructor(name: :string, symbol: :string) {
+    s.name = name
+    s.symbol = symbol
+  }
+  
+  function :ownerOf, { id: :uint256 }, :public, :view, :virtual, returns: :address do
+    owner = s._ownerOf[id]
+    require(owner != address(0), "ERC721: owner query for nonexistent token")
+    
+    return owner
+  end
+  
+  function :balanceOf, { owner: :address }, :public, :view, :virtual, returns: :uint256 do
+    require(owner != address(0), "ERC721: balance query for nonexistent owner")
+    
+    return s._balanceOf[owner]
+  end
+  
+  function :approve, { spender: :address, id: :uint256 }, :public, :virtual do
+    owner = s._ownerOf[id];
+    
+    require(msg.sender == owner || s.isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
+    
+    s.getApproved[id] = spender;
+
+    emit :Approval, owner: owner, spender: spender, id: id
+  end
+  
+  function :setApprovalForAll, { operator: :address, bool: :approved }, :public, :virtual do
+    s.isApprovedForAll[msg.sender][operator] = approved;
+
+    emit :ApprovalForAll, owner: msg.sender, operator: operator, approved: approved
+  end
+  
+  function :transferFrom, { from: :address, to: :address, id: :uint256 }, :public, :virtual do
+    require(from == s._ownerOf[id], "ERC721: transfer of token that is not own");
+    require(to != address(0), "ERC721: transfer to the zero address");
+    
+    require(
+      msg.sender == from ||
+      s.getApproved[id] == msg.sender ||
+      isApprovedForAll[from][msg.sender],
+      "NOT_AUTHORIZED"
+    );
+    
+    s._balanceOf[from] -= 1;
+    s._balanceOf[to] += 1;
+    
+    s._ownerOf[id] = to;
+    
+    s.getApproved[id] = address(0);
+    
+    return nil
+  end
+  
+  function :_exists, { id: :uint256 }, :internal, :virtual, returns: :bool do
+    return s._ownerOf[id] != address(0)
+  end
+  
+  function :_mint, { to: :address, id: :uint256 }, :internal, :virtual do
+    require(to != address(0), "ERC721: mint to the zero address");
+    require(s._ownerOf[id] == address(0), "ERC721: token already minted");
+    
+    s._balanceOf[to] += 1;
+    
+    s._ownerOf[id] = to;
+    
+    emit :Transfer, from: address(0), to: to, id: id
+  end
+  
+  function :_burn, { id: :uint256 }, :internal, :virtual do
+    owner = s._ownerOf[id];
+    
+    require(owner != address(0), "ERC721: burn of nonexistent token");
+    
+    s._balanceOf[owner] -= 1;
+    
+    s._ownerOf[id] = address(0);
+    
+    s.getApproved[id] = address(0);
+    
+    emit :Transfer, from: owner, to: address(0), id: id
+  end
+  
+  function :tokenURI, { id: :uint256 }, :public, :view, :virtual, returns: :string do
+  end
+end

data/lib/0xfacet/contracts/EtherBridge.rb

@@ -0,0 +1,115 @@
+pragma :rubidity, "1.0.0"
+
+import "ERC20"
+import "Upgradeable"
+
+contract :EtherBridge, is: [:ERC20, :Upgradeable], upgradeable: true do
+  event :InitiateWithdrawal, { from: :address, amount: :uint256, withdrawalId: :bytes32 }
+  event :WithdrawalComplete, { to: :address, amounts: [:uint256], withdrawalIds: [:bytes32] }
+
+  address :public, :trustedSmartContract
+  mapping ({ address: :uint256 }), :public, :pendingWithdrawalAmounts
+  mapping ({ address: array(:bytes32) }), :public, :pendingUserWithdrawalIds
+
+  bool :public, :bridgeOutPaused
+  
+  constructor(
+    name: :string,
+    symbol: :string,
+    trustedSmartContract: :address
+  ) {
+    ERC20.constructor(name: name, symbol: symbol, decimals: 18)
+    Upgradeable.constructor(upgradeAdmin: msg.sender)
+    
+    s.trustedSmartContract = trustedSmartContract
+  }
+  
+  function :bridgeIn, { to: :address, amount: :uint256 }, :public do
+    require(
+      msg.sender == s.trustedSmartContract,
+      "Only the trusted smart contract can bridge in tokens"
+    )
+    
+    _mint(to: to, amount: amount)
+  end
+  
+  function :setBridgeOutPause, { newState: :bool }, :public do
+    require(msg.sender == s.upgradeAdmin, "Only the pause admin can pause bridge outs")
+    
+    s.bridgeOutPaused = newState
+    nil
+  end
+  
+  function :bridgeOut, { amount: :uint256 }, :public do
+    require(!s.bridgeOutPaused, "Bridge out is paused")
+    
+    _burn(from: msg.sender, amount: amount)
+    
+    withdrawalId = esc.currentTransactionHash
+    
+    s.pendingWithdrawalAmounts[msg.sender] += amount
+    s.pendingUserWithdrawalIds[msg.sender].push(withdrawalId)
+    
+    emit :InitiateWithdrawal, from: msg.sender, amount: amount, withdrawalId: withdrawalId
+  end
+  
+  function :markWithdrawalComplete, {
+    to: :address,
+    amounts: [:uint256],
+    withdrawalIds: [:bytes32]
+  }, :public do
+    require(
+      msg.sender == s.trustedSmartContract,
+      "Only the trusted smart contract can mark withdrawals as complete"
+    )
+    
+    for i in 0...withdrawalIds.length
+      withdrawalId = withdrawalIds[i]
+      amount = amounts[i]
+      
+      require(
+        s.pendingWithdrawalAmounts[to] >= amount,
+        "Insufficient pending withdrawal"
+      )
+      
+      require(
+        _removeFirstOccurenceOfValueFromArray(
+          s.pendingUserWithdrawalIds[to],
+          withdrawalId
+        ),
+        "Withdrawal id not found"
+      )
+      
+      s.pendingWithdrawalAmounts[to] -= amount
+    end
+      
+    emit :WithdrawalComplete, to: to, amounts: amounts, withdrawalIds: withdrawalIds
+  end
+  
+  function :getPendingWithdrawalsForUser, { user: :address }, :public, :view, returns: [:bytes32] do
+    return s.pendingUserWithdrawalIds[user]
+  end
+  
+  function :_removeFirstOccurenceOfValueFromArray, { arr: array(:bytes32), value: :bytes32 }, :internal, returns: :bool do
+    for i in 0...arr.length
+      if arr[i] == value
+        return _removeItemAtIndex(arr: arr, indexToRemove: i)
+      end
+    end
+    
+    return false
+  end
+  
+  function :_removeItemAtIndex, { arr: array(:bytes32), indexToRemove: :uint256 }, :internal, returns: :bool do
+    lastIndex = arr.length - 1
+    
+    if lastIndex != indexToRemove
+      lastItem = arr[lastIndex]
+      arr[indexToRemove] = lastItem
+    end
+    
+    arr.pop
+    
+    return true
+  end
+end

data/lib/0xfacet/contracts/EtherBridgeV2.rb

@@ -0,0 +1,100 @@
+pragma :rubidity, "1.0.0"
+
+import "ERC20"
+import "Upgradeable"
+
+contract :EtherBridgeV2, is: [:ERC20, :Upgradeable], upgradeable: true do
+  event :BridgedIn, { to: :address, amount: :uint256 }
+  event :InitiateWithdrawal, { from: :address, amount: :uint256, withdrawalId: :bytes32 }
+  event :WithdrawalComplete, { to: :address, amount: :uint256, withdrawalId: :bytes32 }
+  
+  address :public, :trustedSmartContract
+  
+  mapping ({ address: :uint256 }), :public, :pendingWithdrawalAmounts
+  mapping ({ address: array(:bytes32) }), :public, :pendingUserWithdrawalIds
+  
+  mapping ({ bytes32: :uint256 }), :public, :withdrawalIdAmount
+  mapping ({ address: :bytes32 }), :public, :userWithdrawalId
+  
+  constructor(
+    name: :string,
+    symbol: :string,
+    trustedSmartContract: :address
+  ) {
+    require(trustedSmartContract != address(0), "Invalid smart contract")
+
+    ERC20.constructor(name: name, symbol: symbol, decimals: 18)
+    Upgradeable.constructor(upgradeAdmin: msg.sender)
+
+    s.trustedSmartContract = trustedSmartContract
+  }
+  
+  function :onUpgrade, { usersToProcess: [:address] }, :public do
+    require(msg.sender == address(this), "Only the contract can call this function")
+    
+    for i in 0...usersToProcess.length
+      user = usersToProcess[i]
+      
+      require(s.pendingUserWithdrawalIds[user].length == 1, "Migration not possible")
+      
+      withdrawalId = s.pendingUserWithdrawalIds[user].pop
+      amount = s.pendingWithdrawalAmounts[user]
+
+      s.pendingWithdrawalAmounts[user] = 0
+      s.userWithdrawalId[user] = withdrawalId
+      
+      s.withdrawalIdAmount[withdrawalId] = amount
+    end
+    
+    nil
+  end
+  
+  function :bridgeIn, { to: :address, amount: :uint256 }, :public do
+    require(
+      msg.sender == s.trustedSmartContract,
+      "Only the trusted smart contract can bridge in tokens"
+    )
+    
+    _mint(to: to, amount: amount)
+    emit :BridgedIn, to: to, amount: amount
+  end
+  
+  function :bridgeOut, { amount: :uint256 }, :public do
+    withdrawalId = esc.currentTransactionHash
+    require(
+      s.userWithdrawalId[msg.sender] == bytes32(0),
+      "Withdrawal pending"
+    )
+    require(
+      s.withdrawalIdAmount[withdrawalId] == 0,
+      "Already bridged out"
+    )
+    require(amount > 0, "Invalid amount")
+
+    s.userWithdrawalId[msg.sender] = withdrawalId
+    s.withdrawalIdAmount[withdrawalId] = amount
+      
+    _burn(from: msg.sender, amount: amount)
+    emit :InitiateWithdrawal, from: msg.sender, amount: amount, withdrawalId: withdrawalId
+  end
+  
+  function :markWithdrawalComplete, {
+    to: :address,
+    withdrawalId: :bytes32
+  }, :public do
+    require(
+      msg.sender == s.trustedSmartContract,
+      "Only the trusted smart contract can mark withdrawals as complete"
+    )
+    require(
+      s.userWithdrawalId[to] == withdrawalId,
+      "Withdrawal id not found"
+    )
+    
+    amount = s.withdrawalIdAmount[withdrawalId]
+    s.withdrawalIdAmount[withdrawalId] = 0
+    s.userWithdrawalId[to] = bytes32(0)
+      
+    emit :WithdrawalComplete, to: to, amount: amount, withdrawalId: withdrawalId
+  end
+end

data/lib/0xfacet/contracts/EthscriptionERC20Bridge.rb

@@ -0,0 +1,89 @@
+pragma :rubidity, "1.0.0"
+
+import "ERC20"
+import "Upgradeable"
+
+contract :EthscriptionERC20Bridge, is: [:ERC20, :Upgradeable], upgradeable: true do
+  event :BridgedIn, { to: :address, amount: :uint256 }
+  event :InitiateWithdrawal, { from: :address, amount: :uint256, withdrawalId: :bytes32 }
+  event :WithdrawalComplete, { to: :address, amount: :uint256, withdrawalId: :bytes32 }
+  
+  uint256 :public, :mintAmount
+  address :public, :trustedSmartContract
+
+  mapping ({ address: :uint256 }), :public, :bridgedInAmount
+  mapping ({ bytes32: :uint256 }), :public, :withdrawalIdAmount
+  mapping ({ address: :bytes32 }), :public, :userWithdrawalId
+  
+  constructor(
+    name: :string,
+    symbol: :string,
+    mintAmount: :uint256,
+    trustedSmartContract: :address
+  ) {
+    require(mintAmount > 0, "Invalid mint amount")
+    require(trustedSmartContract != address(0), "Invalid smart contract")
+
+    ERC20.constructor(name: name, symbol: symbol, decimals: 18)
+    Upgradeable.constructor(upgradeAdmin: msg.sender)
+    
+    s.mintAmount = mintAmount
+    s.trustedSmartContract = trustedSmartContract
+  }
+  
+  function :bridgeIn, { to: :address, amount: :uint256 }, :public do
+    require(
+      msg.sender == s.trustedSmartContract,
+      "Only the trusted smart contract can bridge in tokens"
+    )
+    
+    s.bridgedInAmount[to] += amount
+
+    _mint(to: to, amount: amount * s.mintAmount * 1.ether)
+    emit :BridgedIn, to: to, amount: amount
+  end
+  
+  function :bridgeOut, { amount: :uint256 }, :public do
+    withdrawalId = esc.currentTransactionHash
+    require(
+      s.userWithdrawalId[msg.sender] == bytes32(0),
+      "Withdrawal pending"
+    )
+    require(
+      s.withdrawalIdAmount[withdrawalId] == 0,
+      "Already bridged out"
+    )
+    require(
+      s.bridgedInAmount[msg.sender] >= amount,
+      "Not enough bridged in"
+    )
+    require(amount > 0, "Invalid amount")
+
+    s.userWithdrawalId[msg.sender] = withdrawalId
+    s.withdrawalIdAmount[withdrawalId] = amount
+    s.bridgedInAmount[msg.sender] -= amount
+      
+    _burn(from: msg.sender, amount: amount * s.mintAmount * 1.ether)
+    emit :InitiateWithdrawal, from: msg.sender, amount: amount, withdrawalId: withdrawalId
+  end
+  
+  function :markWithdrawalComplete, {
+    to: :address,
+    withdrawalId: :bytes32
+  }, :public do
+    require(
+      msg.sender == s.trustedSmartContract,
+      "Only the trusted smart contract can mark withdrawals as complete"
+    )
+    require(
+      s.userWithdrawalId[to] == withdrawalId,
+      "Withdrawal id not found"
+    )
+    
+    amount = s.withdrawalIdAmount[withdrawalId]
+    s.withdrawalIdAmount[withdrawalId] = 0
+    s.userWithdrawalId[to] = bytes32(0)
+      
+    emit :WithdrawalComplete, to: to, amount: amount, withdrawalId: withdrawalId
+  end
+end

data/lib/0xfacet/contracts/GenerativeERC721.rb

@@ -0,0 +1,95 @@
+pragma :rubidity, "1.0.0"
+
+import 'ERC721'
+
+contract :GenerativeERC721, is: :ERC721 do
+  string :public, :generativeScript
+  mapping ({ uint256: :uint256 }), :public, :tokenIdToSeed
+  
+  uint256 :public, :totalSupply
+  uint256 :public, :maxSupply
+  uint256 :public, :maxPerAddress
+  string :public, :description
+  
+  constructor(
+    name: :string,
+    symbol: :string,
+    generativeScript: :string,
+    maxSupply: :uint256,
+    description: :string,
+    maxPerAddress: :uint256
+  ) {
+    ERC721.constructor(name: name, symbol: symbol)
+    
+    s.maxSupply = maxSupply
+    s.maxPerAddress = maxPerAddress
+    s.description = description
+    s.generativeScript = generativeScript
+  }
+  
+  function :mint, { amount: :uint256 }, :public, returns: :uint256 do
+    require(amount > 0, 'Amount must be positive')
+    require(amount + s._balanceOf[msg.sender] <= s.maxPerAddress, 'Exceeded mint limit')
+    require(amount + s.totalSupply <= s.maxSupply, 'Exceeded max supply')
+    
+    hash = blockhash(block.number).cast(:uint256) % (2 ** 48)
+    
+    amount.times do |id|
+      tokenId = s.totalSupply + id
+      seed = hash + tokenId
+      
+      s.tokenIdToSeed[tokenId] = seed
+      
+      _mint(to: msg.sender, id: tokenId)
+    end
+    
+    s.totalSupply += amount
+  end
+  
+  function :tokenURI, { id: :uint256 }, :public, :view, :override, returns: :string do
+    require(_exists(id: id), 'ERC721Metadata: URI query for nonexistent token')
+    
+    html = getHTML(seed: s.tokenIdToSeed[id])
+    
+    html_as_base_64_data_uri = "data:text/html;base64," + esc.base64Encode(html)
+    
+    json_data = {
+      name: "#{s.name} ##{string(id)}",
+      description: s.description,
+      animation_url: html_as_base_64_data_uri,
+    }.to_json
+    
+    return "data:application/json,#{json_data}"
+  end
+  
+  function :getHTML, { seed: :uint256 }, :public, :view, returns: :string do
+    <<~HTML
+      <html>
+        <head>
+          <style>
+            body,
+            html {
+              width: 100%;
+              height: 100%;
+              margin: 0;
+              padding: 0;
+              overflow: hidden;
+              display: block;
+            }
+
+            #canvas {
+              position: absolute;
+            }
+          </style>
+        </head>
+        <body>
+          <canvas id="canvas"></canvas>
+        </body>
+        <script>
+          window.SEED = #{string(seed)};
+          #{s.generativeScript}
+        </script>
+      </html>
+    HTML
+  end
+end

data/lib/0xfacet/contracts/OpenEditionERC721.rb

@@ -0,0 +1,56 @@
+pragma :rubidity, "1.0.0"
+
+import 'ERC721'
+
+contract :OpenEditionERC721, is: :ERC721 do
+  string :public, :contentURI
+  uint256 :public, :maxPerAddress
+  uint256 :public, :totalSupply
+  string :public, :description
+  
+  datetime :public, :mintStart
+  datetime :public, :mintEnd
+  
+  constructor(
+    name: :string,
+    symbol: :string,
+    contentURI: :string,
+    maxPerAddress: :uint256,
+    description: :string,
+    mintStart: :datetime,
+    mintEnd: :datetime
+  ) {
+    ERC721.constructor(name: name, symbol: symbol)
+    
+    s.maxPerAddress = maxPerAddress
+    s.description = description
+    s.contentURI = contentURI
+    s.mintStart = mintStart
+    s.mintEnd = mintEnd
+  }
+  
+  function :mint, { amount: :uint256 }, :public, returns: :uint256 do
+    require(amount > 0, 'Amount must be positive')
+    require(amount + s._balanceOf[msg.sender] <= s.maxPerAddress, 'Exceeded mint limit')
+    require(block.timestamp >= s.mintStart, 'Minting has not started')
+    require(block.timestamp < s.mintEnd, 'Minting has ended')
+    
+    amount.times do |id|
+      _mint(to: msg.sender, id: s.totalSupply + id)
+    end
+    
+    s.totalSupply += amount
+  end
+  
+  function :tokenURI, { id: :uint256 }, :public, :view, :override, returns: :string do
+    require(_exists(id: id), 'ERC721Metadata: URI query for nonexistent token')
+
+    json_data = {
+      name: "#{s.name} ##{string(id)}",
+      description: s.description,
+      image: s.contentURI,
+    }.to_json
+    
+    return "data:application/json,#{json_data}"
+  end
+end

data/lib/0xfacet/contracts/PublicMintERC20.rb

@@ -0,0 +1,38 @@
+pragma :rubidity, "1.0.0"
+
+import 'ERC20'
+
+contract :PublicMintERC20, is: :ERC20 do
+  uint256 :public, :maxSupply
+  uint256 :public, :perMintLimit
+  
+  constructor(
+    name: :string,
+    symbol: :string,
+    maxSupply: :uint256,
+    perMintLimit: :uint256,
+    decimals: :uint8
+  ) {
+    ERC20.constructor(name: name, symbol: symbol, decimals: decimals)
+    s.maxSupply = maxSupply
+    s.perMintLimit = perMintLimit
+  }
+  
+  function :mint, { amount: :uint256 }, :public do
+    require(amount > 0, 'Amount must be positive')
+    require(amount <= s.perMintLimit, 'Exceeded mint limit')
+    
+    require(s.totalSupply + amount <= s.maxSupply, 'Exceeded max supply')
+    
+    _mint(to: msg.sender, amount: amount)
+  end
+  
+  function :airdrop, { to: :address, amount: :uint256 }, :public do
+    require(amount > 0, 'Amount must be positive')
+    require(amount <= s.perMintLimit, 'Exceeded mint limit')
+    
+    require(s.totalSupply + amount <= s.maxSupply, 'Exceeded max supply')
+    
+    _mint(to: to, amount: amount)
+  end
+end

data/lib/0xfacet/contracts/UnsafeNoApprovalERC20.rb

@@ -0,0 +1,39 @@
+pragma :rubidity, "1.0.0"
+
+import 'ERC20'
+
+contract :UnsafeNoApprovalERC20, is: :ERC20 do
+  constructor(
+    name: :string,
+    symbol: :string,
+  ) {
+    ERC20.constructor(name: name, symbol: symbol, decimals: 18)
+  }
+  
+  function :mint, { amount: :uint256 }, :public do
+    require(amount > 0, 'Amount must be positive')
+    
+    _mint(to: msg.sender, amount: amount)
+  end
+  
+  function :airdrop, { to: :address, amount: :uint256 }, :public do
+    require(amount > 0, 'Amount must be positive')
+    
+    _mint(to: to, amount: amount)
+  end
+  
+  function :transferFrom, {
+    from: :address,
+    to: :address,
+    amount: :uint256
+  }, :public, :override, returns: :bool do
+    require(s.balanceOf[from] >= amount, 'Insufficient balance')
+    
+    s.balanceOf[from] -= amount
+    s.balanceOf[to] += amount
+    
+    emit :Transfer, from: from, to: to, amount: amount
+    
+    return true
+  end
+end

data/lib/0xfacet/contracts/Upgradeable.rb

@@ -0,0 +1,37 @@
+pragma :rubidity, "1.0.0"
+
+contract :Upgradeable, abstract: true do
+  address :public, :upgradeAdmin
+  
+  event :ContractUpgraded, { oldHash: :bytes32, newHash: :bytes32 }
+  event :UpgradeAdminChanged, { newUpgradeAdmin: :address }
+  
+  constructor(upgradeAdmin: :address) {
+    s.upgradeAdmin = upgradeAdmin
+  }
+  
+  function :setUpgradeAdmin, { newUpgradeAdmin: :address }, :public do
+    require(msg.sender == s.upgradeAdmin, "NOT_AUTHORIZED")
+    
+    s.upgradeAdmin = newUpgradeAdmin
+    
+    emit :UpgradeAdminChanged, newUpgradeAdmin: newUpgradeAdmin
+  end
+  
+  function :upgradeAndCall, { newHash: :bytes32, migrationCalldata: :string }, :public do
+    upgrade(newHash: newHash)
+
+    (success, data) = address(this).call(migrationCalldata)
+    require(success, "Migration failed")
+  end
+  
+  function :upgrade, { newHash: :bytes32 }, :public do
+    currentHash = esc.getImplementationHash
+    
+    require(msg.sender == s.upgradeAdmin, "NOT_AUTHORIZED")
+    
+    esc.upgradeContract(newHash)
+    
+    emit :ContractUpgraded, oldHash: currentHash, newHash: newHash
+  end
+end

data/lib/0xfacet/contracts.rb

@@ -0,0 +1,8 @@
+
+
+puts "hello, 0xfacet contracts!"
+
+# note: cannot load rubidity contracts as is - require rubidity loader!
+
+
+

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: 0xfacet-contracts
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: 0xfacet-rubidity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: 0xfacet-contracts - rubidity o.g. standard contracts (incl. ERC20, PublicMintERC20,
+  ERC721, GenerativeERC721, etc.)
+email: gerald.bauer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/0xfacet/contracts.rb
+- lib/0xfacet/contracts/ERC20.rb
+- lib/0xfacet/contracts/ERC721.rb
+- lib/0xfacet/contracts/EtherBridge.rb
+- lib/0xfacet/contracts/EtherBridgeV2.rb
+- lib/0xfacet/contracts/EthscriptionERC20Bridge.rb
+- lib/0xfacet/contracts/GenerativeERC721.rb
+- lib/0xfacet/contracts/OpenEditionERC721.rb
+- lib/0xfacet/contracts/PublicMintERC20.rb
+- lib/0xfacet/contracts/UnsafeNoApprovalERC20.rb
+- lib/0xfacet/contracts/Upgradeable.rb
+homepage: https://github.com/s6ruby/rubidity.review
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: 0xfacet-contracts - rubidity o.g. standard contracts (incl. ERC20, PublicMintERC20,
+  ERC721, GenerativeERC721, etc.)
+test_files: []