indev

Author: hschickdevs

.gitignore

@@ -155,4 +155,5 @@ cython_debug/
 .DS_Store
 .idea
 testing.*
-jessie_alpaca_example.ipynb
+testing2.*
+examples/old/jessie_alpaca_example.ipynb

README.md

@@ -63,7 +63,7 @@ How to use the package:
 
 ### Automated Vaults:
 
-3. Creating an [AutomatedVaultPosition](alpaca_finance/positions.py) instance requires the following:
+3. Creating an [AutomatedVaultPosition](alpaca_finance/automated_vault/positions.py) instance requires the following:
     - Your position key (string)
         - This key should match your position key on Alpaca Finance's webapp
         - ![demo](img/demo.png)
@@ -102,7 +102,7 @@ How to use the package:
     # Get the amount of shares held and the USD value of all shares held:
     position.shares()
 
-    # get the full vault summary (See the documentation alpaca_fiance/positions.py for more details):
+    # get the full vault summary (See the documentation alpaca_fiance/position.py for more details):
     position.get_vault_summary()
     ```
 

alpaca_finance/automated_vault/__init__.py

@@ -0,0 +1 @@
+from .position import AutomatedVaultPosition

alpaca_finance/_config.py renamed to alpaca_finance/automated_vault/_config.py

@@ -0,0 +1,174 @@
+from ..util import get_bsc_contract_instance
+from ._config import DELTA_NEUTRAL_ORACLE_ADDRESS, AUTOMATED_VAULT_CONTROLLER_ADDRESS
+# from .work_bytes import WithdrawWorkByte  #  <- Deprecated
+
+import requests
+import web3.contract
+from web3 import Web3
+from bep20.util import checksum
+from eth_abi import encode_abi
+
+
+class DeltaNeutralOracle:
+    def __init__(self, w3_provider: Web3 = None):
+        self.contract = get_bsc_contract_instance(contract_address=DELTA_NEUTRAL_ORACLE_ADDRESS,
+                                                  abi_filename="DeltaNeutralOracle.json",
+                                                  w3_provider=w3_provider)
+
+    def lpToDollar(self, lp_amount: int, pancakeswap_lp_token_address: str) -> int:
+        """Return the value in USD for the given lpAmount"""
+        return self.contract.functions.lpToDollar(lp_amount, checksum(pancakeswap_lp_token_address)).call()
+
+    def dollarToLp(self, dollar_amount: int, lp_token_address: str) -> int:
+        """Return the amount of LP for the given USD"""
+        return self.contract.functions.dollarToLp(dollar_amount, checksum(lp_token_address)).call()
+
+    def getTokenPrice(self, token_address: str) -> int:
+        """Return the price of the given token (address) in USD"""
+        return self.contract.functions.getTokenPrice(checksum(token_address)).call()[0] / 10 ** 18
+
+
+class DeltaNeutralVault:
+    def __init__(self, vault_address: str, w3_provider: Web3 = None, protocol: str = "pancakeswap"):
+        """
+        :param vault_address: The address for the Delta Neutral Vault
+        :param protocol: The protocol ID that the vault resides on (pancakeswap or biswap)
+        :param w3_provider: Web3 provider (optional), if provided speeds up initialization time
+        """
+        AVAILABLE_PROTOCOLS = ["pancakeswap", "biswap"]
+
+        self.contract = get_bsc_contract_instance(contract_address=vault_address,
+                                                  abi_filename="DeltaNeutralVault.json", w3_provider=w3_provider)
+        self.protocol = protocol.lower()
+        assert protocol in AVAILABLE_PROTOCOLS, NotImplementedError(f"Available protocols are {AVAILABLE_PROTOCOLS}")
+
+        self.ACTION_WORK = 1
+
+        r = requests.get("https://raw.githubusercontent.com/alpaca-finance/bsc-alpaca-contract/main/.mainnet.json").json()
+
+        # Get vault addresses:
+        try:
+            self.addresses = list(filter(lambda v: v['address'].lower() == vault_address.lower(), r['DeltaNeutralVaults']))[0]
+            """
+            E.x.
+            "name": "Long 3x BUSD-BTCB PCS2",
+            "symbol": "L3x-BUSDBTCB-PCS2",
+            "address": "0xA1679223b7585725aFb425a6F59737a05e085C40",
+            "deployedBlock": 18042257,
+            "config": "0x39936A4eC165e2372C8d91c011eb36576dBE5d32",
+            "assetToken": "0xe9e7cea3dedca5984780bafc599bd69add087d56",
+            "stableToken": "0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c",
+            "assetVault": "0x7C9e73d4C71dae564d41F78d56439bB4ba87592f",
+            "stableVault": "0x08FC9Ba2cAc74742177e0afC3dC8Aed6961c24e7",
+            "assetDeltaWorker": "0x071ac07A287C643b193bc107D29DF4D53BFFAFf7",
+            "stableDeltaWorker": "0x3F89B3198cB710248136bbB640e88C1618436d20",
+            "oracle": "0x08EA5fB66EA41f236E3001d2655e43A1E735787F",
+            "gateway": "0x0256E784f73391797f80a9902c0fD05a718a812a",
+            "assetVaultPosId": "54752",
+            "stableVaultPosId": "5630"
+            """
+        except IndexError:
+            raise IndexError(f"Could not locate Delta Neutral Vault with address {vault_address}")
+
+        # Get strategy addresses:
+        # self.partialCloseMinimizeStrat = {"pancakeswap": "0x8dcEC5e136B6321a50F8567588c2f25738D286C2",
+        #                                   "biswap": "0x3739d1E01104b019Ff105B3A8F57BC6ed62F18a4"}
+        self.partialCloseMinimizeStrat = {"pancakeswap": r['SharedStrategies']["Pancakeswap"]["StrategyPartialCloseMinimizeTrading"],
+                                          "biswap": r['SharedStrategies']["Biswap"]["StrategyPartialCloseMinimizeTrading"]}
+
+    def invest(self) -> web3.contract.ContractFunction:
+        pass
+
+    def withdraw(self, shares: int) -> web3.contract.ContractFunction:
+        """
+        Withdraw the given amount of shares from the Delta Neutral Vault using the 'Minimize Trading' strategy.
+
+        :param shares: The amount of shares to withdraw (in shares/vault token)
+        :return: Uncalled prepared ContractFunction
+        """
+        # All Slippage Controls
+        minStableTokenAmount = 0
+        minAssetTokenAmount = 0
+
+        # Constant calldata (should not change)
+        _calldata = encode_abi(
+            ["uint256", "uint256"],
+            [25, 1]
+        )
+
+        return self.contract.functions.withdraw(shares, minStableTokenAmount, minAssetTokenAmount, _calldata)
+    
+    def shares(self, user_address: str) -> int:
+        """Return the number of shares owned by the given user"""
+        return self.contract.functions.balanceOf(checksum(user_address)).call()
+
+    def positionInfo(self) -> list:
+        """
+        Return total equity and debt value in USD of stable and asset positions
+
+        :return:
+            - stablePositionEquity
+            - stablePositionDebtValue
+            - StableLpAmount
+            - assetPositionEquity
+            - assetPositionDebtValue
+            - assetLpAmount
+        """
+        return list(self.contract.functions.positionInfo().call())
+    
+    def sharesToUSD(self, share_amount: int) -> int:
+        """Returns the value in USD for the given amount of vault shares"""
+        return self.contract.functions.shareToValue(share_amount).call()
+
+    def stableTokenAddress(self) -> str:
+        """Returns the address for the delta vault stable token"""
+        return self.contract.functions.stableToken().call()
+
+    def assetTokenAddress(self) -> str:
+        """Returns the address for the delta vault stable token"""
+        return self.contract.functions.assetToken().call()
+
+
+class DeltaNeutralVaultGateway:
+    def __init__(self, gateway_address: str, w3_provider: Web3 = None):
+        self.contract = get_bsc_contract_instance(contract_address=gateway_address,
+                                                  abi_filename="DeltaNeutralVaultGateway.json", w3_provider=w3_provider)
+
+    def withdraw(self, shares: int, stableReturnBps: int) -> web3.contract.ContractFunction:
+        """
+        Withdraw shares from the vault using the gateway
+
+        :param shares: The amount of share to withdraw from the vault (in vault tokens) (e.g. 10 shares = 10 ** vault token decimals)
+        :param stableReturnBps: The percentage of tokens returned that should be stable tokens (in Basis Points)
+        :return: uncalled prepared ContractFunction
+        """
+
+        # All Slippage Controls
+        minWithdrawStableTokenAmount = 0  # Minimum stable token shareOwner expect to receive after withdraw.
+        minWithdrawAssetTokenAmount = 0  # Minimum asset token shareOwner expect to receive after withdraw.
+        minSwapStableTokenAmount = 0  # Minimum stable token shareOwner expect to receive after swap.
+        minSwapAssetTokenAmount = 0  # Minimum asset token shareOwner expect to receive after swap.
+
+        # Constant calldata (should not change)
+        _calldata = encode_abi(
+            ["uint256", "uint256"],
+            [25, 1]
+        )
+
+        # stableReturnBps = 10000  # Percentage stable token shareOwner expect to receive in bps (10000 == 100%)
+        return self.contract.functions.withdraw(shares, minWithdrawStableTokenAmount, minWithdrawAssetTokenAmount,
+                                                minSwapStableTokenAmount, minSwapAssetTokenAmount, _calldata, stableReturnBps)
+
+
+class AutomatedVaultController:
+    def __init__(self, w3_provider: Web3 = None):
+        self.contract = get_bsc_contract_instance(contract_address=AUTOMATED_VAULT_CONTROLLER_ADDRESS,
+                                                  abi_filename="AutomatedVaultController.json",
+                                                  w3_provider=w3_provider)
+
+    def getUserVaultShares(self, owner_address: str, vault_address: str) -> int:
+        return self.contract.functions.getUserVaultShares(checksum(owner_address), checksum(vault_address)).call()
+
+    def totalCredit(self, user_address: str) -> int:
+        """Get the user's total credit in USD"""
+        return self.contract.functions.totalCredit(checksum(user_address)).call()

alpaca_finance/abi/AutomatedVaultController.json renamed to alpaca_finance/automated_vault/abi/AutomatedVaultController.json

@@ -0,0 +1,6 @@
+import requests
+
+
+def get_eth_price() -> float:
+    """Returns the realtime price of ETH in USD"""
+    return float(requests.get("https://api.binance.com/api/v3/avgPrice?symbol=ETHUSDT").json()["price"])

alpaca_finance/abi/DeltaNeutralOracle.json renamed to alpaca_finance/automated_vault/abi/DeltaNeutralOracle.json

@@ -1,10 +1,14 @@
-from typing import Optional
+from typing import Optional, Union
+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
 from ._config import DEFAULT_BSC_RPC_URL
-from .vault_contracts import DeltaNeutralVault, DeltaNeutralOracle, AutomatedVaultController, DeltaNeutralVaultGateway
+from .receipt import TransactionReceipt, build_receipt
+from .contracts import DeltaNeutralVault, DeltaNeutralOracle, AutomatedVaultController, DeltaNeutralVaultGateway
 
+from eth_abi import decode_abi
 import requests
+import web3.contract
 from web3 import Web3
 from attrdict import AttrDict
 from bep20 import BEP20Token
@@ -41,15 +45,40 @@ def __init__(self, position_key: str, owner_wallet_address: str, owner_wallet_ke
 
     """ ------------------ Transactional Methods (Requires private wallet key) ------------------ """
 
-    def invest(self):
+    def do_invest(self) -> TransactionReceipt:
         raise NotImplementedError
 
-    def withdraw(self, shares: int):
-        """Withdraws the specified amount of shares from the automated vault position."""
-        return self.vault.withdraw(shares)
+    def do_withdraw(self, shares: int, pct_stable: float = None, strategy: str = "Minimize Trading") -> TransactionReceipt:
+        """
+        Withdraws the specified amount of shares from the automated vault position.
 
-    def close_position(self):
-        raise NotImplementedError
+        :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)
+        """
+        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":
+            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 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)
+
+            return self._execute(self.gateway.withdraw(shares, stableReturnBps=stable_return_bps))
+        else:
+            raise ValueError("Invalid strategy - Options are 'Minimize Trading' or 'Convert All'")
+
+    def do_close(self, pct_stable: float = None, strategy: str = "Minimize Trading") -> TransactionReceipt:
+        """
+        Withdraws all outstanding shares from the pool and closes position.
+
+        :param pct_stable: See self.withdraw()
+        :param strategy: See self.withdraw()
+        """
+        return self.do_withdraw(shares=self.shares()[0], pct_stable=pct_stable, strategy=strategy)
 
     """ ---------------- Informational Methods (Private wallet key not required) ---------------- """
 
@@ -171,28 +200,91 @@ def cost_basis(self) -> float:  # tuple[float, float]
 
     """ -------------------------------- Utility Methods -------------------------------- """
 
-    def sign_and_send_tx(self):
-        pass
+    def _execute(self, function_call: web3.contract.ContractFunction) -> TransactionReceipt:
+        """
+        :param function_call: The uncalled and prepared contract method to sign and send
+        """
+        if self.owner_key is None:
+            raise ValueError("Private key is required to sign transactions")
+
+        txn = function_call.buildTransaction({
+            "from": self.owner_address,
+            'chainId': 56,  # 56: BSC mainnet
+            # 'gas': 76335152,
+            'gasPrice': 5000000000,
+            'nonce': self.w3_provider.eth.get_transaction_count(self.owner_address),
+        })
+        print(txn)
+
+        signed_txn = self.w3_provider.eth.account.sign_transaction(
+            txn, private_key=self.owner_key
+        )
+        tx_hash = self.w3_provider.eth.send_raw_transaction(signed_txn.rawTransaction)
+
+        receipt = dict(self.w3_provider.eth.wait_for_transaction_receipt(tx_hash))
+
+        try:
+            return build_receipt(receipt)
+        except Exception as exc:
+            print(f"COULD NOT BUILD TRANSACTION RECEIPT OBJECT - {exc}")
+            # Catch case to prevent receipt from being lost if TransactionReceipt object somehow can't be built
+            return receipt
+
+    @staticmethod
+    def from_wei(amt: int, decimals: int) -> int:
+        return amt * (10 ** decimals)
 
-    def decode_transaction_data(self, transaction_address: Optional):
+    def _decode_withdraw_transaction(self, transaction_address: Optional):
         """
         Returns the transaction data used to invoke the smart contract function for the underlying contract
         First fetches the transaction data for the HomoraBank.execute() function, then gets the transaction data
         for the underlying smart contract
-        :param w3_provider: The Web3.HTTPProvider object for interacting with the network
+
         :param transaction_address: The transaction address (binary or str)
         :return: (
             decoded bank function (ContractFunction, dict),
             decoded spell function (ContractFunction, dict)
         )
         """
         transaction = self.w3_provider.eth.get_transaction(transaction_address)
+        print(transaction)
+
+        try:
+            decoded_bank_transaction = self.vault.contract.decode_function_input(transaction.input)
+        except:
+            decoded_bank_transaction = self.gateway.contract.decode_function_input(transaction.input)
+
+        decoded_calldata = decode_abi(
+            ['uint256', 'uint256'],
+            decoded_bank_transaction[1]['_data']
+        )
+
+        return decoded_bank_transaction, decoded_calldata
+
+    def _decode_deposit_transaction(self, transaction_address: Optional):
+        """
+        Returns the transaction data used to invoke the smart contract function for the underlying contract
+        First fetches the transaction data for the HomoraBank.execute() function, then gets the transaction data
+        for the underlying smart contract
 
-        decoded_bank_transaction = self.vault.contract.decode_function_input(transaction.input)
+        :param transaction_address: The transaction address (binary or str)
+        :return: (
+            decoded bank function (ContractFunction, dict),
+            decoded spell function (ContractFunction, dict)
+        )
+        """
+        transaction = self.w3_provider.eth.get_transaction(transaction_address)
+        print(transaction)
 
-        # return decoded_bank_transaction
+        try:
+            decoded_bank_transaction = self.vault.contract.decode_function_input(transaction.input)
+        except:
+            decoded_bank_transaction = self.gateway.contract.decode_function_input(transaction.input)
 
-        encoded_contract_data = decoded_bank_transaction[1]['_data']
+        decoded_calldata = decode_abi(
+            ["uint256"],
+            decoded_bank_transaction[1]['_data']
+        )
 
-        return decoded_bank_transaction, self.gateway.contract.decode_function_input(encoded_contract_data)
+        return decoded_bank_transaction, decoded_calldata