@defisaver/sdk 1.3.36 → 1.3.37

package/test/ActionWithL2.js

@@ -1,27 +1,73 @@
 const dfs = require('../src');
-const {encodeForDsProxyCall, encodeForRecipe} = require('./_actionUtils');
-const {assert} = require('chai');
+const AbiCoder = require('web3-eth-abi');
+const { assert } = require('chai');
 
 const MAXUINT = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
-const MAXUINT_HEX = 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+const target = '0x0000000000000000000000000000000000000001';
+const recipient = '0x0000000000000000000000000000000000000002';
+
 describe('ActionWithL2', () => {
+  it('packs integer boundaries, addresses and booleans to their specified widths', () => {
+    const action = new dfs.ActionWithL2('MockSwap', target, [], []);
+    for (const [value, expected] of [[0, '00'], [1, '01'], [255, 'ff']]) {
+      assert.equal(action.numberToBytes1(value), expected);
+    }
+    for (const [value, expected] of [[0, '0000'], [1, '0001'], [65535, 'ffff']]) {
+      assert.equal(action.numberToBytes2(value), expected);
+    }
+    assert.equal(action.numberToBytes32('0'), '0'.repeat(64));
+    assert.equal(action.numberToBytes32('1'), '1'.padStart(64, '0'));
+    assert.equal(action.numberToBytes32(MAXUINT), 'f'.repeat(64));
+    assert.equal(action.addressToBytes20(recipient), '2'.padStart(40, '0'));
+    assert.equal(action.boolToBytes1(false), '00');
+    assert.equal(action.boolToBytes1(true), '01');
+  });
 
-  context('Basic', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.ActionWithL2('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], [MAXUINT, '0x6b175474e89094c44da98b954eedeac495271d0f'])
-    })
-    it('numberToBytes32', () => {
-      assert(MAXUINT_HEX === action.numberToBytes32(MAXUINT));
-    });
+  it('falls back to standard ABI encoding when packed encoding is not overridden', () => {
+    const action = new dfs.ActionWithL2('MockSwap', target, ['uint256'], ['5']);
+    const data = action.encodeForL2DsProxyCall();
+    assert.equal(data.slice(0, 10), '0x389f87ff');
+    assert.equal(AbiCoder.decodeParameter('bytes', `0x${data.slice(10)}`),
+      `0x${'5'.padStart(64, '0')}`);
+    assert.equal(action.encodeForL2Recipe(), `0x${data.slice(10)}`);
   });
-  context('AaveV3WithdrawAction', () => {
-    let action;
-    it('Constructor', () => {
-      action = new dfs.actions.aaveV3.AaveV3WithdrawAction(true, '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb', MAXUINT, "0x6b175474e89094c44da98b954eedeac495271d0f", 9);
-    })
-    it('numberToBytes32', () => {
-      assert(action.encodeForL2DsProxyCall() === '0x2895f3aa000901ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6b175474e89094c44da98b954eedeac495271d0f');
+
+  for (const useDefaultMarket of [true, false]) {
+    it(`encodes Aave withdrawal with ${useDefaultMarket ? 'default' : 'explicit'} market`, () => {
+      const action = new dfs.actions.aaveV3.AaveV3WithdrawAction(
+        useDefaultMarket, target, MAXUINT, recipient, 9,
+      );
+      // uint16 asset ID, bool default market, uint256 amount, address recipient,
+      // followed by the market address only when not using the default.
+      const payload = `0009${useDefaultMarket ? '01' : '00'}${'f'.repeat(64)}${recipient.slice(2)}${useDefaultMarket ? '' : target.slice(2)}`;
+      assert.equal(action.encodeForL2DsProxyCall(), `0x2895f3aa${payload}`);
+      assert.equal(action.encodeForL2Recipe(), `0x${payload}`);
+
+      const previous = { ...dfs.CONFIG };
+      try {
+        dfs.configure({ chainId: 10, testingMode: false });
+        assert.deepEqual(action.encodeForDsProxyCall(), [action.contractAddress, `0x2895f3aa${payload}`]);
+      } finally {
+        dfs.configure(previous);
+      }
     });
+  }
+});
+
+
+describe('ActionWithL2 integer validation', () => {
+  const action = new dfs.ActionWithL2('MockSwap', target, [], []);
+
+  for (const [method, overflow] of [['numberToBytes1', 256], ['numberToBytes2', 65536]]) {
+    it(`${method} rejects overflow, negative, fractional and non-finite values`, () => {
+      for (const value of [overflow, -1, 1.5, NaN, Infinity]) {
+        assert.throws(() => action[method](value), RangeError, 'Value must fit');
+      }
+    });
+  }
+
+  it('preserves hex text accepted by existing JavaScript callers', () => {
+    assert.equal(action.numberToBytes1('10'), '10');
+    assert.equal(action.numberToBytes2('10'), '0010');
   });
-})
+});

package/test/Recipe.js

@@ -93,3 +93,100 @@ describe('Recipe', () => {
     it('encodeForDsProxyCall', () => encodeForDsProxyCall(recipe));
   })
 })
