@defisaver/sdk 1.0.0 → 1.0.2

package/esm/src/actions/compoundV3/CompoundV3PaybackAction.js

@@ -0,0 +1,48 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Action } from "../../Action";
+import { requireAddress } from "../../utils/general";
+import { getAddr } from '../../addresses';
+import { getAssetInfoByAddress } from "@defisaver/tokens";
+/**
+ * CompoundV3PaybackAction - Repays specified amount of base token
+ *
+ * @category CompundV3
+ */
+export class CompoundV3PaybackAction extends Action {
+    /**
+     * @param market Comet proxy address of the market
+     * @param amount amount of base token to be paid back
+     * @param from address from which funds are paid
+     * @param onBehalf address for which the funds are paid back
+     * @param asset address for which the funds are paid back
+     */
+    constructor(market, amount, from, onBehalf, asset) {
+        requireAddress(from);
+        requireAddress(onBehalf);
+        requireAddress(asset);
+        super('CompV3Payback', getAddr('CompV3Payback'), ['address', 'uint256', 'address', 'address'], [market, amount, from, onBehalf, asset].slice(0, 4));
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+        ];
+        this.tokenForApproval = asset;
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.tokenForApproval);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.tokenForApproval, owner: this.args[2] }];
+            return [];
+        });
+    }
+}

package/esm/src/actions/compoundV3/CompoundV3SupplyAction.d.ts

@@ -0,0 +1,22 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * CompoundV3SupplyAction - Supply specified amount of token (base or collateral)
+ *
+ * @category CompundV3
+ */
+export declare class CompoundV3SupplyAction extends Action {
+    tokenForApproval: EthAddress;
+    /**
+     * @param market Comet proxy address of the market
+     * @param tokenAddr
+     * @param amount wei amount of asset to supply
+     * @param from Address from where we're pulling the tokens
+     * @param onBehalf Address of the account we are supplying the tokens
+     */
+    constructor(market: EthAddress, tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/compoundV3/CompoundV3SupplyAction.js

@@ -0,0 +1,45 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Action } from "../../Action";
+import { getAddr } from '../../addresses';
+import { getAssetInfoByAddress } from "@defisaver/tokens";
+/**
+ * CompoundV3SupplyAction - Supply specified amount of token (base or collateral)
+ *
+ * @category CompundV3
+ */
+export class CompoundV3SupplyAction extends Action {
+    /**
+     * @param market Comet proxy address of the market
+     * @param tokenAddr
+     * @param amount wei amount of asset to supply
+     * @param from Address from where we're pulling the tokens
+     * @param onBehalf Address of the account we are supplying the tokens
+     */
+    constructor(market, tokenAddr, amount, from, onBehalf) {
+        super('CompV3Supply', getAddr('CompV3Supply'), ['address', 'address', 'uint256', 'address', 'address'], [market, tokenAddr, amount, from, onBehalf]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4]
+        ];
+        this.tokenForApproval = tokenAddr;
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.tokenForApproval);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.tokenForApproval, owner: this.args[1] }];
+            return [];
+        });
+    }
+}

package/esm/src/actions/compoundV3/CompoundV3TransferAction.d.ts

@@ -0,0 +1,17 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * CompoundV3TransferAction - Transfer specified amount of assets from src address to dst
+ *
+ * @category CompundV3
+ */
+export declare class CompoundV3TransferAction extends Action {
+    /**
+     * @param market Comet proxy address of the market
+     * @param from address of src
+     * @param to address of dst
+     * @param asset address of ERC20 token
+     * @param amount amount of assets to be transferred
+     */
+    constructor(market: EthAddress, from: EthAddress, to: EthAddress, asset: EthAddress, amount: uint256);
+}

package/esm/src/actions/compoundV3/CompoundV3TransferAction.js

@@ -0,0 +1,30 @@
+import { Action } from "../../Action";
+import { requireAddress } from "../../utils/general";
+import { getAddr } from '../../addresses';
+/**
+ * CompoundV3TransferAction - Transfer specified amount of assets from src address to dst
+ *
+ * @category CompundV3
+ */
+export class CompoundV3TransferAction extends Action {
+    /**
+     * @param market Comet proxy address of the market
+     * @param from address of src
+     * @param to address of dst
+     * @param asset address of ERC20 token
+     * @param amount amount of assets to be transferred
+     */
+    constructor(market, from, to, asset, amount) {
+        requireAddress(from);
+        requireAddress(to);
+        requireAddress(asset);
+        super('CompV3Transfer', getAddr('CompV3Transfer'), ['address', 'address', 'address', 'address', 'uint256'], [market, from, to, asset, amount]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+        ];
+    }
+}

