ripple-binary-codec 0.2.7 → 1.0.0-mpt-beta

package/dist/index.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreTypes = exports.DEFAULT_DEFINITIONS = exports.XrplDefinitionsBase = exports.XrplDefinitions = exports.TRANSACTION_TYPES = exports.decodeLedgerData = exports.decodeQuality = exports.encodeQuality = exports.encodeForMultisigning = exports.encodeForSigningClaim = exports.encodeForSigning = exports.encode = exports.decode = void 0;
+const coretypes_1 = require("./coretypes");
+const ledger_hashes_1 = require("./ledger-hashes");
+Object.defineProperty(exports, "decodeLedgerData", { enumerable: true, get: function () { return ledger_hashes_1.decodeLedgerData; } });
+const enums_1 = require("./enums");
+Object.defineProperty(exports, "XrplDefinitionsBase", { enumerable: true, get: function () { return enums_1.XrplDefinitionsBase; } });
+Object.defineProperty(exports, "TRANSACTION_TYPES", { enumerable: true, get: function () { return enums_1.TRANSACTION_TYPES; } });
+Object.defineProperty(exports, "DEFAULT_DEFINITIONS", { enumerable: true, get: function () { return enums_1.DEFAULT_DEFINITIONS; } });
+const xrpl_definitions_1 = require("./enums/xrpl-definitions");
+Object.defineProperty(exports, "XrplDefinitions", { enumerable: true, get: function () { return xrpl_definitions_1.XrplDefinitions; } });
+const types_1 = require("./types");
+Object.defineProperty(exports, "coreTypes", { enumerable: true, get: function () { return types_1.coreTypes; } });
+const utils_1 = require("@xrplf/isomorphic/utils");
+const { signingData, signingClaimData, multiSigningData, binaryToJSON, serializeObject, } = coretypes_1.binary;
+/**
+ * Decode a transaction
+ *
+ * @param binary hex-string of the encoded transaction
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
+ * @returns the JSON representation of the transaction
+ */
+function decode(binary, definitions) {
+    if (typeof binary !== 'string') {
+        throw new Error('binary must be a hex string');
+    }
+    return binaryToJSON(binary, definitions);
+}
+exports.decode = decode;
+/**
+ * Encode a transaction
+ *
+ * @param json The JSON representation of a transaction
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
+ *
+ * @returns A hex-string of the encoded transaction
+ */
+function encode(json, definitions) {
+    if (typeof json !== 'object') {
+        throw new Error();
+    }
+    return (0, utils_1.bytesToHex)(serializeObject(json, { definitions }));
+}
+exports.encode = encode;
+/**
+ * Encode a transaction and prepare for signing
+ *
+ * @param json JSON object representing the transaction
+ * @param signer string representing the account to sign the transaction with
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
+ * @returns a hex string of the encoded transaction
+ */
+function encodeForSigning(json, definitions) {
+    if (typeof json !== 'object') {
+        throw new Error();
+    }
+    return (0, utils_1.bytesToHex)(signingData(json, coretypes_1.HashPrefix.transactionSig, {
+        definitions,
+    }));
+}
+exports.encodeForSigning = encodeForSigning;
+/**
+ * Encode a transaction and prepare for signing with a claim
+ *
+ * @param json JSON object representing the transaction
+ * @param signer string representing the account to sign the transaction with
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
+ * @returns a hex string of the encoded transaction
+ */
+function encodeForSigningClaim(json) {
+    if (typeof json !== 'object') {
+        throw new Error();
+    }
+    return (0, utils_1.bytesToHex)(signingClaimData(json));
+}
+exports.encodeForSigningClaim = encodeForSigningClaim;
+/**
+ * Encode a transaction and prepare for multi-signing
+ *
+ * @param json JSON object representing the transaction
+ * @param signer string representing the account to sign the transaction with
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
+ * @returns a hex string of the encoded transaction
+ */
+function encodeForMultisigning(json, signer, definitions) {
+    if (typeof json !== 'object') {
+        throw new Error();
+    }
+    if (json['SigningPubKey'] !== '') {
+        throw new Error();
+    }
+    const definitionsOpt = definitions ? { definitions } : undefined;
+    return (0, utils_1.bytesToHex)(multiSigningData(json, signer, definitionsOpt));
+}
+exports.encodeForMultisigning = encodeForMultisigning;
+/**
+ * Encode a quality value
+ *
+ * @param value string representation of a number
+ * @returns a hex-string representing the quality
+ */
+function encodeQuality(value) {
+    if (typeof value !== 'string') {
+        throw new Error();
+    }
+    return (0, utils_1.bytesToHex)(coretypes_1.quality.encode(value));
+}
+exports.encodeQuality = encodeQuality;
+/**
+ * Decode a quality value
+ *
+ * @param value hex-string of a quality
+ * @returns a string representing the quality
+ */
+function decodeQuality(value) {
+    if (typeof value !== 'string') {
+        throw new Error();
+    }
+    return coretypes_1.quality.decode(value).toString();
+}
+exports.decodeQuality = decodeQuality;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,2CAAyD;AACzD,mDAAkD;AAiJhD,iGAjJO,gCAAgB,OAiJP;AA9IlB,mCAIgB;AA6Id,oGAhJA,2BAAmB,OAgJA;AAFnB,kGA7IA,yBAAiB,OA6IA;AAGjB,oGA/IA,2BAAmB,OA+IA;AA7IrB,+DAA0D;AA2IxD,gGA3IO,kCAAe,OA2IP;AA1IjB,mCAAmC;AA6IjC,0FA7IO,iBAAS,OA6IP;AA5IX,mDAAoD;AAEpD,MAAM,EACJ,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,eAAe,GAChB,GAAG,kBAAM,CAAA;AAEV;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,MAAc,EAAE,WAAiC;IAC/D,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAA;KAC/C;IACD,OAAO,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AAC1C,CAAC;AA0GC,wBAAM;AAxGR;;;;;;;GAOG;AACH,SAAS,MAAM,CAAC,IAAY,EAAE,WAAiC;IAC7D,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,KAAK,EAAE,CAAA;KAClB;IACD,OAAO,IAAA,kBAAU,EAAC,eAAe,CAAC,IAAkB,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC,CAAA;AACzE,CAAC;AA4FC,wBAAM;AA1FR;;;;;;;GAOG;AACH,SAAS,gBAAgB,CACvB,IAAY,EACZ,WAAiC;IAEjC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,KAAK,EAAE,CAAA;KAClB;IACD,OAAO,IAAA,kBAAU,EACf,WAAW,CAAC,IAAkB,EAAE,sBAAU,CAAC,cAAc,EAAE;QACzD,WAAW;KACZ,CAAC,CACH,CAAA;AACH,CAAC;AAuEC,4CAAgB;AArElB;;;;;;;GAOG;AACH,SAAS,qBAAqB,CAAC,IAAY;IACzC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,KAAK,EAAE,CAAA;KAClB;IACD,OAAO,IAAA,kBAAU,EAAC,gBAAgB,CAAC,IAAmB,CAAC,CAAC,CAAA;AAC1D,CAAC;AAyDC,sDAAqB;AAvDvB;;;;;;;GAOG;AACH,SAAS,qBAAqB,CAC5B,IAAY,EACZ,MAAc,EACd,WAAiC;IAEjC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,KAAK,EAAE,CAAA;KAClB;IACD,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,EAAE;QAChC,MAAM,IAAI,KAAK,EAAE,CAAA;KAClB;IACD,MAAM,cAAc,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAAA;IAChE,OAAO,IAAA,kBAAU,EACf,gBAAgB,CAAC,IAAkB,EAAE,MAAM,EAAE,cAAc,CAAC,CAC7D,CAAA;AACH,CAAC;AAiCC,sDAAqB;AA/BvB;;;;;GAKG;AACH,SAAS,aAAa,CAAC,KAAa;IAClC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,MAAM,IAAI,KAAK,EAAE,CAAA;KAClB;IACD,OAAO,IAAA,kBAAU,EAAC,mBAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;AAC1C,CAAC;AAqBC,sCAAa;AAnBf;;;;;GAKG;AACH,SAAS,aAAa,CAAC,KAAa;IAClC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,MAAM,IAAI,KAAK,EAAE,CAAA;KAClB;IACD,OAAO,mBAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAA;AACzC,CAAC;AASC,sCAAa"}

