@dripfi/drip-sdk 1.4.9 → 1.4.10

package/dist/abi/ERC20.json

@@ -0,0 +1,222 @@
+[
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_spender",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_from",
+                "type": "address"
+            },
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "name": "_owner",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "name": "balance",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "name": "_owner",
+                "type": "address"
+            },
+            {
+                "name": "_spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "payable": true,
+        "stateMutability": "payable",
+        "type": "fallback"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    }
+]

package/dist/contracts/ERC20TokenContract.d.ts

@@ -0,0 +1,10 @@
+import { BigNumber, BigNumberish, ethers, Signer } from 'ethers';
+export default class ERC20TokenContract {
+    address: string;
+    contract: ethers.Contract;
+    constructor(address: string, signer: Signer);
+    getPrecission(): Promise<number>;
+    getAllowance(owner: string, spender: string): Promise<BigNumber>;
+    approveToken(spender: string, parsedAmount: BigNumberish): Promise<string>;
+    transfer(receiver: string, parsedAmount: string): Promise<string>;
+}

package/dist/contracts/ERC20TokenContract.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const ERC20_json_1 = __importDefault(require("../abi/ERC20.json"));
+class ERC20TokenContract {
+    address;
+    contract;
+    constructor(address, signer) {
+        this.address = address;
+        this.contract = new ethers_1.ethers.Contract(address, ERC20_json_1.default, signer);
+    }
+    async getPrecission() {
+        const decimals = await this.contract.decimals();
+        return decimals;
+    }
+    async getAllowance(owner, spender) {
+        const allowance = await this.contract.allowance(owner, spender);
+        return allowance;
+    }
+    async approveToken(spender, parsedAmount) {
+        const tx = await this.contract.approve(spender, parsedAmount);
+        const txHash = (await tx.wait()).hash;
+        return txHash;
+    }
+    async transfer(receiver, parsedAmount) {
+        const tx = await this.contract.transfer(receiver, parsedAmount);
+        const txHash = (await tx.wait()).hash;
+        return txHash;
+    }
+}
+exports.default = ERC20TokenContract;

package/dist/contracts/PerqSwapAndRecyclerContract.d.ts

@@ -1,7 +1,8 @@
-import { ContractTransaction, ethers } from 'ethers';
+import { ContractTransaction } from 'ethers';
 import BasePerqContract from './BasePerqContract';
+import PerqSdk from '../PerqSdk';
 export default class PerqSwapAndRecyclerContract extends BasePerqContract {
-    constructor(address: string, signer?: ethers.Signer);
+    constructor(perqSdk: PerqSdk);
     swapAndRecycle(beneficiary: string | undefined, path: string[], amountInWithDecimals: string, minAmountOutWithDecimals: string, price: string, deadline: string, signature: string): Promise<ContractTransaction>;
     swapETHAndRecycle(beneficiary: string | undefined, path: string[], minAmountOutWithDecimals: string, amountInEth: string, price: string, deadline: string, signature: string): Promise<ContractTransaction>;
 }

package/dist/contracts/PerqSwapAndRecyclerContract.js

