0xfacet-uniswap 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67fdf9cf8741ea2e11cc2303c9a1af2777a368e8ef1eb85103534c8fe839bc41
+  data.tar.gz: d5315a440b27540f9dbde981d7b2d09401b6f1fabb06bb2556f8a07fd7830525
+SHA512:
+  metadata.gz: 81f4c5700297ea41913c3d6c7a4e458a4610737aa51f7a7a43eca0a615108ea18db75da3f6e25fbb67fe90c54659da968ed0488d71108bb14ac0eed307828eec
+  data.tar.gz: 4d6881f200b049da793e15b45355f06d5f4cd100ea4b5cb029af4fd95e538f2ea679d9805a59984f9ed96f6f392aff8a56edb95e08bec40ea423ab15744d6f1b

data/CHANGELOG.md

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

data/Manifest.txt

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

data/README.md

@@ -0,0 +1,24 @@
+# 0xFacet Rubidity O.G. Uniswap V2 Contracts
+
+0xfacet-uniswap - rubidity o.g. uniswap v2 contracts (incl. UniswapV2Factory, UniswapV2Pair, UniswapV2Router, 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-uniswap](https://rubygems.org/gems/0xfacet-uniswap)
+* rdoc  :: [rubydoc.info/gems/0xfacet-uniswap](http://rubydoc.info/gems/0xfacet-uniswap)
+
+
+
+## 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,33 @@
+require 'hoe'
+
+# require './lib/0xfacet/uniswap/version.rb'
+
+
+Hoe.spec '0xfacet-uniswap' do
+
+  self.version =   '0.0.1'
+
+  self.summary = '0xfacet-uniswap - rubidity o.g. uniswap v2 contracts (incl. UniswapV2Factory, UniswapV2Pair, UniswapV2Router, 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'],
+    ['0xfacet-contracts', '>= 0.0.1'],
+  ]
+
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+end

data/lib/0xfacet/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/0xfacet/uniswap/UniswapV2Callee.rb

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

data/lib/0xfacet/uniswap/UniswapV2ERC20.rb

@@ -0,0 +1,13 @@
+pragma :rubidity, "1.0.0"
+
+import 'ERC20'
+
+contract :UniswapV2ERC20, is: :ERC20, abstract: true do
+  constructor() {
+    ERC20.constructor(
+      name: "ScribeSwap V2",
+      symbol: "SCR",
+      decimals: 18
+    )
+  }
+end

data/lib/0xfacet/uniswap/UniswapV2Factory.rb

@@ -0,0 +1,63 @@
+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) {
+    s.feeToSetter = _feeToSetter
+  }
+
+  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 = tokenA.cast(:uint256) < tokenB.cast(:uint256) ? [tokenA, tokenB] : [tokenB, tokenA]
+    
+    require(token0 != address(0), "Scribeswap: ZERO_ADDRESS");
+    require(s.getPair[token0][token1] == address(0), "Scribeswap: PAIR_EXISTS");
+    
+    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
+
+  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

data/lib/0xfacet/uniswap/UniswapV2Pair.rb