package/dist/ledger-hashes.d.ts

@@ -0,0 +1,48 @@
+import { Hash256 } from './types/hash-256';
+import { JsonObject } from './types/serialized-type';
+import { XrplDefinitionsBase } from './enums';
+/**
+ * Function computing the hash of a transaction tree
+ *
+ * @param param An array of transaction objects to hash
+ * @returns A Hash256 object
+ */
+declare function transactionTreeHash(param: Array<JsonObject>): Hash256;
+/**
+ * Function computing the hash of accountState
+ *
+ * @param param A list of accountStates hash
+ * @returns A Hash256 object
+ */
+declare function accountStateHash(param: Array<JsonObject>): Hash256;
+/**
+ * Interface describing a ledger header
+ */
+interface ledgerObject {
+    ledger_index: number;
+    total_coins: string | number | bigint;
+    parent_hash: string;
+    transaction_hash: string;
+    account_hash: string;
+    parent_close_time: number;
+    close_time: number;
+    close_time_resolution: number;
+    close_flags: number;
+}
+/**
+ * Serialize and hash a ledger header
+ *
+ * @param header a ledger header
+ * @returns the hash of header
+ */
+declare function ledgerHash(header: ledgerObject): Hash256;
+/**
+ * Decodes a serialized ledger header
+ *
+ * @param binary A serialized ledger header
+ * @param definitions Type definitions to parse the ledger objects.
+ *      Used if there are non-default ledger objects to decode.
+ * @returns A JSON object describing a ledger header
+ */
+declare function decodeLedgerData(binary: string, definitions?: XrplDefinitionsBase): object;
+export { accountStateHash, transactionTreeHash, ledgerHash, decodeLedgerData };

