@defisaver/sdk 1.0.0 → 1.0.2

package/esm/src/actions/reflexer/ReflexerSupplyAction.js

@@ -0,0 +1,44 @@
+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 { tokenFromJoin, getAssetInfo } from "@defisaver/tokens";
+import { getAddr } from '../../addresses';
+/**
+ * ReflexerSupplyAction - Supply token to a Safe
+ *
+ * @category Reflexer
+ */
+export class ReflexerSupplyAction extends Action {
+    /**
+     * @param safeId
+     * @param amount
+     * @param adapterAddr
+     * @param from Tokens will be supplied from this address
+     */
+    constructor(safeId, amount, adapterAddr, from) {
+        super('ReflexerSupply', getAddr('ReflexerSupply'), ['uint256', 'uint256', 'address', 'address'], [safeId, amount, adapterAddr, from]);
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = tokenFromJoin(this.args[2]);
+            if (asset !== 'ETH')
+                return [{ asset: getAssetInfo(asset).address, owner: this.args[3] }];
+            return [];
+        });
+    }
+    getEthValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = tokenFromJoin(this.args[2]);
+            if (asset === 'ETH')
+                return this.args[1];
+            return '0';
+        });
+    }
+}

package/esm/src/actions/reflexer/ReflexerWithdrawAction.d.ts

@@ -0,0 +1,16 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * ReflexerWithdrawAction - Withdraw token from a Safe
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerWithdrawAction extends Action {
+    /**
+     * @param safeId
+     * @param amount
+     * @param adapterAddr
+     * @param to
+     */
+    constructor(safeId: uint256, amount: uint256, adapterAddr: EthAddress, to: EthAddress);
+}

package/esm/src/actions/reflexer/ReflexerWithdrawAction.js

@@ -0,0 +1,20 @@
+import { Action } from "../../Action";
+import { requireAddress } from "../../utils/general";
+import { getAddr } from '../../addresses';
+/**
+ * ReflexerWithdrawAction - Withdraw token from a Safe
+ *
+ * @category Reflexer
+ */
+export class ReflexerWithdrawAction extends Action {
+    /**
+     * @param safeId
+     * @param amount
+     * @param adapterAddr
+     * @param to
+     */
+    constructor(safeId, amount, adapterAddr, to) {
+        requireAddress(to);
+        super('ReflexerWithdraw', getAddr('ReflexerWithdraw'), ['uint256', 'uint256', 'address', 'address'], [safeId, amount, adapterAddr, to]);
+    }
+}

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

@@ -0,0 +1,8 @@
+export * from './ReflexerOpenSafeAction';
+export * from './ReflexerGenerateAction';
+export * from './ReflexerSupplyAction';
+export * from './ReflexerPaybackAction';
+export * from './ReflexerWithdrawAction';
+export * from './ReflexerNativeUniV2SaviourDepositAction';
+export * from './ReflexerNativeUniV2SaviourWithdrawAction';
+export * from './ReflexerNativeUniV2SaviourGetReservesAction';

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

@@ -0,0 +1,8 @@
+export * from './ReflexerOpenSafeAction';
+export * from './ReflexerGenerateAction';
+export * from './ReflexerSupplyAction';
+export * from './ReflexerPaybackAction';
+export * from './ReflexerWithdrawAction';
+export * from './ReflexerNativeUniV2SaviourDepositAction';
+export * from './ReflexerNativeUniV2SaviourWithdrawAction';
+export * from './ReflexerNativeUniV2SaviourGetReservesAction';

package/esm/src/actions/uniswap/UniswapSupplyAction.d.ts

@@ -0,0 +1,26 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * Supplies a pair tokens to uniswap pool
+ *
+ * @category Uniswap
+ */
+export declare class UniswapSupplyAction extends Action {
+    /**
+     * @param tokenA
+     * @param tokenB
+     * @param from
+     * @param to
+     * @param amountADesired
+     * @param amountBDesired
+     * @param amountAMin
+     * @param amountBMin
+     * @param deadline
+     */
+    constructor(tokenA: EthAddress, tokenB: EthAddress, from: EthAddress, to: EthAddress, amountADesired: uint256, amountBDesired: uint256, amountAMin: uint256, amountBMin: uint256, deadline: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+        specialApproveLabel: string;
+    }[]>;
+}

package/esm/src/actions/uniswap/UniswapSupplyAction.js

