@truffle/codec - npm Package Compare versions

Comparing version 0.15.2 to 0.15.3

dist/lib/core.d.ts

@@ -14,3 +14,4 @@ import * as Ast from "./ast";
  */
-export declare function decodeCalldata(info: Evm.EvmInfo, isConstructor?: boolean): Generator<DecoderRequest, CalldataDecoding, Uint8Array>;
+export declare function decodeCalldata(info: Evm.EvmInfo, isConstructor?: boolean, //ignored if context! trust context instead if have
+strictAbiMode?: boolean): Generator<DecoderRequest, CalldataDecoding, Uint8Array>;
 /**
@@ -17,0 +18,0 @@ * @Category Decoding

dist/lib/core.js

@@ -55,3 +55,8 @@ "use strict";
  */
-function* decodeCalldata(info, isConstructor //ignored if context! trust context instead if have
+function* decodeCalldata(info, isConstructor, //ignored if context! trust context instead if have
+strictAbiMode //used for selector-based decoding. has two effects:
+//1. sets the strictAbiMode option when calling decode(), causing it to throw
+//if it encounters a problem rather than returning an ErrorResult;
+//2. performs a re-encoding check at the end (like decodeEvevent and decodeReturndata)
+//and throws if it fails
 ) {
@@ -130,3 +135,4 @@ const context = info.currentContext;
                 abiPointerBase: allocation.offset,
-                allowRetry: decodingMode === "full"
+                allowRetry: decodingMode === "full",
+                strictAbiMode
             });
@@ -150,3 +156,4 @@ }
                 argumentAllocation.pointer, info, {
-                    abiPointerBase: allocation.offset
+                    abiPointerBase: allocation.offset,
+                    strictAbiMode
                 });
@@ -167,2 +174,21 @@ //4. the remaining parameters will then automatically be decoded in ABI mode due to (1),
     }
+    //if we're in strict mode, do a re-encoding check
+    if (strictAbiMode) {
+        const decodedArgumentValues = decodedArguments.map(argument => argument.value);
+        const reEncodedData = AbiData.Encode.encodeTupleAbi(decodedArgumentValues, info.allocations.abi);
+        const selectorLength = isConstructor
+            ? (context.binary.length - 2) / 2 //for a constructor, the bytecode acts as the "selector"
+            : //note we have to account for the fact that it's a hex string
+                Evm.Utils.SELECTOR_SIZE;
+        const encodedData = info.state.calldata.subarray(selectorLength); //slice off the selector
+        if (!Evm.Utils.equalData(reEncodedData, encodedData)) {
+            //if not, this allocation doesn't work
+            debug("rejected due to mismatch");
+            throw new errors_1.StopDecodingError({
+                kind: "ReEncodingMismatchError",
+                data: encodedData,
+                reEncodedData
+            });
+        }
+    }
     if (isConstructor) {
@@ -169,0 +195,0 @@ return {

dist/lib/format/errors.d.ts

@@ -759,3 +759,3 @@ import type BN from "bn.js";
  */
-export type InternalUseError = OverlongArrayOrStringStrictModeError | InternalFunctionInABIError;
+export type InternalUseError = OverlongArrayOrStringStrictModeError | InternalFunctionInABIError | ReEncodingMismatchError;
 /**
@@ -779,1 +779,13 @@ * Error for the stricter length check in strict mode
 }
+/**
+ * This isn't really an error that one can get as part of a `Result`, but we
+ * need something for when re-encoding doesn't match and we're decoding a
+ * transaction (since there we have to error instead of just skipping).
+ *
+ * @Category Internal-use errors
+ */
+export interface ReEncodingMismatchError {
+    kind: "ReEncodingMismatchError";
+    data: Uint8Array;
+    reEncodedData: Uint8Array;
+}

dist/lib/format/utils/inspect.d.ts

@@ -17,2 +17,8 @@ /// <reference types="node" />
     noHideAddress?: boolean;
+    /**
+     * This flag, if set, causes mappings to be rendered via objects
+     * rather than Maps.  This is intended for compatibility and not
+     * recommended for normal use.
+     */
+    renderMappingsViaObjects?: boolean;
 }
@@ -19,0 +25,0 @@ /**

dist/lib/format/utils/inspect.js

@@ -127,6 +127,16 @@ "use strict";
                     case "mapping":
-                        return util_1.default.inspect(new Map(this.result.value.map(({ key, value }) => [
-                            new ResultInspector(key, this.options),
-                            new ResultInspector(value, this.options)
-                        ])), options);
+                        if (!this.options.renderMappingsViaObjects) {
+                            //normal case
+                            return util_1.default.inspect(new Map(this.result.value.map(({ key, value }) => [
+                                new ResultInspector(key, this.options),
+                                new ResultInspector(value, this.options)
+                            ])), options);
+                        }
+                        else {
+                            //compatibility case
+                            return util_1.default.inspect(Object.assign({}, ...this.result.value.map(({ key, value }) => ({
+                                //need to stringify key
+                                [util_1.default.inspect(new ResultInspector(key, this.options), options)]: new ResultInspector(value, this.options)
+                            }))), options);
+                        }
                     case "struct": {
@@ -133,0 +143,0 @@ let coercedResult = this.result;

dist/lib/types.d.ts

@@ -204,5 +204,14 @@ import type BN from "bn.js";
      * @truffle/codec itself.  See individual interpretations for details.
-     * (Currently there are none for this type.)
      */
-    interpretations: {};
+    interpretations: {
+        /**
+         * If we can't recognize the function, we attempt to see if we can decode based on the
+         * function selector alone using https://www.4byte.directory/ to determine possible
+         * signatures.  Note these decodings will necessarily be made in ABI mode, and will
+         * even be lacking names of struct members.
+         *
+         * This interpretation will only be present if the array is nonempty.
+         */
+        selectorBasedDecodings?: FunctionDecoding[];
+    };
 }
@@ -233,5 +242,14 @@ /**
      * @truffle/codec itself.  See individual interpretations for details.
-     * (Currently there are none for this type.)
      */
-    interpretations: {};
+    interpretations: {
+        /**
+         * If we can't recognize the function, we attempt to see if we can decode based on the
+         * function selector alone using https://www.4byte.directory/ to determine possible
+         * signatures.  Note these decodings will necessarily be made in ABI mode, and will
+         * even be lacking names of struct members.
+         *
+         * This interpretation will only be present if the array is nonempty.
+         */
+        selectorBasedDecodings?: FunctionDecoding[];
+    };
 }
@@ -238,0 +256,0 @@ /**

package.json

@@ -15,3 +15,3 @@ {
   },
-  "version": "0.15.2",
+  "version": "0.15.3",
   "main": "dist/lib/index.js",
@@ -67,3 +67,3 @@ "files": [
   },
-  "gitHead": "7983a54d1f931d770c6fbb028bc27cdbcf5dfcbe"
+  "gitHead": "cb01f46c8df6b8aa693856ecdf7c0f37159c4864"
 }

No alert changes

Improved metrics

Total package byte prevSize

27786239

0.4%

Number of package files

985

0.41%

Lines of code

115235

0.72%

No dependency changes