@@ -0,0 +1,253 @@
+pragma :rubidity, "1.0.0"
+
+import 'UniswapV2Callee'
+import 'UniswapV2ERC20'
+
+contract :IUniswapV2Factory, abstract: true do
+  function :feeTo, :external, :view, returns: :address
+end
+
+contract :UniswapV2Pair, is: :UniswapV2ERC20 do
+  uint256 :public, :MINIMUM_LIQUIDITY
+
+  address :public, :factory
+  address :public, :token0
+  address :public, :token1
+
+  uint112 :private, :reserve0
+  uint112 :private, :reserve1
+  uint32  :private, :blockTimestampLast
+
+  uint256 :public, :price0CumulativeLast
+  uint256 :public, :price1CumulativeLast
+  uint256 :public, :kLast
+
+  uint256 :private, :unlocked
+  
+  function :getReserves, {}, :public, :view, returns: {
+    _reserve0: :uint112, _reserve1: :uint112, _blockTimestampLast: :uint32
+  } do
+    return {
+      _reserve0: s.reserve0,
+      _reserve1: s.reserve1,
+      _blockTimestampLast: s.blockTimestampLast
+    }
+  end
+  
+  function :_safeTransfer, { token: :address, to: :address, value: :uint256 }, :private do
+    result = ERC20(token).transfer(to: to, amount: value)
+    
+    require(result, "ScribeSwap: TRANSFER_FAILED")
+  end
+  
+  event :Mint, { sender: :address, amount0: :uint256, amount1: :uint256 }
+  event :Burn, { sender: :address, amount0: :uint256, amount1: :uint256, to: :address }
+  event :Swap, { 
+    sender: :address, 
+    amount0In: :uint256, 
+    amount1In: :uint256, 
+    amount0Out: :uint256, 
+    amount1Out: :uint256, 
+    to: :address 
+  }
+  event :Sync, { reserve0: :uint112, reserve1: :uint112 }
+  event :PreSwapReserves, { reserve0: :uint112, reserve1: :uint112 }
+  
+  constructor() {
+    UniswapV2ERC20.constructor()
+    
+    s.factory = msg.sender
+    
+    s.MINIMUM_LIQUIDITY = 10 ** 3
+    s.unlocked = 1
+  }
+  
+  # Can't call it initialize bc of Ruby (for now)
+  function :init, { _token0: :address, _token1: :address }, :external do
+    require(msg.sender == s.factory, 'ScribeSwap: FORBIDDEN')
+
+    s.token0 = _token0
+    s.token1 = _token1
+    
+    return nil
+  end
+  
+  function :_update, {
+    balance0: :uint256,
+    balance1: :uint256,
+    _reserve0: :uint112,
+    _reserve1: :uint112
+  }, :private do
+    require(balance0 <= (2 ** 112 - 1) && balance1 <= (2 ** 112 - 1), 'ScribeSwap: OVERFLOW')
+    
+    blockTimestamp = uint32(block.timestamp % 2 ** 32)
+    timeElapsed = blockTimestamp - s.blockTimestampLast # overflow is desired
+    
+    if timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0
+      # * never overflows, and + overflow is desired
+      s.price0CumulativeLast += uint256(uqdiv(encode(_reserve1), _reserve0)) * timeElapsed
+      s.price1CumulativeLast += uint256(uqdiv(encode(_reserve0), _reserve1)) * timeElapsed
+    end
+    
+    emit :PreSwapReserves, reserve0: s.reserve0, reserve1: s.reserve1
+    
+    s.reserve0 = uint112(balance0)
+    s.reserve1 = uint112(balance1)
+    
+    s.blockTimestampLast = blockTimestamp
+    emit :Sync, reserve0: s.reserve0, reserve1: s.reserve1
+  end
+  
+  function :encode, { y: :uint112 }, :internal, :pure, returns: :uint224 do
+    return uint224(y) * (2 ** 112)
+  end
+
+  function :uqdiv, { x: :uint224, y: :uint112 }, :internal, :pure, returns: :uint224 do
+    return x / uint224(y)
+  end
+  
+  function :_mintFee, { _reserve0: :uint112, _reserve1: :uint112 }, :private, returns: :bool do
+    feeTo = IUniswapV2Factory(s.factory).feeTo
+    feeOn = feeTo != address(0)
+    _kLast = s.kLast
+    
+    if feeOn
+      if _kLast != 0
+        rootK = sqrt(_reserve0 * _reserve1)
+        rootKLast = sqrt(_kLast)
+        if rootK > rootKLast
+          numerator = totalSupply * (rootK - rootKLast)
+          denominator = rootK * 5 + rootKLast
+          liquidity = numerator.div(denominator)
+          _mint(feeTo, liquidity) if liquidity > 0
+        end
+      end
+    elsif _kLast != 0
+      s.kLast = 0
+    end
+    feeOn
+  end
+  
+  function :mint, { to: :address }, :public, returns: :uint256 do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    _reserve0, _reserve1, _ = getReserves
+    
+    balance0 = ERC20(s.token0).balanceOf(address(this))
+    balance1 = ERC20(s.token1).balanceOf(address(this))
+    amount0 = balance0 - _reserve0
+    amount1 = balance1 - _reserve1
+    
+    feeOn = _mintFee(_reserve0, _reserve1)
+    _totalSupply = s.totalSupply
+    if _totalSupply == 0
+      liquidity = sqrt(amount0 * amount1) - s.MINIMUM_LIQUIDITY
+      _mint(address(0), s.MINIMUM_LIQUIDITY)
+    else
+      liquidity = [
+        (amount0 * _totalSupply).div(_reserve0),
+        (amount1 * _totalSupply).div(_reserve1)
+      ].min
+    end
+
+    require(liquidity > 0, 'ScribeSwap: INSUFFICIENT_LIQUIDITY_MINTED')
+    _mint(to, liquidity)
+  
+    _update(balance0, balance1, _reserve0, _reserve1)
+    s.kLast = s.reserve0 * s.reserve1 if feeOn
+    
+    emit :Mint, sender: msg.sender, amount0: amount0, amount1: amount1
+    
+    return liquidity
+  end
+  
+  function :burn, { to: :address }, :external, :lock, returns: { amount0: :uint256, amount1: :uint256 } do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+
+    _reserve0, _reserve1, _ = getReserves
+    _token0 = s.token0
+    _token1 = s.token1
+    balance0 = ERC20(_token0).balanceOf(address(this))
+    balance1 = ERC20(_token1).balanceOf(address(this))
+    liquidity = s.balanceOf[address(this)]
+  
+    feeOn = _mintFee(_reserve0, _reserve1)
+    _totalSupply = s.totalSupply
+    amount0 = (liquidity * balance0).div(_totalSupply)
+    amount1 = (liquidity * balance1).div(_totalSupply)
+    
+    require(amount0 > 0 && amount1 > 0, 'ScribeSwap: INSUFFICIENT_LIQUIDITY_BURNED')
+    _burn(address(this), liquidity)
+    _safeTransfer(_token0, to, amount0)
+    _safeTransfer(_token1, to, amount1)
+    balance0 = ERC20(_token0).balanceOf(address(this))
+    balance1 = ERC20(_token1).balanceOf(address(this))
+  
+    _update(balance0, balance1, _reserve0, _reserve1)
+    s.kLast = s.reserve0 * s.reserve1 if feeOn
+    
+    emit :Burn, sender: msg.sender, amount0: amount0, amount1: amount1, to: to
+    
+    return { amount0: amount0, amount1: amount1 }
+  end
+  
+  function :swap, { amount0Out: :uint256, amount1Out: :uint256, to: :address, data: :bytes }, :external do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    require(amount0Out > 0 || amount1Out > 0, 'ScribeSwap: INSUFFICIENT_OUTPUT_AMOUNT')
+    _reserve0, _reserve1, _ = getReserves
+    require(amount0Out < _reserve0 && amount1Out < _reserve1, 'ScribeSwap: INSUFFICIENT_LIQUIDITY')
+  
+    balance0 = 0
+    balance1 = 0
+    _token0 = s.token0
+    _token1 = s.token1
+    
+    require(to != _token0 && to != _token1, 'ScribeSwap: INVALID_TO')
+    
+    _safeTransfer(_token0, to, amount0Out) if amount0Out > 0 # optimistically transfer tokens
+    _safeTransfer(_token1, to, amount1Out) if amount1Out > 0 # optimistically transfer tokens
+    
+    UniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data) if data.length > 0
+    
+    balance0 = ERC20(_token0).balanceOf(address(this))
+    balance1 = ERC20(_token1).balanceOf(address(this))
+
+    amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0
+    amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0
+
+    require(amount0In > 0 || amount1In > 0, 'ScribeSwap: INSUFFICIENT_INPUT_AMOUNT')
+  
+    balance0Adjusted = balance0 * 1000 - amount0In * 3
+    balance1Adjusted = balance1 * 1000 - amount1In * 3
+    
+    require(
+      balance0Adjusted * balance1Adjusted >= uint256(_reserve0) * _reserve1 * (1000 ** 2),
+      'ScribeSwap: K'
+    )
+  
+    _update(balance0, balance1, _reserve0, _reserve1)
+    emit :Swap, sender: msg.sender, amount0In: amount0In, amount1In: amount1In, amount0Out: amount0Out, amount1Out: amount1Out, to: to
+  end
+  
+  function :skim, { to: :address }, :external do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    _token0 = s.token0
+    _token1 = s.token1
+    
+    _safeTransfer(_token0, to, ERC20(_token0).balanceOf(address(this)) - s.reserve0)
+    _safeTransfer(_token1, to, ERC20(_token1).balanceOf(address(this)) - s.reserve1)
+  end
+  
+  function :sync, {}, :external do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    _update(
+      ERC20(s.token0).balanceOf(address(this)),
+      ERC20(s.token1).balanceOf(address(this)),
+      s.reserve0,
+      s.reserve1
+    )
+  end
+end

