@defisaver/sdk 1.3.36 → 1.3.37-semi-continuous-dev

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];