package/esm/src/actions/compoundV3/CompoundV3WithdrawAction.d.ts

@@ -0,0 +1,17 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * CompoundV3WithdrawAction - Withdraw token from an Compound position
+ *
+ * @category CompundV3
+ */
+export declare class CompoundV3WithdrawAction extends Action {
+    /**
+     * @param market Comet proxy address of the market
+     * @param to Address where we are sending the tokens
+     * @param asset Address of asset to withdraw
+     * @param amount Wei amount in specified asset
+     * @param onBehalf Address from where we are withdrawing the tokens
+     */
+    constructor(market: EthAddress, to: EthAddress, asset: EthAddress, amount: uint256, onBehalf: EthAddress);
+}

package/esm/src/actions/compoundV3/CompoundV3WithdrawAction.js

@@ -0,0 +1,29 @@
+import { Action } from "../../Action";
+import { requireAddress } from "../../utils/general";
+import { getAddr } from "../../addresses";
+/**
+ * CompoundV3WithdrawAction - Withdraw token from an Compound position
+ *
+ * @category CompundV3
+ */
+export class CompoundV3WithdrawAction extends Action {
+    /**
+     * @param market Comet proxy address of the market
+     * @param to Address where we are sending the tokens
+     * @param asset Address of asset to withdraw
+     * @param amount Wei amount in specified asset
+     * @param onBehalf Address from where we are withdrawing the tokens
+     */
+    constructor(market, to, asset, amount, onBehalf) {
+        requireAddress(to);
+        requireAddress(asset);
+        super("CompV3Withdraw", getAddr("CompV3Withdraw"), ["address", "address", "address", "uint256", "address"], [market, to, asset, amount, onBehalf]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+        ];
+    }
+}

package/esm/src/actions/compoundV3/index.d.ts

@@ -0,0 +1,7 @@
+export * from './CompoundV3SupplyAction';
+export * from './CompoundV3BorrowAction';
+export * from './CompoundV3PaybackAction';
+export * from './CompoundV3WithdrawAction';
+export * from './CompoundV3ClaimAction';
+export * from './CompoundV3AllowAction';
+export * from './CompoundV3TransferAction';

package/esm/src/actions/compoundV3/index.js

@@ -0,0 +1,7 @@
+export * from './CompoundV3SupplyAction';
+export * from './CompoundV3BorrowAction';
+export * from './CompoundV3PaybackAction';
+export * from './CompoundV3WithdrawAction';
+export * from './CompoundV3ClaimAction';
+export * from './CompoundV3AllowAction';
+export * from './CompoundV3TransferAction';

package/esm/src/actions/convex/ConvexClaimAction.d.ts

@@ -0,0 +1,17 @@
+import { Action } from '../../Action';
+import { EthAddress } from '../../types';
+/**
+ * ConvexClaimAction - Claims convex rewards
+ *
+ * @category Convex
+ */
+export declare class ConvexClaimAction extends Action {
+    curveLp: EthAddress;
+    /**
+     * @param from
+     * @param to
+     * @param curveLp
+     */
+    constructor(from: EthAddress, to: EthAddress, curveLp: EthAddress);
+    getAssetsToApprove(): Promise<any>;
+}

package/esm/src/actions/convex/ConvexClaimAction.js

@@ -0,0 +1,59 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { getConvexPool } from '../../utils/convex-utils';
+import { requireAddress } from '../../utils/general';
+/**
+ * ConvexClaimAction - Claims convex rewards
+ *
+ * @category Convex
+ */
+export class ConvexClaimAction extends Action {
+    /**
+     * @param from
+     * @param to
+     * @param curveLp
+     */
+    constructor(from, to, curveLp) {
+        requireAddress(to);
+        const convexPool = getConvexPool(curveLp);
+        const crvRewards = convexPool.crvRewards;
+        super('ConvexClaim', getAddr('ConvexClaim'), [
+            'address',
+            'address',
+            'address',
+        ], [
+            from,
+            to,
+            crvRewards,
+        ]);
+        this.curveLp = curveLp;
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = getConvexPool(this.curveLp);
+            const owner = this.args[0];
+            return [
+                getAddr('CrvToken'),
+                getAddr('CvxToken'),
+            ].concat(pool.extraRewards.map((e) => e.token)).reduce((acc, e) => {
+                if (!acc.includes(e.toLowerCase()))
+                    acc.push(e.toLowerCase());
+                return acc;
+            }, []).map((e) => Object({ asset: e, owner }));
+        });
+    }
+}

