rubysol-contracts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 93eaae4a1c50deb7cd758c3d4722586ae4db0043658ff5f67c4e3511f1c39067
+  data.tar.gz: 5abc50f516b527db09d6b88d8d1b2ecdcb7813f60149bea0eacf674e627b767d
+SHA512:
+  metadata.gz: ed4147e02ef81e836a395d62d3bdebf85badb296b51015588141c1f0f0ad8206fa70c689856c5ecce70d8d8abc0ed656d33307a878ef5986f1e3f72124e2d57f
+  data.tar.gz: a9772883af9fb960c6771711274ae79d94715609c4bdf2ed8926cdde93330e10b9bfee5adbd629a883480ca05bb204043104e58361d6f98f2eb02c5f0c77b348

data/CHANGELOG.md

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

data/Manifest.txt

@@ -0,0 +1,14 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/rubysol/contracts.rb
+lib/rubysol/contracts/erc20.rb
+lib/rubysol/contracts/erc20_liquidity_pool.rb
+lib/rubysol/contracts/erc721.rb
+lib/rubysol/contracts/ether_erc20_bridge.rb
+lib/rubysol/contracts/ethscription_erc20_bridge.rb
+lib/rubysol/contracts/generative_erc721.rb
+lib/rubysol/contracts/open_edition_erc721.rb
+lib/rubysol/contracts/public_mint_erc20.rb
+lib/rubysol/contracts/version.rb

data/README.md