data/lib/0xfacet/uniswap/UniswapV2Router.rb

@@ -0,0 +1,323 @@
+pragma :rubidity, "1.0.0"
+
+import 'UniswapV2Factory'
+
+contract :UniswapV2Router do
+  address :public, :factory
+  address :public, :WETH
+  
+  constructor(_factory: :address, _WETH: :address) {
+    s.factory = _factory
+    s.WETH = _WETH
+  }
+  
+  function :_addLiquidity, {
+    tokenA: :address,
+    tokenB: :address,
+    amountADesired: :uint256,
+    amountBDesired: :uint256,
+    amountAMin: :uint256,
+    amountBMin: :uint256
+  }, :internal, :virtual, returns: { amountA: :uint256, amountB: :uint256 } do
+    if UniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)
+      UniswapV2Factory(factory).createPair(tokenA, tokenB)
+    end
+    
+    reserveA, reserveB = getReserves(s.factory, tokenA, tokenB)
+    
+    if reserveA == 0 && reserveB == 0
+      return { amountA: amountADesired, amountB: amountBDesired }
+    else
+      amountBOptimal = quote(amountADesired, reserveA, reserveB)
+      
+      if amountBOptimal <= amountBDesired
+        require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT')
+        
+        return { amountA: amountADesired, amountB: amountBOptimal }
+      else
+        amountAOptimal = quote(amountBDesired, reserveB, reserveA)
+        
+        require(amountAOptimal <= amountADesired, "ASSERT")
+        
+        require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT')
+        
+        return { amountA: amountAOptimal, amountB: amountBDesired }
+      end
+    end
+  end
+  
+  function :addLiquidity, {
+    tokenA: :address,
+    tokenB: :address,
+    amountADesired: :uint256,
+    amountBDesired: :uint256,
+    amountAMin: :uint256,
+    amountBMin: :uint256,
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, returns: { amountA: :uint256, amountB: :uint256, liquidity: :uint256 } do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+    
+    amountA, amountB = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin)
+    
+    pair = pairFor(s.factory, tokenA, tokenB)
+    
+    _safeTransferFrom(token: tokenA, from: msg.sender, to: pair, value: amountA)
+    _safeTransferFrom(token: tokenB, from: msg.sender, to: pair, value: amountB)
+    
+    liquidity = UniswapV2Pair(pair).mint(to: to)
+    
+    return { amountA: amountA, amountB: amountB, liquidity: liquidity }
+  end
+  
+  function :removeLiquidity, {
+    tokenA: :address,
+    tokenB: :address,
+    liquidity: :uint256,
+    amountAMin: :uint256,
+    amountBMin: :uint256,
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, returns: { amountA: :uint256, amountB: :uint256 } do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+    
+    pair = pairFor(s.factory, tokenA, tokenB)
+    UniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity)
+    
+    amount0, amount1 = UniswapV2Pair(pair).burn(to)
+    
+    token0, _ = sortTokens(tokenA, tokenB)
+
+    (amountA, amountB) = tokenA == token0 ? [amount0, amount1] : [amount1, amount0]
+    
+    require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT')
+    require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT')
+    
+    return { amountA: amountA, amountB: amountB }
+  end
+  
+  function :swapExactTokensForTokens, { 
+    amountIn: :uint256, 
+    amountOutMin: :uint256, 
+    path: [:address],
+    to: :address, 
+    deadline: :uint256 
+  }, :public, :virtual, returns: [:uint256] do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+
+    amounts = getAmountsOut(factory, amountIn, path)
+    
+    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT')
+    
+    _safeTransferFrom(
+      path[0], msg.sender, pairFor(factory, path[0], path[1]), amounts[0]
+    )
+    
+    _swap(amounts, path, to)
+    
+    return amounts
+  end
+  
+  function :swapTokensForExactTokens, {
+    amountOut: :uint256,
+    amountInMax: :uint256,
+    path: [:address],
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, returns: [:uint256] do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+    
+    amounts = getAmountsIn(factory, amountOut, path)
+    require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT')
+  
+    _safeTransferFrom(
+      path[0], msg.sender, pairFor(factory, path[0], path[1]), amounts[0]
+    )
+  
+    _swap(amounts, path, to)
+  
+    return amounts
+  end
+  
+  function :_swap, {
+    amounts: [:uint256],
+    path: [:address],
+    _to: :address
+  }, :internal, :virtual do
+    # TODO: how bad can this loop get?
+    
+    for i in 0...(path.length - 1)
+      input, output = path[i], path[i + 1]
+      token0, _ = sortTokens(input, output)
+      amountOut = amounts[i + 1]
+      amount0Out, amount1Out = input == token0 ? [0, amountOut] : [amountOut, 0]
+      to = i < path.length - 2 ? pairFor(factory, output, path[i + 2]) : _to
+
+      UniswapV2Pair(pairFor(factory, input, output)).swap(amount0Out, amount1Out, to, "")
+    end
+    
+    return nil
+  end
+  
+  function :_safeTransferFrom, { token: :address, from: :address, to: :address, value: :uint256 }, :private do
+    result = ERC20(token).transferFrom(from: from, to: to, amount: value)
+    
+    require(result, "ScribeSwap: TRANSFER_FAILED")
+  end
+  
+  function :getAmountsOut, {
+    factory: :address,
+    amountIn: :uint256,
+    path: [:address]
+  }, :public, :view, returns: [:uint256] do
+    require(path.length >= 2, 'UniswapV2Library: INVALID_PATH')
+    
+    amounts = array(:uint256, path.length)
+    amounts[0] = amountIn
+    
+    for i in 0...(path.length - 1)
+      reserveIn, reserveOut = getReserves(factory, path[i], path[i + 1])
+      amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut)
+    end
+    
+    return amounts
+  end
+  
+  function :getAmountOut, {
+    amountIn: :uint256,
+    reserveIn: :uint256,
+    reserveOut: :uint256
+  }, :public, :view, returns: :uint256 do
+    require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
+    require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+    
+    amountInWithFee = amountIn * 997;
+    numerator = amountInWithFee * reserveOut
+    denominator = reserveIn * 1000 + amountInWithFee
+    amountOut = numerator.div(denominator)
+    
+    return amountOut
+  end
+  
+  function :getAmountsIn, {
+    factory: :address,
+    amountOut: :uint256,
+    path: [:address]
+  }, :public, :view, returns: [:uint256] do
+    require(path.length >= 2, 'UniswapV2Library: INVALID_PATH')
+  
+    amounts = array(:uint256, path.length)
+    amounts[amounts.length - 1] = amountOut
+    
+    for i in (path.length - 1).downto(1)
+      reserveIn, reserveOut = getReserves(factory, path[i - 1], path[i])
+      amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut)
+    end
+  
+    return amounts
+  end
+  
+  function :getAmountIn, {
+    amountOut: :uint256,
+    reserveIn: :uint256,
+    reserveOut: :uint256
+  }, :public, :view, returns: :uint256 do
+    require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT')
+    require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY')
+  
+    numerator = reserveIn * amountOut * 1000
+    denominator = (reserveOut - amountOut) * 997
+    amountIn = (numerator.div(denominator)) + 1
+  
+    return amountIn
+  end
+  
+  function :quote, {
+    amountA: :uint256,
+    reserveA: :uint256,
+    reserveB: :uint256
+  }, :public, :pure, returns: :uint256 do
+    require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
+    require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+    
+    return (amountA * reserveB).div(reserveA);
+  end
+  
+  function :getReserves, {
+    factory: :address,
+    tokenA: :address,
+    tokenB: :address
+  }, :public, :view, returns: { reserveA: :uint256, reserveB: :uint256 } do
+    token0, _ = sortTokens(tokenA, tokenB)
+    
+    reserve0, reserve1, _ = UniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
+    
+    (reserveA, reserveB) = tokenA == token0 ? [reserve0, reserve1] : [reserve1, reserve0]
+    
+    return {
+      reserveA: reserveA,
+      reserveB: reserveB
+    }
+  end
+  
+  function :pairFor, {
+    factory: :address,
+    tokenA: :address,
+    tokenB: :address
+  }, :internal, :pure, returns: :address do
+    token0, token1 = sortTokens(tokenA, tokenB)
+    
+    return create2_address(
+      salt: keccak256(abi.encodePacked(token0, token1)),
+      deployer: factory,
+      contract_type: "UniswapV2Pair"
+    )
+  end
+  
+  function :sortTokens, { tokenA: :address, tokenB: :address }, :internal, :pure, returns: { token0: :address, token1: :address } do
+    require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES')
+    
+    token0, token1 = tokenA.cast(:uint256) < tokenB.cast(:uint256) ? [tokenA, tokenB] : [tokenB, tokenA]
+    
+    require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS')
+    
+    return { token0: token0, token1: token1 }
+  end
+  
+  function :userStats, {
+    user: :address,
+    tokenA: :address,
+    tokenB: :address,
+  }, :public, :view, returns: {
+    userTokenABalance: :uint256,
+    userTokenBBalance: :uint256,
+    tokenAName: :string,
+    tokenBName: :string,
+    tokenAReserves: :uint256,
+    tokenBReserves: :uint256,
+    userLPBalance: :uint256,
+    pairAddress: :address
+  } do
+    tokenAReserves = 0
+    tokenBReserves = 0
+    userLPBalance = 0
+    
+    if UniswapV2Factory(s.factory).getPair(tokenA, tokenB) != address(0)
+      tokenAReserves, tokenBReserves = getReserves(s.factory, tokenA, tokenB)
+      
+      pair = UniswapV2Factory(s.factory).getPair(tokenA, tokenB)
+      userLPBalance = UniswapV2ERC20(pair).balanceOf(user)
+    end
+    
+    return {
+      userTokenABalance: ERC20(tokenA).balanceOf(user),
+      userTokenBBalance: ERC20(tokenB).balanceOf(user),
+      tokenAName: ERC20(tokenA).name(),
+      tokenBName: ERC20(tokenB).name(),
+      tokenAReserves: tokenAReserves,
+      tokenBReserves: tokenBReserves,
+      userLPBalance: userLPBalance,
+      pairAddress: pair
+    }
+  end
+end