package/esm/src/actions/convex/ConvexDepositAction.d.ts

@@ -0,0 +1,22 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, uint8 } from '../../types';
+/**
+ * ConvexDepositAction - Deposits (wraps) Curve LP into convex, stakes wrapped LP, or does both
+ *
+ * @category Convex
+ */
+export declare class ConvexDepositAction extends Action {
+    curveLp: EthAddress;
+    /**
+     * @param from
+     * @param to
+     * @param curveLp
+     * @param amount
+     * @param option
+     */
+    constructor(from: EthAddress, to: EthAddress, curveLp: EthAddress, amount: uint256, option: uint8);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/convex/ConvexDepositAction.js

@@ -0,0 +1,66 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { DepositOption, getConvexPool } from '../../utils/convex-utils';
+import { requireAddress } from '../../utils/general';
+/**
+ * ConvexDepositAction - Deposits (wraps) Curve LP into convex, stakes wrapped LP, or does both
+ *
+ * @category Convex
+ */
+export class ConvexDepositAction extends Action {
+    /**
+     * @param from
+     * @param to
+     * @param curveLp
+     * @param amount
+     * @param option
+     */
+    constructor(from, to, curveLp, amount, option) {
+        requireAddress(to);
+        const convexPool = getConvexPool(curveLp);
+        const pid = convexPool.pid;
+        super('ConvexDeposit', getAddr('ConvexDeposit'), [
+            'address',
+            'address',
+            'uint256',
+            'uint256',
+            'uint8',
+        ], [
+            from,
+            to,
+            pid,
+            amount,
+            option,
+        ]);
+        this.curveLp = curveLp;
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = getConvexPool(this.curveLp);
+            const assetToPull = {
+                [DepositOption.WRAP]: pool.lpToken,
+                [DepositOption.STAKE]: pool.token,
+                [DepositOption.WRAP_AND_STAKE]: pool.lpToken,
+            };
+            return [{
+                    asset: assetToPull[this.args[4]], owner: this.args[0],
+                }];
+        });
+    }
+}

package/esm/src/actions/convex/ConvexWithdrawAction.d.ts

@@ -0,0 +1,22 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, uint8 } from '../../types';
+/**
+ * ConvexWithdrawAction - Withdraws (unwraps) Curve LP from convex, unstakes wrapped LP, or does both
+ *
+ * @category Convex
+ */
+export declare class ConvexWithdrawAction extends Action {
+    curveLp: EthAddress;
+    /**
+     * @param from
+     * @param to
+     * @param curveLp
+     * @param amount
+     * @param option
+     */
+    constructor(from: EthAddress, to: EthAddress, curveLp: EthAddress, amount: uint256, option: uint8);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/convex/ConvexWithdrawAction.js

@@ -0,0 +1,63 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { getConvexPool, WithdrawOption } from '../../utils/convex-utils';
+import { requireAddress } from '../../utils/general';
+/**
+ * ConvexWithdrawAction - Withdraws (unwraps) Curve LP from convex, unstakes wrapped LP, or does both
+ *
+ * @category Convex
+ */
+export class ConvexWithdrawAction extends Action {
+    /**
+     * @param from
+     * @param to
+     * @param curveLp
+     * @param amount
+     * @param option
+     */
+    constructor(from, to, curveLp, amount, option) {
+        requireAddress(to);
+        const convexPool = getConvexPool(curveLp);
+        const pid = convexPool.pid;
+        super('ConvexWithdraw', getAddr('ConvexWithdraw'), [
+            'address',
+            'address',
+            'uint256',
+            'uint256',
+            'uint8',
+        ], [
+            from,
+            to,
+            pid,
+            amount,
+            option,
+        ]);
+        this.curveLp = curveLp;
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = getConvexPool(this.curveLp);
+            const owner = this.args[0];
+            if (this.args[4] === WithdrawOption.UNWRAP) {
+                return [{ asset: pool.token, owner }];
+            }
+            return [];
+        });
+    }
+}

package/esm/src/actions/convex/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ConvexDepositAction';
+export * from './ConvexWithdrawAction';
+export * from './ConvexClaimAction';

package/esm/src/actions/convex/index.js

@@ -0,0 +1,3 @@
+export * from './ConvexDepositAction';
+export * from './ConvexWithdrawAction';
+export * from './ConvexClaimAction';