@@ -0,0 +1,315 @@
+# Rubysol Contracts
+
+ rubysol-contracts - standard contracts (incl. erc20, erc721, etc) for ruby for layer 1 (l1) with "off-chain" indexer
+ 
+* home  :: [github.com/s6ruby/rubidity](https://github.com/s6ruby/rubidity)
+* bugs  :: [github.com/s6ruby/rubidity/issues](https://github.com/s6ruby/rubidity/issues)
+* gem   :: [rubygems.org/gems/rubysol-contracts](https://rubygems.org/gems/rubysol-contracts)
+* rdoc  :: [rubydoc.info/gems/rubysol-contracts](http://rubydoc.info/gems/rubysol-contracts)
+
+
+
+
+## What's Solidity?! What's Rubidity?! What's Rubysol?!
+
+See [**Solidity - Contract Application Binary Interface (ABI) Specification** »](https://docs.soliditylang.org/en/latest/abi-spec.html)
+
+See [**Rubidity - Ruby for Layer 1 (L1) Contracts / Protocols with "Off-Chain" Indexer**  »](https://github.com/s6ruby/rubidity)
+
+See [**Rubysol - Ruby for Layer 1 (L1) Contracts / Protocols with "Off-Chain" Indexer**  »](https://github.com/s6ruby/rubidity/tree/master/rubysol)
+
+
+
+
+## Usage
+
+Let's try the PublicMintERC20 contract...
+
+<details>
+<summary markdown="1">Show Source</summary>
+
+[contracts/public_mint_erc20.rb](lib/rubysol/contracts/public_mint_erc20.rb):
+
+```ruby
+class PublicMintERC20 < ERC20
+  
+  storage maxSupply:    UInt,
+          perMintLimit: UInt 
+  
+  sig [String, String, UInt, UInt, UInt]
+  def constructor(
+    name:,
+    symbol:,
+    maxSupply:,
+    perMintLimit:,
+    decimals:
+  ) 
+    super( name: name, 
+           symbol: symbol, 
+           decimals: decimals)
+ 
+    @maxSupply    = maxSupply
+    @perMintLimit = perMintLimit
+  end
+ 
+
+  sig  [UInt]
+  def mint( amount: )
+    assert(amount > 0, 'Amount must be positive')
+    assert(amount <= @perMintLimit, 'Exceeded mint limit')
+    
+    assert( @totalSupply + amount <= @maxSupply, 'Exceeded max supply')
+    
+    _mint(to: msg.sender, amount: amount)
+  end
+  
+  sig [Address, UInt]
+  def airdrop( to:, amount: ) 
+    assert(amount > 0, 'Amount must be positive')
+    assert(amount <= @perMintLimit, 'Exceeded mint limit')
+    
+    assert(@totalSupply + amount <= @maxSupply, 'Exceeded max supply')
+    
+    _mint(to: to, amount: amount)
+  end
+end
+```
+
+</details>
+
+that builds on the ERC20 (base) contract.
+
+<details>
+<summary markdown="1">Show Source</summary>
+
+[contracts/erc20.rb](lib/rubysol/contracts/erc20.rb):
+
+```ruby
+class ERC20 < Contract
+  
+  event :Transfer, from:    Address, 
+                   to:      Address, 
+                   amount:  UInt
+  event :Approval, owner:   Address, 
+                   spender: Address, 
+                   amount:  UInt
+
+  storage name:        String, 
+          symbol:      String,  
+          decimals:    UInt, 
+          totalSupply: UInt, 
+          balanceOf:   mapping( Address, UInt ), 
+          allowance:   mapping( Address, mapping( Address, UInt ))
+          
+
+  sig [String, String, UInt] 
+  def constructor(name:, 
+                  symbol:, 
+                  decimals:) 
+    @name = name
+    @symbol = symbol
+    @decimals = decimals
+  end
+
+
+  sig [Address, UInt], returns: Bool
+  def approve( spender:, 
+               amount: ) 
+    @allowance[msg.sender][spender] = amount
+    
+    log Approval, owner: msg.sender, spender: spender, amount: amount
+    
+    true
+  end
+  
+
+  sig [Address, UInt],  returns: Bool
+  def decreaseAllowanceUntilZero( spender:, 
+                                  difference: )
+    allowed = @allowance[msg.sender][spender]
+    
+    newAllowed = allowed > difference ? allowed - difference : 0
+    
+    approve(spender: spender, amount: newAllowed)
+    
+    true
+  end
+
+
+  sig [Address, UInt],  returns: Bool
+  def transfer( to:, 
+                amount: )
+    assert @balanceOf[msg.sender] >= amount, 'Insufficient balance'
+    
+    @balanceOf[msg.sender] -= amount
+    @balanceOf[to] += amount
+
+    log Transfer, from: msg.sender, to: to, amount: amount
+    
+    true
+  end
+  
+  sig [Address, Address, UInt], returns: Bool
+  def transferFrom( 
+       from:,
+       to:,
+       amount:)
+    allowed = @allowance[from][msg.sender]
+    
+    assert @balanceOf[from] >= amount, 'Insufficient balance'
+    assert allowed >= amount, 'Insufficient allowance'
+    
+    @allowance[from][msg.sender] = allowed - amount
+    
+    @balanceOf[from] -= amount
+    @balanceOf[to] += amount
+    
+    log Transfer, from: from, to: to, amount: amount
+    
+    true
+  end
+  
+  sig [Address, UInt]
+  def _mint( to:,
+             amount: )
+    @totalSupply += amount
+    @balanceOf[to] += amount
+    
+    log Transfer, from: address(0), to: to, amount: amount
+  end
+  
+  sig [Address, UInt]
+  def _burn( from:, 
+             amount: )
+     @balanceOf[from] -= amount
+     @totalSupply -= amount
+    
+     log Transfer, from: from, to: address(0), amount: amount
+  end
+end
+```
+
+</details>
+
+
+
+Let's go.
+
+``` ruby
+require 'rubysol/contracts'
+
+contract = PublicMintERC20.construct(
+    name: 'My Fun Token',  # String,
+    symbol: 'FUN',         # String,
+    maxSupply:  21000000,  #  UInt,
+    perMintLimit: 1000,    #  UInt,
+    decimals:     18,      #  UInt
+  ) 
+
+
+contract.serialize
+# {:name=>"My Fun Token",
+#   :symbol=>"FUN",
+#   :decimals=>18,
+#   :totalSupply=>0,
+#   :balanceOf=>{},
+#   :allowance=>{},
+#   :maxSupply=>21000000,
+# :perMintLimit=>1000}
+
+alice   = '0x'+'a'*40 # e.g. '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+bob     = '0x'+'b'*40 # e.g. '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+charlie = '0x'+'c'*40 # e.g. '0xcccccccccccccccccccccccccccccccccccccccc'
+
+
+#  sig [UInt]
+#  def mint( amount: )
+contract.msg.sender = alice
+
+contract.mint( 100 )
+contract.mint( 200 )
+
+contract.msg.sender = bob
+
+contract.mint( 300 )
+contract.mint( 400 )
+
+#  sig [Address, UInt]
+#  def airdrop( to:, amount: ) 
+contract.airdrop( alice, 500 )
+contract.airdrop( charlie, 600  )
+
+contract.serialize
+# {:name=>"My Fun Token",
+#  :symbol=>"FUN",
+#  :decimals=>18,
+#  :totalSupply=>2100,
+#  :balanceOf=>
+#  {"0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"=>800,
+#   "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"=>700,
+#   "0xcccccccccccccccccccccccccccccccccccccccc"=>600},
+# :allowance=>{},
+# :maxSupply=>21000000,
+# :perMintLimit=>1000}
+
+
+#  sig [Address, UInt],  returns: Bool
+#  def transfer( to:, amount: )
+contract.transfer( alice, 1  )
+contract.transfer( charlie, 2  )
+
+#  sig [Address, UInt], returns: Bool
+#  def approve( spender:, amount: ) 
+contract.approve( alice, 11 )
+contract.approve( charlie, 22 )
+
+
+# sig [Address, Address, UInt], returns: Bool
+# def transferFrom( from:, to:, amount:)
+contract.msg.sender = alice
+
+contract.approve( bob, 33 )
+
+contract.transferFrom( bob, charlie, 3 )
+contract.transferFrom( bob, alice, 4 )
+
+contract.serialize
+# {:name=>"My Fun Token",
+#  :symbol=>"FUN",
+#  :decimals=>18,
+#  :totalSupply=>2100,
+#  :balanceOf=> 
+#  {"0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"=>805,
+#   "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"=>690,
+#   "0xcccccccccccccccccccccccccccccccccccccccc"=>605},
+#  :allowance=>
+#  {"0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"=> {
+#      "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"=>4, 
+#      "0xcccccccccccccccccccccccccccccccccccccccc"=>22},
+#   "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"=> {
+#      "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"=>33}},
+# :maxSupply=>21000000,
+# :perMintLimit=>1000}
+```
+
+And so on. That's it for now.
+
+
+
+## Bonus - More Blockchain (Crypto) Tools, Libraries & Scripts In Ruby
+
+See [**/blockchain**](https://github.com/rubycocos/blockchain) 
+at the ruby code commons (rubycocos) org.
+
+
+
+
+
+## Questions? Comments?
+
+Join us in the [Rubidity & Rubysol (community) discord (chat server)](https://discord.gg/3JRnDUap6y). Yes you can.
+Your questions and commentary welcome.
+
+Or post them over at the [Help & Support](https://github.com/geraldb/help) page. Thanks.
+
+

data/Rakefile

@@ -0,0 +1,29 @@
+require 'hoe'
+require './lib/rubysol/contracts/version.rb'
+
+Hoe.spec 'rubysol-contracts' do
+
+  self.version =  Rubysol::Module::Contracts::VERSION
+
+  self.summary = 'rubysol-contracts - standard contracts (incl. erc20, erc721, etc) for ruby for layer 1 (l1) with "off-chain" indexer'
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/s6ruby/rubidity' }
+
+  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 = [
+    ['rubysol', '>= 0.1.0'],
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+end

data/lib/rubysol/contracts/erc20.rb

@@ -0,0 +1,77 @@
+class ERC20 < Contract   #  abstract: true
+
+  event :Transfer, from: Address, 
+                   to:   Address, 
+                   amount: UInt 
+  event :Approval, owner: Address, 
+                   spender: Address, 
+                   amount: UInt 
+
+  storage name:        String, 
+          symbol:      String, 
+          decimals:    UInt,
+          totalSupply: UInt,
+          balanceOf:   mapping( Address, UInt), 
+          allowance:   mapping( Address, mapping( Address, UInt))
+          
+  sig [String, String, UInt]        
+  def constructor(name:, symbol:, decimals:)
+    @name     = name
+    @symbol   = symbol
+    @decimals = decimals
+  end
+
+  sig [Address, UInt], returns: Bool 
+  def approve( spender:, amount: )
+    @allowance[msg.sender][spender] = amount
+    
+    log Approval, owner: msg.sender, spender: spender, amount: amount
+    
+    true
+  end
+
+  sig [Address, UInt], returns: Bool 
+  def transfer( to:, amount: )
+    assert @balanceOf[msg.sender] >= amount, "Insufficient balance"
+    
+    @balanceOf[msg.sender] -= amount
+    @balanceOf[to] += amount
+
+    log Transfer, from: msg.sender, to: to, amount: amount
+    
+    true
+  end
+  
+  sig [Address, Address, UInt], returns: Bool
+  def transferFrom( from:, to:, amount: )
+    allowed = @allowance[from][msg.sender]
+    
+    assert @balanceOf[from] >= amount, "Insufficient balance"
+    assert allowed >= amount, "Insufficient allowance"
+    
+    @allowance[from][msg.sender] = allowed - amount
+    
+    @balanceOf[from] -= amount
+    @balanceOf[to] += amount
+    
+    log Transfer, from: from, to: to, amount: amount
+    
+    true
+  end
+  
+  sig [Address, UInt]
+  def _mint( to:, amount: )
+    @totalSupply += amount
+    @balanceOf[to] += amount
+    
+    log Transfer, from: address(0), to: to, amount: amount
+  end
+  
+  sig [Address, UInt]
+  def _burn( from:, amount: )
+    @balanceOf[from] -= amount
+    @totalSupply -= amount
+    
+    log Transfer, from: from, to: address(0), amount: amount
+  end
+end  # class ERC20 

data/lib/rubysol/contracts/erc20_liquidity_pool.rb

@@ -0,0 +1,84 @@
+class ERC20LiquidityPool < Contract
+
+  storage token0: Address,
+          token1: Address
+
+  sig [Address, Address]           
+  def constructor( token0:, 
+                   token1: ) 
+    @token0 = token0
+    @token1 = token1
+  end
+  
+  sig [UInt, UInt]
+  def addLiquidity( token0Amount:, 
+                    token1Amount: )
+    ERC20(@token0).transferFrom(
+      from: msg.sender,
+      to: address( this ),   ## note: add support for this (alias for self ??)
+      amount: token0Amount
+    )
+    
+    ERC20(@token1).transferFrom(
+      from: msg.sender,
+      to: address(this),
+      amount: token1Amount
+    )
+  end
+  
+
+  sig [], :view   ### fix- support multiple, returns: [UInt, UInt]
+  def reserves
+    {
+      token0: ERC20(@token0).balanceOf(address(this)),
+      token1: ERC20(@token1).balanceOf(address(this))
+    }
+  end
+
+ 
+
+  sig [Address, Address, UInt], :view, returns: UInt
+  def calculateOutputAmount( inputToken:,
+                             outputToken:,
+                             inputAmount: )
+    inputReserve  = ERC20(inputToken).balanceOf(address(this))
+    outputReserve = ERC20(outputToken).balanceOf(address(this))
+    
+    ((inputAmount * outputReserve) / (inputReserve + inputAmount)).to_i
+  end
+
+
+  sig [Address, Address, UInt], returns: UInt
+  def swap(
+    inputToken:,
+    outputToken:,
+    inputAmount: )
+    assert [@token0, @token1].include?(inputToken), "Invalid input token"
+    assert [@token0, @token1].include?(outputToken), "Invalid output token"
+    
+    assert inputToken != outputToken, "Input and output tokens can't be the same"
+    
+    outputAmount = calculateOutputAmount(
+      inputToken: inputToken,
+      outputToken: outputToken,
+      inputAmount: inputAmount
+    )
+    
+    outputReserve = ERC20(outputToken).balanceOf( address(this))
+    
+    assert outputAmount <= outputReserve, "Insufficient output reserve"
+  
+    ERC20(inputToken).transferFrom(
+      from: msg.sender,
+      to: dumbContractId(this),
+      amount: inputAmount
+    )
+  
+    ERC20(outputToken).transfer(
+      msg.sender,
+      outputAmount
+    )
+  
+    outputAmount
+  end
+end

data/lib/rubysol/contracts/erc721.rb

@@ -0,0 +1,121 @@
+class ERC721 < Contract
+  
+  event :Transfer, from: Address, 
+                   to:   Address, 
+                   id:   UInt
+  event :Approval, owner:  Address, 
+                   spender: Address, 
+                     id:     UInt 
+  event :ApprovalForAll,  owner:    Address, 
+                           operator: Address, 
+                           approved: Bool 
+
+  storage  name:             String,
+           symbol:           String,
+           _ownerOf:         mapping( UInt, Address ),
+           _balanceOf:       mapping( Address, UInt ),
+           getApproved:      mapping( UInt, Address ), 
+           isApprovedForAll: mapping( Address, mapping( Address, Bool ))
+
+  sig  [String, String]           
+  def constructor( name:, 
+                   symbol: ) 
+    @name   = name
+    @symbol = symbol
+  end
+
+
+  sig [ UInt ], :view, returns: Address 
+  def ownerOf( id )
+    owner = @_ownerOf[id]
+    assert owner != address(0), "ERC721: owner query for nonexistent token"
+    
+    owner
+  end
+  
+  sig [ Address ], :view, returns: UInt
+  def balanceOf( owner: ) 
+    assert owner != address(0), "ERC721: balance query for nonexistent owner"
+    
+    @_balanceOf[owner]
+  end
+  
+  sig [ Address, UInt]
+  def approve( spender:, 
+               id: )
+    owner = @_ownerOf[id]
+    
+    assert msg.sender == owner || @isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED"
+    
+    @getApproved[id] = spender;
+
+    log Approval, owner: owner, spender: spender, id: id
+  end
+  
+  sig [Address, Bool]
+  def setApprovalForAll( operator:,
+                         approved: ) 
+    @isApprovedForAll[msg.sender][operator] = approved;
+
+    log ApprovalForAll, owner: msg.sender, operator: operator, approved: approved
+  end
+  
+  sig [ Address, Address, UInt]
+  def transferFrom( from:, 
+                    to:, 
+                    id: )
+    assert from == @_ownerOf[id], "ERC721: transfer of token that is not own"
+    assert to != address(0), "ERC721: transfer to the zero address"
+    
+    assert(
+      msg.sender == from ||
+      @getApproved[id] == msg.sender ||
+      @isApprovedForAll[from][msg.sender],
+      "NOT_AUTHORIZED"
+    )
+    
+    @_balanceOf[from] -= 1
+    @_balanceOf[to] += 1
+    
+    @_ownerOf[id] = to
+    
+    @getApproved[id] = address(0)
+  end
+  
+  sig [UInt]
+  def _exists( id )
+    @_ownerOf[id] != address(0)
+  end
+ 
+  sig [Address, UInt]
+  def _mint( to:, 
+             id: )
+    assert to != address(0), "ERC721: mint to the zero address"
+    assert @_ownerOf[id] == address(0), "ERC721: token already minted"
+    
+    @_balanceOf[to] += 1
+
+    @_ownerOf[id] = to
+    
+    log Transfer, from: address(0), to: to, id: id
+  end
+  
+  sig [UInt]
+  def _burn( id: )
+    owner = @_ownerOf[id]
+    
+    assert owner != address(0), "ERC721: burn of nonexistent token"
+    
+    @_balanceOf[owner] -= 1
+    
+    @_ownerOf[id] = address(0)
+    
+    @getApproved[id] = address(0)
+    
+    log Transfer, from: owner, to: address(0), id: id
+  end
+  
+  sig [UInt], :view, returns: String
+  def tokenURI( id: )
+  end
+end

data/lib/rubysol/contracts/ether_erc20_bridge.rb

@@ -0,0 +1,54 @@
+class EtherERC20Bridge < ERC20
+ 
+  event :InitiateWithdrawal, from: Address, amount: UInt
+  event :WithdrawalComplete, to: Address, amount: UInt
+
+  storage trustedSmartContract: Address, 
+         pendingWithdrawals:     mapping( Address, UInt ) 
+  
+  sig [String, String, Address]
+  def constructor(
+    name:,
+    symbol:,
+    trustedSmartContract:) 
+    super(name: name, symbol: symbol, decimals: 18)
+    
+    @trustedSmartContract = trustedSmartContract
+  end
+  
+  sig [Address, UInt]
+  def bridgeIn( to:, amount: )
+    assert(
+      address(msg.sender) == @trustedSmartContract,
+      "Only the trusted smart contract can bridge in tokens"
+    )
+    
+    _mint(to: to, amount: amount)
+  end
+  
+  sig  [UInt]
+  def bridgeOut( amount: )
+    _burn(from: msg.sender, amount: amount)
+    
+    @pendingWithdrawals[address(msg.sender)] += amount
+    
+    log InitiateWithdrawal, from: address(msg.sender), amount: amount
+  end
+  
+  sig  [Address, UInt] 
+  def markWithdrawalComplete( to:, amount: )
+    assert(
+      address(msg.sender) == @trustedSmartContract,
+      'Only the trusted smart contract can mark withdrawals as complete'
+    )
+    
+    assert(
+      @pendingWithdrawals[to] >= amount,
+      'Insufficient pending withdrawal'
+    )
+    
+    @pendingWithdrawals[to] -= amount
+    
+    log WithdrawalComplete, to: to, amount: amount
+  end
+end

data/lib/rubysol/contracts/ethscription_erc20_bridge.rb

@@ -0,0 +1,119 @@
+class EthscriptionERC20Bridge < ERC20
+  
+  event :InitiateWithdrawal, from: Address, escrowedId: InscriptionId 
+  event :WithdrawalComplete, to:   Address, escrowedId: InscriptionId 
+
+  storage ethscriptionsTicker:     String, 
+          ethscriptionMintAmount:  UInt, 
+          ethscriptionMaxSupply:   UInt, 
+          ethscriptionDeployId:    InscriptionId, 
+          trustedSmartContract:    Address, 
+          pendingWithdrawalEthscriptionToOwner: mapping( InscriptionId, Address ),
+          bridgedEthscriptionToOwner:   mapping( InscriptionId, Address )
+          
+  sig  [String, String, Address, InscriptionId]           
+  def constructor(
+    name:,
+    symbol:,
+    trustedSmartContract:,
+    ethscriptionDeployId:) 
+    super(name: name, symbol: symbol, decimals: 18)
+    
+    @trustedSmartContract = trustedSmartContract
+    @ethscriptionDeployId = ethscriptionDeployId
+    
+    deploy = esc.findEthscriptionById( ethscriptionDeployId )
+    uri = deploy.contentUri
+    parsed = JSON.parse(uri.split("data:,").last)
+    
+    assert(parsed['op'] == 'deploy', "Invalid ethscription deploy id")
+    assert(parsed['p'] == 'erc-20', "Invalid protocol")
+    
+    @ethscriptionsTicker = parsed['tick']
+    @ethscriptionMintAmount = parsed['lim']
+    @ethscriptionMaxSupply = parsed['max']
+  end
+
+  
+  sig  [Address, InscriptionId]
+  def bridgeIn( to:, escrowedId: )
+    assert(
+      address(msg.sender) == @trustedSmartContract,
+      "Only the trusted smart contract can bridge in tokens"
+    )
+    
+    assert(
+      @bridgedEthscriptionToOwner[escrowedId] == address(0),
+      "Ethscription already bridged in"
+    )
+    
+    assert(
+      @pendingWithdrawalEthscriptionToOwner[escrowedId] == address(0),
+      "Ethscription withdrawal initiated"
+    )
+    
+    ethscription = esc.findEthscriptionById(escrowedId)
+    uri = ethscription.contentUri
+    
+    match_data = uri.match(/data:,{"p":"erc-20","op":"mint","tick":"([a-z]+)","id":"([1-9]+\d*)","amt":"([1-9]+\d*)"}/)
+    
+    assert(match_data.present?, "Invalid ethscription content uri")
+    
+    tick, id, amt = match_data.captures
+    
+    tick = tick.cast(:string)
+    id = id.cast(:uint256)
+    amt = amt.cast(:uint256)
+    
+    assert(tick == @ethscriptionsTicker, "Invalid ethscription ticker")
+    assert(amt == @ethscriptionMintAmount, "Invalid ethscription mint amount")
+
+    maxId = @ethscriptionMaxSupply / @ethscriptionMintAmount
+    
+    assert(id > 0 && id <= maxId, "Invalid token id")
+    
+    assert(
+      ethscription.currentOwner == @trustedSmartContract,
+      "Ethscription not owned by recipient. Observed owner: #{ethscription.currentOwner}, expected owner: #{@trustedSmartContract}"
+    )
+    
+    assert(
+      ethscription.previousOwner == to,
+      "Ethscription not previously owned by to. Observed previous owner: #{ethscription.previousOwner}, expected previous owner: #{to}"
+    )
+    
+    @bridgedEthscriptionToOwner[escrowedId] = to
+    _mint(to: to, amount: @ethscriptionMintAmount * (10 ** decimals))
+  end
+  
+
+  sig  [InscriptionId]    
+  def bridgeOut( escrowedId )
+    assert( @bridgedEthscriptionToOwner[escrowedId] == address(msg.sender), "Ethscription not owned by sender")
+    
+    _burn(from: msg.sender, amount: @ethscriptionMintAmount * (10 ** decimals))
+    
+    @bridgedEthscriptionToOwner[escrowedId] = address(0)
+    @pendingWithdrawalEthscriptionToOwner[escrowedId] = address(msg.sender)
+    
+    log InitiateWithdrawal, from: address(msg.sender), escrowedId: :ethscriptionId
+  end
+  
+
+  sig [Address, InscriptionId] 
+  def markWithdrawalComplete( to:, escrowedId: )
+    assert(
+      address(msg.sender) == @trustedSmartContract,
+      'Only the trusted smart contract can mark withdrawals as complete'
+    )
+    
+    assert(
+      @pendingWithdrawalEthscriptionToOwner[escrowedId] == to,
+      "Withdrawal not initiated"
+    )
+    
+    @pendingWithdrawalEthscriptionToOwner[escrowedId] = address(0)
+    
+    log WithdrawalComplete, to: to, escrowedId: :ethscriptionId
+  end
+end

data/lib/rubysol/contracts/generative_erc721.rb

@@ -0,0 +1,93 @@
+class GenerativeERC721 < ERC721
+  
+  storage generativeScript: String,
+          tokenIdToSeed:    mapping( UInt, UInt ),  
+          totalSupply:      UInt, 
+          maxSupply:        UInt, 
+          maxPerAddress:    UInt, 
+          description:      String 
+  
+  sig [ String, String, String, UInt, String, UInt]  
+  def constructor(
+    name:,
+    symbol:,
+    generativeScript:,
+    maxSupply:,
+    description:,
+    maxPerAddress: )
+    super(name: name, symbol: symbol)
+    
+    @maxSupply = maxSupply
+    @maxPerAddress = maxPerAddress
+    @description = description
+    @generativeScript = generativeScript
+  end
+  
+  sig [UInt]
+  def mint( amount )
+    assert(amount > 0, 'Amount must be positive')
+    assert(amount + @_balanceOf[msg.sender] <= @maxPerAddress, 'Exceeded mint limit')
+    assert(amount + @totalSupply <= @maxSupply, 'Exceeded max supply')
+    
+    hash = block.blockhash(block.number).cast(:uint256) % (2 ** 48)
+    
+    amount.times do |id|
+      tokenId = @totalSupply + id
+      seed = hash + tokenId
+      
+      @tokenIdToSeed[tokenId] = seed
+      
+      _mint(to: msg.sender, id: tokenId)
+    end
+    
+    @totalSupply += amount
+  end
+  
+  sig [UInt], :view,  returns: String
+  def tokenURI( id )
+    assert( _exists(id: id), 'ERC721Metadata: URI query for nonexistent token')
+    
+    html = getHTML(seed: @tokenIdToSeed[id])
+    
+    html_as_base_64_data_uri = "data:text/html;base64,#{Base64.strict_encode64(html)}"
+    
+    json_data = {
+      name: "#{@name} ##{string(id)}",
+      description: @description,
+      animation_url: html_as_base_64_data_uri,
+    }.to_json
+    
+    "data:application/json,#{json_data}"
+  end
+  
+  sig [UInt], :view, returns: String
+  def getHTML( seed )
+    %{<!DOCTYPE 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)};
+        #{@generativeScript}
+      </script>
+    </html>}
+  end
+end

data/lib/rubysol/contracts/open_edition_erc721.rb

@@ -0,0 +1,54 @@
+class OpenEditionERC721 < ERC721
+  
+  storage contentURI:    String, 
+          maxPerAddress: UInt,
+          totalSupply:   UInt,
+          description:   String,
+          mintStart:     Timestamp,
+          mintEnd:       Timestamp
+
+  sig [String, String, String, UInt, String, Timestamp, Timestamp]        
+  def constructor(
+    name:,
+    symbol:,
+    contentURI:,
+    maxPerAddress:,
+    description:,
+    mintStart:,
+    mintEnd: )
+    super(name: name, symbol: symbol)
+    
+    @maxPerAddress = maxPerAddress
+    @description = description
+    @contentURI = contentURI
+    @mintStart = mintStart
+    @mintEnd = mintEnd
+  end
+
+  sig [UInt]
+  def mint( amount: )
+    assert(amount > 0, 'Amount must be positive')
+    assert(amount + @_balanceOf[msg.sender] <= @maxPerAddress, 'Exceeded mint limit')
+    assert(block.timestamp >= @mintStart, 'Minting has not started')
+    assert(block.timestamp < @mintEnd, 'Minting has ended')
+    
+    amount.times do |id|
+      _mint(to: msg.sender, id: @totalSupply + id)
+    end
+    
+    @totalSupply += amount
+  end
+  
+  sig [UInt], :view, returns: String
+  def tokenURI( id: ) 
+    assert(_exists(id: id), 'ERC721Metadata: URI query for nonexistent token')
+
+    json_data = {
+      name: "#{@name} ##{string(id)}",
+      description: @description,
+      image: @contentURI,
+    }.to_json
+    
+    "data:application/json,#{json_data}"
+  end
+end

data/lib/rubysol/contracts/public_mint_erc20.rb

@@ -0,0 +1,37 @@
+
+class PublicMintERC20 < ERC20
+
+  storage maxSupply:    UInt,
+          perMintLimit: UInt
+  
+  sig [String, String, UInt, UInt, UInt]
+  def constructor(
+    name:,
+    symbol:,
+    maxSupply:,
+    perMintLimit:,
+    decimals: 
+    )
+    super( name: name, symbol: symbol, decimals: decimals )
+    @maxSupply    = maxSupply
+    @perMintLimit = perMintLimit
+  end
+  
+  sig [UInt]  
+  def mint( amount: )
+    assert amount > 0, 'Amount must be positive'
+    assert amount <= @perMintLimit, 'Exceeded mint limit'    
+    assert @totalSupply + amount <= @maxSupply, 'Exceeded max supply'
+    
+    _mint( to: msg.sender, amount: amount )
+  end
+  
+  sig [Address, UInt]
+  def airdrop( to:, amount: )
+    assert amount > 0, 'Amount must be positive'
+    assert amount <= @perMintLimit, 'Exceeded mint limit'
+    assert @totalSupply + amount <= @maxSupply, 'Exceeded max supply'
+    
+    _mint( to: to, amount: amount )
+  end
+end  # class PublicMintERC20

data/lib/rubysol/contracts/version.rb

@@ -0,0 +1,23 @@
+module Rubysol
+  module Module
+    module Contracts
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      VERSION = [MAJOR,MINOR,PATCH].join('.')
+    
+      def self.version
+        VERSION
+      end
+    
+      def self.banner
+        "rubysol-contracts/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
+      end
+    
+      def self.root
+        File.expand_path( File.dirname(File.dirname(File.dirname(File.dirname(__FILE__)))) )
+      end
+    
+    end # module Contracts
+  end # module Module
+end # module Rubysol

data/lib/rubysol/contracts.rb

@@ -0,0 +1,18 @@
+require 'solidity/typed'
+require 'rubysol'
+
+## our own code / contracts
+require_relative 'contracts/version'
+require_relative 'contracts/erc20.rb'
+require_relative 'contracts/erc20_liquidity_pool.rb'
+require_relative 'contracts/erc721.rb'
+require_relative 'contracts/ether_erc20_bridge.rb'
+require_relative 'contracts/ethscription_erc20_bridge.rb'
+require_relative 'contracts/generative_erc721.rb'
+require_relative 'contracts/open_edition_erc721.rb'
+require_relative 'contracts/public_mint_erc20.rb'
+
+
+
+
+puts Rubysol::Module::Contracts.banner     ## say hello

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: rubysol-contracts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubysol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !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: rubysol-contracts - standard contracts (incl. erc20, erc721, etc) for
+  ruby for layer 1 (l1) with "off-chain" indexer
+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/rubysol/contracts.rb
+- lib/rubysol/contracts/erc20.rb
+- lib/rubysol/contracts/erc20_liquidity_pool.rb
+- lib/rubysol/contracts/erc721.rb
+- lib/rubysol/contracts/ether_erc20_bridge.rb
+- lib/rubysol/contracts/ethscription_erc20_bridge.rb
+- lib/rubysol/contracts/generative_erc721.rb
+- lib/rubysol/contracts/open_edition_erc721.rb
+- lib/rubysol/contracts/public_mint_erc20.rb
+- lib/rubysol/contracts/version.rb
+homepage: https://github.com/s6ruby/rubidity
+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: rubysol-contracts - standard contracts (incl. erc20, erc721, etc) for ruby
+  for layer 1 (l1) with "off-chain" indexer
+test_files: []