uniswap 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 06b64f10df9f1cb893dbf1e22e0c7fbbbc1a3b077c5f362d2c385ec46e321f16
+  data.tar.gz: edb9d0db8f5edd36a5ac62ff456483f6dad7e480ee7a911377bf48c9d83c12da
+SHA512:
+  metadata.gz: 7264444379e503aa697de99c6fbd16d39fbcce95411d91a7a4ca053dd761886dc2fcddf9c2efa9fe4678b585dc248b4f0d54dd8eb8910d2fa4b62a46bc257560
+  data.tar.gz: 6b0f03feb962ad4881c5393239ab7b41f55715e7afe2160e2fcb7c38719b58d6aae903d1c821de8bb2cb3c2135bf4a474ff2c883f7aad4e1f3d3e9ca3602a7e3

data/CHANGELOG.md

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

data/Manifest.txt

@@ -0,0 +1,15 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/uniswap.rb
+lib/uniswap/ERC20.rb
+lib/uniswap/PublicMintERC20.rb
+lib/uniswap/UniswapSetupZapV2.rb
+lib/uniswap/UniswapV2Callee.rb
+lib/uniswap/UniswapV2ERC20.rb
+lib/uniswap/UniswapV2Factory.rb
+lib/uniswap/UniswapV2Pair.rb
+lib/uniswap/UniswapV2Router.rb
+lib/uniswap/UniswapV2RouterWithRewards.rb
+lib/uniswap/UnsafeNoApprovalERC20.rb

data/README.md