@@ -0,0 +1,65 @@
+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 { getAssetInfoByAddress } from "@defisaver/tokens";
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ * Supplies a pair tokens to uniswap pool
+ *
+ * @category Uniswap
+ */
+export class UniswapSupplyAction extends Action {
+    /**
+     * @param tokenA
+     * @param tokenB
+     * @param from
+     * @param to
+     * @param amountADesired
+     * @param amountBDesired
+     * @param amountAMin
+     * @param amountBMin
+     * @param deadline
+     */
+    constructor(tokenA, tokenB, from, to, amountADesired, amountBDesired, amountAMin, amountBMin, deadline) {
+        requireAddress(to);
+        super('UniSupply', getAddr('UniSupply'), [
+            "address",
+            "address",
+            "address",
+            "address",
+            "uint256",
+            "uint256",
+            "uint256",
+            "uint256",
+            "uint256",
+        ], [tokenA, tokenB, from, to, amountADesired, amountBDesired, amountAMin, amountBMin, deadline]);
+        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* () {
+            const assetA = getAssetInfoByAddress(this.args[0]);
+            const assetB = getAssetInfoByAddress(this.args[1]);
+            const approveArr = [];
+            if (assetA.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[0], owner: this.args[2], specialApproveLabel: 'uniswap v2' });
+            if (assetB.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[1], owner: this.args[2], specialApproveLabel: 'uniswap v2' });
+            return approveArr;
+        });
+    }
+}

package/esm/src/actions/uniswap/UniswapWithdrawAction.d.ts

@@ -0,0 +1,25 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * Withdraws liquidity from uniswap pool
+ *
+ * @category Uniswap
+ */
+export declare class UniswapWithdrawAction extends Action {
+    /**
+     * @param tokenA
+     * @param tokenB
+     * @param liquidity
+     * @param to
+     * @param from
+     * @param amountAMin
+     * @param amountBMin
+     * @param deadline
+     */
+    constructor(tokenA: EthAddress, tokenB: EthAddress, liquidity: uint256, to: EthAddress, from: EthAddress, amountAMin: uint256, amountBMin: uint256, deadline: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+        specialApproveLabel: string;
+    }[]>;
+}

package/esm/src/actions/uniswap/UniswapWithdrawAction.js

@@ -0,0 +1,56 @@
+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 { getPoolAddressByAddresses } from "../../utils/uniswapLP";
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ * Withdraws liquidity from uniswap pool
+ *
+ * @category Uniswap
+ */
+export class UniswapWithdrawAction extends Action {
+    /**
+     * @param tokenA
+     * @param tokenB
+     * @param liquidity
+     * @param to
+     * @param from
+     * @param amountAMin
+     * @param amountBMin
+     * @param deadline
+     */
+    constructor(tokenA, tokenB, liquidity, to, from, amountAMin, amountBMin, deadline) {
+        requireAddress(to);
+        super('UniWithdraw', getAddr('UniWithdraw'), [
+            "address",
+            "address",
+            "uint256",
+            "address",
+            "address",
+            "uint256",
+            "uint256",
+            "uint256",
+        ], [tokenA, tokenB, liquidity, to, from, amountAMin, amountBMin, deadline]);
+        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 lpAddress = getPoolAddressByAddresses(this.args[0], this.args[1]);
+            return [{ asset: lpAddress, owner: this.args[4], specialApproveLabel: 'uniswap v2' }];
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './UniswapSupplyAction';
+export * from './UniswapWithdrawAction';

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

@@ -0,0 +1,2 @@
+export * from './UniswapSupplyAction';
+export * from './UniswapWithdrawAction';

package/esm/src/actions/uniswapV3/UniswapV3CollectAction.d.ts

@@ -0,0 +1,24 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * Collects fees earned by user on position identified by tokenId
+ *
+ * @category UniswapV3
+ */
+export declare class UniswapV3CollectAction extends ActionWithL2 {
+    from: EthAddress;
+    /**
+     * @param tokenId
+     * @param recipient
+     * @param amount0Max
+     * @param amount1Max
+     * @param from
+     */
+    constructor(tokenId: uint256, recipient: EthAddress, amount0Max: uint256, amount1Max: uint256, from: EthAddress);
+    getAssetsToApprove(): Promise<{
+        nft: string;
+        tokenId: any;
+        owner: string;
+        specialApproveLabel: string;
+    }[]>;
+}

package/esm/src/actions/uniswapV3/UniswapV3CollectAction.js

@@ -0,0 +1,47 @@
+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 { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+/**
+ * Collects fees earned by user on position identified by tokenId
+ *
+ * @category UniswapV3
+ */
+export class UniswapV3CollectAction extends ActionWithL2 {
+    /**
+     * @param tokenId
+     * @param recipient
+     * @param amount0Max
+     * @param amount1Max
+     * @param from
+     */
+    constructor(tokenId, recipient, amount0Max, amount1Max, from) {
+        super('UniCollectV3', getAddr('UniCollectV3'), [
+            "uint256",
+            "address",
+            "uint128",
+            "uint128",
+        ], [tokenId, recipient, amount0Max, amount1Max]);
+        this.from = from;
+        this.mappableArgs = [
+            this.args[0],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{
+                    nft: getAddr('UniswapV3PositionManager'),
+                    tokenId: this.args[0],
+                    owner: this.from,
+                    specialApproveLabel: 'uniswap v3'
+                }];
+        });
+    }
+}

package/esm/src/actions/uniswapV3/UniswapV3CreatePoolAction.d.ts

@@ -0,0 +1,30 @@
+import { EthAddress, uint256, uint24, int24, uint160 } from '../../types';
+import { ActionWithL2 } from '../../ActionWithL2';
+/**
+ * Create a uniswap v3 pool
+ *
+ * @category UniswapV3
+ */
+export declare class UniswapV3CreatePoolAction extends ActionWithL2 {
+    /**
+     * @param token0
+     * @param token1
+     * @param fee
+     * @param tickLower
+     * @param tickUpper
+     * @param amount0Desired
+     * @param amount1Desired
+     * @param amount0Min
+     * @param amount1Min
+     * @param recipient
+     * @param deadline
+     * @param from
+     * @param sqrtPriceX96
+     */
+    constructor(token0: EthAddress, token1: EthAddress, fee: uint24, tickLower: int24, tickUpper: int24, amount0Desired: uint256, amount1Desired: uint256, amount0Min: uint256, amount1Min: uint256, recipient: EthAddress, deadline: uint256, from: EthAddress, sqrtPriceX96: uint160);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+        specialApproveLabel: string;
+    }[]>;
+}

