@defisaver/sdk 1.2.36 → 1.3.0

package/src/utils/zeroExExchange.ts

@@ -1,206 +1,206 @@
-/**
- * @module utils.zeroExExchange
- */
-
-import Dec from 'decimal.js';
-import axios from 'axios';
-import { assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
-import { EthAddress } from '../types';
-
-import { SellAction } from '../actions/basic';
-import { parsePriceFromContract, formatPriceForContract } from './general';
-
-const API_URL = 'https://api.0x.org/swap/v1/';
-const ZEROX_WRAPPER = '0x0c4e16899f2059F4e41ddB164317414a5c0d2988';
-
-/**
- * Gets price estimate from 0x API.
- *
- * @param _sellToken
- * @param _buyToken
- * @param _amount
- * @param convertAmountToWei should amount be converted to wei
- * @param infoOnly should be true if just for showing price
- * @param acceptedSlippagePercent Slippage percentage tolerated [0-100]
- * @param shouldSell look for price to sell or to buy
- *
- */
-const get0xPrice = async (_sellToken: string, _buyToken: string, _amount: string, convertAmountToWei = true, infoOnly = false, acceptedSlippagePercent = 3, shouldSell = true): Promise<{ data: string; price: string; guaranteedPrice: string; protocolFee: string; to: EthAddress; value: string; wrapper: EthAddress; allowanceTarget: EthAddress; estimatedGas: string; }> => {
-  // 0x API expects WETH symbol
-  const buyToken = _buyToken.replace(/^ETH$/, 'WETH');
-  const sellToken = _sellToken.replace(/^ETH$/, 'WETH');
-
-  const amount = convertAmountToWei
-    ? assetAmountInWei(_amount, shouldSell ? sellToken : buyToken)
-    : _amount;
-
-  const formattedSlippage = new Dec(acceptedSlippagePercent).div(100).toFixed(2);
-
-  let url = shouldSell
-    ? `${API_URL}${infoOnly ? 'price' : 'quote'}?sellToken=${sellToken}&buyToken=${buyToken}&sellAmount=${amount}&affiliateAddress=0x322d58b9E75a6918f7e7849AEe0fF09369977e08&takerAddress=${ZEROX_WRAPPER}`
-    : `${API_URL}${infoOnly ? 'price' : 'quote'}?sellToken=${sellToken}&buyToken=${buyToken}&buyAmount=${amount}&affiliateAddress=0x322d58b9E75a6918f7e7849AEe0fF09369977e08&takerAddress=${ZEROX_WRAPPER}`;
-
-  if (!infoOnly) {
-    url += `&intentOnFilling=true&skipValidation=true&slippagePercentage=${formattedSlippage}&shouldSellEntireBalance=true`;
-  }
-  const res = await axios.get(url, {
-    headers: {
-      'Content-Type': 'application/json',
-      // '0x-API-KEY': zeroxToken, // TODO let users supply token for RFQ support
-    },
-  });
-
-  if (res.status !== 200) throw new Error(JSON.stringify(res.data));
-
-  const data = res.data;
-
-  // convert price to be able to compare with other prices onchain
-  if (!shouldSell) {
-    data.price = new Dec(1).div(data.price).toString();
-    if (data.guaranteedPrice) data.guaranteedPrice = new Dec(1).div(data.guaranteedPrice).toString();
-  }
-  data.price = formatPriceForContract(data.price, sellToken, buyToken);
-  if (new Dec(data.protocolFee).gt(0)) {
-    data.protocolFee = new Dec(data.protocolFee).mul(150).div(100).toString();
-  }
-  data.value = sellToken === 'WETH'
-    ? new Dec(data.value).plus(amount).toString()
-    : data.value;
-  data.wrapper = ZEROX_WRAPPER;
-
-  return data;
-};
-
-/**
- * Gets price estimate.
- * Example: getBestExchangePrice('1', 'ETH', 'DAI') for selling 1 ETH for DAI
- * Example: getBestExchangePrice('1000', 'ETH', 'DAI', false) for buying 1000 DAI while selling ETH
- *
- * @param amount sellAmount or buyAmount, depending on `shouldSell` (not in wei)
- * @param sellToken Symbol for asset being sold
- * @param buyToken Symbol for asset being bought
- * @param shouldSell=true Look for price to sell or to buy
- *
- */
-const estimatePrice = async (amount: string, sellToken: string, buyToken: string, shouldSell = true): Promise<string> => {
-  if (!amount || !parseFloat(amount)) return '0';
-  if (sellToken === buyToken) return '1';
-  const zeroxData = await get0xPrice(sellToken, buyToken, amount, true, true, 0, shouldSell);
-  return parsePriceFromContract(zeroxData.price, sellToken, buyToken);
-};
-
-/**
- * Gets price estimate for selling a specific amount.
- * Example: getBestExchangePrice('1', 'ETH', 'DAI') - swapping 1 ETH for some DAI
- *
- * @param sellAmount amount of sellToken (not in wei)
- * @param sellToken Symbol for asset being sold
- * @param buyToken Symbol for asset being bought
- * @returns price of sellToken in buyToken
- */
-export const estimateSellPrice = async (sellAmount: string, sellToken: string, buyToken: string): Promise<string> => estimatePrice(sellAmount, sellToken, buyToken, true);
-
-/**
- * Gets price estimate for buying a specific amount.
- * Example: estimateBuyPrice('1000', 'DAI', 'ETH') - swapping 1000 DAI for some ETH
- *
- * @param buyAmount amount of buyToken (not in wei)
- * @param buyToken Symbol for asset being bought
- * @param sellToken Symbol for asset being sold
- * @returns price of sellToken in buyToken
- */
-export const estimateBuyPrice = async (buyAmount: string, buyToken: string, sellToken: string): Promise<string> => estimatePrice(buyAmount, sellToken, buyToken, false);
-
-/**
- * @param sellToken Symbol for asset being sold ('ETH')
- * @param buyToken Symbol for asset being bought ('DAI')
- * @param sellAmount Amount of asset being sold ('1.5') - '0' if buying
- * @param buyAmount Amount of asset being bought ('1500.123') - '0' if selling
- * @param expectedPrice Price received from estimatePrice (so minPrice can be calculated based on what user saw)
- * @param acceptedSlippagePercent Slippage percentage tolerated [0-100]
- * @param shouldSell look for price to sell or to buy (if false sellToken becomes becomes buyToken and vice-versa)
- * @param fromAccount Withdraw funds from this addr
- * @param toAccount Send funds to this addr
- * @return SellAction
- *
- */
-const createExchangeAction = async (
-  sellToken: string,
-  buyToken: string,
-  sellAmount: string,
-  buyAmount: string,
-  expectedPrice: string,
-  acceptedSlippagePercent: number,
-  shouldSell = true,
-  fromAccount: EthAddress,
-  toAccount: EthAddress,
-): Promise<SellAction> => {
-  const sellTokenData = getAssetInfo(sellToken);
-  const buyTokenData = getAssetInfo(buyToken);
-
-  const zeroExData = await get0xPrice(sellTokenData.symbol, buyTokenData.symbol, shouldSell ? sellAmount : buyAmount, true, false, acceptedSlippagePercent, shouldSell);
-
-  const protocolFee = zeroExData.protocolFee;
-
-  // let value = zeroExData.protocolFee;
-  // if (withValue && sellTokenData.symbol === 'ETH') {
-  //   value = new Dec(value).add(window._web3.utils.toWei(srcAmount.toString())).toFixed(0);
-  // }
-
-  const offchainDataArray = [
-    zeroExData.wrapper,
-    zeroExData.to,
-    zeroExData.allowanceTarget,
-    zeroExData.price,
-    zeroExData.protocolFee,
-    zeroExData.data,
-  ];
-
-  const orderData = [
-    sellTokenData.address,
-    buyTokenData.address,
-    assetAmountInWei(sellAmount, sellToken),
-    assetAmountInWei(buyAmount, buyToken),
-    formatPriceForContract(zeroExData.guaranteedPrice, sellTokenData.symbol, buyTokenData.symbol),
-    0, // set by contract
-    '0x0000000000000000000000000000000000000000', // set by contract
-    '0x0000000000000000000000000000000000000000', // onchain wrapper
-    '0x', // wrapperData,
-    offchainDataArray,
-  ];
-  return new SellAction(orderData, fromAccount, toAccount, protocolFee);
-};
-
-/**
- * Fetches prices and creates order ready to be passed to transaction.
- * This should only be called when before sending tx, not to be used for just querying the price.
- * For that purpose, the estimateSellPrice method can be used.
- *
- * @param sellAmount Amount of asset being sold ('1.5')
- * @param sellToken Symbol for asset being sold ('ETH')
- * @param buyToken Symbol for asset being bought ('DAI')
- * @param expectedPrice Price received from estimatePrice (so minPrice can be calculated based on what user saw)
- * @param acceptedSlippagePercent Slippage percentage tolerated [0-100]
- * @param fromAccount Withdraw funds from this addr
- * @param toAccount Send funds to this addr
- */
-export const createSellAction = async (
-  sellAmount: string,
-  sellToken: string,
-  buyToken: string,
-  expectedPrice: string,
-  acceptedSlippagePercent: string | number,
-  fromAccount: EthAddress,
-  toAccount: EthAddress,
-): Promise<SellAction> => createExchangeAction(
-  sellToken,
-  buyToken,
-  sellAmount,
-  '0',
-  expectedPrice,
-  typeof (acceptedSlippagePercent) === 'string' ? parseFloat(acceptedSlippagePercent) : acceptedSlippagePercent,
-  true,
-  fromAccount,
-  toAccount,
-);
-
+/**
+ * @module utils.zeroExExchange
+ */
+
+import Dec from 'decimal.js';
+import axios from 'axios';
+import { assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
+import { EthAddress } from '../types';
+
+import { SellAction } from '../actions/basic';
+import { parsePriceFromContract, formatPriceForContract } from './general';
+
+const API_URL = 'https://api.0x.org/swap/v1/';
+const ZEROX_WRAPPER = '0x0c4e16899f2059F4e41ddB164317414a5c0d2988';
+
+/**
+ * Gets price estimate from 0x API.
+ *
+ * @param _sellToken
+ * @param _buyToken
+ * @param _amount
+ * @param convertAmountToWei should amount be converted to wei
+ * @param infoOnly should be true if just for showing price
+ * @param acceptedSlippagePercent Slippage percentage tolerated [0-100]
+ * @param shouldSell look for price to sell or to buy
+ *
+ */
+const get0xPrice = async (_sellToken: string, _buyToken: string, _amount: string, convertAmountToWei = true, infoOnly = false, acceptedSlippagePercent = 3, shouldSell = true): Promise<{ data: string; price: string; guaranteedPrice: string; protocolFee: string; to: EthAddress; value: string; wrapper: EthAddress; allowanceTarget: EthAddress; estimatedGas: string; }> => {
+  // 0x API expects WETH symbol
+  const buyToken = _buyToken.replace(/^ETH$/, 'WETH');
+  const sellToken = _sellToken.replace(/^ETH$/, 'WETH');
+
+  const amount = convertAmountToWei
+    ? assetAmountInWei(_amount, shouldSell ? sellToken : buyToken)
+    : _amount;
+
+  const formattedSlippage = new Dec(acceptedSlippagePercent).div(100).toFixed(2);
+
+  let url = shouldSell
+    ? `${API_URL}${infoOnly ? 'price' : 'quote'}?sellToken=${sellToken}&buyToken=${buyToken}&sellAmount=${amount}&affiliateAddress=0x322d58b9E75a6918f7e7849AEe0fF09369977e08&takerAddress=${ZEROX_WRAPPER}`
+    : `${API_URL}${infoOnly ? 'price' : 'quote'}?sellToken=${sellToken}&buyToken=${buyToken}&buyAmount=${amount}&affiliateAddress=0x322d58b9E75a6918f7e7849AEe0fF09369977e08&takerAddress=${ZEROX_WRAPPER}`;
+
+  if (!infoOnly) {
+    url += `&intentOnFilling=true&skipValidation=true&slippagePercentage=${formattedSlippage}&shouldSellEntireBalance=true`;
+  }
+  const res = await axios.get(url, {
+    headers: {
+      'Content-Type': 'application/json',
+      // '0x-API-KEY': zeroxToken, // TODO let users supply token for RFQ support
+    },
+  });
+
+  if (res.status !== 200) throw new Error(JSON.stringify(res.data));
+
+  const data = res.data;
+
+  // convert price to be able to compare with other prices onchain
+  if (!shouldSell) {
+    data.price = new Dec(1).div(data.price).toString();
+    if (data.guaranteedPrice) data.guaranteedPrice = new Dec(1).div(data.guaranteedPrice).toString();
+  }
+  data.price = formatPriceForContract(data.price, sellToken, buyToken);
+  if (new Dec(data.protocolFee).gt(0)) {
+    data.protocolFee = new Dec(data.protocolFee).mul(150).div(100).toString();
+  }
+  data.value = sellToken === 'WETH'
+    ? new Dec(data.value).plus(amount).toString()
+    : data.value;
+  data.wrapper = ZEROX_WRAPPER;
+
+  return data;
+};
+
+/**
+ * Gets price estimate.
+ * Example: getBestExchangePrice('1', 'ETH', 'DAI') for selling 1 ETH for DAI
+ * Example: getBestExchangePrice('1000', 'ETH', 'DAI', false) for buying 1000 DAI while selling ETH
+ *
+ * @param amount sellAmount or buyAmount, depending on `shouldSell` (not in wei)
+ * @param sellToken Symbol for asset being sold
+ * @param buyToken Symbol for asset being bought
+ * @param shouldSell=true Look for price to sell or to buy
+ *
+ */
+const estimatePrice = async (amount: string, sellToken: string, buyToken: string, shouldSell = true): Promise<string> => {
+  if (!amount || !parseFloat(amount)) return '0';
+  if (sellToken === buyToken) return '1';
+  const zeroxData = await get0xPrice(sellToken, buyToken, amount, true, true, 0, shouldSell);
+  return parsePriceFromContract(zeroxData.price, sellToken, buyToken);
+};
+
+/**
+ * Gets price estimate for selling a specific amount.
+ * Example: getBestExchangePrice('1', 'ETH', 'DAI') - swapping 1 ETH for some DAI
+ *
+ * @param sellAmount amount of sellToken (not in wei)
+ * @param sellToken Symbol for asset being sold
+ * @param buyToken Symbol for asset being bought
+ * @returns price of sellToken in buyToken
+ */
+export const estimateSellPrice = async (sellAmount: string, sellToken: string, buyToken: string): Promise<string> => estimatePrice(sellAmount, sellToken, buyToken, true);
+
+/**
+ * Gets price estimate for buying a specific amount.
+ * Example: estimateBuyPrice('1000', 'DAI', 'ETH') - swapping 1000 DAI for some ETH
+ *
+ * @param buyAmount amount of buyToken (not in wei)
+ * @param buyToken Symbol for asset being bought
+ * @param sellToken Symbol for asset being sold
+ * @returns price of sellToken in buyToken
+ */
+export const estimateBuyPrice = async (buyAmount: string, buyToken: string, sellToken: string): Promise<string> => estimatePrice(buyAmount, sellToken, buyToken, false);
+
+/**
+ * @param sellToken Symbol for asset being sold ('ETH')
+ * @param buyToken Symbol for asset being bought ('DAI')
+ * @param sellAmount Amount of asset being sold ('1.5') - '0' if buying
+ * @param buyAmount Amount of asset being bought ('1500.123') - '0' if selling
+ * @param expectedPrice Price received from estimatePrice (so minPrice can be calculated based on what user saw)
+ * @param acceptedSlippagePercent Slippage percentage tolerated [0-100]
+ * @param shouldSell look for price to sell or to buy (if false sellToken becomes becomes buyToken and vice-versa)
+ * @param fromAccount Withdraw funds from this addr
+ * @param toAccount Send funds to this addr
+ * @return SellAction
+ *
+ */
+const createExchangeAction = async (
+  sellToken: string,
+  buyToken: string,
+  sellAmount: string,
+  buyAmount: string,
+  expectedPrice: string,
+  acceptedSlippagePercent: number,
+  shouldSell = true,
+  fromAccount: EthAddress,
+  toAccount: EthAddress,
+): Promise<SellAction> => {
+  const sellTokenData = getAssetInfo(sellToken);
+  const buyTokenData = getAssetInfo(buyToken);
+
+  const zeroExData = await get0xPrice(sellTokenData.symbol, buyTokenData.symbol, shouldSell ? sellAmount : buyAmount, true, false, acceptedSlippagePercent, shouldSell);
+
+  const protocolFee = zeroExData.protocolFee;
+
+  // let value = zeroExData.protocolFee;
+  // if (withValue && sellTokenData.symbol === 'ETH') {
+  //   value = new Dec(value).add(window._web3.utils.toWei(srcAmount.toString())).toFixed(0);
+  // }
+
+  const offchainDataArray = [
+    zeroExData.wrapper,
+    zeroExData.to,
+    zeroExData.allowanceTarget,
+    zeroExData.price,
+    zeroExData.protocolFee,
+    zeroExData.data,
+  ];
+
+  const orderData = [
+    sellTokenData.address,
+    buyTokenData.address,
+    assetAmountInWei(sellAmount, sellToken),
+    assetAmountInWei(buyAmount, buyToken),
+    formatPriceForContract(zeroExData.guaranteedPrice, sellTokenData.symbol, buyTokenData.symbol),
+    0, // set by contract
+    '0x0000000000000000000000000000000000000000', // set by contract
+    '0x0000000000000000000000000000000000000000', // onchain wrapper
+    '0x', // wrapperData,
+    offchainDataArray,
+  ];
+  return new SellAction(orderData, fromAccount, toAccount, protocolFee);
+};
+
+/**
+ * Fetches prices and creates order ready to be passed to transaction.
+ * This should only be called when before sending tx, not to be used for just querying the price.
+ * For that purpose, the estimateSellPrice method can be used.
+ *
+ * @param sellAmount Amount of asset being sold ('1.5')
+ * @param sellToken Symbol for asset being sold ('ETH')
+ * @param buyToken Symbol for asset being bought ('DAI')
+ * @param expectedPrice Price received from estimatePrice (so minPrice can be calculated based on what user saw)
+ * @param acceptedSlippagePercent Slippage percentage tolerated [0-100]
+ * @param fromAccount Withdraw funds from this addr
+ * @param toAccount Send funds to this addr
+ */
+export const createSellAction = async (
+  sellAmount: string,
+  sellToken: string,
+  buyToken: string,
+  expectedPrice: string,
+  acceptedSlippagePercent: string | number,
+  fromAccount: EthAddress,
+  toAccount: EthAddress,
+): Promise<SellAction> => createExchangeAction(
+  sellToken,
+  buyToken,
+  sellAmount,
+  '0',
+  expectedPrice,
+  typeof (acceptedSlippagePercent) === 'string' ? parseFloat(acceptedSlippagePercent) : acceptedSlippagePercent,
+  true,
+  fromAccount,
+  toAccount,
+);
+

package/test/Action.js

@@ -1,62 +1,62 @@
-const dfs = require('../src');
-const {encodeForDsProxyCall, encodeForRecipe} = require('./_actionUtils');
-const {assert} = require('chai');
-
-describe('Action', () => {
-
-  context('Basic', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.Action('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], [5, '0x6b175474e89094c44da98b954eedeac495271d0f'])
-    })
-    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
-    it('encodeForRecipe', () => encodeForRecipe(action));
-  });
-
-  context('With tuples', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.Action(
-        "DFSSell",
-        "0x0a80C3C540eEF99811f4579fa7b1A0617294e06f",
-        [
-          ["address", "address", "uint256", "uint256", "uint256", "uint256", "address", "address", "bytes", ["address", "address", "uint256", "uint256", "bytes"]],
-          "address",
-          "address",
-        ],
-        [
-          ['0x6b175474e89094c44da98b954eedeac495271d0f', '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', 1000000000000, 0, 0, 0, '0x0000000000000000000000000000000000000000', '0x6403BD92589F825FfeF6b62177FCe9149947cb9f', '0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', ['0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', 0, 0, []]],
-          '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f',
-          '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f'
-        ]
-      );
-    })
-    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
-    it('encodeForRecipe', () => encodeForRecipe(action));
-  })
-
-  context('With param mapping', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.Action('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], ['$1', '0x6b175474e89094c44da98b954eedeac495271d0f']);
-      action.mappableArgs = [action.args[0][0], action.args[0][1]];
-    })
-    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
-    it('encodeForRecipe', () => encodeForRecipe(action));
-  })
-
-  context('With param mapping inside a tuple', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.Action('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', [['uint256'], 'address'], [['$1'], '0x6b175474e89094c44da98b954eedeac495271d0f']);
-    })
-    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
-    it('encodeForRecipe with incorrect mappableArgs throws', () => {
-      assert.throws(() => encodeForRecipe(action));
-    });
-    it('encodeForRecipe with custom mappableArgs', () => {
-      action.mappableArgs = [action.args[0][0][0], action.args[0][1]];
-      encodeForRecipe(action)
-    });
-  })
-})
+const dfs = require('../src');
+const {encodeForDsProxyCall, encodeForRecipe} = require('./_actionUtils');
+const {assert} = require('chai');
+
+describe('Action', () => {
+
+  context('Basic', () => {
+    let action;
+    it('Constructor', () => {
+      action = new dfs.Action('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], [5, '0x6b175474e89094c44da98b954eedeac495271d0f'])
+    })
+    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+    it('encodeForRecipe', () => encodeForRecipe(action));
+  });
+
+  context('With tuples', () => {
+    let action;
+    it('Constructor', () => {
+      action = new dfs.Action(
+        "DFSSell",
+        "0x0a80C3C540eEF99811f4579fa7b1A0617294e06f",
+        [
+          ["address", "address", "uint256", "uint256", "uint256", "uint256", "address", "address", "bytes", ["address", "address", "uint256", "uint256", "bytes"]],
+          "address",
+          "address",
+        ],
+        [
+          ['0x6b175474e89094c44da98b954eedeac495271d0f', '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', 1000000000000, 0, 0, 0, '0x0000000000000000000000000000000000000000', '0x6403BD92589F825FfeF6b62177FCe9149947cb9f', '0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', ['0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', 0, 0, []]],
+          '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f',
+          '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f'
+        ]
+      );
+    })
+    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+    it('encodeForRecipe', () => encodeForRecipe(action));
+  })
+
+  context('With param mapping', () => {
+    let action;
+    it('Constructor', () => {
+      action = new dfs.Action('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], ['$1', '0x6b175474e89094c44da98b954eedeac495271d0f']);
+      action.mappableArgs = [action.args[0][0], action.args[0][1]];
+    })
+    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+    it('encodeForRecipe', () => encodeForRecipe(action));
+  })
+
+  context('With param mapping inside a tuple', () => {
+    let action;
+    it('Constructor', () => {
+      action = new dfs.Action('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', [['uint256'], 'address'], [['$1'], '0x6b175474e89094c44da98b954eedeac495271d0f']);
+    })
+    it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+    it('encodeForRecipe with incorrect mappableArgs throws', () => {
+      assert.throws(() => encodeForRecipe(action));
+    });
+    it('encodeForRecipe with custom mappableArgs', () => {
+      action.mappableArgs = [action.args[0][0][0], action.args[0][1]];
+      encodeForRecipe(action)
+    });
+  })
+})

package/test/ActionWithL2.js

@@ -1,27 +1,27 @@
-const dfs = require('../src');
-const {encodeForDsProxyCall, encodeForRecipe} = require('./_actionUtils');
-const {assert} = require('chai');
-
-const MAXUINT = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
-const MAXUINT_HEX = 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
-describe('ActionWithL2', () => {
-
-  context('Basic', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.ActionWithL2('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], [MAXUINT, '0x6b175474e89094c44da98b954eedeac495271d0f'])
-    })
-    it('numberToBytes32', () => {
-      assert(MAXUINT_HEX === action.numberToBytes32(MAXUINT));
-    });
-  });
-  context('AaveV3WithdrawAction', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.actions.aaveV3.AaveV3WithdrawAction(true, '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb', MAXUINT, "0x6b175474e89094c44da98b954eedeac495271d0f", 9);
-    })
-    it('numberToBytes32', () => {
-      assert(action.encodeForL2DsProxyCall() === '0x2895f3aa000901ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6b175474e89094c44da98b954eedeac495271d0f');
-    });
-  });
-})
+const dfs = require('../src');
+const {encodeForDsProxyCall, encodeForRecipe} = require('./_actionUtils');
+const {assert} = require('chai');
+
+const MAXUINT = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+const MAXUINT_HEX = 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+describe('ActionWithL2', () => {
+
+  context('Basic', () => {
+    let action;
+    it('Constructor', () => {
+      action = new dfs.ActionWithL2('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], [MAXUINT, '0x6b175474e89094c44da98b954eedeac495271d0f'])
+    })
+    it('numberToBytes32', () => {
+      assert(MAXUINT_HEX === action.numberToBytes32(MAXUINT));
+    });
+  });
+  context('AaveV3WithdrawAction', () => {
+    let action;
+    it('Constructor', () => {
+      action = new dfs.actions.aaveV3.AaveV3WithdrawAction(true, '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb', MAXUINT, "0x6b175474e89094c44da98b954eedeac495271d0f", 9);
+    })
+    it('numberToBytes32', () => {
+      assert(action.encodeForL2DsProxyCall() === '0x2895f3aa000901ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6b175474e89094c44da98b954eedeac495271d0f');
+    });
+  });
+})