package/dist/ledger-hashes.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeLedgerData = exports.ledgerHash = exports.transactionTreeHash = exports.accountStateHash = void 0;
+const shamap_1 = require("./shamap");
+const hash_prefixes_1 = require("./hash-prefixes");
+const hashes_1 = require("./hashes");
+const binary_1 = require("./binary");
+const hash_256_1 = require("./types/hash-256");
+const st_object_1 = require("./types/st-object");
+const uint_64_1 = require("./types/uint-64");
+const uint_32_1 = require("./types/uint-32");
+const uint_8_1 = require("./types/uint-8");
+const binary_parser_1 = require("./serdes/binary-parser");
+/**
+ * Computes the hash of a list of objects
+ *
+ * @param itemizer Converts an item into a format that can be added to SHAMap
+ * @param itemsJson Array of items to add to a SHAMap
+ * @returns the hash of the SHAMap
+ */
+function computeHash(itemizer, itemsJson) {
+    const map = new shamap_1.ShaMap();
+    itemsJson.forEach((item) => map.addItem(...itemizer(item)));
+    return map.hash();
+}
+/**
+ * Convert a transaction into an index and an item
+ *
+ * @param json transaction with metadata
+ * @returns a tuple of index and item to be added to SHAMap
+ */
+function transactionItemizer(json) {
+    if (!json.hash) {
+        throw new Error();
+    }
+    const index = hash_256_1.Hash256.from(json.hash);
+    const item = {
+        hashPrefix() {
+            return hash_prefixes_1.HashPrefix.transaction;
+        },
+        toBytesSink(sink) {
+            const serializer = new binary_1.BinarySerializer(sink);
+            serializer.writeLengthEncoded(st_object_1.STObject.from(json));
+            serializer.writeLengthEncoded(st_object_1.STObject.from(json.metaData));
+        },
+    };
+    return [index, item, undefined];
+}
+/**
+ * Convert an entry to a pair Hash256 and ShaMapNode
+ *
+ * @param json JSON describing a ledger entry item
+ * @returns a tuple of index and item to be added to SHAMap
+ */
+function entryItemizer(json) {
+    const index = hash_256_1.Hash256.from(json.index);
+    const bytes = (0, binary_1.serializeObject)(json);
+    const item = {
+        hashPrefix() {
+            return hash_prefixes_1.HashPrefix.accountStateEntry;
+        },
+        toBytesSink(sink) {
+            sink.put(bytes);
+        },
+    };
+    return [index, item, undefined];
+}
+/**
+ * Function computing the hash of a transaction tree
+ *
+ * @param param An array of transaction objects to hash
+ * @returns A Hash256 object
+ */
+function transactionTreeHash(param) {
+    const itemizer = transactionItemizer;
+    return computeHash(itemizer, param);
+}
+exports.transactionTreeHash = transactionTreeHash;
+/**
+ * Function computing the hash of accountState
+ *
+ * @param param A list of accountStates hash
+ * @returns A Hash256 object
+ */
+function accountStateHash(param) {
+    const itemizer = entryItemizer;
+    return computeHash(itemizer, param);
+}
+exports.accountStateHash = accountStateHash;
+/**
+ * Serialize and hash a ledger header
+ *
+ * @param header a ledger header
+ * @returns the hash of header
+ */
+function ledgerHash(header) {
+    const hash = new hashes_1.Sha512Half();
+    hash.put(hash_prefixes_1.HashPrefix.ledgerHeader);
+    if (header.parent_close_time === undefined ||
+        header.close_flags === undefined) {
+        throw new Error();
+    }
+    uint_32_1.UInt32.from(header.ledger_index).toBytesSink(hash);
+    uint_64_1.UInt64.from(BigInt(String(header.total_coins))).toBytesSink(hash);
+    hash_256_1.Hash256.from(header.parent_hash).toBytesSink(hash);
+    hash_256_1.Hash256.from(header.transaction_hash).toBytesSink(hash);
+    hash_256_1.Hash256.from(header.account_hash).toBytesSink(hash);
+    uint_32_1.UInt32.from(header.parent_close_time).toBytesSink(hash);
+    uint_32_1.UInt32.from(header.close_time).toBytesSink(hash);
+    uint_8_1.UInt8.from(header.close_time_resolution).toBytesSink(hash);
+    uint_8_1.UInt8.from(header.close_flags).toBytesSink(hash);
+    return hash.finish();
+}
+exports.ledgerHash = ledgerHash;
+/**
+ * Decodes a serialized ledger header
+ *
+ * @param binary A serialized ledger header
+ * @param definitions Type definitions to parse the ledger objects.
+ *      Used if there are non-default ledger objects to decode.
+ * @returns A JSON object describing a ledger header
+ */
+function decodeLedgerData(binary, definitions) {
+    if (typeof binary !== 'string') {
+        throw new Error('binary must be a hex string');
+    }
+    const parser = new binary_parser_1.BinaryParser(binary, definitions);
+    return {
+        ledger_index: parser.readUInt32(),
+        total_coins: parser.readType(uint_64_1.UInt64).valueOf().toString(),
+        parent_hash: parser.readType(hash_256_1.Hash256).toHex(),
+        transaction_hash: parser.readType(hash_256_1.Hash256).toHex(),
+        account_hash: parser.readType(hash_256_1.Hash256).toHex(),
+        parent_close_time: parser.readUInt32(),
+        close_time: parser.readUInt32(),
+        close_time_resolution: parser.readUInt8(),
+        close_flags: parser.readUInt8(),
+    };
+}
+exports.decodeLedgerData = decodeLedgerData;
+//# sourceMappingURL=ledger-hashes.js.map

