@defisaver/sdk 1.0.0 → 1.0.2

package/esm/src/actions/mstable/MStableClaimAction.js

@@ -0,0 +1,25 @@
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
+import { getAddr } from '../../addresses';
+/**
+ * MStableClaimAction
+ *
+ * @category MStable
+ */
+export class MStableClaimAction extends Action {
+    /**
+     * @param vaultAddress
+     * @param to
+     * @param first
+     * @param last
+     */
+    constructor(vaultAddress, to, first, last) {
+        requireAddress(vaultAddress);
+        requireAddress(to);
+        super('MStableClaim', getAddr('MStableClaim'), ['address', 'address', 'uint256', 'uint256'], [vaultAddress, to, first, last]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+        ];
+    }
+}

package/esm/src/actions/mstable/MStableDepositAction.d.ts

@@ -0,0 +1,25 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * MStableDepositAction
+ *
+ * @category MStable
+ */
+export declare class MStableDepositAction extends Action {
+    /**
+     * @param bAsset
+     * @param mAsset
+     * @param saveAddress
+     * @param vaultAddress
+     * @param from
+     * @param to
+     * @param amount
+     * @param minOut
+     * @param assetPair
+     */
+    constructor(bAsset: EthAddress, mAsset: EthAddress, saveAddress: EthAddress, vaultAddress: EthAddress, from: EthAddress, to: EthAddress, amount: uint256, minOut: uint256, assetPair: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/mstable/MStableDepositAction.js

@@ -0,0 +1,75 @@
+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 mstableAssetPairs from '../../utils/mstableAssetPairs';
+/**
+ * MStableDepositAction
+ *
+ * @category MStable
+ */
+export class MStableDepositAction extends Action {
+    /**
+     * @param bAsset
+     * @param mAsset
+     * @param saveAddress
+     * @param vaultAddress
+     * @param from
+     * @param to
+     * @param amount
+     * @param minOut
+     * @param assetPair
+     */
+    constructor(bAsset, mAsset, saveAddress, vaultAddress, from, to, amount, minOut, assetPair) {
+        requireAddress(bAsset);
+        requireAddress(mAsset);
+        requireAddress(saveAddress);
+        requireAddress(vaultAddress);
+        requireAddress(from);
+        requireAddress(to);
+        super('MStableDeposit', getAddr('MStableDeposit'), ['address', 'address', 'address', 'address', 'address', 'address', 'uint256', 'uint256', 'uint256'], [bAsset, mAsset, saveAddress, vaultAddress, from, to, amount, minOut, assetPair]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+            this.args[5],
+            this.args[6],
+            this.args[7],
+            this.args[8],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetPair = this.args[8];
+            const owner = this.args[4];
+            let asset;
+            switch (assetPair) {
+                case mstableAssetPairs.BASSET_MASSET:
+                case mstableAssetPairs.BASSET_IMASSET:
+                case mstableAssetPairs.BASSET_IMASSETVAULT:
+                    asset = this.args[0];
+                    break;
+                case mstableAssetPairs.MASSET_IMASSET:
+                case mstableAssetPairs.MASSET_IMASSETVAULT:
+                    asset = this.args[1];
+                    break;
+                case mstableAssetPairs.IMASSET_IMASSETVAULT:
+                    asset = this.args[2];
+                    break;
+                default:
+                    return [];
+            }
+            return [{ asset, owner }];
+        });
+    }
+}

package/esm/src/actions/mstable/MStableWithdrawAction.d.ts

@@ -0,0 +1,25 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * MStableWithdrawAction
+ *
+ * @category MStable
+ */
+export declare class MStableWithdrawAction extends Action {
+    /**
+     * @param bAsset
+     * @param mAsset
+     * @param saveAddress
+     * @param vaultAddress
+     * @param from
+     * @param to
+     * @param amount
+     * @param minOut
+     * @param assetPair
+     */
+    constructor(bAsset: EthAddress, mAsset: EthAddress, saveAddress: EthAddress, vaultAddress: EthAddress, from: EthAddress, to: EthAddress, amount: uint256, minOut: uint256, assetPair: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/mstable/MStableWithdrawAction.js

@@ -0,0 +1,74 @@
+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 mstableAssetPairs from '../../utils/mstableAssetPairs';
+/**
+ * MStableWithdrawAction
+ *
+ * @category MStable
+ */
+export class MStableWithdrawAction extends Action {
+    /**
+     * @param bAsset
+     * @param mAsset
+     * @param saveAddress
+     * @param vaultAddress
+     * @param from
+     * @param to
+     * @param amount
+     * @param minOut
+     * @param assetPair
+     */
+    constructor(bAsset, mAsset, saveAddress, vaultAddress, from, to, amount, minOut, assetPair) {
+        requireAddress(bAsset);
+        requireAddress(mAsset);
+        requireAddress(saveAddress);
+        requireAddress(vaultAddress);
+        requireAddress(from);
+        requireAddress(to);
+        super('MStableWithdraw', getAddr('MStableWithdraw'), ['address', 'address', 'address', 'address', 'address', 'address', 'uint256', 'uint256', 'uint256'], [bAsset, mAsset, saveAddress, vaultAddress, from, to, amount, minOut, assetPair]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+            this.args[5],
+            this.args[6],
+            this.args[7],
+            this.args[8],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetPair = this.args[8];
+            const owner = this.args[4];
+            let asset;
+            switch (assetPair) {
+                case mstableAssetPairs.BASSET_IMASSETVAULT:
+                case mstableAssetPairs.MASSET_IMASSETVAULT:
+                case mstableAssetPairs.IMASSET_IMASSETVAULT:
+                    return [];
+                case mstableAssetPairs.MASSET_IMASSET:
+                case mstableAssetPairs.BASSET_IMASSET:
+                    asset = this.args[2];
+                    break;
+                case mstableAssetPairs.BASSET_MASSET:
+                    asset = this.args[1];
+                    break;
+                default:
+                    return [];
+            }
+            return [{ asset, owner }];
+        });
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './MStableDepositAction';
+export * from './MStableWithdrawAction';
+export * from './MStableClaimAction';

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

@@ -0,0 +1,3 @@
+export * from './MStableDepositAction';
+export * from './MStableWithdrawAction';
+export * from './MStableClaimAction';

package/esm/src/actions/rari/RariDepositAction.d.ts

@@ -0,0 +1,22 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * RariDepositAction - action that deposits one stablecoin (DAI, USDC, USDT, TUSD, BUSD, and sUSD) and receives RSPT back
+ *
+ * @category Rari
+ */
+export declare class RariDepositAction extends Action {
+    /**
+     * @param fundManager fundManager for the pool which we want to deposit into
+     * @param stablecoinAddress stablecoin token address
+     * @param poolTokenAddress poolTokenAddress
+     * @param amount amount of stablecoin to pull and deposit
+     * @param from stablecoins will be taken from this address
+     * @param to RSPT will be sent to this address
+     */
+    constructor(fundManager: EthAddress, stablecoinAddress: EthAddress, poolTokenAddress: EthAddress, amount: uint256, from: EthAddress, to: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/rari/RariDepositAction.js

@@ -0,0 +1,41 @@
+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 { requireAddress } from '../../utils/general';
+/**
+ * RariDepositAction - action that deposits one stablecoin (DAI, USDC, USDT, TUSD, BUSD, and sUSD) and receives RSPT back
+ *
+ * @category Rari
+ */
+export class RariDepositAction extends Action {
+    /**
+     * @param fundManager fundManager for the pool which we want to deposit into
+     * @param stablecoinAddress stablecoin token address
+     * @param poolTokenAddress poolTokenAddress
+     * @param amount amount of stablecoin to pull and deposit
+     * @param from stablecoins will be taken from this address
+     * @param to RSPT will be sent to this address
+     */
+    constructor(fundManager, stablecoinAddress, poolTokenAddress, amount, from, to) {
+        requireAddress(to);
+        super('RariDeposit', getAddr('RariDeposit'), ['address', 'address', 'address', 'uint256', 'address', 'address'], [fundManager, stablecoinAddress, poolTokenAddress, amount, from, to]);
+        this.mappableArgs = [
+            this.args[3],
+            this.args[4],
+            this.args[5],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{ asset: this.args[1], owner: this.args[4] }];
+        });
+    }
+}

package/esm/src/actions/rari/RariWithdrawAction.d.ts

@@ -0,0 +1,23 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * RariWithdrawAction - Send pool tokens to fund manager which burns them, receive underlying stablecoin back
+ *
+ * @category Rari
+ */
+export declare class RariWithdrawAction extends Action {
+    /**
+     * @param fundManager fundManager for the pool which we want to withdraw from
+     * @param poolTokenAddress poolToken address
+     * @param poolTokensAmountToPull amount of tokens to pull to proxy
+     * @param from poolTokens will be taken from this address
+     * @param stablecoinAddress stablecoin token address
+     * @param stablecoinAmountToWithdraw amount of stablecoin to withdraw from Rari
+     * @param to stablecoins withdrawn will be sent to this address
+     */
+    constructor(fundManager: EthAddress, poolTokenAddress: EthAddress, poolTokensAmountToPull: uint256, from: EthAddress, stablecoinAddress: EthAddress, stablecoinAmountToWithdraw: uint256, to: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/rari/RariWithdrawAction.js

@@ -0,0 +1,43 @@
+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 { requireAddress } from '../../utils/general';
+/**
+ * RariWithdrawAction - Send pool tokens to fund manager which burns them, receive underlying stablecoin back
+ *
+ * @category Rari
+ */
+export class RariWithdrawAction extends Action {
+    /**
+     * @param fundManager fundManager for the pool which we want to withdraw from
+     * @param poolTokenAddress poolToken address
+     * @param poolTokensAmountToPull amount of tokens to pull to proxy
+     * @param from poolTokens will be taken from this address
+     * @param stablecoinAddress stablecoin token address
+     * @param stablecoinAmountToWithdraw amount of stablecoin to withdraw from Rari
+     * @param to stablecoins withdrawn will be sent to this address
+     */
+    constructor(fundManager, poolTokenAddress, poolTokensAmountToPull, from, stablecoinAddress, stablecoinAmountToWithdraw, to) {
+        requireAddress(to);
+        super('RariWithdraw', getAddr('RariWithdraw'), ['address', 'address', 'uint256', 'address', 'address', 'uint256', 'address'], [fundManager, poolTokenAddress, poolTokensAmountToPull, from, stablecoinAddress, stablecoinAmountToWithdraw, to]);
+        this.mappableArgs = [
+            this.args[2],
+            this.args[3],
+            this.args[5],
+            this.args[6],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{ asset: this.args[1], owner: this.args[3] }];
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './RariDepositAction';
+export * from './RariWithdrawAction';

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

@@ -0,0 +1,2 @@
+export * from './RariDepositAction';
+export * from './RariWithdrawAction';

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

@@ -0,0 +1,15 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * ReflexerGenerateAction - Generated Dai from a Safe
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerGenerateAction extends Action {
+    /**
+     * @param safeId
+     * @param amount Amount of Rai to generate in wei
+     * @param to Generated Rai will be sent to this address
+     */
+    constructor(safeId: uint256, amount: uint256, to: EthAddress);
+}

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

@@ -0,0 +1,19 @@
+import { Action } from "../../Action";
+import { requireAddress } from "../../utils/general";
+import { getAddr } from '../../addresses';
+/**
+ * ReflexerGenerateAction - Generated Dai from a Safe
+ *
+ * @category Reflexer
+ */
+export class ReflexerGenerateAction extends Action {
+    /**
+     * @param safeId
+     * @param amount Amount of Rai to generate in wei
+     * @param to Generated Rai will be sent to this address
+     */
+    constructor(safeId, amount, to) {
+        requireAddress(to);
+        super('ReflexerGenerate', getAddr('ReflexerGenerate'), ['uint256', 'uint256', 'address'], [safeId, amount, to]);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * ReflexerNativeUniV2SaviourDepositAction - Deposit lpToken in the contract in order to provide cover for a specific SAFE managed by the SAFE Manager
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerNativeUniV2SaviourDepositAction extends Action {
+    /**
+     * @param from
+     * @param safeId
+     * @param lpTokenAmount
+     */
+    constructor(from: EthAddress, safeId: uint256, lpTokenAmount: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+}

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

@@ -0,0 +1,37 @@
+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';
+/**
+ * ReflexerNativeUniV2SaviourDepositAction - Deposit lpToken in the contract in order to provide cover for a specific SAFE managed by the SAFE Manager
+ *
+ * @category Reflexer
+ */
+export class ReflexerNativeUniV2SaviourDepositAction extends Action {
+    /**
+     * @param from
+     * @param safeId
+     * @param lpTokenAmount
+     */
+    constructor(from, safeId, lpTokenAmount) {
+        super('ReflexerNativeUniV2SaviourDeposit', getAddr('ReflexerNativeUniV2SaviourDeposit'), ['address', 'uint256', 'uint256'], [from, safeId, lpTokenAmount]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenAddress = getAddr('RaiWethUniV2LPToken');
+            return [{ asset: tokenAddress, owner: this.args[0] }];
+        });
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * ReflexerNativeUniV2SaviourGetReservesAction - Get back system coins or collateral tokens that were withdrawn from Uniswap and not used to save a specific SAFE
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerNativeUniV2SaviourGetReservesAction extends Action {
+    /**
+     * @param to
+     * @param safeId
+     */
+    constructor(to: EthAddress, safeId: uint256);
+}

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

@@ -0,0 +1,21 @@
+import { Action } from "../../Action";
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ * ReflexerNativeUniV2SaviourGetReservesAction - Get back system coins or collateral tokens that were withdrawn from Uniswap and not used to save a specific SAFE
+ *
+ * @category Reflexer
+ */
+export class ReflexerNativeUniV2SaviourGetReservesAction extends Action {
+    /**
+     * @param to
+     * @param safeId
+     */
+    constructor(to, safeId) {
+        requireAddress(to);
+        super('ReflexerNativeUniV2SaviourGetReserves', getAddr('ReflexerNativeUniV2SaviourGetReserves'), ['address', 'uint256'], [to, safeId]);
+        this.mappableArgs = [
+            this.args[0],
+        ];
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * ReflexerNativeUniV2SaviourWithdrawAction -  Withdraw lpToken from the contract and provide less cover for a SAFE
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerNativeUniV2SaviourWithdrawAction extends Action {
+    /**
+     * @param to
+     * @param safeId
+     * @param lpTokenAmount
+     */
+    constructor(to: EthAddress, safeId: uint256, lpTokenAmount: uint256);
+}

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

@@ -0,0 +1,23 @@
+import { Action } from "../../Action";
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ * ReflexerNativeUniV2SaviourWithdrawAction -  Withdraw lpToken from the contract and provide less cover for a SAFE
+ *
+ * @category Reflexer
+ */
+export class ReflexerNativeUniV2SaviourWithdrawAction extends Action {
+    /**
+     * @param to
+     * @param safeId
+     * @param lpTokenAmount
+     */
+    constructor(to, safeId, lpTokenAmount) {
+        requireAddress(to);
+        super('ReflexerNativeUniV2SaviourWithdraw', getAddr('ReflexerNativeUniV2SaviourWithdraw'), ['address', 'uint256', 'uint256',], [to, safeId, lpTokenAmount]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[2],
+        ];
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Action } from "../../Action";
+import { EthAddress } from '../../types';
+/**
+ * ReflexerOpenSafeAction
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerOpenSafeAction extends Action {
+    /**
+     * @param adapterAddr
+     */
+    constructor(adapterAddr: EthAddress);
+}

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

@@ -0,0 +1,15 @@
+import { Action } from "../../Action";
+import { getAddr } from '../../addresses';
+/**
+ * ReflexerOpenSafeAction
+ *
+ * @category Reflexer
+ */
+export class ReflexerOpenSafeAction extends Action {
+    /**
+     * @param adapterAddr
+     */
+    constructor(adapterAddr) {
+        super('ReflexerOpen', getAddr('ReflexerOpen'), ['address'], [adapterAddr]);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * ReflexerPaybackAction - Payback RAI to a Safe
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerPaybackAction extends Action {
+    /**
+     * @param safeId
+     * @param amount Amount of RAI to be payed back in wei
+     * @param from RAI will be sent from this address
+     */
+    constructor(safeId: uint256, amount: uint256, from: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+}

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

@@ -0,0 +1,32 @@
+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 { getAssetInfo } from "@defisaver/tokens";
+import { getAddr } from '../../addresses';
+/**
+ * ReflexerPaybackAction - Payback RAI to a Safe
+ *
+ * @category Reflexer
+ */
+export class ReflexerPaybackAction extends Action {
+    /**
+     * @param safeId
+     * @param amount Amount of RAI to be payed back in wei
+     * @param from RAI will be sent from this address
+     */
+    constructor(safeId, amount, from) {
+        super('ReflexerPayback', getAddr('ReflexerPayback'), ['uint256', 'uint256', 'address'], [safeId, amount, from]);
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{ asset: getAssetInfo('RAI').address, owner: this.args[2] }];
+        });
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * ReflexerSupplyAction - Supply token to a Safe
+ *
+ * @category Reflexer
+ */
+export declare class ReflexerSupplyAction extends Action {
+    /**
+     * @param safeId
+     * @param amount
+     * @param adapterAddr
+     * @param from Tokens will be supplied from this address
+     */
+    constructor(safeId: uint256, amount: uint256, adapterAddr: EthAddress, from: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+    getEthValue(): Promise<any>;
+}