@@ -7,8 +7,8 @@ const ethers_1 = require("ethers");
 const PerqSwapAndRecyclerAbi_json_1 = __importDefault(require("../abi/PerqSwapAndRecyclerAbi.json"));
 const BasePerqContract_1 = __importDefault(require("./BasePerqContract"));
 class PerqSwapAndRecyclerContract extends BasePerqContract_1.default {
-    constructor(address, signer) {
-        super(address, new ethers_1.ethers.utils.Interface(PerqSwapAndRecyclerAbi_json_1.default), signer);
+    constructor(perqSdk) {
+        super(perqSdk.perqConfig.perqSwapAndRecyclerAddress, new ethers_1.ethers.utils.Interface(PerqSwapAndRecyclerAbi_json_1.default), perqSdk.signer);
     }
     async swapAndRecycle(beneficiary = ethers_1.ethers.constants.AddressZero, path, amountInWithDecimals, minAmountOutWithDecimals, price, deadline, signature) {
         if (!this.contract.signer) {

package/dist/contracts/PerqTokenRecyclerContract.d.ts

@@ -1,6 +1,7 @@
-import { ContractTransaction, ethers } from 'ethers';
+import { ContractTransaction } from 'ethers';
 import BasePerqContract from './BasePerqContract';
+import PerqSdk from '../PerqSdk';
 export default class PerqTokenRecyclerContract extends BasePerqContract {
-    constructor(address: string, signer?: ethers.Signer);
+    constructor(perqSdk: PerqSdk);
     recycle(amountToRecycle: string, beneficiary: string | undefined, price: string, deadline: string, signature: string): Promise<ContractTransaction>;
 }

package/dist/contracts/PerqTokenRecyclerContract.js

@@ -7,8 +7,8 @@ const ethers_1 = require("ethers");
 const TokenRecyclerAbi_json_1 = __importDefault(require("../abi/TokenRecyclerAbi.json"));
 const BasePerqContract_1 = __importDefault(require("./BasePerqContract"));
 class PerqTokenRecyclerContract extends BasePerqContract_1.default {
-    constructor(address, signer) {
-        super(address, new ethers_1.ethers.utils.Interface(TokenRecyclerAbi_json_1.default), signer);
+    constructor(perqSdk) {
+        super(perqSdk.perqConfig.perqTokenRecyclerAddress, new ethers_1.ethers.utils.Interface(TokenRecyclerAbi_json_1.default), perqSdk.signer);
     }
     async recycle(amountToRecycle, beneficiary = ethers_1.ethers.constants.AddressZero, price, deadline, signature) {
         if (!this.contract.signer) {

package/dist/contracts/PerqVestingContract.d.ts

@@ -1,7 +1,8 @@
-import { BigNumber, ContractTransaction, ethers } from 'ethers';
+import { BigNumber, ContractTransaction } from 'ethers';
 import BasePerqContract from './BasePerqContract';
+import PerqSdk from '../PerqSdk';
 export default class PerqVestingContract extends BasePerqContract {
-    constructor(address: string, signer?: ethers.Signer);
+    constructor(perqSdk: PerqSdk);
     start(): Promise<BigNumber>;
     end(): Promise<BigNumber>;
     vested(beneficiary: string): Promise<BigNumber>;

package/dist/contracts/PerqVestingContract.js

@@ -7,8 +7,8 @@ const ethers_1 = require("ethers");
 const PerqVestingAbi_json_1 = __importDefault(require("../abi/PerqVestingAbi.json"));
 const BasePerqContract_1 = __importDefault(require("./BasePerqContract"));
 class PerqVestingContract extends BasePerqContract_1.default {
-    constructor(address, signer) {
-        super(address, new ethers_1.ethers.utils.Interface(PerqVestingAbi_json_1.default), signer);
+    constructor(perqSdk) {
+        super(perqSdk.perqConfig.perqVestingAddress, new ethers_1.ethers.utils.Interface(PerqVestingAbi_json_1.default), perqSdk.signer);
     }
     async start() {
         if (!this.contract.signer) {

package/dist/subpackages/LitePackage.d.ts

@@ -0,0 +1,16 @@
+import PerqSdk from '../PerqSdk';
+import MigrationOption from '../types/MigrationOption';
+export default class LitePackage {
+    perqSdk: PerqSdk;
+    constructor(perqSdk: PerqSdk);
+    private validateChain;
+    deposit(tokenAddress: string, vaultAddress: string, onChainProjectId: number, amount: string): Promise<string>;
+    getSwapAndDepositAllowance(tokenAddress: string): Promise<string>;
+    approveSwapAndDeposit(tokenAddress: string, amount: string): Promise<string>;
+    swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, amount: string, vaultAddress: string, onChainProjectId: number): Promise<string>;
+    withdraw(tokenAddress: string, vaultAddress: string, onChainProjectId: number, amount: string): Promise<string>;
+    wrapAndDepositEth(vaultAddress: string, onChainProjectId: number, amount: string): Promise<any>;
+    getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number): Promise<string>;
+    getMigrationOptions(vaultAddress: string, onChainProjectId: number): Promise<MigrationOption[]>;
+    migrateDepositToOtherProject(tokenAddress: string, vaultAddress: string, fromProjectId: number, toProjectId: number, amount: string): Promise<string>;
+}

package/dist/subpackages/LitePackage.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const ERC20TokenContract_1 = __importDefault(require("../contracts/ERC20TokenContract"));
+const ChainId_1 = require("../types/ChainId");
+const WETH_DECIMAL_PRECISION = 18;
+class LitePackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async validateChain(signer, vaultAddress, onChainProjectId) {
+        const vault = await this.perqSdk.perqApi.fetchPoolLiteDetails(vaultAddress, onChainProjectId);
+        const currentChainId = await signer.getChainId();
+        if (vault.chainId !== currentChainId) {
+            throw Error(`Wrong chain, current chain: ${currentChainId} does not match vault chain: ${vault.chainId}`);
+        }
+    }
+    async deposit(tokenAddress, vaultAddress, onChainProjectId, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        this.validateChain(this.perqSdk.signer, vaultAddress, onChainProjectId);
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmountToDeposit = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        const res = await this.perqSdk.yelayLiteSdk.vaults.deposit(vaultAddress, onChainProjectId, BigInt(parsedAmountToDeposit.toString()));
+        return res.hash;
+    }
+    async getSwapAndDepositAllowance(tokenAddress) {
+        const res = await this.perqSdk.yelayLiteSdk.vaults.vaultWrapperAllowance(tokenAddress);
+        return res.toString();
+    }
+    async approveSwapAndDeposit(tokenAddress, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmountToApprove = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        const res = await this.perqSdk.yelayLiteSdk.vaults.approveVaultWrapper(tokenAddress, parsedAmountToApprove.toBigInt());
+        return res.hash;
+    }
+    async swapAndDeposit(fromTokenAddress, toTokenAddress, amount, vaultAddress, onChainProjectId) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        this.validateChain(this.perqSdk.signer, vaultAddress, onChainProjectId);
+        const tokenContract = new ERC20TokenContract_1.default(fromTokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmountToSwapAndDeposit = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        const swapInfo = await this.perqSdk.perqApi.getSwapInfo(fromTokenAddress, toTokenAddress, parsedAmountToSwapAndDeposit, this.perqSdk.yelayLiteSdk.swapperAddress, ChainId_1.BASE_CHAIN_ID);
+        const swapArgsStruct = {
+            tokenIn: swapInfo[0].token,
+            swapTarget: swapInfo[0].swapTarget,
+            swapCallData: swapInfo[0].swapCallData,
+        };
+        const res = await this.perqSdk.yelayLiteSdk.vaults.swapAndDeposit(vaultAddress.toLowerCase(), onChainProjectId, parsedAmountToSwapAndDeposit.toBigInt(), swapArgsStruct);
+        return res.hash;
+    }
+    async withdraw(tokenAddress, vaultAddress, onChainProjectId, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        this.validateChain(this.perqSdk.signer, vaultAddress, onChainProjectId);
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmountToWithdraw = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        const res = await this.perqSdk.yelayLiteSdk.vaults.redeem(vaultAddress, onChainProjectId, BigInt(parsedAmountToWithdraw.toString()));
+        return res.hash;
+    }
+    async wrapAndDepositEth(vaultAddress, onChainProjectId, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        this.validateChain(this.perqSdk.signer, vaultAddress, onChainProjectId);
+        const parsedAmount = ethers_1.ethers.utils.parseUnits(amount, WETH_DECIMAL_PRECISION);
+        const res = await this.perqSdk.yelayLiteSdk.vaults.depositEth(vaultAddress, onChainProjectId, BigInt(parsedAmount.toString()));
+        return res.hash;
+    }
+    async getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals) {
+        return this.perqSdk.perqApi.getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals, ChainId_1.BASE_CHAIN_ID.toString());
+    }
+    async getMigrationOptions(vaultAddress, onChainProjectId) {
+        return this.perqSdk.perqApi.fetchMigrationOptions(vaultAddress, onChainProjectId);
+    }
+    async migrateDepositToOtherProject(tokenAddress, vaultAddress, fromProjectId, toProjectId, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        this.validateChain(this.perqSdk.signer, vaultAddress, fromProjectId);
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmountToDeposit = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        const res = await this.perqSdk.yelayLiteSdk.vaults.migrate(vaultAddress, fromProjectId, toProjectId, BigInt(parsedAmountToDeposit.toString()));
+        return res.hash;
+    }
+}
+exports.default = LitePackage;

package/dist/subpackages/LoyaltyCardsPackage.d.ts

@@ -0,0 +1,12 @@
+import { BeansBalance, BeanEntry, PerqToBeansSwapInfo, LoyaltyCard } from '../types';
+import PerqSdk from '../PerqSdk';
+export default class LoyaltyPackage {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getBeansBalance(): Promise<BeansBalance>;
+    getBeansHistory(): Promise<BeanEntry[]>;
+    getSwapPerqForBeansInfo(): Promise<PerqToBeansSwapInfo>;
+    upgradeLoyaltyCard(index: number): Promise<LoyaltyCard>;
+    getOwnedLoyaltyCard(): Promise<LoyaltyCard>;
+    getAllLoyaltyCards(): Promise<LoyaltyCard[]>;
+}

package/dist/subpackages/LoyaltyCardsPackage.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class LoyaltyPackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getBeansBalance() {
+        const userAddress = await this.perqSdk.signer.getAddress();
+        return this.perqSdk.perqApi.fetchBeansBalance(userAddress);
+    }
+    async getBeansHistory() {
+        const userAddress = await this.perqSdk.signer.getAddress();
+        return this.perqSdk.perqApi.fetchBeansHistory(userAddress);
+    }
+    async getSwapPerqForBeansInfo() {
+        return this.perqSdk.perqApi.getSwapPerqForBeansInfo();
+    }
+    async upgradeLoyaltyCard(index) {
+        const payload = {
+            index,
+        };
+        const signedPayload = await this.perqSdk.signHandler.signPayload(payload);
+        return this.perqSdk.perqApi.upgradeLoyaltyCard(signedPayload);
+    }
+    async getOwnedLoyaltyCard() {
+        const signerAddress = await this.perqSdk.signer.getAddress();
+        return this.perqSdk.perqApi.fetchOwnedLoyaltyCard(signerAddress);
+    }
+    async getAllLoyaltyCards() {
+        return this.perqSdk.perqApi.fetchAllLoyaltyCards();
+    }
+}
+exports.default = LoyaltyPackage;

package/dist/subpackages/PoolsPackage.d.ts

@@ -0,0 +1,16 @@
+import PerqSdk from '../PerqSdk';
+import { DetailedProjectData, MyPerqData, ReducedProjectData, UserRewards, UserVaultBalance, VaultData, VaultStats } from '../types';
+export default class PoolsPackage {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getUserPoolBalance(vaultAddress: string, onChainProjectId: number): Promise<UserVaultBalance>;
+    getAllPools(): Promise<VaultData[]>;
+    getMyPerqBalance(): Promise<MyPerqData[]>;
+    getPoolDetails(vaultAddress: string, onChainProjectId: number): Promise<VaultData>;
+    getAllProjects(): Promise<ReducedProjectData[]>;
+    getProjectDetails(projectName: string): Promise<DetailedProjectData>;
+    getPoolStats(): Promise<VaultStats>;
+    getRewardsPerHour(vaultAddress: string): Promise<number>;
+    getUserBoostedNfts(vaultAddress: string): Promise<string[]>;
+    getRewards(): Promise<UserRewards>;
+}

package/dist/subpackages/PoolsPackage.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PoolsPackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getUserPoolBalance(vaultAddress, onChainProjectId) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const userAddress = await this.perqSdk.signer.getAddress();
+        return await this.perqSdk.perqApi.fetchLitePoolUserBalance(userAddress.toLowerCase(), vaultAddress.toLowerCase(), onChainProjectId);
+    }
+    async getAllPools() {
+        return this.perqSdk.perqApi.fetchAllPools();
+    }
+    async getMyPerqBalance() {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const userAddress = await this.perqSdk.signer.getAddress();
+        const myPerqBalance = this.perqSdk.perqApi.fetchMyPerqData(userAddress);
+        return myPerqBalance;
+    }
+    async getPoolDetails(vaultAddress, onChainProjectId) {
+        return this.perqSdk.perqApi.fetchPoolLiteDetails(vaultAddress, onChainProjectId);
+    }
+    async getAllProjects() {
+        return this.perqSdk.perqApi.fetchAllProjects();
+    }
+    async getProjectDetails(projectName) {
+        return this.perqSdk.perqApi.fetchProjetctDetails(projectName);
+    }
+    async getPoolStats() {
+        return this.perqSdk.perqApi.fetchPoolStats();
+    }
+    async getRewardsPerHour(vaultAddress) {
+        const userAddress = await this.perqSdk.signer.getAddress();
+        return this.perqSdk.perqApi.fetchRewardsPerHour(userAddress, vaultAddress);
+    }
+    async getUserBoostedNfts(vaultAddress) {
+        const userAddress = await this.perqSdk.signer.getAddress();
+        return this.perqSdk.perqApi.getUserBoostedNfts(userAddress, vaultAddress);
+    }
+    async getRewards() {
+        const userAddress = await this.perqSdk.signer.getAddress();
+        const userRewards = this.perqSdk.perqApi.fetchUserRewards(userAddress);
+        return userRewards;
+    }
+}
+exports.default = PoolsPackage;

package/dist/subpackages/RecyclerPackage.d.ts

@@ -0,0 +1,13 @@
+import { BigNumber } from 'ethers';
+import PerqSdk from '../PerqSdk';
+export default class RecyclerPackage {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getTokenAllowanceForRecycler(tokenAddress: string): Promise<BigNumber>;
+    getTokenAllowanceForSwapAndRecycler(tokenAddress: string): Promise<BigNumber>;
+    recycleTokens(tokenAddress: string | undefined, amountToRecycle: string, beneficiary: string | undefined, price: string, deadline: string, signature: string): Promise<string>;
+    swapAndRecycleETH(beneficiary: string, path: string[], minAmountOutWithDecimals: string, amountOfEth: string, price: string, deadline: string, signature: string): Promise<string>;
+    swapAndRecycleERC20(beneficiary: string, path: string[], minAmountOutWithDecimals: string, amountInWithDecimals: string, price: string, deadline: string, signature: string): Promise<string>;
+    approveTokenForRecycler(tokenAddress: string, amount: string): Promise<string>;
+    approveTokenForSwapAndRecycler(tokenAddress: string, amount: string): Promise<string>;
+}