package/dist/ledger-hashes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger-hashes.js","sourceRoot":"","sources":["../src/ledger-hashes.ts"],"names":[],"mappings":"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"}

package/dist/quality.d.ts

@@ -0,0 +1,21 @@
+import BigNumber from 'bignumber.js';
+/**
+ * class for encoding and decoding quality
+ */
+declare class quality {
+    /**
+     * Encode quality amount
+     *
+     * @param arg string representation of an amount
+     * @returns Serialized quality
+     */
+    static encode(quality: string): Uint8Array;
+    /**
+     * Decode quality amount
+     *
+     * @param arg hex-string denoting serialized quality
+     * @returns deserialized quality
+     */
+    static decode(quality: string): BigNumber;
+}
+export { quality };

package/dist/quality.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quality = void 0;
+const types_1 = require("./types");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("@xrplf/isomorphic/utils");
+/**
+ * class for encoding and decoding quality
+ */
+class quality {
+    /**
+     * Encode quality amount
+     *
+     * @param arg string representation of an amount
+     * @returns Serialized quality
+     */
+    static encode(quality) {
+        const decimal = (0, bignumber_js_1.default)(quality);
+        const exponent = ((decimal === null || decimal === void 0 ? void 0 : decimal.e) || 0) - 15;
+        const qualityString = decimal.times(`1e${-exponent}`).abs().toString();
+        const bytes = types_1.coreTypes.UInt64.from(BigInt(qualityString)).toBytes();
+        bytes[0] = exponent + 100;
+        return bytes;
+    }
+    /**
+     * Decode quality amount
+     *
+     * @param arg hex-string denoting serialized quality
+     * @returns deserialized quality
+     */
+    static decode(quality) {
+        const bytes = (0, utils_1.hexToBytes)(quality).slice(-8);
+        const exponent = bytes[0] - 100;
+        const mantissa = new bignumber_js_1.default(`0x${(0, utils_1.bytesToHex)(bytes.slice(1))}`);
+        return mantissa.times(`1e${exponent}`);
+    }
+}
+exports.quality = quality;
+//# sourceMappingURL=quality.js.map

