@taquito/local-forging 23.0.3 → 24.0.0-RC.0

package/dist/taquito-local-forging.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-local-forging.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-local-forging.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/protocols.d.ts

@@ -21,6 +21,7 @@ export declare enum ProtocolsHash {
     PsQuebecn = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg",
     PsRiotuma = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7",
     PtSeouLou = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh",
+    PtTALLiNt = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu",
     ProtoALpha = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"
 }
 export declare function ProtoInferiorTo(a: ProtocolsHash, b: ProtocolsHash): boolean;

package/dist/types/taquito-local-forging.d.ts

@@ -5,7 +5,6 @@
 import 'fast-text-encoding';
 import { ForgeParams, Forger } from './interface';
 import { CODEC } from './constants';
-import { CODEC as CODECPROTO022 } from './constants-proto022';
 import { ProtocolsHash } from './protocols';
 export { CODEC, opMapping, opMappingReverse } from './constants';
 export * from './decoder';
@@ -14,8 +13,8 @@ export * from './uint8array-consumer';
 export * from './interface';
 export { VERSION } from './version';
 export { ProtocolsHash } from './protocols';
-export declare function getCodec(codec: CODEC | CODECPROTO022, _proto: ProtocolsHash): {
-    encoder: import("./encoder-proto022").Encoder<any>;
+export declare function getCodec(codec: CODEC, _proto: ProtocolsHash): {
+    encoder: import("./encoder").Encoder<any>;
     decoder: (hex: string) => any;
 };
 export declare class LocalForger implements Forger {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/local-forging",
-  "version": "23.0.3",
+  "version": "24.0.0-RC.0",
   "description": "Provide local forging functionality to be with taquito",
   "keywords": [
     "tezos",
@@ -24,7 +24,7 @@
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "scripts": {
     "test": "jest --coverage",
@@ -67,18 +67,19 @@
     ]
   },
   "dependencies": {
-    "@taquito/core": "^23.0.3",
-    "@taquito/utils": "^23.0.3",
+    "@taquito/core": "^24.0.0-RC.0",
+    "@taquito/utils": "^24.0.0-RC.0",
     "bignumber.js": "^9.1.2",
-    "fast-text-encoding": "^1.0.6"
+    "fast-text-encoding": "^1.0.6",
+    "whatwg-url": "^15.1.0"
   },
   "devDependencies": {
-    "@taquito/rpc": "^23.0.3",
+    "@taquito/rpc": "^24.0.0-RC.0",
     "@types/bluebird": "^3.5.42",
     "@types/estree": "^1.0.5",
     "@types/fast-text-encoding": "^1.0.3",
     "@types/jest": "^29.5.12",
-    "@types/node": "^18",
+    "@types/node": "^20",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
     "colors": "^1.4.0",
@@ -95,6 +96,7 @@
     "rimraf": "^6.0.1",
     "rollup": "^4.22.4",
     "rollup-plugin-json": "^4.0.0",
+    "rollup-plugin-polyfill-node": "^0.13.0",
     "rollup-plugin-typescript2": "^0.36.0",
     "shelljs": "^0.8.5",
     "stream-browserify": "^3.0.0",
@@ -106,5 +108,5 @@
     "webpack": "^5.94.0",
     "webpack-cli": "^5.1.4"
   },
-  "gitHead": "2abf349e97af45f11210b3121078b9d96699d5da"
+  "gitHead": "784d536e73487529e402a3379be899bc5ac0342c"
 }

package/dist/lib/codec-proto022.js

@@ -1,563 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.burnLimitDecoder = exports.burnLimitEncoder = exports.entrypointNameDecoder = exports.entrypointNameEncoder = exports.blockPayloadHashDecoder = exports.blockPayloadHashEncoder = exports.valueParameterDecoder = exports.valueParameterEncoder = exports.parametersEncoder = exports.entrypointEncoder = exports.parametersDecoder = exports.entrypointDecoder = exports.zarithDecoder = exports.zarithEncoder = exports.smartRollupCommitmentHashDecoder = exports.smartContractAddressDecoder = exports.smartRollupAddressDecoder = exports.addressDecoder = exports.smartRollupCommitmentHashEncoder = exports.publicKeyDecoder = exports.smartContractAddressEncoder = exports.smartRollupAddressEncoder = exports.addressEncoder = exports.publicKeyEncoder = exports.publicKeyHashesEncoder = exports.publicKeyHashEncoder = exports.delegateDecoder = exports.boolDecoder = exports.int16Decoder = exports.int16Encoder = exports.int32Decoder = exports.int32Encoder = exports.delegateEncoder = exports.pvmKindDecoder = exports.pvmKindEncoder = exports.ballotDecoder = exports.ballotEncoder = exports.proposalsEncoder = exports.proposalsDecoder = exports.proposalDecoder = exports.proposalEncoder = exports.boolEncoder = exports.tz1Encoder = exports.branchEncoder = exports.publicKeyHashesDecoder = exports.publicKeyHashDecoder = exports.branchDecoder = exports.tz1Decoder = exports.prefixDecoder = exports.prefixEncoder = void 0;
-exports.slotHeaderDecoder = exports.slotHeaderEncoder = exports.dalCommitmentDecoder = exports.dalCommitmentEncoder = exports.smartRollupMessageDecoder = exports.smartRollupMessageEncoder = exports.paddedBytesDecoder = exports.paddedBytesEncoder = exports.signatureProofDecoder = exports.signatureProofEncoder = exports.depositsLimitDecoder = exports.depositsLimitEncoder = void 0;
-const utils_1 = require("@taquito/utils");
-const errors_1 = require("./errors");
-const bignumber_js_1 = require("bignumber.js");
-const constants_proto022_1 = require("./constants-proto022");
-const codec_proto022_1 = require("./michelson/codec-proto022");
-const uint8array_consumer_1 = require("./uint8array-consumer");
-const utils_2 = require("./utils");
-const core_1 = require("@taquito/core");
-// https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
-const prefixEncoder = (prefix) => (str) => {
-    return (0, utils_1.buf2hex)(Buffer.from((0, utils_1.b58cdecode)(str, utils_1.prefix[prefix])));
-};
-exports.prefixEncoder = prefixEncoder;
-const prefixDecoder = (pre) => (str) => {
-    const val = str.consume(utils_1.prefixLength[pre]);
-    return (0, utils_1.b58cencode)(val, utils_1.prefix[pre]);
-};
-exports.prefixDecoder = prefixDecoder;
-exports.tz1Decoder = (0, exports.prefixDecoder)(utils_1.Prefix.TZ1);
-exports.branchDecoder = (0, exports.prefixDecoder)(utils_1.Prefix.B);
-const publicKeyHashDecoder = (val) => {
-    const prefix = val.consume(1);
-    if (prefix[0] === 0x00) {
-        return (0, exports.prefixDecoder)(utils_1.Prefix.TZ1)(val);
-    }
-    else if (prefix[0] === 0x01) {
-        return (0, exports.prefixDecoder)(utils_1.Prefix.TZ2)(val);
-    }
-    else if (prefix[0] === 0x02) {
-        return (0, exports.prefixDecoder)(utils_1.Prefix.TZ3)(val);
-    }
-    else if (prefix[0] === 0x03) {
-        return (0, exports.prefixDecoder)(utils_1.Prefix.TZ4)(val);
-    }
-};
-exports.publicKeyHashDecoder = publicKeyHashDecoder;
-const publicKeyHashesDecoder = (val) => {
-    if (!(0, exports.boolDecoder)(val)) {
-        return;
-    }
-    const publicKeyHashes = [];
-    val.consume(4);
-    while (val.length() > 0) {
-        publicKeyHashes.push((0, exports.publicKeyHashDecoder)(val));
-    }
-    return publicKeyHashes;
-};
-exports.publicKeyHashesDecoder = publicKeyHashesDecoder;
-exports.branchEncoder = (0, exports.prefixEncoder)(utils_1.Prefix.B);
-exports.tz1Encoder = (0, exports.prefixEncoder)(utils_1.Prefix.TZ1);
-const boolEncoder = (bool) => (bool ? 'ff' : '00');
-exports.boolEncoder = boolEncoder;
-const proposalEncoder = (proposal) => {
-    return (0, exports.prefixEncoder)(utils_1.Prefix.P)(proposal);
-};
-exports.proposalEncoder = proposalEncoder;
-const proposalDecoder = (proposal) => {
-    return (0, exports.prefixDecoder)(utils_1.Prefix.P)(proposal);
-};
-exports.proposalDecoder = proposalDecoder;
-const proposalsDecoder = (proposal) => {
-    const proposals = [];
-    proposal.consume(4);
-    while (proposal.length() > 0) {
-        proposals.push((0, exports.proposalDecoder)(proposal));
-    }
-    return proposals;
-};
-exports.proposalsDecoder = proposalsDecoder;
-const proposalsEncoder = (proposals) => {
-    return (0, utils_2.pad)(32 * proposals.length) + proposals.map((x) => (0, exports.proposalEncoder)(x)).join('');
-};
-exports.proposalsEncoder = proposalsEncoder;
-const ballotEncoder = (ballot) => {
-    switch (ballot) {
-        case 'yay':
-            return '00';
-        case 'nay':
-            return '01';
-        case 'pass':
-            return '02';
-        default:
-            throw new errors_1.InvalidBallotValueError(ballot);
-    }
-};
-exports.ballotEncoder = ballotEncoder;
-const ballotDecoder = (ballot) => {
-    const value = ballot.consume(1);
-    switch (value[0]) {
-        case 0x00:
-            return 'yay';
-        case 0x01:
-            return 'nay';
-        case 0x02:
-            return 'pass';
-        default:
-            throw new errors_1.DecodeBallotValueError(value[0].toString());
-    }
-};
-exports.ballotDecoder = ballotDecoder;
-const pvmKindEncoder = (pvm) => {
-    switch (pvm) {
-        case 'arith':
-            return '00';
-        case 'wasm_2_0_0':
-            return '01';
-        case 'riscv':
-            return '02';
-        default:
-            throw new errors_1.UnsupportedPvmKindError(pvm);
-    }
-};
-exports.pvmKindEncoder = pvmKindEncoder;
-const pvmKindDecoder = (pvm) => {
-    const value = pvm.consume(1);
-    switch (value[0]) {
-        case 0x00:
-            return 'arith';
-        case 0x01:
-            return 'wasm_2_0_0';
-        case 0x02:
-            return 'riscv';
-        default:
-            throw new errors_1.DecodePvmKindError(value[0].toString());
-    }
-};
-exports.pvmKindDecoder = pvmKindDecoder;
-const delegateEncoder = (val) => {
-    if (val) {
-        return (0, exports.boolEncoder)(true) + (0, exports.publicKeyHashEncoder)(val);
-    }
-    else {
-        return (0, exports.boolEncoder)(false);
-    }
-};
-exports.delegateEncoder = delegateEncoder;
-const int32Encoder = (val) => {
-    const num = parseInt(String(val), 10);
-    const byte = [];
-    for (let i = 0; i < 4; i++) {
-        const shiftBy = (4 - (i + 1)) * 8;
-        byte.push((num & (0xff << shiftBy)) >> shiftBy);
-    }
-    return Buffer.from(byte).toString('hex');
-};
-exports.int32Encoder = int32Encoder;
-const int32Decoder = (val) => {
-    const num = val.consume(4);
-    let finalNum = 0;
-    for (let i = 0; i < num.length; i++) {
-        finalNum = finalNum | (num[i] << ((num.length - (i + 1)) * 8));
-    }
-    return finalNum;
-};
-exports.int32Decoder = int32Decoder;
-const int16Encoder = (val) => {
-    const num = parseInt(String(val), 10);
-    const byte = [];
-    for (let i = 0; i < 2; i++) {
-        const shiftBy = (2 - (i + 1)) * 8;
-        byte.push((num & (0xff << shiftBy)) >> shiftBy);
-    }
-    return Buffer.from(byte).toString('hex');
-};
-exports.int16Encoder = int16Encoder;
-const int16Decoder = (val) => {
-    const num = val.consume(2);
-    let finalNum = 0;
-    for (let i = 0; i < num.length; i++) {
-        finalNum = finalNum | (num[i] << ((num.length - (i + 1)) * 8));
-    }
-    return finalNum;
-};
-exports.int16Decoder = int16Decoder;
-const boolDecoder = (val) => {
-    const bool = val.consume(1);
-    return bool[0] === 0xff;
-};
-exports.boolDecoder = boolDecoder;
-const delegateDecoder = (val) => {
-    const hasDelegate = (0, exports.boolDecoder)(val);
-    if (hasDelegate) {
-        return (0, exports.publicKeyHashDecoder)(val);
-    }
-};
-exports.delegateDecoder = delegateDecoder;
-const publicKeyHashEncoder = (val) => {
-    const pubkeyPrefix = val.substring(0, 3);
-    switch (pubkeyPrefix) {
-        case utils_1.Prefix.TZ1:
-            return '00' + (0, exports.prefixEncoder)(utils_1.Prefix.TZ1)(val);
-        case utils_1.Prefix.TZ2:
-            return '01' + (0, exports.prefixEncoder)(utils_1.Prefix.TZ2)(val);
-        case utils_1.Prefix.TZ3:
-            return '02' + (0, exports.prefixEncoder)(utils_1.Prefix.TZ3)(val);
-        case utils_1.Prefix.TZ4:
-            return '03' + (0, exports.prefixEncoder)(utils_1.Prefix.TZ4)(val);
-        default:
-            throw new utils_1.InvalidKeyHashError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one for the following "${utils_1.Prefix.TZ1}", "${utils_1.Prefix.TZ2}", "${utils_1.Prefix.TZ3}" or "${utils_1.Prefix.TZ4}".`);
-    }
-};
-exports.publicKeyHashEncoder = publicKeyHashEncoder;
-const publicKeyHashesEncoder = (val) => {
-    if (!val) {
-        return (0, exports.boolEncoder)(false);
-    }
-    if (val.length === 0) {
-        return (0, exports.boolEncoder)(true) + (0, utils_2.pad)(0);
-    }
-    const publicKeyHashes = val.reduce((prev, curr) => {
-        return prev + (0, exports.publicKeyHashEncoder)(curr);
-    }, '');
-    return (0, exports.boolEncoder)(true) + (0, utils_2.pad)(publicKeyHashes.length / 2) + publicKeyHashes;
-};
-exports.publicKeyHashesEncoder = publicKeyHashesEncoder;
-const publicKeyEncoder = (val) => {
-    const pubkeyPrefix = val.substring(0, 4);
-    switch (pubkeyPrefix) {
-        case utils_1.Prefix.EDPK:
-            return '00' + (0, exports.prefixEncoder)(utils_1.Prefix.EDPK)(val);
-        case utils_1.Prefix.SPPK:
-            return '01' + (0, exports.prefixEncoder)(utils_1.Prefix.SPPK)(val);
-        case utils_1.Prefix.P2PK:
-            return '02' + (0, exports.prefixEncoder)(utils_1.Prefix.P2PK)(val);
-        case utils_1.Prefix.BLPK:
-            return '03' + (0, exports.prefixEncoder)(utils_1.Prefix.BLPK)(val);
-        default:
-            throw new utils_1.InvalidPublicKeyError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following '${utils_1.Prefix.EDPK}', '${utils_1.Prefix.SPPK}', '${utils_1.Prefix.P2PK}' or '${utils_1.Prefix.BLPK}'.`);
-    }
-};
-exports.publicKeyEncoder = publicKeyEncoder;
-const addressEncoder = (val) => {
-    const pubkeyPrefix = val.substring(0, 3);
-    switch (pubkeyPrefix) {
-        case utils_1.Prefix.TZ1:
-        case utils_1.Prefix.TZ2:
-        case utils_1.Prefix.TZ3:
-        case utils_1.Prefix.TZ4:
-            return '00' + (0, exports.publicKeyHashEncoder)(val);
-        case utils_1.Prefix.KT1:
-            return '01' + (0, exports.prefixEncoder)(utils_1.Prefix.KT1)(val) + '00';
-        default:
-            throw new core_1.InvalidAddressError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following prefix '${utils_1.Prefix.TZ1}', ${utils_1.Prefix.TZ2}', '${utils_1.Prefix.TZ3}', '${utils_1.Prefix.TZ4}' or '${utils_1.Prefix.KT1}'.`);
-    }
-};
-exports.addressEncoder = addressEncoder;
-const smartRollupAddressEncoder = (val) => {
-    if (val.substring(0, 3) !== utils_1.Prefix.SR1) {
-        throw new errors_1.InvalidSmartRollupAddressError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SR1}'.`);
-    }
-    return (0, exports.prefixEncoder)(utils_1.Prefix.SR1)(val);
-};
-exports.smartRollupAddressEncoder = smartRollupAddressEncoder;
-const smartContractAddressEncoder = (val) => {
-    const prefix = val.substring(0, 3);
-    if (prefix === utils_1.Prefix.KT1) {
-        return '01' + (0, exports.prefixEncoder)(utils_1.Prefix.KT1)(val) + '00';
-    }
-    throw new core_1.InvalidContractAddressError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.KT1}'.`);
-};
-exports.smartContractAddressEncoder = smartContractAddressEncoder;
-const publicKeyDecoder = (val) => {
-    const preamble = val.consume(1);
-    switch (preamble[0]) {
-        case 0x00:
-            return (0, exports.prefixDecoder)(utils_1.Prefix.EDPK)(val);
-        case 0x01:
-            return (0, exports.prefixDecoder)(utils_1.Prefix.SPPK)(val);
-        case 0x02:
-            return (0, exports.prefixDecoder)(utils_1.Prefix.P2PK)(val);
-        case 0x03:
-            return (0, exports.prefixDecoder)(utils_1.Prefix.BLPK)(val);
-        default:
-            throw new utils_1.InvalidPublicKeyError(val.toString(), (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED));
-    }
-};
-exports.publicKeyDecoder = publicKeyDecoder;
-const smartRollupCommitmentHashEncoder = (val) => {
-    const prefix = val.substring(0, 4);
-    if (prefix === utils_1.Prefix.SRC1) {
-        return (0, exports.prefixEncoder)(utils_1.Prefix.SRC1)(val);
-    }
-    throw new errors_1.InvalidSmartRollupCommitmentHashError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SRC1}'`);
-};
-exports.smartRollupCommitmentHashEncoder = smartRollupCommitmentHashEncoder;
-const addressDecoder = (val) => {
-    const preamble = val.consume(1);
-    switch (preamble[0]) {
-        case 0x00:
-            return (0, exports.publicKeyHashDecoder)(val);
-        case 0x01: {
-            const address = (0, exports.prefixDecoder)(utils_1.Prefix.KT1)(val);
-            val.consume(1);
-            return address;
-        }
-        default:
-            throw new core_1.InvalidAddressError(val.toString(), ': Unable to decode.');
-    }
-};
-exports.addressDecoder = addressDecoder;
-const smartRollupAddressDecoder = (val) => {
-    const address = (0, exports.prefixDecoder)(utils_1.Prefix.SR1)(val);
-    if (address.substring(0, 3) !== utils_1.Prefix.SR1) {
-        throw new errors_1.InvalidSmartRollupAddressError(address, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SR1}'.`);
-    }
-    return address;
-};
-exports.smartRollupAddressDecoder = smartRollupAddressDecoder;
-const smartContractAddressDecoder = (val) => {
-    const preamble = val.consume(1);
-    if (preamble[0] === 0x01) {
-        const scAddress = (0, exports.prefixDecoder)(utils_1.Prefix.KT1)(val);
-        val.consume(1);
-        return scAddress;
-    }
-    throw new core_1.InvalidContractAddressError(val.toString(), (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED));
-};
-exports.smartContractAddressDecoder = smartContractAddressDecoder;
-const smartRollupCommitmentHashDecoder = (val) => {
-    const address = (0, exports.prefixDecoder)(utils_1.Prefix.SRC1)(val);
-    if (address.substring(0, 4) !== utils_1.Prefix.SRC1) {
-        throw new errors_1.InvalidSmartRollupCommitmentHashError(address, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SRC1}'`);
-    }
-    return address;
-};
-exports.smartRollupCommitmentHashDecoder = smartRollupCommitmentHashDecoder;
-const zarithEncoder = (n) => {
-    const fn = [];
-    let nn = new bignumber_js_1.default(n, 10);
-    if (nn.isNaN()) {
-        throw new TypeError(`Invalid zarith number ${n}`);
-    }
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        if (nn.lt(128)) {
-            if (nn.lt(16))
-                fn.push('0');
-            fn.push(nn.toString(16));
-            break;
-        }
-        else {
-            let b = nn.mod(128);
-            nn = nn.minus(b);
-            nn = nn.dividedBy(128);
-            b = b.plus(128);
-            fn.push(b.toString(16));
-        }
-    }
-    return fn.join('');
-};
-exports.zarithEncoder = zarithEncoder;
-const zarithDecoder = (n) => {
-    let mostSignificantByte = 0;
-    while (mostSignificantByte < n.length() && (n.get(mostSignificantByte) & 128) !== 0) {
-        mostSignificantByte += 1;
-    }
-    let num = new bignumber_js_1.default(0);
-    for (let i = mostSignificantByte; i >= 0; i -= 1) {
-        const tmp = n.get(i) & 0x7f;
-        num = num.multipliedBy(128);
-        num = num.plus(tmp);
-    }
-    n.consume(mostSignificantByte + 1);
-    return new bignumber_js_1.default(num).toString();
-};
-exports.zarithDecoder = zarithDecoder;
-const entrypointDecoder = (value) => {
-    const preamble = (0, utils_2.pad)(value.consume(1)[0], 2);
-    if (preamble in constants_proto022_1.entrypointMapping) {
-        return constants_proto022_1.entrypointMapping[preamble];
-    }
-    else {
-        const entry = (0, codec_proto022_1.extractRequiredLen)(value, 1);
-        const entrypoint = Buffer.from(entry).toString('utf8');
-        if (entrypoint.length > constants_proto022_1.ENTRYPOINT_MAX_LENGTH) {
-            throw new errors_1.OversizedEntryPointError(entrypoint);
-        }
-        return entrypoint;
-    }
-};
-exports.entrypointDecoder = entrypointDecoder;
-const parametersDecoder = (val) => {
-    const preamble = val.consume(1);
-    if (preamble[0] === 0x00) {
-        return;
-    }
-    else {
-        const encodedEntrypoint = (0, exports.entrypointDecoder)(val);
-        const params = (0, codec_proto022_1.extractRequiredLen)(val);
-        const parameters = (0, codec_proto022_1.valueDecoder)(new uint8array_consumer_1.Uint8ArrayConsumer(params));
-        return {
-            entrypoint: encodedEntrypoint,
-            value: parameters,
-        };
-    }
-};
-exports.parametersDecoder = parametersDecoder;
-const entrypointEncoder = (entrypoint) => {
-    if (entrypoint in constants_proto022_1.entrypointMappingReverse) {
-        return `${constants_proto022_1.entrypointMappingReverse[entrypoint]}`;
-    }
-    else {
-        if (entrypoint.length > constants_proto022_1.ENTRYPOINT_MAX_LENGTH) {
-            throw new errors_1.OversizedEntryPointError(entrypoint);
-        }
-        const value = { string: entrypoint };
-        return `ff${(0, codec_proto022_1.valueEncoder)(value).slice(8)}`;
-    }
-};
-exports.entrypointEncoder = entrypointEncoder;
-const parametersEncoder = (val) => {
-    if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
-        return '00';
-    }
-    const encodedEntrypoint = (0, exports.entrypointEncoder)(val.entrypoint);
-    const parameters = (0, codec_proto022_1.valueEncoder)(val.value);
-    const length = (0, utils_2.pad)(parameters.length / 2);
-    return `ff${encodedEntrypoint}${length}${parameters}`;
-};
-exports.parametersEncoder = parametersEncoder;
-const valueParameterEncoder = (value) => {
-    const valueEncoded = (0, codec_proto022_1.valueEncoder)(value);
-    return `${(0, utils_2.pad)(valueEncoded.length / 2)}${valueEncoded}`;
-};
-exports.valueParameterEncoder = valueParameterEncoder;
-const valueParameterDecoder = (val) => {
-    const value = (0, codec_proto022_1.extractRequiredLen)(val);
-    return (0, codec_proto022_1.valueDecoder)(new uint8array_consumer_1.Uint8ArrayConsumer(value));
-};
-exports.valueParameterDecoder = valueParameterDecoder;
-exports.blockPayloadHashEncoder = (0, exports.prefixEncoder)(utils_1.Prefix.VH);
-exports.blockPayloadHashDecoder = (0, exports.prefixDecoder)(utils_1.Prefix.VH);
-const entrypointNameEncoder = (entrypoint) => {
-    const value = { string: entrypoint };
-    return `${(0, codec_proto022_1.valueEncoder)(value).slice(2)}`;
-};
-exports.entrypointNameEncoder = entrypointNameEncoder;
-const entrypointNameDecoder = (val) => {
-    const entry = (0, codec_proto022_1.extractRequiredLen)(val);
-    return Buffer.from(entry).toString('utf8');
-};
-exports.entrypointNameDecoder = entrypointNameDecoder;
-const burnLimitEncoder = (val) => {
-    return !val ? '00' : `ff${(0, exports.zarithEncoder)(val)}`;
-};
-exports.burnLimitEncoder = burnLimitEncoder;
-const burnLimitDecoder = (value) => {
-    const prefix = value.consume(1);
-    if (Buffer.from(prefix).toString('hex') !== '00') {
-        return (0, exports.zarithDecoder)(value);
-    }
-};
-exports.burnLimitDecoder = burnLimitDecoder;
-const depositsLimitEncoder = (val) => {
-    return !val ? '00' : `ff${(0, exports.zarithEncoder)(val)}`;
-};
-exports.depositsLimitEncoder = depositsLimitEncoder;
-const depositsLimitDecoder = (value) => {
-    const prefix = value.consume(1);
-    if (Buffer.from(prefix).toString('hex') !== '00') {
-        return (0, exports.zarithDecoder)(value);
-    }
-};
-exports.depositsLimitDecoder = depositsLimitDecoder;
-const signatureV1Encoder = (val) => {
-    const signaturePrefix = val.substring(0, 5);
-    switch (signaturePrefix) {
-        case utils_1.Prefix.EDSIG:
-            return (0, exports.paddedBytesEncoder)((0, exports.prefixEncoder)(utils_1.Prefix.EDSIG)(val));
-        case utils_1.Prefix.SPSIG:
-            return (0, exports.paddedBytesEncoder)((0, exports.prefixEncoder)(utils_1.Prefix.SPSIG)(val));
-        case utils_1.Prefix.P2SIG:
-            return (0, exports.paddedBytesEncoder)((0, exports.prefixEncoder)(utils_1.Prefix.P2SIG)(val));
-        case utils_1.Prefix.BLSIG:
-            return (0, exports.paddedBytesEncoder)((0, exports.prefixEncoder)(utils_1.Prefix.BLSIG)(val));
-        default:
-            throw new core_1.InvalidSignatureError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following '${utils_1.Prefix.EDSIG}', '${utils_1.Prefix.SPSIG}', '${utils_1.Prefix.P2SIG}' or '${utils_1.Prefix.BLSIG}'.`);
-    }
-};
-const signatureV1Decoder = (val) => {
-    val.consume(4);
-    if (val.length().toString() === '96') {
-        return (0, exports.prefixDecoder)(utils_1.Prefix.BLSIG)(val);
-    }
-    else {
-        throw new core_1.ProhibitedActionError('currently we only support decoding of BLSIG signatures');
-    }
-};
-const signatureProofEncoder = (val) => {
-    if (val) {
-        return (0, exports.boolEncoder)(true) + signatureV1Encoder(val);
-    }
-    else {
-        return (0, exports.boolEncoder)(false);
-    }
-};
-exports.signatureProofEncoder = signatureProofEncoder;
-const signatureProofDecoder = (value) => {
-    const hasProof = (0, exports.boolDecoder)(value);
-    if (hasProof) {
-        return signatureV1Decoder(value);
-    }
-};
-exports.signatureProofDecoder = signatureProofDecoder;
-const paddedBytesEncoder = (val, paddingLength = 8) => {
-    return `${(0, utils_2.pad)(val.length / 2, paddingLength)}${val}`;
-};
-exports.paddedBytesEncoder = paddedBytesEncoder;
-const paddedBytesDecoder = (val) => {
-    const value = (0, codec_proto022_1.extractRequiredLen)(val);
-    return Buffer.from(value).toString('hex');
-};
-exports.paddedBytesDecoder = paddedBytesDecoder;
-const smartRollupMessageEncoder = (val) => {
-    const message = val.reduce((prev, curr) => {
-        return prev + `${(0, utils_2.pad)(curr.length / 2)}${curr}`;
-    }, '');
-    return `${(0, utils_2.pad)(message.length / 2)}${message}`;
-};
-exports.smartRollupMessageEncoder = smartRollupMessageEncoder;
-const smartRollupMessageDecoder = (val) => {
-    const valueArray = (0, codec_proto022_1.extractRequiredLen)(val);
-    const ret = (0, codec_proto022_1.stripLengthPrefixFromBytes)(new uint8array_consumer_1.Uint8ArrayConsumer(valueArray));
-    return ret.map((value) => Buffer.from(value).toString('hex'));
-};
-exports.smartRollupMessageDecoder = smartRollupMessageDecoder;
-const dalCommitmentEncoder = (val) => {
-    const prefix = val.substring(0, 2);
-    if (prefix === utils_1.Prefix.SH) {
-        return (0, exports.prefixEncoder)(utils_1.Prefix.SH)(val);
-    }
-    throw new errors_1.InvalidDalCommitmentError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SH}'`);
-};
-exports.dalCommitmentEncoder = dalCommitmentEncoder;
-const dalCommitmentDecoder = (val) => {
-    const commitment = (0, exports.prefixDecoder)(utils_1.Prefix.SH)(val);
-    if (commitment.substring(0, 2) !== utils_1.Prefix.SH) {
-        throw new errors_1.InvalidDalCommitmentError(commitment, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SH}'`);
-    }
-    return commitment;
-};
-exports.dalCommitmentDecoder = dalCommitmentDecoder;
-const slotHeaderEncoder = (val) => {
-    return (0, utils_2.pad)(val.slot_index, 2) + (0, exports.dalCommitmentEncoder)(val.commitment) + val.commitment_proof;
-};
-exports.slotHeaderEncoder = slotHeaderEncoder;
-const slotHeaderDecoder = (val) => {
-    const preamble = val.consume(1);
-    return {
-        slot_index: Number(preamble[0].toString(10)),
-        commitment: (0, exports.dalCommitmentDecoder)(val),
-        commitment_proof: (0, utils_2.toHexString)(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
-    };
-};
-exports.slotHeaderDecoder = slotHeaderDecoder;