data/lib/0xfacet/uniswap/UniswapV2RouterWithRewards.rb

@@ -0,0 +1,360 @@
+pragma :rubidity, "1.0.0"
+
+import 'Upgradeable'
+import 'UniswapV2Router'
+
+contract :UniswapV2RouterWithRewards, is: [:UniswapV2Router, :Upgradeable], upgradeable: true do
+  event :FeeAccrued, {
+    total: :uint256,
+    toStakers: :uint256,
+    toSwappers: :uint256,
+    toProtocol: :uint256
+  }
+  
+  address :public, :feeAdmin
+  uint256 :public, :feeBPS
+  
+  uint256 :public, :swapperFeePct
+  uint256 :public, :stakerFeePct
+  uint256 :public, :protocolFeePct
+  
+  mapping ({ address: :uint256 }), :public, :stakerRewardsPool
+  uint256 :public, :swapperRewardsPool
+  uint256 :public, :protocolFeePool
+  
+  mapping ({ address: mapping(address: :uint256) }), :public, :stakedLP
+  mapping ({ address: mapping(address: :uint256) }), :public, :rewardDebt
+  mapping ({ address: :uint256 }), :public, :totalStakedLP
+  mapping ({ address: :uint256 }), :public, :accRewardsPerShare
+  
+  array :address, :public, :topFiveSwappers, initial_length: 5
+  mapping ({ address: :uint256 }), :public, :feesGeneratedBySwapper
+  mapping ({ address: :uint256 }), :public, :swapperRewards
+  
+  uint256 :public, :decimals
+  
+  constructor(
+    _factory: :address,
+    _WETH: :address,
+    feeBPS: :uint256,
+    swapperFeePct: :uint256,
+    stakerFeePct: :uint256,
+    protocolFeePct: :uint256,
+    feeAdmin: :address
+  ) {
+    updateFees(
+      feeBPS: feeBPS,
+      swapperFeePct: swapperFeePct,
+      stakerFeePct: stakerFeePct,
+      protocolFeePct: protocolFeePct,
+      feeAdmin: feeAdmin
+    )
+    
+    s.decimals = 18
+    
+    UniswapV2Router.constructor(_factory: _factory, _WETH: _WETH)
+    Upgradeable.constructor(upgradeAdmin: msg.sender)
+  }
+  
+  function :updateFees, {
+    feeBPS: :uint256,
+    swapperFeePct: :uint256,
+    stakerFeePct: :uint256,
+    protocolFeePct: :uint256,
+    feeAdmin: :address
+  }, :public do
+    require(msg.sender == s.feeAdmin || s.feeAdmin == address(0), 'Only fee admin can update fees')
+    require(feeBPS <= 10000, 'Fee cannot be greater than 100%')
+    require(
+      swapperFeePct + stakerFeePct + protocolFeePct == 100,
+      'Fees must add up to 100%'
+    )
+    require(feeAdmin != address(0), 'Fee admin cannot be address(0)')
+    
+    s.feeBPS = feeBPS
+    s.stakerFeePct = stakerFeePct
+    s.swapperFeePct = swapperFeePct
+    s.protocolFeePct = protocolFeePct
+    
+    s.feeAdmin = feeAdmin
+    nil
+  end
+  
+  function :stakeLP, { lpToken: :address, amount: :uint256 }, :public, returns: :bool do
+    lpPair = UniswapV2Pair(lpToken)
+    token0 = lpPair.token0()
+    token1 = lpPair.token1()
+    
+    require(token0 == s.WETH || token1 == s.WETH, 'One of the tokens must be WETH')
+    require(amount > 0, 'Stake amount must be greater than 0')
+    
+    updateStakeAmount(lpToken: lpToken, amount: amount, isStaking: true, user: msg.sender)
+  
+    ERC20(lpToken).transferFrom(msg.sender, address(this), amount)
+  end
+  
+  function :unstakeLP, { lpToken: :address, amount: :uint256 }, :public, returns: :bool do
+    require(s.stakedLP[msg.sender][lpToken] >= amount, 'Insufficient staked amount')
+    require(amount > 0, 'Unstake amount must be greater than 0')
+    
+    updateStakeAmount(lpToken: lpToken, amount: amount, isStaking: false, user: msg.sender)
+    
+    ERC20(lpToken).transfer(msg.sender, amount)
+  end
+  
+  function :withdrawStakingRewards, { lpToken: :address }, :public do
+    updateStakeAmount(lpToken: lpToken, amount: 0, isStaking: true, user: msg.sender)
+  end
+  
+  function :updateStakeAmount, {
+    lpToken: :address,
+    amount: :uint256,
+    isStaking: :bool,
+    user: :address
+   }, :internal do
+    updateStakingRewards(lpToken: lpToken)
+
+    pending = pendingStakingRewards(user: user, lpToken: lpToken)
+    
+    require(pending > 0 || amount > 0, 'Nothing to do')
+    
+    if pending > 0
+      ERC20(s.WETH).transfer(user, pending)
+    end
+    
+    if isStaking
+      s.stakedLP[user][lpToken] += amount
+      s.totalStakedLP[lpToken] += amount
+    else
+      s.stakedLP[user][lpToken] -= amount
+      s.totalStakedLP[lpToken] -= amount
+    end
+    
+    unScaledDebt = s.stakedLP[user][lpToken] * s.accRewardsPerShare[lpToken]
+    
+    s.rewardDebt[user][lpToken] = unScaledDebt.div(1.ether)
+    nil
+  end
+  
+  function :swapExactTokensForTokens, { 
+    amountIn: :uint256,
+    amountOutMin: :uint256,
+    path: [:address],
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, :override, returns: [:uint256] do
+    amounts = UniswapV2Router.swapExactTokensForTokens(
+      amountIn: amountIn - calculateFeeAmount(amountIn),
+      amountOutMin: amountOutMin,
+      path: path,
+      to: to,
+      deadline: deadline
+    )
+    
+    feeInWETH = chargeFeeInWETH(amountIn, path[0])
+    
+    lpToken = pairFor(factory, path[0], path[1])
+    
+    s.stakerRewardsPool[lpToken] += (feeInWETH * s.stakerFeePct).div(100)
+    s.protocolFeePool += (feeInWETH * s.protocolFeePct).div(100)
+    
+    updateTopFiveSwappers(
+      currentSwapper: msg.sender,
+      currentFee: feeInWETH
+    )
+    
+    emit :FeeAccrued, {
+      total: feeInWETH,
+      toStakers: (feeInWETH * s.stakerFeePct).div(100),
+      toSwappers: (feeInWETH * s.swapperFeePct).div(100),
+      toProtocol: (feeInWETH * s.protocolFeePct).div(100)
+    }
+    
+    amounts
+  end
+  
+  function :swapTokensForExactTokens, {
+    amountOut: :uint256,
+    amountInMax: :uint256,
+    path: [:address],
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, :override, returns: [:uint256] do
+    amounts = UniswapV2Router.swapTokensForExactTokens(
+      amountOut: amountOut + calculateFeeAmount(amountOut),
+      amountInMax: amountInMax,
+      path: path,
+      to: to,
+      deadline: deadline
+    )
+    
+    feeInWETH = chargeFeeInWETH(amountOut, path[1])
+    
+    lpToken = pairFor(factory, path[0], path[1])
+    
+    s.stakerRewardsPool[lpToken] += (feeInWETH * s.stakerFeePct).div(100)
+    s.protocolFeePool += (feeInWETH * s.protocolFeePct).div(100)
+    
+    updateTopFiveSwappers(
+      currentSwapper: msg.sender,
+      currentFee: feeInWETH
+    )
+    
+    emit :FeeAccrued, {
+      total: feeInWETH,
+      toStakers: (feeInWETH * s.stakerFeePct).div(100),
+      toSwappers: (feeInWETH * s.swapperFeePct).div(100),
+      toProtocol: (feeInWETH * s.protocolFeePct).div(100)
+    }
+    
+    amounts
+  end
+  
+  function :calculateFeeAmount, { amount: :uint256 }, :public, :view, returns: :uint256 do
+    return (amount * s.feeBPS).div(10000)
+  end
+  
+  function :calculateAccRewardsPerShare, { lpToken: :address }, :internal, :view, returns: :uint256 do
+    accRewardsPerShare = s.accRewardsPerShare[lpToken]
+    
+    if s.totalStakedLP[lpToken] > 0 && s.stakerRewardsPool[lpToken] > 0
+      accRewardPerShareIncrement = (s.stakerRewardsPool[lpToken] * 1.ether).div(s.totalStakedLP[lpToken])
+      accRewardsPerShare += accRewardPerShareIncrement
+    end
+    
+    return accRewardsPerShare
+  end
+  
+  function :updateStakingRewards, { lpToken: :address }, :internal do
+    s.accRewardsPerShare[lpToken] = calculateAccRewardsPerShare(lpToken: lpToken)
+    s.stakerRewardsPool[lpToken] = 0
+    nil
+  end
+  
+  function :pendingStakingRewards, { user: :address, lpToken: :address }, :public, :view, returns: :uint256 do
+    accRewardsPerShare = calculateAccRewardsPerShare(lpToken: lpToken)
+    
+    topLine = (s.stakedLP[user][lpToken] * accRewardsPerShare).div(1.ether)
+    
+    return topLine - s.rewardDebt[user][lpToken]
+  end
+  
+  function :chargeFeeInWETH, {
+    amount: :uint256,
+    token: :address
+  }, :internal, :virtual, returns: :uint256 do
+    feeAmount = calculateFeeAmount(amount)
+    
+    if token == s.WETH
+      ERC20(token).transferFrom(
+        from: msg.sender,
+        to: address(this),
+        amount: feeAmount
+      )
+      
+      return feeAmount
+    end
+    
+    path = array(:address, 2)
+    path[0] = token
+    path[1] = s.WETH
+    
+    feeInWETH = UniswapV2Router.swapExactTokensForTokens(
+      amountIn: feeAmount,
+      amountOutMin: 0,
+      path: path,
+      to: address(this),
+      deadline: block.timestamp + 1
+    )[1]
+    
+    return feeInWETH
+  end
+  
+  function :updateSwapperRewards, :internal do
+    nonNullSwapperCount = 0
+
+    forLoop(
+      condition: ->(i) { i < s.topFiveSwappers.length },
+      max_iterations: 5
+    ) do |i|
+      if s.topFiveSwappers[i] != address(0)
+        nonNullSwapperCount += 1
+      end
+    end
+    
+    return if nonNullSwapperCount == 0
+    
+    individualSwapperReward = s.swapperRewardsPool.div(nonNullSwapperCount)
+    
+    forLoop(
+      condition: ->(i) { i < s.topFiveSwappers.length },
+      max_iterations: 5
+    ) do |i|
+      swapper = s.topFiveSwappers[i]
+      if swapper != address(0)
+        s.swapperRewards[swapper] += individualSwapperReward
+      end
+    end
+    
+    s.swapperRewardsPool = 0
+    nil
+  end
+  
+  function :withdrawProtocolRewards, { to: :address }, :public, returns: :bool do
+    require(msg.sender == s.feeAdmin, "Only fee admin can withdraw protocol rewards")
+    
+    amount = s.protocolFeePool
+    require(amount > 0, "No rewards to withdraw")
+    
+    s.protocolFeePool = 0
+    
+    ERC20(s.WETH).transfer(to, amount)
+  end
+  
+  function :withdrawSwapperRewards, :public, returns: :bool do
+    updateSwapperRewards()
+    
+    amount = s.swapperRewards[msg.sender]
+    require(amount > 0, "No rewards to withdraw")
+    
+    s.swapperRewards[msg.sender] = 0
+    
+    ERC20(s.WETH).transfer(msg.sender, amount)
+  end
+  
+  function :updateTopFiveSwappers, { currentSwapper: :address, currentFee: :uint256 }, :internal do
+    updateSwapperRewards()
+    
+    s.feesGeneratedBySwapper[currentSwapper] += currentFee
+    s.swapperRewardsPool += (currentFee * s.swapperFeePct).div(100)
+
+    newTotal = s.feesGeneratedBySwapper[currentSwapper]
+  
+    forLoop(
+      condition: ->(i) { i < s.topFiveSwappers.length },
+      max_iterations: 5
+    ) do |i|
+      return if s.topFiveSwappers[i] == currentSwapper
+    end
+    
+    minFee = 2 ** 256 - 1
+    minIndex = 0
+    
+    forLoop(
+      condition: -> i { i < s.topFiveSwappers.length },
+      max_iterations: 5
+    ) do |i|
+      swapper = s.topFiveSwappers[i]
+      if swapper == address(0) || s.feesGeneratedBySwapper[swapper] < minFee
+        minFee = s.feesGeneratedBySwapper[swapper]
+        minIndex = i
+      end
+    end
+    
+    if newTotal > minFee
+      s.topFiveSwappers[minIndex] = currentSwapper
+    end
+    
+    nil
+  end
+end

data/lib/0xfacet/uniswap.rb

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

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: 0xfacet-uniswap
+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: 0xfacet-contracts
+  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-uniswap - rubidity o.g. uniswap v2 contracts (incl. UniswapV2Factory,
+  UniswapV2Pair, UniswapV2Router, 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/uniswap.rb
+- lib/0xfacet/uniswap/UniswapSetupZapV2.rb
+- lib/0xfacet/uniswap/UniswapV2Callee.rb
+- lib/0xfacet/uniswap/UniswapV2ERC20.rb
+- lib/0xfacet/uniswap/UniswapV2Factory.rb
+- lib/0xfacet/uniswap/UniswapV2Pair.rb
+- lib/0xfacet/uniswap/UniswapV2Router.rb
+- lib/0xfacet/uniswap/UniswapV2RouterWithRewards.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-uniswap - rubidity o.g. uniswap v2 contracts (incl. UniswapV2Factory,
+  UniswapV2Pair, UniswapV2Router, etc.)
+test_files: []