package/esm/src/actions/uniswapV3/UniswapV3CreatePoolAction.js

@@ -0,0 +1,69 @@
+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 { getAssetInfoByAddress } from '@defisaver/tokens';
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ * Create a uniswap v3 pool
+ *
+ * @category UniswapV3
+ */
+export class UniswapV3CreatePoolAction extends ActionWithL2 {
+    /**
+     * @param token0
+     * @param token1
+     * @param fee
+     * @param tickLower
+     * @param tickUpper
+     * @param amount0Desired
+     * @param amount1Desired
+     * @param amount0Min
+     * @param amount1Min
+     * @param recipient
+     * @param deadline
+     * @param from
+     * @param sqrtPriceX96
+     */
+    constructor(token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, amount0Min, amount1Min, recipient, deadline, from, sqrtPriceX96) {
+        requireAddress(recipient);
+        super('UniCreatePoolV3', getAddr('UniCreatePoolV3'), [
+            "address",
+            "address",
+            "uint24",
+            "int24",
+            "int24",
+            "uint256",
+            "uint256",
+            "uint256",
+            "uint256",
+            "address",
+            "uint256",
+            "address",
+            "uint160",
+        ], [token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, amount0Min, amount1Min, recipient, deadline, from, sqrtPriceX96]);
+        this.mappableArgs = [
+            this.args[5],
+            this.args[6],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetA = getAssetInfoByAddress(this.args[0]);
+            const assetB = getAssetInfoByAddress(this.args[1]);
+            const approveArr = [];
+            if (assetA.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[0], owner: this.args[11], specialApproveLabel: 'uniswap v3' });
+            if (assetB.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[1], owner: this.args[11], specialApproveLabel: 'uniswap v3' });
+            return approveArr;
+        });
+    }
+}

package/esm/src/actions/uniswapV3/UniswapV3MintAction.d.ts

@@ -0,0 +1,29 @@
+import { EthAddress, uint256, uint24, int24 } from '../../types';
+import { ActionWithL2 } from '../../ActionWithL2';
+/**
+ * Creates a new Uniswap v3 LP supply position
+ *
+ * @category UniswapV3
+ */
+export declare class UniswapV3MintAction extends ActionWithL2 {
+    /**
+     * @param token0
+     * @param token1
+     * @param fee
+     * @param tickLower
+     * @param tickUpper
+     * @param amount0Desired
+     * @param amount1Desired
+     * @param amount0Min
+     * @param amount1Min
+     * @param recipient
+     * @param deadline
+     * @param from
+     */
+    constructor(token0: EthAddress, token1: EthAddress, fee: uint24, tickLower: int24, tickUpper: int24, amount0Desired: uint256, amount1Desired: uint256, amount0Min: uint256, amount1Min: uint256, recipient: EthAddress, deadline: uint256, from: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+        specialApproveLabel: string;
+    }[]>;
+}

