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

package/README.md

@@ -1,16 +1,62 @@
-# DeFi Saver Recipe SDK
+# DeFi Saver SDK
 
-Create complex transactions that interact with multiple DeFi protocols.
+Build actions and combine them into recipes for DeFi Saver smart wallets.
 
----
+## Installation
 
- - [General docs](https://docs.defisaver.com/)
- - [SDK docs](https://github.com/DecenterApps/defisaver-sdk/blob/master/DEV.md)
- - [Available Actions](https://github.com/DecenterApps/defisaver-sdk/blob/master/ACTIONS.md)
- - [Pre-made recipes - TODO](https://github.com/DecenterApps/defisaver-sdk/blob/master/RECIPES.md)
+```sh
+npm install @defisaver/sdk
+```
+
+## Example
+
+Encode a recipe that wraps 0.1 ETH into WETH on Ethereum:
+
+```js
+const { configure, Recipe, actions } = require('@defisaver/sdk');
+
+async function main() {
+  configure({ chainId: 1, testingMode: false });
+
+  const recipe = new Recipe('Wrap ETH', [
+    new actions.basic.WrapEthAction('100000000000000000'),
+  ]);
+
+  const [target, data] = recipe.encodeForDsProxyCall();
+  const value = await recipe.getEthValue();
+  console.log({ target, data, value });
+}
+
+main().catch(console.error);
+```
+
+Amounts use token base units as decimal strings. Here, `value` is the ETH amount in wei. `target` and `data` are arguments for the smart wallet's `execute(address,bytes)` call; encoding does not submit a transaction.
+
+- [Developer guide](docs/DEV.md): recipes, approvals, configuration, and contributing.
+- [Action implementations](src/actions): current constructors and parameter documentation, grouped by protocol.
+- [DeFi Saver documentation](https://docs.defisaver.com/): product and protocol guides.
 
 ## Testing
 
-`npm run test` - Run all tests
+From a local checkout, install dependencies with `npm ci`, then run:
+
+```sh
+# Run offline tests (no RPC required)
+npm run test:unit
+
+# Run all tests, including RPC-dependent wallet tests
+npm test
+
+# Run a single test file (test/Recipe.js)
+npm run test-single --name=Recipe
+```
+
+The full suite requires `RPC` in your environment or a local `.env` file for the wallet tests. Point it at a local or forked test chain.
+
+## Building
+
+```sh
+npm run build
+```
 
-`npm run test-single --name=your_test_name` - Run single test for specified name e.g. for MyTest.js test name is MyTest
+Builds the package and runs lint with automatic fixes. To check lint without changing files, use `npm run lint-check`.

package/docs/DEV.md

@@ -0,0 +1,63 @@
+# Developer guide
+
+The SDK models a transaction as an `Action`, or a sequence of actions as a `Recipe`. Action constructors describe contract inputs; the shared classes handle encoding and composition. See the [README](../README.md) for installation and a minimal example.
+
+## Configuration and amounts
+
+Call `configure({ chainId: 1, testingMode: false })` before constructing actions or recipes. Addresses are resolved during construction. Configuration is global, including the token library's network: avoid switching chains while working with existing objects or concurrent operations.
+
+Use decimal strings in token base units: `'1000000'` represents 1 token with 6 decimals, and `'1000000000000000000'` represents 1 token with 18 decimals. Avoid JavaScript numbers for large amounts. Special values such as a maximum amount are action-specific; check the constructor documentation.
+
+Supported networks are exported as `networks`. Use `getAddr(name, chainId)` to look up a deployment; it throws when the chain or named deployment is unavailable. Network support does not imply every action is deployed there.
+
+## Composing a recipe
+
+This example encodes pulling 1 WETH from an owner into the wallet and returning the amount received to that owner. Replace the example owner with your address when integrating it.
+
+```js
+const { configure, Recipe, actions } = require('@defisaver/sdk');
+
+async function main() {
+  configure({ chainId: 1, testingMode: false });
+
+  const owner = '0x0000000000000000000000000000000000000001';
+  const weth = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+  const recipe = new Recipe('Pull and return WETH', [
+    new actions.basic.PullTokenAction(weth, owner, '1000000000000000000'),
+    new actions.basic.SendTokenAction(weth, owner, '$1'),
+  ]);
+
+  const approvals = await recipe.getAssetsToApprove();
+  const value = await recipe.getEthValue();
+  const [target, data] = recipe.encodeForDsProxyCall();
+  console.log({ approvals, target, data, value });
+}
+
+main().catch(console.error);
+```
+
+`'$1'` refers to the first action's return value, with numbering starting at **1**. References must point to an earlier action and be used in an input that supports mapping. A return value's meaning depends on the action; it is not necessarily a token amount. Nested inputs can have a custom mapping order, defined by the action's `mappableArgs`.
+
+`getAssetsToApprove()` describes assets and owners requiring approval. For the ERC-20 example above, the owner approves the executing smart wallet to spend WETH before execution. The returned metadata does not perform approvals or check existing allowances. NFT approvals use different fields; inspect the returned type when supporting them.
+
+For a DSProxy, pass `target` and `data` to its `execute(address,bytes)` method and attach `value` to that transaction. Other wallet integrations must use their appropriate execution path. Do not treat the returned target as a standalone user transaction destination.
+
+A single action also exposes `encodeForDsProxyCall()`, `getAssetsToApprove()`, and `getEthValue()`. `ActionWithL2` supports specialized packed calldata; callers should normally use the public encoding methods rather than pack bytes themselves.
+
+## Strategies
+
+`Strategy` describes reusable automation: add subscription slots with `addSubSlot`, triggers with `addTrigger`, and actions with `addAction`. Strategy inputs can refer to named subscription slots such as `'&vaultId'`, or the special addresses `'&proxy'` and `'&eoa'`. Action return references still use `'$1'`, `'$2'`, and so on.
+
+Strategy encoding is separate from recipe execution. See the [strategy example](../test/Strategy.js) and [implementation](../src/Strategy.ts) for the current API.
+
+## Adding an action
+
+1. Add a class under the relevant [protocol directory](../src/actions), extending `Action` or `ActionWithL2`.
+2. Match the contract's action name, ABI types, and argument order in the `super` call. Define `mappableArgs` in the order expected by the contract.
+3. Implement approval metadata and ETH value when needed. Implement packed L2 encoding only when the contract supports it.
+4. Export the class through the protocol index and add its deployments to [addresses.ts](../src/addresses.ts).
+5. Add tests for encoded values, mappings, approvals, and ETH value, including relevant boundary cases. Keep constructor parameter documentation beside the implementation.
+
+[PullTokenAction](../src/actions/basic/PullTokenAction.ts) is a small example. Use existing actions for structure, and the corresponding contract as the source of truth for input semantics.
+
+See the [README](../README.md#testing) for testing commands.

package/esm/src/Action.js

@@ -12,7 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Action_instances, _Action__getArgumentMappingWithSlots, _Action__getPlaceholderForType;
+var _Action_instances, _Action__getReturnValueReference, _Action__getArgumentMappingWithSlots, _Action__getPlaceholderForType;
 import AbiCoder from 'web3-eth-abi';
 import { keccak256, padLeft, toHex } from 'web3-utils';
 import { CONFIG } from './config';
@@ -52,12 +52,12 @@ export 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.');
             }
+            const reference = __classPrivateFieldGet(this, _Action_instances, "m", _Action__getReturnValueReference).call(this, arg);
+            if (reference !== undefined)
+                return reference;
             return 0;
         });
     }
@@ -100,7 +100,7 @@ export class Action {
         if (Array.isArray(arg))
             return arg.map((_arg, i) => this._replaceWithPlaceholders(_arg, paramTypeParsed[i]));
         if (typeof (paramType) === 'string') {
-            if (new RegExp(/\$\d+/).test(arg))
+            if (__classPrivateFieldGet(this, _Action_instances, "m", _Action__getReturnValueReference).call(this, arg) !== undefined)
                 return __classPrivateFieldGet(this, _Action_instances, "m", _Action__getPlaceholderForType).call(this, paramType);
             if (new RegExp(/&\w+/).test(arg))
                 return __classPrivateFieldGet(this, _Action_instances, "m", _Action__getPlaceholderForType).call(this, paramType);
@@ -196,14 +196,22 @@ export class Action {
         }));
     }
 }