package/dist/quality.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality.js","sourceRoot":"","sources":["../src/quality.ts"],"names":[],"mappings":";;;;;;AAAA,mCAAmC;AACnC,gEAAoC;AACpC,mDAAgE;AAEhE;;GAEG;AACH,MAAM,OAAO;IACX;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,OAAe;QAC3B,MAAM,OAAO,GAAG,IAAA,sBAAS,EAAC,OAAO,CAAC,CAAA;QAClC,MAAM,QAAQ,GAAG,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,CAAC,KAAI,CAAC,CAAC,GAAG,EAAE,CAAA;QACvC,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAA;QACtE,MAAM,KAAK,GAAG,iBAAS,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,EAAE,CAAA;QACpE,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,GAAG,GAAG,CAAA;QACzB,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,OAAe;QAC3B,MAAM,KAAK,GAAG,IAAA,kBAAU,EAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC3C,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAA;QAC/B,MAAM,QAAQ,GAAG,IAAI,sBAAS,CAAC,KAAK,IAAA,kBAAU,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;QACjE,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,QAAQ,EAAE,CAAC,CAAA;IACxC,CAAC;CACF;AAEQ,0BAAO"}

package/dist/serdes/binary-parser.d.ts

@@ -0,0 +1,100 @@
+import { XrplDefinitionsBase, FieldInstance } from '../enums';
+import { type SerializedType } from '../types/serialized-type';
+/**
+ * BinaryParser is used to compute fields and values from a HexString
+ */
+declare class BinaryParser {
+    private bytes;
+    definitions: XrplDefinitionsBase;
+    /**
+     * Initialize bytes to a hex string
+     *
+     * @param hexBytes a hex string
+     * @param definitions Rippled definitions used to parse the values of transaction types and such.
+     *                          Can be customized for sidechains and amendments.
+     */
+    constructor(hexBytes: string, definitions?: XrplDefinitionsBase);
+    /**
+     * Peek the first byte of the BinaryParser
+     *
+     * @returns The first byte of the BinaryParser
+     */
+    peek(): number;
+    /**
+     * Consume the first n bytes of the BinaryParser
+     *
+     * @param n the number of bytes to skip
+     */
+    skip(n: number): void;
+    /**
+     * read the first n bytes from the BinaryParser
+     *
+     * @param n The number of bytes to read
+     * @return The bytes
+     */
+    read(n: number): Uint8Array;
+    /**
+     * Read an integer of given size
+     *
+     * @param n The number of bytes to read
+     * @return The number represented by those bytes
+     */
+    readUIntN(n: number): number;
+    readUInt8(): number;
+    readUInt16(): number;
+    readUInt32(): number;
+    size(): number;
+    end(customEnd?: number): boolean;
+    /**
+     * Reads variable length encoded bytes
+     *
+     * @return The variable length bytes
+     */
+    readVariableLength(): Uint8Array;
+    /**
+     * Reads the length of the variable length encoded bytes
+     *
+     * @return The length of the variable length encoded bytes
+     */
+    readVariableLengthLength(): number;
+    /**
+     * Reads the field ordinal from the BinaryParser
+     *
+     * @return Field ordinal
+     */
+    readFieldOrdinal(): number;
+    /**
+     * Read the field from the BinaryParser
+     *
+     * @return The field represented by the bytes at the head of the BinaryParser
+     */
+    readField(): FieldInstance;
+    /**
+     * Read a given type from the BinaryParser
+     *
+     * @param type The type that you want to read from the BinaryParser
+     * @return The instance of that type read from the BinaryParser
+     */
+    readType(type: typeof SerializedType): SerializedType;
+    /**
+     * Get the type associated with a given field
+     *
+     * @param field The field that you wan to get the type of
+     * @return The type associated with the given field
+     */
+    typeForField(field: FieldInstance): typeof SerializedType;
+    /**
+     * Read value of the type specified by field from the BinaryParser
+     *
+     * @param field The field that you want to get the associated value for
+     * @return The value associated with the given field
+     */
+    readFieldValue(field: FieldInstance): SerializedType;
+    /**
+     * Get the next field and value from the BinaryParser
+     *
+     * @return The field and value
+     */
+    readFieldAndValue(): [FieldInstance, SerializedType];
+}
+export { BinaryParser };