+
+
+describe('Recipe composition', () => {
+  const AbiCoder = require('web3-eth-abi');
+  const owner = '0x0000000000000000000000000000000000000001';
+  const otherOwner = '0x0000000000000000000000000000000000000002';
+
+  it('encodes ordered action data, IDs and mappings in the recipe tuple', () => {
+    const first = new dfs.Action('MockDeposit', owner, ['uint256'], ['7']);
+    const second = new dfs.Action('MockSwap', owner, ['uint256', 'address'], ['$1', otherOwner]);
+    const recipe = new dfs.Recipe('Mapped recipe', [first]);
+    assert.strictEqual(recipe.addAction(second), recipe);
+    const zeroWord = '0'.repeat(64);
+    // Expected values are independent of the actions' encoding methods.
+    const expected = [
+      'Mapped recipe',
+      [`0x${'7'.padStart(64, '0')}`, `0x${zeroWord}${'2'.padStart(64, '0')}`],
+      [`0x${zeroWord}`, `0x${zeroWord}`],
+      ['0xf7012350', '0xe45f86c0'],
+      [[0], [1, 0]],
+    ];
+    const signature = 'executeRecipe((string,bytes[],bytes32[],bytes4[],uint8[][]))';
+    const data = AbiCoder.encodeParameter('(string,bytes[],bytes32[],bytes4[],uint8[][])', expected);
+    assert.deepEqual(recipe.encodeForDsProxyCall(), [
+      dfs.getAddr('RecipeExecutor'),
+      AbiCoder.encodeFunctionSignature(signature) + data.slice(2),
+    ]);
+  });
+
+  it('sums ETH values exactly above JavaScript safe integer precision', async () => {
+    const recipe = new dfs.Recipe('ETH value', [
+      new dfs.actions.basic.WrapEthAction('1000000000000000000'),
+      new dfs.actions.basic.WrapEthAction('1'),
+      new dfs.actions.basic.WrapEthAction('99', false),
+    ]);
+    assert.equal(await recipe.getEthValue(), '1000000000000000001');
+    assert.equal(await new dfs.Recipe('Empty').getEthValue(), '0');
+  });
+
+  it('deduplicates ERC-20 approvals by asset and owner and excludes native ETH', async () => {
+    const weth = getAssetInfo('WETH').address;
+    const dai = getAssetInfo('DAI').address;
+    const recipe = new dfs.Recipe('Approvals', [
+      new dfs.actions.basic.PullTokenAction(weth, owner, '1'),
+      new dfs.actions.basic.PullTokenAction(weth, owner, '2'),
+      new dfs.actions.basic.PullTokenAction(weth, otherOwner, '3'),
+      new dfs.actions.basic.PullTokenAction(dai, owner, '4'),
+    ]);
+    const nativeAction = new dfs.Action('Native', owner, [], []);
+    nativeAction.getAssetsToApprove = async () => [{ asset: getAssetInfo('ETH').address, owner }];
+    recipe.addAction(nativeAction);
+    assert.deepEqual(await recipe.getAssetsToApprove(), [
+      { asset: weth, owner, specialApproveLabel: undefined },
+      { asset: weth, owner: otherOwner, specialApproveLabel: undefined },
+      { asset: dai, owner, specialApproveLabel: undefined },
+    ]);
+    assert.deepEqual(await new dfs.Recipe('Empty').getAssetsToApprove(), []);
+  });
+
+  it('rejects non-action entries both at construction and when adding an action', () => {
+    assert.throws(() => new dfs.Recipe('Invalid', [{}]), TypeError, 'Supplied action does not inherit Action');
+    const recipe = new dfs.Recipe('Empty');
+    assert.throws(() => recipe.addAction({}), TypeError, 'Supplied action does not inherit Action');
+    assert.lengthOf(recipe.actions, 0);
+  });
+});
+
+
+describe('Recipe validation and NFT approvals', () => {
+  const owner = '0x0000000000000000000000000000000000000001';
+  const collectionA = '0x0000000000000000000000000000000000000002';
+  const collectionB = '0x0000000000000000000000000000000000000003';
+
+  it('keeps different NFT contracts, token IDs and owners while removing exact duplicates', async () => {
+    const approvals = [
+      { owner, nft: collectionA, tokenId: '1' },
+      { owner, nft: collectionA, tokenId: '1' },
+      { owner, nft: collectionB, tokenId: '1' },
+      { owner, nft: collectionA, tokenId: '2' },
+      { owner: collectionB, nft: collectionA, tokenId: '1' },
+    ];
+    const actions = approvals.map(approval => {
+      const action = new dfs.Action('NFT', owner, [], []);
+      action.getAssetsToApprove = async () => [approval];
+      return action;
+    });
+    assert.deepEqual(await new dfs.Recipe('NFT approvals', actions).getAssetsToApprove(),
+      [approvals[0], ...approvals.slice(2)].map(approval => ({ ...approval, specialApproveLabel: undefined })));
+  });
+
+  it('reports empty recipes clearly for both regular and TxSaver encoding', () => {
+    const recipe = new dfs.Recipe('Empty');
+    assert.throws(() => recipe.encodeForDsProxyCall(), 'Cannot encode an empty recipe');
+    assert.throws(() => recipe.encodeForTxSaverCall({ shouldTakeFeeFromPosition: false }),
+      'Cannot encode an empty recipe');
+  });
+});