-_Action_instances = new WeakSet(), _Action__getArgumentMappingWithSlots = function _Action__getArgumentMappingWithSlots(subSlots) {
+_Action_instances = new WeakSet(), _Action__getReturnValueReference = function _Action__getReturnValueReference(arg) {
+    if (typeof arg !== 'string' || !/\$\d+/.test(arg))
+        return undefined;
+    const index = Number(arg.slice(1));
+    if (!/^\$\d+$/.test(arg) || !Number.isSafeInteger(index) || index < 1) {
+        throw new Error(`Invalid action return reference: ${arg}`);
+    }
+    return index;
+}, _Action__getArgumentMappingWithSlots = function _Action__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.');
         }
+        const reference = __classPrivateFieldGet(this, _Action_instances, "m", _Action__getReturnValueReference).call(this, arg);
+        if (reference !== undefined)
+            return reference;
         // Handle SubSlots placeholder values in strategies
         if (new RegExp(/&\w+/).test(arg)) {
             if (arg === '&proxy')

package/esm/src/ActionWithL2.js

@@ -34,10 +34,14 @@ export class ActionWithL2 extends Action {
     }
     numberToBytes2(number) {
         const 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) {
         const 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) {

package/esm/src/Recipe.js

@@ -146,7 +146,9 @@ export class Recipe {
             for (const pairsPerAction of assetOwnerPairs) {
                 for (const pair of pairsPerAction) {
                     const 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,
@@ -196,6 +198,8 @@ export class Recipe {
     }
 }
 _Recipe_instances = new WeakSet(), _Recipe__encodeForCall = function _Recipe__encodeForCall() {
+    if (this.actions.length === 0)
+        throw new Error('Cannot encode an empty recipe');
     const encoded = this.actions.map(action => action.encodeForRecipe());
     const transposed = encoded[0].map((_, colIndex) => encoded.map(row => row[colIndex]));
     const taskStruct = [

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "@defisaver/sdk",
-  "version": "1.3.36",
+  "version": "1.3.37-semi-continuous-dev",
   "description": "",
   "main": "./umd/index.js",
   "module": "./esm/src/index.js",
   "types": "./esm/src/index.d.ts",
   "scripts": {
     "test": "mocha 'test/**'",
+    "test:unit": "mocha 'test/**/*.js' --exclude test/DfsWeb3.js",
     "test-single": "mocha ./test/$npm_config_name.js",
     "version-bump": "git commit -am \"Version bump to $(npm version patch | cut -c 2-)\"",
     "build:esm": "rm -rf esm && tsc -p tsconfig.esm.json",
     "build:umd": "rm -rf umd && webpack --config=webpack.umd.js",
     "build": "npm run lint && npm run build:umd && npm run build:esm",
-    "documentMD": "npx typedoc --plugin typedoc-plugin-markdown --out docs/md",
-    "document": "npx typedoc --out docs/default",
     "lint": "eslint . --ext .ts --fix",
     "lint-check": "eslint .",
     "build-test": "npm run build && npm run test"
@@ -74,11 +73,8 @@
     "chai": "^4.2.0",
     "dotenv": "^10.0.0",
     "eslint": "^8.57.0",
-    "jsdoc-to-markdown": "^9.1.3",
     "mocha": "^11.8.0",
     "ts-node": "^10.9.1",
-    "typedoc": "^0.23.20",
-    "typedoc-plugin-markdown": "^3.13.6",
     "typescript": "^4.8.4",
     "webpack": "^5.91.0",
     "webpack-cli": "^4.10.0"

package/src/Action.ts

@@ -49,16 +49,25 @@ export class Action {
     return keccak256(this.name).substr(0, 10);
   }
 
+  #_getReturnValueReference(arg: unknown): number | undefined {
+    if (typeof arg !== 'string' || !/\$\d+/.test(arg)) return undefined;
+    const index = Number(arg.slice(1));
+    if (!/^\$\d+$/.test(arg) || !Number.isSafeInteger(index) || index < 1) {
+      throw new Error(`Invalid action return reference: ${arg}`);
+    }
+    return index;
+  }
+
   /**
    *
    */
   #_getArgumentMappingWithSlots(subSlots: Args) : Array<number> {
     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.');
       }
+      const reference = this.#_getReturnValueReference(arg);
+      if (reference !== undefined) return reference;
 
       // Handle SubSlots placeholder values in strategies
       if (new RegExp(/&\w+/).test(arg)) {
@@ -77,11 +86,11 @@ export class Action {
    */
   _getArgumentMapping() : Args {
     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.');
       }
+      const reference = this.#_getReturnValueReference(arg);
+      if (reference !== undefined) return reference;
       return 0;
     });
   }
@@ -136,7 +145,7 @@ export class Action {
     const 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 this.#_getPlaceholderForType(paramType);
+      if (this.#_getReturnValueReference(arg) !== undefined) return this.#_getPlaceholderForType(paramType);
       if (new RegExp(/&\w+/).test(arg)) return this.#_getPlaceholderForType(paramType);
     }
     return arg;

package/src/ActionWithL2.ts

@@ -31,11 +31,13 @@ export class ActionWithL2 extends Action {
 
   numberToBytes2(number:number) {
     const 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:number) {
     const 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');
   }
 

package/src/Recipe.ts

@@ -57,6 +57,7 @@ export class Recipe {
    *
    */
   #_encodeForCall(): Array<string | Array<any>> {
+    if (this.actions.length === 0) throw new Error('Cannot encode an empty recipe');
     const encoded = this.actions.map(action => action.encodeForRecipe());
     const transposed = encoded[0].map((_, colIndex) => encoded.map(row => row[colIndex]));
     const taskStruct = [
@@ -170,7 +171,9 @@ export class Recipe {
     for (const pairsPerAction of assetOwnerPairs) {
       for (const pair of pairsPerAction) {
         const 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!,

package/test/Action.js

@@ -39,7 +39,8 @@ describe('Action', () => {
     let action;
     it('Constructor', () => {
       action = new dfs.Action('MockSwap', '0x0a80C3C540eEF99811f4579fa7b1A0617294e06f', ['uint256', 'address'], ['$1', '0x6b175474e89094c44da98b954eedeac495271d0f']);
-      action.mappableArgs = [action.args[0][0], action.args[0][1]];
+      action.mappableArgs = [action.args[0], action.args[1]];
+      assert.deepEqual(action.encodeForRecipe()[3], [1, 0]);
     })
     it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
     it('encodeForRecipe', () => encodeForRecipe(action));
@@ -55,8 +56,87 @@ describe('Action', () => {
       assert.throws(() => encodeForRecipe(action));
     });
     it('encodeForRecipe with custom mappableArgs', () => {
-      action.mappableArgs = [action.args[0][0][0], action.args[0][1]];
-      encodeForRecipe(action)
+      action.mappableArgs = [action.args[0][0], action.args[1]];
+      assert.deepEqual(action.encodeForRecipe()[3], [1, 0]);
     });
   })
 })
+
+
+describe('Action encoding', () => {
+  const AbiCoder = require('web3-eth-abi');
+  const target = '0x0000000000000000000000000000000000000001';
+  const recipient = '0x0000000000000000000000000000000000000002';
+  const zeroWord = '0'.repeat(64);
+
+  it('encodes the target, selector, arguments, ID and unmapped inputs', () => {
+    const action = new dfs.Action('MockSwap', target, ['uint256', 'address'], ['5', recipient]);
+    // Static ABI tuple: one word for the amount, one for the address.
+    const payload = `0x${'5'.padStart(64, '0')}${'2'.padStart(64, '0')}`;
+    assert.deepEqual(action.encodeForRecipe(), [payload, `0x${zeroWord}`, '0xe45f86c0', [0, 0]]);
+    const [address, data] = action.encodeForDsProxyCall();
+    assert.equal(address, target);
+    assert.equal(data.slice(0, 10), '0x389f87ff'); // executeActionDirect(bytes)
+    assert.equal(AbiCoder.decodeParameter('bytes', `0x${data.slice(10)}`), payload);
+  });
+
+  it('replaces mapped inputs with zeros without changing the original arguments', () => {
+    const args = ['$2', recipient];
+    const action = new dfs.Action('MockSwap', target, ['uint256', 'address'], args);
+    const [payload, , , mapping] = action.encodeForRecipe();
+    assert.equal(payload, `0x${zeroWord}${'2'.padStart(64, '0')}`);
+    assert.deepEqual(mapping, [2, 0]);
+    assert.deepEqual(args, ['$2', recipient]);
+  });
+
+  it('preserves nested tuple and array values around mapped inputs', () => {
+    const args = [['7', ['$1', recipient]], ['11', '13']];
+    const action = new dfs.Action('MockSwap', target,
+      [['uint256', ['uint256', 'address']], 'uint256[]'], args);
+    action.mappableArgs = [args[0][1][0], args[0][1][1]];
+    const [payload, , , mapping] = action.encodeForRecipe();
+    const decoded = AbiCoder.decodeParameter('((uint256,(uint256,address)),uint256[])', payload);
+    assert.equal(decoded[0][0], '7');
+    assert.equal(decoded[0][1][0], '0');
+    assert.equal(decoded[0][1][1], recipient);
+    assert.deepEqual(decoded[1], ['11', '13']);
+    assert.deepEqual(mapping, [1, 0]);
+    assert.equal(args[0][1][0], '$1');
+  });
+
+  it('maps strategy slots and special wallet references', () => {
+    const action = new dfs.Action('MockSwap', target,
+      ['uint256', 'uint256', 'address', 'address', 'uint256'],
+      ['$1', '&amount', '&proxy', '&eoa', '9']);
+    assert.deepEqual(action.encodeForStrategy({ '&amount': { index: 128 } }),
+      ['0xe45f86c0', [1, 128, 254, 255, 0]]);
+  });
+
+  it('rejects mismatched argument counts', () => {
+    assert.throws(() => new dfs.Action('MockSwap', target, ['uint256'], []),
+      'Parameters/arguments length mismatch');
+  });
+});
+
+
+describe('Action reference validation', () => {
+  const target = '0x0000000000000000000000000000000000000001';
+
+  for (const reference of ['$0', '$1junk', 'prefix$1', '$1.5', '$9007199254740992']) {
+    it(`rejects malformed reference ${reference} in every encoding path`, () => {
+      const action = new dfs.Action('MockSwap', target, ['uint256'], [reference]);
+      for (const encode of [
+        () => action.encodeForDsProxyCall(),
+        () => action.encodeForRecipe(),
+        () => action.encodeForStrategy({}),
+      ]) {
+        assert.throws(encode, `Invalid action return reference: ${reference}`);
+      }
+    });
+  }
+
+  it('preserves existing leading-zero references and ordinary strings', () => {
+    const action = new dfs.Action('MockSwap', target, ['uint256', 'string'], ['$01', '$price']);
+    assert.deepEqual(action.encodeForRecipe()[3], [1, 0]);
+  });
+});

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');
   });
-})
+});