@@ -0,0 +1,60 @@
+# Uniswap V2 - Core (Dumb) Contracts (Rubidity Edition)
+
+
+uniswap - core uniswap v2 (dumb) contracts for ruby (rubidity) 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/uniswap](https://rubygems.org/gems/uniswap)
+* rdoc  :: [rubydoc.info/gems/uniswap](http://rubydoc.info/gems/uniswap)
+
+
+## What's Solidity?! What's Rubidity?!
+
+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)
+
+
+
+## What's Uniswap?! What's Facetswap?!
+
+See the [**Uniswap V2 White Paper (PDF), March 2020**](https://uniswap.org/whitepaper.pdf) or
+the [**Uniswap V2 Core Contracts (in Solidity)**](https://github.com/Uniswap/v2-core).
+
+See the [**Facetswap App / Service**](https://facetswap.com) 
+(running Uniswap V2 contracts in Rubidity).
+
+
+
+
+## Usage
+
+Available contracts include:
+
+- [ERC20](lib/uniswap/ERC20.rb)
+- [UniswapV2ERC20 (is ERC20)](lib/uniswap/UniswapV2ERC20.rb)
+- [UniswapV2Pair (is UniswapV2ERC20)](lib/uniswap/UniswapV2Pair.rb)
+- ...
+
+And so on.  To be continued ...
+
+
+
+
+
+## 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 (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/uniswap/version.rb'
+
+
+Hoe.spec 'uniswap' do
+  self.version = '0.0.1'   # Rubidity::Module::Uniswap::VERSION
+
+  self.summary = 'uniswap - core uniswap v2 (dumb) contracts for ruby (rubidity) 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 = [
+    ['rubidity', '>= 0.8.1'],
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+end

data/lib/uniswap/ERC20.rb

@@ -0,0 +1,79 @@
+
+
+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/uniswap/PublicMintERC20.rb

@@ -0,0 +1,39 @@
+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
+  ) do
+    super(name: name, symbol: symbol, decimals: decimals)
+    s.maxSupply = maxSupply
+    s.perMintLimit = perMintLimit
+  end
+  
+  
+  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/uniswap/UniswapSetupZapV2.rb

@@ -0,0 +1,156 @@
+pragma :rubidity, "1.0.0"
+
+import 'UniswapV2Factory'
+import 'UnsafeNoApprovalERC20'
+import 'UniswapV2Router'
+import 'PublicMintERC20'
+
+contract :UniswapSetupZapV2 do
+  array :address, :public, :factories
+  array :address, :public, :tokenAs
+  array :address, :public, :tokenBs
+  array :address, :public, :pairs
+  array :address, :public, :routers
+  
+  string :public, :name
+  
+  event :ZapOneSetup, { factory: :address, tokenA: :address, tokenB: :address, pair: :address, router: :address }
+  
+  constructor() {
+    s.name = 'UniswapSetupZapV2'
+  }
+  
+  function :zapDumbSwap, { etherAddress: :address, admin: :address }, :public do
+    ether = ERC20(etherAddress)
+    etherBalance = ether.balanceOf(address(this))
+    
+    require(etherBalance > 10.ether, 'Not enough ether')
+    
+    factory = new UniswapV2Factory(_feeToSetter: address(this))
+    factory.setFeeTo(admin)
+    factory.setFeeToSetter(admin)
+    
+    router = new UniswapV2Router(
+      _factory: factory,
+      _WETH: address(0)
+    )
+    
+    ether.approve(router, (2 ** 255))
+    
+    names = array(:string)
+    symbols = array(:string)
+    
+    names.push("Chameleon")
+    symbols.push("CHAM")
+    
+    names.push("Mirage")
+    symbols.push("MIR")
+    
+    names.push("Emerald")
+    symbols.push("EMD")
+    
+    names.push("Oasis")
+    symbols.push("OAS")
+        
+    names.push("Paradox")
+    symbols.push("PARA")
+    
+    names.push("Peridot")
+    symbols.push("PERI")
+    
+    for i in 0...names.length
+      supply = ((i + 1) * 2000).ether
+      
+      token = new PublicMintERC20(
+        name: names[i],
+        symbol: symbols[i],
+        maxSupply: supply,
+        perMintLimit: supply,
+        decimals: 18
+      )
+      
+      token.mint(amount: supply)
+      token.approve(router, (2 ** 255))
+      
+      router.addLiquidity(
+        tokenA: etherAddress,
+        tokenB: token,
+        amountADesired: etherBalance.div(names.length),
+        amountBDesired: supply,
+        amountAMin: 0,
+        amountBMin: 0,
+        to: admin,
+        deadline: block.timestamp + 1000
+      )
+    end
+    
+    return nil
+  end
+  
+  function :doZapOld, :public do
+    factory = new UniswapV2Factory(_feeToSetter: msg.sender)
+    
+    tokenA = new UnsafeNoApprovalERC20(
+      name: "TokenA (#{block.number})",
+      symbol: "TKA",
+    )
+    
+    tokenB = new UnsafeNoApprovalERC20(
+      name: "TokenB (#{block.number})",
+      symbol: "TKB",
+    )
+    
+    router = new UniswapV2Router(
+      _factory: factory,
+      _WETH: address(this)
+    )
+    
+    pair = factory.createPair(tokenA, tokenB)
+    
+    tokenA.airdrop(to: msg.sender, amount: 1e6.ether)
+    tokenB.airdrop(to: msg.sender, amount: 1e6.ether)
+    
+    s.factories.push(factory)
+    s.tokenAs.push(tokenA)
+    s.tokenBs.push(tokenB)
+    s.pairs.push(pair)
+    s.routers.push(router)
+    
+    emit :ZapOneSetup, { factory: factory, tokenA: tokenA, tokenB: tokenB, pair: pair, router: router }
+  end
+  
+  function :lastZap, :public, :view, returns: { factory: :address, tokenA: :address, tokenB: :address, pair: :address, router: :address } do
+    return {
+      factory: s.factories[s.factories.length - 1],
+      tokenA: s.tokenAs[s.tokenAs.length - 1],
+      tokenB: s.tokenBs[s.tokenBs.length - 1],
+      pair: s.pairs[s.pairs.length - 1],
+      router: s.routers[s.routers.length - 1]
+    }
+  end
+  
+  function :userStats, {
+    user: :address,
+    router: :address,
+    factory: :address,
+    tokenA: :address,
+    tokenB: :address,
+  }, :public, :view, returns: {
+    userTokenABalance: :uint256,
+    userTokenBBalance: :uint256,
+    tokenAReserves: :uint256,
+    tokenBReserves: :uint256,
+    userLPBalance: :uint256
+  } do
+    tokenAReserves, tokenBReserves = UniswapV2Router(router).getReserves(factory, tokenA, tokenB)
+    pair = UniswapV2Factory(factory).getPair(tokenA, tokenB)
+    
+    return {
+      userTokenABalance: ERC20(tokenA).balanceOf(user),
+      userTokenBBalance: ERC20(tokenB).balanceOf(user),
+      tokenAReserves: tokenAReserves,
+      tokenBReserves: tokenBReserves,
+      userLPBalance: UniswapV2ERC20(pair).balanceOf(user)
+    }
+  end
+end

data/lib/uniswap/UniswapV2Callee.rb

@@ -0,0 +1,11 @@
+pragma :rubidity, "1.0.0"
+
+contract :UniswapV2Callee, abstract: true do
+  function :uniswapV2Call, {
+    sender: :address,
+    amount0: :uint256,
+    amount1: :uint256,
+    data: :bytes
+  }, :virtual, :external do
+  end
+end

data/lib/uniswap/UniswapV2ERC20.rb

@@ -0,0 +1,12 @@
+
+class UniswapV2ERC20 < ERC20   # abstract: true 
+  sig []
+  def constructor
+    super(
+      name: "ScribeSwap V2",
+      symbol: "SCR",
+      decimals: 18
+    )
+  end
+end   # class UniswapV2ERC20
+

data/lib/uniswap/UniswapV2Factory.rb

@@ -0,0 +1,81 @@
+pragma :rubidity, "1.0.0"
+
+import 'UniswapV2Pair'
+
+
+contract :UniswapV2Factory do
+  address :public, :feeTo
+  address :public, :feeToSetter
+
+  mapping ({ address: mapping({ address: :address })}), :public, :getPair
+  array :address, :public, :allPairs
+
+  event :PairCreated, { token0: :address, token1: :address, pair: :address, pairLength: :uint256 }
+
+  constructor(_feeToSetter: :address) do
+    s.feeToSetter = _feeToSetter
+  end
+
+  function :allPairsLength, {}, :public, :view, returns: :uint256 do
+    return s.allPairs.length
+  end
+  
+  function :getAllPairs, {}, :public, :view, returns: [:address] do
+    return s.allPairs
+  end
+
+  function :createPair, { tokenA: :address, tokenB: :address }, :public, returns: :address do
+    require(tokenA != tokenB, 'Scribeswap: IDENTICAL_ADDRESSES')
+    
+    token0, token1 = uint256( tokenA ) < uint256( tokenB ) ? [tokenA, tokenB] : [tokenB, tokenA]
+    
+    require(token0 != address(0), "Scribeswap: ZERO_ADDRESS");
+    require(s.getPair[token0][token1] == address(0), "Scribeswap: PAIR_EXISTS");
+
+=begin    
+    salt = keccak256(abi.encodePacked(token0, token1))
+    
+    pair = new UniswapV2Pair({ salt: salt })
+    pair.init(token0, token1)
+    
+    s.getPair[token0][token1] = pair
+    s.getPair[token1][token0] = pair
+    
+    s.allPairs.push(pair)
+    emit(:PairCreated, { token0: token0, token1: token1, pair: pair, pairLength: s.allPairs.length })
+    
+    return pair
+=end
+
+    ## fix-fix-fix - auto set call stack/msg.sender
+    Runtime.msg.sender = __address__
+    pair = UniswapV2Pair.construct
+    pair.init( token0, token1 )
+
+    s.getPair[token0][token1] = pair.__address__
+    s.getPair[token1][token0] = pair.__address__
+
+    s.allPairs.push( pair.__address__ )
+    emit :PairCreated, token0: token0, token1: token1, pair: pair.__address__, pairLength: s.allPairs.length
+
+    return pair.__address__
+  end
+
+  
+
+  function :setFeeTo, { _feeTo: :address }, :public do
+    require(msg.sender == feeToSetter, "Scribeswap: FORBIDDEN")
+    
+    s.feeTo = _feeTo
+    
+    return nil
+  end
+
+  function :setFeeToSetter, { _feeToSetter: :address }, :public do
+    require(msg.sender == feeToSetter, "Scribeswap: FORBIDDEN")
+    
+    s.feeToSetter = _feeToSetter
+    
+    return nil
+  end
+end