package/tsconfig.json

@@ -71,9 +71,5 @@
   },
   "include": [
     "./src/*",
-  ],
-  "typedocOptions": {
-    "entryPoints": ["./src/index.ts"],
-    "out": "docs",
-}
+  ]
 }

package/umd/index.js

@@ -59,9 +59,6 @@ class Action {
    * @param args
    */
   constructor(name, contractAddress, paramTypes, args) {
-    /**
-     *
-     */
     _classPrivateMethodInitSpec(this, _Action_brand);
     _defineProperty(this, "contractAddress", void 0);
     _defineProperty(this, "paramTypes", void 0);
@@ -89,11 +86,11 @@ class Action {
    */
   _getArgumentMapping() {
     return this.mappableArgs.map(arg => {
-      if (new RegExp(/\$\d+/).test(arg)) {
-        if (Array.isArray(arg)) throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
-        // eslint-disable-next-line
-        return parseInt(arg.substr(1));
+      if (Array.isArray(arg) && /\$\d+/.test(arg.toString())) {
+        throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
       }
+      var reference = _assertClassBrand(_Action_brand, this, _getReturnValueReference).call(this, arg);
+      if (reference !== undefined) return reference;
       return 0;
     });
   }
@@ -139,7 +136,7 @@ class Action {
     var paramTypeParsed = this._parseParamType(paramType, arg);
     if (Array.isArray(arg)) return arg.map((_arg, i) => this._replaceWithPlaceholders(_arg, paramTypeParsed[i]));
     if (typeof paramType === 'string') {
-      if (new RegExp(/\$\d+/).test(arg)) return _assertClassBrand(_Action_brand, this, _getPlaceholderForType).call(this, paramType);
+      if (_assertClassBrand(_Action_brand, this, _getReturnValueReference).call(this, arg) !== undefined) return _assertClassBrand(_Action_brand, this, _getPlaceholderForType).call(this, paramType);
       if (new RegExp(/&\w+/).test(arg)) return _assertClassBrand(_Action_brand, this, _getPlaceholderForType).call(this, paramType);
     }
     return arg;
@@ -243,13 +240,24 @@ class Action {
     });
   }
 }
+function _getReturnValueReference(arg) {
+  if (typeof arg !== 'string' || !/\$\d+/.test(arg)) return undefined;
+  var index = Number(arg.slice(1));
+  if (!/^\$\d+$/.test(arg) || !Number.isSafeInteger(index) || index < 1) {
+    throw new Error("Invalid action return reference: ".concat(arg));
+  }
+  return index;
+}
+/**
+ *
+ */
 function _getArgumentMappingWithSlots(subSlots) {
   return this.mappableArgs.map(arg => {
-    if (new RegExp(/\$\d+/).test(arg)) {
-      if (Array.isArray(arg)) throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
-      // eslint-disable-next-line
-      return parseInt(arg.substr(1));
+    if (Array.isArray(arg) && /\$\d+/.test(arg.toString())) {
+      throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
     }
+    var reference = _assertClassBrand(_Action_brand, this, _getReturnValueReference).call(this, arg);
+    if (reference !== undefined) return reference;
 
     // Handle SubSlots placeholder values in strategies
     if (new RegExp(/&\w+/).test(arg)) {
@@ -1043,10 +1051,12 @@ class ActionWithL2 extends _Action__WEBPACK_IMPORTED_MODULE_1__.Action {
   }
   numberToBytes2(number) {
     var hexNumber = number.toString(16);
+    if (!/^[0-9a-f]{1,4}$/i.test(hexNumber)) throw new RangeError('Value must fit in an unsigned 2-byte integer');
     return hexNumber.padStart(4, '0');
   }
   numberToBytes1(number) {
     var hexNumber = number.toString(16);
+    if (!/^[0-9a-f]{1,2}$/i.test(hexNumber)) throw new RangeError('Value must fit in an unsigned 1-byte integer');
     return hexNumber.padStart(2, '0');
   }
   numberToBytes32(number) {
@@ -1233,7 +1243,7 @@ class Recipe {
       for (var pairsPerAction of assetOwnerPairs) {
         var _loop = function* _loop(pair) {
           var isNft = !pair.asset;
-          if (!uniqueAssetOwnerPairs.find(_pair => _pair.owner === pair.owner && (isNft ? _pair.tokenId === pair.tokenId : _pair.asset === pair.asset))) {
+          if (!uniqueAssetOwnerPairs.find(_pair => _pair.owner === pair.owner && (isNft ? 'nft' in _pair && _pair.nft === pair.nft && _pair.tokenId === pair.tokenId : _pair.asset === pair.asset))) {
             if (isNft) {
               uniqueAssetOwnerPairs.push({
                 owner: pair.owner,
@@ -1295,6 +1305,7 @@ class Recipe {
   }
 }
 function _encodeForCall() {
+  if (this.actions.length === 0) throw new Error('Cannot encode an empty recipe');
   var encoded = this.actions.map(action => action.encodeForRecipe());
   var transposed = encoded[0].map((_, colIndex) => encoded.map(row => row[colIndex]));
   var taskStruct = [this.name, ...transposed];
@@ -1327,8 +1338,8 @@ var actionAddresses = {
     TokenBalance: '0xa92B177950F1460119940436515FD857C24494BC',
     AutomationV2Unsub: '0xe35Fb12fE9796847751076aCf5ee7d124108612C',
     SendTokenAndUnwrap: '0x4155537e6933E59a62deb68f6ad93d237d07242a',
-    ToggleSub: '0x2120ad7b4eE1795C8B027c1592eCB918faAb163A',
-    UpdateSub: '0xF6Cb8f7e61a64075ec8FAC3f298745605E543233',
+    ToggleSub: '0xf247a8525E7486884E7227EB9a161507F0FF46A6',
+    UpdateSub: '0x919c472bFA4B50FcACF9849501344aFDde2E4675',
     TransferNFT: '0x861e893E1796F81248e75F06C0b09Abdc8fe2f6F',
     CreateSub: '0xEB13C96257667cF0A037305A46092bf7C70A61e1',
     ApproveToken: '0xA4161cED7A29F0a3424e464a4a2dBf75888c5BF9',
@@ -1670,8 +1681,8 @@ var actionAddresses = {
     SubInputs: '0x60d00020f12dd202eAfDba84e8F69E165a84c64D',
     ApproveToken: '0x842a81d2cfe26d401CD63Cc14e9DEf275c197C1a',
     SendTokenAndUnwrap: '0xd4f69250cb4d1f083Dd372FEace391A16ABbfBDc',
-    ToggleSub: '0xfc19a12e35bb0b5e6a3d3017be9e9022a6486eee',
-    UpdateSub: '0xAe6ea1d13dF2bE60dC7933DB56067Cb89d6A2cDe',
+    ToggleSub: '0xA4Eaad8Fe80d1E47f2b95CED2bcFb648d5929735',
+    UpdateSub: '0xe2c7D66b40e00Dd14844Db8d02142f23D4Da7071',
     CreateSub: '0x2daED8030BFC87B3d27c02E2f044B9CF4841Ff3e',
     TokenBalance: '0xC6FF5b01f7c7b35b6e093fF70D2332B361C5Be5A',
     TokenizedVaultAdapter: '0xdf31669FEd440f5BfF658ca0bBF0D22B8abdeb73',
@@ -1733,14 +1744,14 @@ var actionAddresses = {
     SubInputs: '0x8ec14f9568e1d7cf73b68df899808abd7fe6fc8d',
     SendTokenAndUnwrap: '0x009C5B1c7C844Bd662Da3991295b1B3Bd71a430c',
     ApproveToken: '0x01058999F5Ac434EF48DFB5Cd942c57A7661787B',
-    ToggleSub: '0x2eabbab99759c2ab6e9e309d42ee07d3bc7c38fe',
+    ToggleSub: '0x75469d8f96368F87718162e528104B59550CD71E',
     CreateSub: '0xbFD17a0a844b75976585a382a5BcCaFC9EAd731f',
     TokenBalance: '0x483B903E702F60698Dd8124558C6199922737f1F',
     TokenizedVaultAdapter: '0xD05C512bDFf6D3eAc5328807B3bC075F35271167',
     ChangeProxyOwner: '0xacf5bAD9543A98EcAcC620cF6CB989Ec88f1650D',
     PermitToken: '0x2E5E7a691092C158bb8341b936eF24FCcA6c0e00',
     HandleAuth: '0xbfcab1339e1a56a0a836cbca6457eaf71f148fcb',
-    UpdateSub: '0x3511f444362F8cBd185DbF21C9488D16c1306461',
+    UpdateSub: '0x404c3EE602fb4b2D3E36E371bEA36a27B2177107',
     TransferNFT: '0xf73b14cf4bc10509446fc4111407a721f8a81f7d',
     MerklClaim: '0xdab7b1865efa8d1f8fe1602dea9285b4a599c45c',
     // aave v3
@@ -1839,9 +1850,9 @@ var actionAddresses = {
     ChangeProxyOwner: '0x7b55d25BfF49Fd62563823570f47E9a35AA39541',
     PermitToken: '0x57c8ae94a5A11dA33e0518054102488b604628D0',
     HandleAuth: '0x18a90e6db79199ace00140631ef931e0bd97837c',
-    ToggleSub: '0x5F16C0a08d52b67fc73706c494F7535Dd3382b58',
+    ToggleSub: '0x8879fF7E7B08cdE2e634F7Cd90219e66FB64F01D',
     CreateSub: '0xeE739937085A716477BCB5b01b0f74e1BE046645',
-    UpdateSub: '0x1601c6ABCDE6e6d8Ad96628AFe20d47908127Aea',
+    UpdateSub: '0xB3598798599d3A22EA667e5557C53c139653c673',
     MerklClaim: '0xa2c6cd875c52bf5c27516fae3b6ba9241790908a',
     TransferNFT: '0xe49c70c673c3ef9019fe9c875ed5ed3dc02f5613',
     GasFeeTakerL2: '0xAEe02caf404332c40Fd7FF8d5c25F91f7c1641d0',
@@ -2002,7 +2013,7 @@ var actionAddresses = {
 };
 var otherAddresses = {
   [_config__WEBPACK_IMPORTED_MODULE_0__.NETWORKS.ethereum.chainId]: {
-    RecipeExecutor: '0xbc3Fc959FeF3F12a41738f406c02198cdeE7481F',
+    RecipeExecutor: '0x6e7dEde13E011Eee74E0c731A06c158377fc1Cae',
     DFSRegistry: '0x287778F121F134C66212FB16c9b53eC991D32f5b',
     DFSProxyRegistry: '0x0cCB1F91beb8590949880D2a61C26C11d6280319',
     ProxyRegistry: '0x4678f0a6958e4D2Bc4F1BAF7Bc52E8F3564f3fE4',
@@ -2022,7 +2033,7 @@ var otherAddresses = {
     Empty: '0x0000000000000000000000000000000000000000'
   },
   [_config__WEBPACK_IMPORTED_MODULE_0__.NETWORKS.optimism.chainId]: {
-    RecipeExecutor: '0xEC891E6b5A93F5f29241De6B234a4e77A5456A1C',
+    RecipeExecutor: '0x3296C0f3Ff67B00306e5Ce251CDfA1E0160F5742',
     DFSRegistry: '0xAf707Ee480204Ed6e2640B53cE86F680D28Afcbd',
     ProxyRegistry: '0x283Cc5C26e53D66ed2Ea252D986F094B37E6e895',
     SFProxyEntryPoint: '0x06299D4A07E8C6D7C1aEc14Ab2F46DF05Dd9588E',
@@ -2033,7 +2044,7 @@ var otherAddresses = {
     UniswapV3PositionManager: '0xC36442b4a4522E871399CD717aBDD847Ab11FE88'
   },
   [_config__WEBPACK_IMPORTED_MODULE_0__.NETWORKS.arbitrum.chainId]: {
-    RecipeExecutor: '0x667609f05DdC5E9Fb939eC376F07953403745cf3',
+    RecipeExecutor: '0x1674Df46e92A393d6B29139BF8C2d2885F40F7B2',
     DFSRegistry: '0xBF1CaC12DB60819Bfa71A328282ecbc1D40443aA',
     ProxyRegistry: '0x283Cc5C26e53D66ed2Ea252D986F094B37E6e895',
     SFProxyEntryPoint: '0x15D776C062bF292f8F70A81533E49adC7C06Cb69',
@@ -2044,7 +2055,7 @@ var otherAddresses = {
     UniswapV3PositionManager: '0xC36442b4a4522E871399CD717aBDD847Ab11FE88'
   },
   [_config__WEBPACK_IMPORTED_MODULE_0__.NETWORKS.base.chainId]: {
-    RecipeExecutor: '0xc91305DdE651c899EF8eE1D0C33E7dab1B5ABF0D',
+    RecipeExecutor: '0xB81865b724eF6DAc41DFf125E5445701924ea19D',
     DFSRegistry: '0x347FB634271F666353F23A3362f3935D96F97476',
     ProxyRegistry: '0x425fA97285965E01Cc5F951B62A51F6CDEA5cc0d',
     SFProxyEntryPoint: '0xab6e5cde983fF98Cdb0F61f5F99cb58D40D0c837',