package/dist/serdes/binary-parser.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryParser = void 0;
+const enums_1 = require("../enums");
+const utils_1 = require("@xrplf/isomorphic/utils");
+/**
+ * BinaryParser is used to compute fields and values from a HexString
+ */
+class BinaryParser {
+    /**
+     * Initialize bytes to a hex string
+     *
+     * @param hexBytes a hex string
+     * @param definitions Rippled definitions used to parse the values of transaction types and such.
+     *                          Can be customized for sidechains and amendments.
+     */
+    constructor(hexBytes, definitions = enums_1.DEFAULT_DEFINITIONS) {
+        this.bytes = (0, utils_1.hexToBytes)(hexBytes);
+        this.definitions = definitions;
+    }
+    /**
+     * Peek the first byte of the BinaryParser
+     *
+     * @returns The first byte of the BinaryParser
+     */
+    peek() {
+        if (this.bytes.byteLength === 0) {
+            throw new Error();
+        }
+        return this.bytes[0];
+    }
+    /**
+     * Consume the first n bytes of the BinaryParser
+     *
+     * @param n the number of bytes to skip
+     */
+    skip(n) {
+        if (n > this.bytes.byteLength) {
+            throw new Error();
+        }
+        this.bytes = this.bytes.slice(n);
+    }
+    /**
+     * read the first n bytes from the BinaryParser
+     *
+     * @param n The number of bytes to read
+     * @return The bytes
+     */
+    read(n) {
+        if (n > this.bytes.byteLength) {
+            throw new Error();
+        }
+        const slice = this.bytes.slice(0, n);
+        this.skip(n);
+        return slice;
+    }
+    /**
+     * Read an integer of given size
+     *
+     * @param n The number of bytes to read
+     * @return The number represented by those bytes
+     */
+    readUIntN(n) {
+        if (0 >= n || n > 4) {
+            throw new Error('invalid n');
+        }
+        return this.read(n).reduce((a, b) => (a << 8) | b) >>> 0;
+    }
+    readUInt8() {
+        return this.readUIntN(1);
+    }
+    readUInt16() {
+        return this.readUIntN(2);
+    }
+    readUInt32() {
+        return this.readUIntN(4);
+    }
+    size() {
+        return this.bytes.byteLength;
+    }
+    end(customEnd) {
+        const length = this.bytes.byteLength;
+        return length === 0 || (customEnd !== undefined && length <= customEnd);
+    }
+    /**
+     * Reads variable length encoded bytes
+     *
+     * @return The variable length bytes
+     */
+    readVariableLength() {
+        return this.read(this.readVariableLengthLength());
+    }
+    /**
+     * Reads the length of the variable length encoded bytes
+     *
+     * @return The length of the variable length encoded bytes
+     */
+    readVariableLengthLength() {
+        const b1 = this.readUInt8();
+        if (b1 <= 192) {
+            return b1;
+        }
+        else if (b1 <= 240) {
+            const b2 = this.readUInt8();
+            return 193 + (b1 - 193) * 256 + b2;
+        }
+        else if (b1 <= 254) {
+            const b2 = this.readUInt8();
+            const b3 = this.readUInt8();
+            return 12481 + (b1 - 241) * 65536 + b2 * 256 + b3;
+        }
+        throw new Error('Invalid variable length indicator');
+    }
+    /**
+     * Reads the field ordinal from the BinaryParser
+     *
+     * @return Field ordinal
+     */
+    readFieldOrdinal() {
+        let type = this.readUInt8();
+        let nth = type & 15;
+        type >>= 4;
+        if (type === 0) {
+            type = this.readUInt8();
+            if (type === 0 || type < 16) {
+                throw new Error('Cannot read FieldOrdinal, type_code out of range');
+            }
+        }
+        if (nth === 0) {
+            nth = this.readUInt8();
+            if (nth === 0 || nth < 16) {
+                throw new Error('Cannot read FieldOrdinal, field_code out of range');
+            }
+        }
+        return (type << 16) | nth;
+    }
+    /**
+     * Read the field from the BinaryParser
+     *
+     * @return The field represented by the bytes at the head of the BinaryParser
+     */
+    readField() {
+        return this.definitions.field.fromString(this.readFieldOrdinal().toString());
+    }
+    /**
+     * Read a given type from the BinaryParser
+     *
+     * @param type The type that you want to read from the BinaryParser
+     * @return The instance of that type read from the BinaryParser
+     */
+    readType(type) {
+        return type.fromParser(this);
+    }
+    /**
+     * Get the type associated with a given field
+     *
+     * @param field The field that you wan to get the type of
+     * @return The type associated with the given field
+     */
+    typeForField(field) {
+        return field.associatedType;
+    }
+    /**
+     * Read value of the type specified by field from the BinaryParser
+     *
+     * @param field The field that you want to get the associated value for
+     * @return The value associated with the given field
+     */
+    readFieldValue(field) {
+        const type = this.typeForField(field);
+        if (!type) {
+            throw new Error(`unsupported: (${field.name}, ${field.type.name})`);
+        }
+        const sizeHint = field.isVariableLengthEncoded
+            ? this.readVariableLengthLength()
+            : undefined;
+        const value = type.fromParser(this, sizeHint);
+        if (value === undefined) {
+            throw new Error(`fromParser for (${field.name}, ${field.type.name}) -> undefined `);
+        }
+        return value;
+    }
+    /**
+     * Get the next field and value from the BinaryParser
+     *
+     * @return The field and value
+     */
+    readFieldAndValue() {
+        const field = this.readField();
+        return [field, this.readFieldValue(field)];
+    }
+}
+exports.BinaryParser = BinaryParser;
+//# sourceMappingURL=binary-parser.js.map