package/esm/src/actions/curve/CurveClaimFeesAction.d.ts

@@ -0,0 +1,13 @@
+import { Action } from '../../Action';
+import { EthAddress } from '../../types';
+/**
+ * @category Curve
+ */
+export declare class CurveClaimFeesAction extends Action {
+    /**
+     *
+     * @param claimFor
+     * @param receiver
+     */
+    constructor(claimFor: EthAddress, receiver: EthAddress);
+}

package/esm/src/actions/curve/CurveClaimFeesAction.js

@@ -0,0 +1,22 @@
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
+import { getAddr } from '../../addresses';
+/**
+ * @category Curve
+ */
+export class CurveClaimFeesAction extends Action {
+    /**
+     *
+     * @param claimFor
+     * @param receiver
+     */
+    constructor(claimFor, receiver) {
+        requireAddress(claimFor);
+        requireAddress(receiver);
+        super('CurveClaimFeesAction', getAddr('CurveClaimFeesAction'), ['address', 'address'], [claimFor, receiver]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+        ];
+    }
+}

package/esm/src/actions/curve/CurveDepositAction.d.ts

@@ -0,0 +1,18 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * @category Curve
+ */
+export declare class CurveDepositAction extends Action {
+    tokensForApproval: Array<EthAddress>;
+    /**
+     * @param sender
+     * @param receiver
+     * @param poolAddr
+     * @param minMintAmount
+     * @param useUnderlying
+     * @param amounts
+     */
+    constructor(sender: EthAddress, receiver: EthAddress, poolAddr: EthAddress, minMintAmount: uint256, useUnderlying: boolean, amounts?: Array<uint256>);
+    getAssetsToApprove(): Promise<any[]>;
+}

package/esm/src/actions/curve/CurveDepositAction.js

@@ -0,0 +1,78 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getAssetInfo } from '@defisaver/tokens';
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
+import { getAddr } from '../../addresses';
+import { poolInfo, makeFlags } from '../../utils/curve-utils';
+/**
+ * @category Curve
+ */
+export class CurveDepositAction extends Action {
+    /**
+     * @param sender
+     * @param receiver
+     * @param poolAddr
+     * @param minMintAmount
+     * @param useUnderlying
+     * @param amounts
+     */
+    constructor(sender, receiver, poolAddr, minMintAmount, useUnderlying, amounts = []) {
+        requireAddress(sender);
+        requireAddress(receiver);
+        let depositTarget;
+        let depositTargetType = 0;
+        let explicitUnderlying = false;
+        let tokensForApproval;
+        const pool = poolInfo.find((e) => e.swapAddr.toLowerCase() === poolAddr.toLowerCase());
+        if (useUnderlying) {
+            if (pool.depositContract) {
+                depositTarget = pool.depositContract;
+                depositTargetType = pool.zapType + 1;
+            }
+            else {
+                depositTarget = pool.swapAddr;
+                explicitUnderlying = pool.underlyingFlag;
+                if (!explicitUnderlying)
+                    throw Error('pool has no underlying deposit mechanism');
+            }
+            tokensForApproval = pool.underlyingCoins;
+        }
+        else {
+            depositTarget = pool.swapAddr;
+            tokensForApproval = pool.coins;
+        }
+        super('CurveDeposit', getAddr('CurveDeposit'), ['address', 'address', 'address', 'uint256', 'uint8', 'uint256[]'], [
+            sender,
+            receiver,
+            depositTarget,
+            minMintAmount,
+            makeFlags(depositTargetType, explicitUnderlying, 0),
+            amounts,
+        ]);
+        this.tokensForApproval = tokensForApproval;
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+            ...this.args[5],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.tokensForApproval.map((e) => Object({
+                asset: e.toLowerCase() !== getAssetInfo('ETH').address.toLowerCase() ? e : getAssetInfo('WETH').address,
+                owner: this.args[0],
+            }));
+        });
+    }
+}

package/esm/src/actions/curve/CurveGaugeDepositAction.d.ts

@@ -0,0 +1,20 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * @category Curve
+ */
+export declare class CurveGaugeDepositAction extends Action {
+    /**
+     *
+     * @param gaugeAddr
+     * @param lpToken
+     * @param sender
+     * @param onBehalfOf
+     * @param amount
+     */
+    constructor(gaugeAddr: EthAddress, lpToken: EthAddress, sender: EthAddress, onBehalfOf: EthAddress, amount: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}