@ledgerhq/context-module 0.0.0-develop-20241017000946 → 0.0.0-rnble-transport-20250219100517

package/lib/types/src/uniswap/domain/UniswapContextLoader.d.ts

@@ -0,0 +1,105 @@
+import { ContextLoader } from "../../shared/domain/ContextLoader";
+import { ClearSignContext } from "../../shared/model/ClearSignContext";
+import { TransactionContext } from "../../shared/model/TransactionContext";
+import { type TokenDataSource } from "../../token/data/TokenDataSource";
+import { type CommandDecoderDataSource } from "../../uniswap/data/CommandDecoderDataSource";
+export declare class UniswapContextLoader implements ContextLoader {
+    private commandDecoderDataSource;
+    private tokenDataSource;
+    constructor(commandDecoderDataSource: CommandDecoderDataSource, tokenDataSource: TokenDataSource);
+    load(transaction: TransactionContext): Promise<ClearSignContext[]>;
+    /**
+     * Constructs the external plugin context for Uniswap external plugin command.
+     *
+     * @private
+     * @returns {ClearSignContext} - The generated external plugin context.
+     */
+    private _buildUniswapPluginCommandData;
+    /**
+     * Extracts and decodes the clear sign contexts from a Uniswap calldata transaction.
+     *
+     * This function:
+     * - Parses the calldata using the Uniswap `execute` function signature.
+     * - Extracts and validates the `commands` and `inputs`.
+     * - Decodes the commands and ensures they match the number of inputs.
+     * - Extracts addresses used in the transaction and verifies if chaining swaps are supported.
+     * - Fetches token information for unique addresses.
+     * - Returns an array of `ClearSignContext` objects representing either token data or errors.
+     *
+     * @private
+     * @param {HexaString} calldata - The raw calldata of the Uniswap transaction.
+     * @param {number} chainId - The blockchain chain ID where the transaction is being executed.
+     * @returns {Promise<ClearSignContext[]>} - A promise resolving to an array of clear sign contexts.
+     */
+    private _extractClearSignContexts;
+    /**
+     * Extracts Uniswap-supported commands from a hexadecimal string.
+     * Each command is represented by one byte (2 hex characters), and this function:
+     * - Maps each command to a known Uniswap command.
+     * - Returns `Nothing` if any extracted command is unsupported.
+     *
+     * @private
+     * @param {HexaString} hex - A hexadecimal string representing commands.
+     * @returns {Maybe<UniswapSupportedCommand[]>} - A `Maybe` containing an array of recognized commands, or `Nothing` if any command is unsupported.
+     *
+     * @example
+     * // Valid command extraction
+     * _extractCommands('0x0008');
+     * // Returns: Just(['0x00', '0x08'])
+     *
+     * @example
+     * // Contains an unsupported command (0x05 is not supported)
+     * _extractCommands('0x0005');
+     * // Returns: Nothing
+     *
+     * @example
+     * // Empty or invalid input
+     * _extractCommands('0x');
+     * // Returns: Nothing
+     */
+    private _extractCommands;
+    /**
+     * Checks if the provided swap commands can be chained together.
+     * A valid chain requires that:
+     * - The output asset of the previous swap matches the input asset of the next swap.
+     * - The pool version remains consistent across swaps.
+     *
+     * @private
+     * @param {Array<[UniswapSupportedCommand, HexaString[]]>} data - An array of tuples containing a swap command and associated addresses.
+     * @returns {boolean} - Returns `true` if the swap commands form a valid chain, otherwise `false`.
+     *
+     * @example
+     * // Valid chaining: same output/input asset and pool version
+     * _isChainingSwapSupported([
+     *   ['0x08', ['0xABC', '0xDEF']],
+     *   ['0x08', ['0xDEF', '0x123']]
+     * ]);
+     * // Returns: true
+     *
+     * @example
+     * // Invalid chaining: different pool versions
+     * _isChainingSwapSupported([
+     *   ['0x08', ['0xABC', '0xDEF']],
+     *   ['0x01', ['0xDEF', '0x123']]
+     * ]);
+     * // Returns: false
+     *
+     * @example
+     * // Invalid chaining: output does not match next input
+     * _isChainingSwapSupported([
+     *   ['0x01A1', ['0xABC', '0xDEF']],
+     *   ['0x01B2', ['0xXYZ', '0x123']]
+     * ]);
+     * // Returns: false
+     */
+    private _isChainingSwapSupported;
+    /**
+     * Checks if a given value is an array of hexadecimal strings.
+     *
+     * @private
+     * @param {unknown} array - The value to check.
+     * @returns {array is HexaString[]} - `true` if the value is an array of hexadecimal strings, otherwise `false`.
+     */
+    private _isHexaStringArray;
+}
+//# sourceMappingURL=UniswapContextLoader.d.ts.map

package/lib/types/src/uniswap/domain/UniswapContextLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniswapContextLoader.d.ts","sourceRoot":"","sources":["../../../../../src/uniswap/domain/UniswapContextLoader.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EACL,gBAAgB,EAEjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAcpE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAGxF,qBACa,oBAAqB,YAAW,aAAa;IAGtD,OAAO,CAAC,wBAAwB;IAEhC,OAAO,CAAC,eAAe;gBAFf,wBAAwB,EAAE,wBAAwB,EAElD,eAAe,EAAE,eAAe;IAGpC,IAAI,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAsBxE;;;;;OAKG;IACH,OAAO,CAAC,8BAA8B;IAetC;;;;;;;;;;;;;;;OAeG;YACW,yBAAyB;IA8DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,OAAO,CAAC,wBAAwB;IA2BhC;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;CAM3B"}

package/lib/types/src/uniswap/domain/UniswapContextLoader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=UniswapContextLoader.test.d.ts.map

package/lib/types/src/uniswap/domain/UniswapContextLoader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniswapContextLoader.test.d.ts","sourceRoot":"","sources":["../../../../../src/uniswap/domain/UniswapContextLoader.test.ts"],"names":[],"mappings":""}