Token approval bugfixes & other improvements

- Added token approval for vault token (required once for withdraw)
- Added token allowance assertions
- Added checksum() utility function

Author: hschickdevs

README.md

@@ -122,7 +122,9 @@ How to use the package
 
 
     # Approve a token for deposit to the vault (only required once if never approved):
-    position.do_approve_deposit_token(<token_address> or <BEP20Token object>)
+    position.do_approve_token(<token_address> or <BEP20Token object>)
+    # Approve the vault token for withdraw if using the "Convert All" strategy (only required once if never approved):
+    position.do_approve_token(position.bep20_vault_token, _spender=position.gateway.address)
 
 
     # Invest the given amount of stable and asset token into the vault:

alpaca_finance/__init__.py

@@ -1 +1 @@
-__version__ = "1.0.0"
+__version__ = "1.1.1"

alpaca_finance/automated_vault/contracts.py

@@ -37,6 +37,7 @@ def __init__(self, vault_address: str, w3_provider: Web3 = None, protocol: str =
         """
         AVAILABLE_PROTOCOLS = ["pancakeswap", "biswap"]
 
+        self.address = vault_address
         self.contract = get_bsc_contract_instance(contract_address=vault_address,
                                                   abi_filename="DeltaNeutralVault.json", w3_provider=w3_provider)
         self.protocol = protocol.lower()
@@ -141,6 +142,7 @@ def assetTokenAddress(self) -> str:
 
 class DeltaNeutralVaultGateway:
     def __init__(self, gateway_address: str, w3_provider: Web3 = None):
+        self.address = gateway_address
         self.contract = get_bsc_contract_instance(contract_address=gateway_address,
                                                   abi_filename="DeltaNeutralVaultGateway.json", w3_provider=w3_provider)
 

alpaca_finance/automated_vault/position.py

@@ -1,7 +1,7 @@
 from typing import Union, Optional
 from math import floor
 
-from ..util import get_entry_prices, get_web3_provider, get_vault_addresses
+from ..util import get_entry_prices, get_web3_provider, get_vault_addresses, checksum
 from ._config import DEFAULT_BSC_RPC_URL
 from .receipt import TransactionReceipt, build_receipt
 from .contracts import DeltaNeutralVault, DeltaNeutralOracle, AutomatedVaultController, DeltaNeutralVaultGateway
@@ -10,6 +10,7 @@
 import requests
 import web3.contract
 from web3 import Web3
+from web3.constants import MAX_INT
 from attrdict import AttrDict
 from bep20 import BEP20Token
 
@@ -47,18 +48,33 @@ def __init__(self, position_key: str, owner_wallet_address: str, owner_wallet_ke
 
     """ ------------------ Transactional Methods (Requires private wallet key) ------------------ """
 
-    def do_invest(self, stable_token_amt: int = 0, asset_token_amt: int = 0) -> TransactionReceipt:
+    def do_invest(self, stable_token_amt: int = 0, asset_token_amt: int = 0, _approve=False) -> TransactionReceipt:
         """
         Invest the specified amount of each token into the Automated Vault.
         Use self.asset_token and self.stable_token to identify the underlying assets.
 
         :param stable_token_amt: The amount of stable token to deposit
         :param asset_token_amt: The amount of asset token to deposit
+        :param _approve: If True, approves the deposit token for spending by the vault token
         :return:
         """
         assert stable_token_amt > 0 or asset_token_amt > 0, \
             "Please provide an investment value for either the stable or asset tokens"
 
+        # Ensure that allowances match desired investment amount
+        if stable_token_amt > 0:
+            token_bal = self.stable_token.balanceOf(self.owner_address)
+            assert token_bal >= stable_token_amt, \
+                f"Insufficient funds to invest {stable_token_amt} {self.stable_token.symbol()} ({token_bal} Owned)"
+            if _approve:
+                self.do_approve_token(self.stable_token)
+        if asset_token_amt > 0:
+            token_bal = self.asset_token.balanceOf(self.owner_address)
+            assert token_bal >= asset_token_amt, \
+                f"Insufficient funds to invest {asset_token_amt} {self.asset_token.symbol()} ({token_bal} Owned)"
+            if _approve:
+                self.do_approve_token(self.asset_token)
+
         return self._execute(self.vault.invest(stable_token_amt, asset_token_amt, shareReceiver=self.owner_address))
 
     def do_withdraw(self, shares: int, pct_stable: float = None, strategy: str = "Minimize Trading") -> TransactionReceipt:
@@ -68,14 +84,23 @@ def do_withdraw(self, shares: int, pct_stable: float = None, strategy: str = "Mi
         :param shares: The amount of share to withdraw from the vault (in share tokens) (self.shares()[0] = close position)
         :param pct_stable: The percentage of stable token returned to the owner (.50 = 50% stable and 50% asset returned)
         :param strategy: The strategy to use to withdraw, as shown on the webapp (Minimize Trading, Convert All)
+        (NOT IN USE) :param _approve: If True, force approves the vault token to be spent by either the gateway or the vault contract
         """
         assert self.shares()[0] >= shares, f"Shares owned insufficient to withdraw {shares} " \
                                            f"({self.from_wei(shares, self.bep20_vault_token.decimals())}) shares"
 
         if strategy.lower() == "minimize trading":
+            # assert self.bep20_vault_token.allowance(self.owner_address, self.vault.address) >= shares, \
+            #     f"Insufficient approval amount - Spender ({self.vault.address}) requires an allowance of {shares} " \
+            #     f"{self.bep20_vault_token.symbol()} ({self.bep20_vault_token.address})"
+
             return self._execute(self.vault.withdraw(shares))
         elif strategy.lower() == "convert all":
             assert pct_stable is not None, "Please provide a stable token percentage to determine token swap"
+            assert self.bep20_vault_token.allowance(self.owner_address, self.gateway.address) >= shares, \
+                f"Insufficient approval amount - Spender ({self.gateway.address}) requires an allowance of {shares} " \
+                f"{self.bep20_vault_token.symbol()} ({self.bep20_vault_token.address})"
+
             assert 0.0 < pct_stable <= 1.0, "Invalid value for pct_stable parameter, must follow 0.0 < pct_stable <= 1.0"
 
             stable_return_bps = floor(pct_stable * 10000)
@@ -93,17 +118,26 @@ def do_close(self, pct_stable: float = None, strategy: str = "Minimize Trading")
         """
         return self.do_withdraw(shares=self.shares()[0], pct_stable=pct_stable, strategy=strategy)
 
-    def do_approve_deposit_token(self, token: Union[BEP20Token, str], amount: int = None) -> TransactionReceipt:
+    def do_approve_token(self, token: Union[BEP20Token, str], amount: int = None, _spender: str = None) -> TransactionReceipt:
         """
-        Approves the given token for deposit into an Automated Vault.
+        Approves the given token for usage by the Automated Vault.
 
         :param token: Optional - either the BEP20Token object, or the token address (str)
         :param amount: The amount of token to approve, default = maximum
+        :param _spender: (Should not be changed by the caller) The address to give token spending access to
         """
         if type(token) != BEP20Token:
             token = BEP20Token(token)
 
-        func_call = token.prepare_approve(self.address, amount)
+        if amount is None:
+            # Use maximum approval amount if no amount is specified
+            amount = 2 ** 256 - 1
+
+        if _spender is None:
+            _spender = self.address
+
+        func_call = token.prepare_approve(checksum(_spender), amount)
+
         return self._execute(func_call)
 
 

alpaca_finance/util.py

@@ -8,6 +8,9 @@
 from web3 import Web3
 
 
+checksum = lambda addr: Web3.toChecksumAddress(addr)
+
+
 def get_web3_provider(network_rpc_url: str) -> Web3:
     """Returns a Web3 connection provider object"""
     return Web3(Web3.HTTPProvider(network_rpc_url))

examples/automated_vault/approve_deposit_token.ipynb renamed to examples/automated_vault/approve_token.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -17,7 +17,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -29,7 +29,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -51,7 +51,7 @@
     {
      "data": {
       "text/plain": [
-       "('Long 3x BUSD-BTCB PCS2', 'l3x-busdbtcb-pcs2', 'BUSD')"
+       "('Long 3x BUSD-BTCB PCS2', 'l3x-busdbtcb-pcs2', 'BUSD', 'L3x-BUSDBTCB-PCS2')"
       ]
      },
      "execution_count": 5,
@@ -63,7 +63,7 @@
     "# Create a automated vault position instance:\n",
     "position = AutomatedVaultPosition(position_key=POSITION_KEY, owner_wallet_address=PUBKEY, owner_wallet_key=PRIVKEY)\n",
     "\n",
-    "position.name, position.key, position.asset_token.symbol()"
+    "position.name, position.key, position.asset_token.symbol(), position.bep20_vault_token.symbol()"
    ]
   },
   {
@@ -90,7 +90,7 @@
     }
    ],
    "source": [
-    "txn_recept = position.do_approve_deposit_token(position.asset_token)\n",
+    "txn_recept = position.do_approve_token(position.asset_token)\n",
     "txn_recept"
    ]
   },
@@ -113,6 +113,56 @@
    "source": [
     "f\"Gas Spend USD: ${txn_recept.gasSpendUSD}\""
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Approve vault token (L3x-BUSDBTCB-PCS2) for withdraw from the vault\n",
+    "\n",
+    "> NOTE: This is only needed if the **\"Convert All\"** strategy is used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "TransactionReceipt(transactionHash=HexBytes('0x48f5dd6535f5a2c92ade75494ee1215e037bc8bef91fa98025390d1f865130ce'), blockHash=HexBytes('0xb909a29e08c35350dd6975fc814cef96408afcb79199178d615e25cf4793b982'), blockNumber=19902313, contractAddress=None, cumulativeGasUsed=4586517, gasSpendUSD=0.04049917075722871, fromAddress='0xC9E6e248928aC18eD6b103653cBcF66d23B743C6', toAddress='0xA1679223b7585725aFb425a6F59737a05e085C40', status=1, transactionIndex=48, type='0x0', effectiveGasPrice=None)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "txn_receipt = position.do_approve_token(position.bep20_vault_token, _spender=position.gateway.address)\n",
+    "txn_receipt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Gas Spend USD: $0.04049917075722871'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f\"Gas Spend USD: ${txn_receipt.gasSpendUSD}\""
+   ]
   }
  ],
  "metadata": {

requirements.txt

@@ -1,7 +1,7 @@
 attrdict
 web3
 requests
-bep20>=1.0.1
+bep20>=1.0.2
 eth_abi
 hexbytes
 python-dotenv