package/esm/src/actions/uniswapV3/UniswapV3MintAction.js

@@ -0,0 +1,67 @@
+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 { getAssetInfoByAddress } from '@defisaver/tokens';
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ * Creates a new Uniswap v3 LP supply position
+ *
+ * @category UniswapV3
+ */
+export class UniswapV3MintAction extends ActionWithL2 {
+    /**
+     * @param token0
+     * @param token1
+     * @param fee
+     * @param tickLower
+     * @param tickUpper
+     * @param amount0Desired
+     * @param amount1Desired
+     * @param amount0Min
+     * @param amount1Min
+     * @param recipient
+     * @param deadline
+     * @param from
+     */
+    constructor(token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, amount0Min, amount1Min, recipient, deadline, from) {
+        requireAddress(recipient);
+        super('UniMintV3', getAddr('UniMintV3'), [
+            "address",
+            "address",
+            "uint24",
+            "int24",
+            "int24",
+            "uint256",
+            "uint256",
+            "uint256",
+            "uint256",
+            "address",
+            "uint256",
+            "address",
+        ], [token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, amount0Min, amount1Min, recipient, deadline, from]);
+        this.mappableArgs = [
+            this.args[5],
+            this.args[6],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetA = getAssetInfoByAddress(this.args[0]);
+            const assetB = getAssetInfoByAddress(this.args[1]);
+            const approveArr = [];
+            if (assetA.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[0], owner: this.args[11], specialApproveLabel: 'uniswap v3' });
+            if (assetB.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[1], owner: this.args[11], specialApproveLabel: 'uniswap v3' });
+            return approveArr;
+        });
+    }
+}

package/esm/src/actions/uniswapV3/UniswapV3SupplyAction.d.ts

@@ -0,0 +1,26 @@
+import { EthAddress, uint256 } from '../../types';
+import { ActionWithL2 } from '../../ActionWithL2';
+/**
+ * Supplies a pair of tokens to an existing Uniswap v3 position identified by tokenId
+ *
+ * @category UniswapV3
+ */
+export declare class UniswapV3SupplyAction extends ActionWithL2 {
+    /**
+     * @param tokenId
+     * @param amount0Desired
+     * @param amount1Desired
+     * @param amount0Min
+     * @param amount1Min
+     * @param deadline
+     * @param from
+     * @param token0
+     * @param token1
+     */
+    constructor(tokenId: uint256, amount0Desired: uint256, amount1Desired: uint256, amount0Min: uint256, amount1Min: uint256, deadline: uint256, from: EthAddress, token0: EthAddress, token1: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+        specialApproveLabel: string;
+    }[]>;
+}

package/esm/src/actions/uniswapV3/UniswapV3SupplyAction.js

@@ -0,0 +1,60 @@
+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 { getAssetInfoByAddress } from '@defisaver/tokens';
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+/**
+ * Supplies a pair of tokens to an existing Uniswap v3 position identified by tokenId
+ *
+ * @category UniswapV3
+ */
+export class UniswapV3SupplyAction extends ActionWithL2 {
+    /**
+     * @param tokenId
+     * @param amount0Desired
+     * @param amount1Desired
+     * @param amount0Min
+     * @param amount1Min
+     * @param deadline
+     * @param from
+     * @param token0
+     * @param token1
+     */
+    constructor(tokenId, amount0Desired, amount1Desired, amount0Min, amount1Min, deadline, from, token0, token1) {
+        super('UniSupplyV3', getAddr('UniSupplyV3'), [
+            "uint256",
+            "uint256",
+            "uint256",
+            "uint256",
+            "uint256",
+            "uint256",
+            "address",
+            "address",
+            "address",
+        ], [tokenId, amount0Desired, amount1Desired, amount0Min, amount1Min, deadline, from, token0, token1]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetA = getAssetInfoByAddress(this.args[7]);
+            const assetB = getAssetInfoByAddress(this.args[8]);
+            const approveArr = [];
+            if (assetA.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[7], owner: this.args[6], specialApproveLabel: 'uniswap v3' });
+            if (assetB.symbol !== 'ETH')
+                approveArr.push({ asset: this.args[8], owner: this.args[6], specialApproveLabel: 'uniswap v3' });
+            return approveArr;
+        });
+    }
+}