@taquito/local-forging 21.0.5 → 22.0.0-RC.0

package/dist/taquito-local-forging.es6.js

@@ -1,5 +1,5 @@
 import { Prefix, buf2hex, b58cdecode, prefix, prefixLength, b58cencode, InvalidKeyHashError, invalidDetail, ValidationResult, InvalidPublicKeyError, validateBlock } from '@taquito/utils';
-import { ParameterValidationError, InvalidHexStringError, InvalidAddressError, InvalidContractAddressError, InvalidOperationKindError, InvalidBlockHashError } from '@taquito/core';
+import { ParameterValidationError, InvalidHexStringError, InvalidAddressError, InvalidContractAddressError, InvalidSignatureError, ProhibitedActionError, InvalidOperationKindError, InvalidBlockHashError } from '@taquito/core';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 
 const toHexString = (bytes) => bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
@@ -12,8 +12,8 @@ const pad = (num, paddingLen = 8) => {
  * Copyright (c) 2018 Andrew Kishino
  */
 // See: https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
-const ENTRYPOINT_MAX_LENGTH = 31;
-var CODEC;
+const ENTRYPOINT_MAX_LENGTH$1 = 31;
+var CODEC$1;
 (function (CODEC) {
     CODEC["SECRET"] = "secret";
     CODEC["RAW"] = "raw";
@@ -58,6 +58,7 @@ var CODEC;
     CODEC["BURN_LIMIT"] = "burn_limit";
     CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
     CODEC["OP_UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
+    CODEC["SIGNATURE_PROOF"] = "signature_proof";
     CODEC["OP_DRAIN_DELEGATE"] = "drain_delegate";
     CODEC["DEPOSITS_LIMIT"] = "deposits_limit";
     CODEC["OP_SET_DEPOSITS_LIMIT"] = "set_deposits_limit";
@@ -67,9 +68,9 @@ var CODEC;
     CODEC["OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE"] = "smart_rollup_execute_outbox_message";
     CODEC["OP_DAL_PUBLISH_COMMITMENT"] = "dal_publish_commitment";
     CODEC["SLOT_HEADER"] = "slot_header";
-})(CODEC || (CODEC = {}));
+})(CODEC$1 || (CODEC$1 = {}));
 // See https://tezos.gitlab.io/shell/p2p_api.html#alpha-michelson-v1-primitives-enumeration-unsigned-8-bit-integer
-const opMapping = {
+const opMapping$1 = {
     '00': 'parameter',
     '01': 'storage',
     '02': 'code',
@@ -231,13 +232,13 @@ const opMapping = {
 };
 const opMappingReverse = (() => {
     const result = {};
-    Object.keys(opMapping).forEach((key) => {
-        result[opMapping[key]] = key;
+    Object.keys(opMapping$1).forEach((key) => {
+        result[opMapping$1[key]] = key;
     });
     return result;
 })();
 // See https://tezos.gitlab.io/shell/p2p_api.html
-const kindMapping = {
+const kindMapping$1 = {
     0x04: 'activate_account',
     0x6b: 'reveal',
     0x6e: 'delegation',
@@ -260,16 +261,16 @@ const kindMapping = {
     0xe6: 'dal_publish_commitment',
     0x11: 'failing_noop',
 };
-const kindMappingReverse = (() => {
+const kindMappingReverse$1 = (() => {
     const result = {};
-    Object.keys(kindMapping).forEach((key) => {
+    Object.keys(kindMapping$1).forEach((key) => {
         const keyNum = typeof key === 'string' ? parseInt(key, 10) : key;
-        result[kindMapping[keyNum]] = pad(keyNum, 2);
+        result[kindMapping$1[keyNum]] = pad(keyNum, 2);
     });
     return result;
 })();
 // See https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
-const entrypointMapping = {
+const entrypointMapping$1 = {
     '00': 'default',
     '01': 'root',
     '02': 'do',
@@ -281,10 +282,10 @@ const entrypointMapping = {
     '08': 'finalize_unstake',
     '09': 'set_delegate_parameters',
 };
-const entrypointMappingReverse = (() => {
+const entrypointMappingReverse$1 = (() => {
     const result = {};
-    Object.keys(entrypointMapping).forEach((key) => {
-        result[entrypointMapping[key]] = key;
+    Object.keys(entrypointMapping$1).forEach((key) => {
+        result[entrypointMapping$1[key]] = key;
     });
     return result;
 })();
@@ -311,7 +312,7 @@ class OversizedEntryPointError extends ParameterValidationError {
         super();
         this.entrypoint = entrypoint;
         this.name = 'OversizedEntryPointError';
-        this.message = `Invalid entrypoint length "${entrypoint.length}", maximum length is "${ENTRYPOINT_MAX_LENGTH}".`;
+        this.message = `Invalid entrypoint length "${entrypoint.length}", maximum length is "${ENTRYPOINT_MAX_LENGTH$1}".`;
     }
 }
 /**
@@ -666,12 +667,12 @@ const primDecoder = (value, preamble) => {
     let argsCount = Math.floor((preamble[0] - 0x03) / 2);
     const op = value.consume(1)[0].toString(16).padStart(2, '0');
     const result = {
-        prim: opMapping[op],
+        prim: opMapping$1[op],
     };
-    if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
+    if (opMapping$1[op] === 'LAMBDA' || opMapping$1[op] === 'LAMBDA_REC') {
         value.consume(4);
     }
-    if (opMapping[op] === 'view') {
+    if (opMapping$1[op] === 'view') {
         if (argsCount != 0) {
             return primViewDecoder(value, result);
         }
@@ -681,13 +682,13 @@ const primDecoder = (value, preamble) => {
     }
     let combPairArgs;
     let combPairAnnots;
-    if ((opMapping[op] === 'pair' || opMapping[op] === 'Pair') && argsCount > 2) {
+    if ((opMapping$1[op] === 'pair' || opMapping$1[op] === 'Pair') && argsCount > 2) {
         combPairArgs = decodeCombPair(value);
         argsCount = 0;
         combPairAnnots = decodeAnnots(value);
     }
     const args = new Array(argsCount).fill(0).map(() => valueDecoder(value));
-    if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
+    if (opMapping$1[op] === 'LAMBDA' || opMapping$1[op] === 'LAMBDA_REC') {
         value.consume(4);
     }
     if (combPairArgs) {
@@ -736,59 +737,62 @@ const decodeAnnots = (val) => {
 };
 
 // https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
-const prefixEncoder = (prefix$1) => (str) => {
+const prefixEncoder$1 = (prefix$1) => (str) => {
     return buf2hex(Buffer.from(b58cdecode(str, prefix[prefix$1])));
 };
-const prefixDecoder = (pre) => (str) => {
+const prefixDecoder$1 = (pre) => (str) => {
     const val = str.consume(prefixLength[pre]);
     return b58cencode(val, prefix[pre]);
 };
-const tz1Decoder = prefixDecoder(Prefix.TZ1);
-const branchDecoder = prefixDecoder(Prefix.B);
-const publicKeyHashDecoder = (val) => {
+const tz1Decoder$1 = prefixDecoder$1(Prefix.TZ1);
+const branchDecoder$1 = prefixDecoder$1(Prefix.B);
+const publicKeyHashDecoder$1 = (val) => {
     const prefix = val.consume(1);
     if (prefix[0] === 0x00) {
-        return prefixDecoder(Prefix.TZ1)(val);
+        return prefixDecoder$1(Prefix.TZ1)(val);
     }
     else if (prefix[0] === 0x01) {
-        return prefixDecoder(Prefix.TZ2)(val);
+        return prefixDecoder$1(Prefix.TZ2)(val);
     }
     else if (prefix[0] === 0x02) {
-        return prefixDecoder(Prefix.TZ3)(val);
+        return prefixDecoder$1(Prefix.TZ3)(val);
+    }
+    else if (prefix[0] === 0x03) {
+        return prefixDecoder$1(Prefix.TZ4)(val);
     }
 };
-const publicKeyHashesDecoder = (val) => {
-    if (!boolDecoder(val)) {
-        return undefined;
+const publicKeyHashesDecoder$1 = (val) => {
+    if (!boolDecoder$1(val)) {
+        return;
     }
     const publicKeyHashes = [];
     val.consume(4);
     while (val.length() > 0) {
-        publicKeyHashes.push(publicKeyHashDecoder(val));
+        publicKeyHashes.push(publicKeyHashDecoder$1(val));
     }
     return publicKeyHashes;
 };
-const branchEncoder = prefixEncoder(Prefix.B);
-const tz1Encoder = prefixEncoder(Prefix.TZ1);
-const boolEncoder = (bool) => (bool ? 'ff' : '00');
-const proposalEncoder = (proposal) => {
-    return prefixEncoder(Prefix.P)(proposal);
+const branchEncoder$1 = prefixEncoder$1(Prefix.B);
+const tz1Encoder$1 = prefixEncoder$1(Prefix.TZ1);
+const boolEncoder$1 = (bool) => (bool ? 'ff' : '00');
+const proposalEncoder$1 = (proposal) => {
+    return prefixEncoder$1(Prefix.P)(proposal);
 };
-const proposalDecoder = (proposal) => {
-    return prefixDecoder(Prefix.P)(proposal);
+const proposalDecoder$1 = (proposal) => {
+    return prefixDecoder$1(Prefix.P)(proposal);
 };
-const proposalsDecoder = (proposal) => {
+const proposalsDecoder$1 = (proposal) => {
     const proposals = [];
     proposal.consume(4);
     while (proposal.length() > 0) {
-        proposals.push(proposalDecoder(proposal));
+        proposals.push(proposalDecoder$1(proposal));
     }
     return proposals;
 };
-const proposalsEncoder = (proposals) => {
-    return pad(32 * proposals.length) + proposals.map((x) => proposalEncoder(x)).join('');
+const proposalsEncoder$1 = (proposals) => {
+    return pad(32 * proposals.length) + proposals.map((x) => proposalEncoder$1(x)).join('');
 };
-const ballotEncoder = (ballot) => {
+const ballotEncoder$1 = (ballot) => {
     switch (ballot) {
         case 'yay':
             return '00';
@@ -800,7 +804,7 @@ const ballotEncoder = (ballot) => {
             throw new InvalidBallotValueError(ballot);
     }
 };
-const ballotDecoder = (ballot) => {
+const ballotDecoder$1 = (ballot) => {
     const value = ballot.consume(1);
     switch (value[0]) {
         case 0x00:
@@ -813,7 +817,7 @@ const ballotDecoder = (ballot) => {
             throw new DecodeBallotValueError(value[0].toString());
     }
 };
-const pvmKindEncoder = (pvm) => {
+const pvmKindEncoder$1 = (pvm) => {
     switch (pvm) {
         case 'arith':
             return '00';
@@ -825,7 +829,7 @@ const pvmKindEncoder = (pvm) => {
             throw new UnsupportedPvmKindError(pvm);
     }
 };
-const pvmKindDecoder = (pvm) => {
+const pvmKindDecoder$1 = (pvm) => {
     const value = pvm.consume(1);
     switch (value[0]) {
         case 0x00:
@@ -838,15 +842,15 @@ const pvmKindDecoder = (pvm) => {
             throw new DecodePvmKindError(value[0].toString());
     }
 };
-const delegateEncoder = (val) => {
+const delegateEncoder$1 = (val) => {
     if (val) {
-        return boolEncoder(true) + publicKeyHashEncoder(val);
+        return boolEncoder$1(true) + publicKeyHashEncoder$1(val);
     }
     else {
-        return boolEncoder(false);
+        return boolEncoder$1(false);
     }
 };
-const int32Encoder = (val) => {
+const int32Encoder$1 = (val) => {
     const num = parseInt(String(val), 10);
     const byte = [];
     for (let i = 0; i < 4; i++) {
@@ -855,7 +859,7 @@ const int32Encoder = (val) => {
     }
     return Buffer.from(byte).toString('hex');
 };
-const int32Decoder = (val) => {
+const int32Decoder$1 = (val) => {
     const num = val.consume(4);
     let finalNum = 0;
     for (let i = 0; i < num.length; i++) {
@@ -863,7 +867,7 @@ const int32Decoder = (val) => {
     }
     return finalNum;
 };
-const int16Encoder = (val) => {
+const int16Encoder$1 = (val) => {
     const num = parseInt(String(val), 10);
     const byte = [];
     for (let i = 0; i < 2; i++) {
@@ -872,7 +876,7 @@ const int16Encoder = (val) => {
     }
     return Buffer.from(byte).toString('hex');
 };
-const int16Decoder = (val) => {
+const int16Decoder$1 = (val) => {
     const num = val.consume(2);
     let finalNum = 0;
     for (let i = 0; i < num.length; i++) {
@@ -880,113 +884,117 @@ const int16Decoder = (val) => {
     }
     return finalNum;
 };
-const boolDecoder = (val) => {
+const boolDecoder$1 = (val) => {
     const bool = val.consume(1);
     return bool[0] === 0xff;
 };
-const delegateDecoder = (val) => {
-    const hasDelegate = boolDecoder(val);
+const delegateDecoder$1 = (val) => {
+    const hasDelegate = boolDecoder$1(val);
     if (hasDelegate) {
-        return publicKeyHashDecoder(val);
+        return publicKeyHashDecoder$1(val);
     }
 };
-const publicKeyHashEncoder = (val) => {
+const publicKeyHashEncoder$1 = (val) => {
     const pubkeyPrefix = val.substring(0, 3);
     switch (pubkeyPrefix) {
         case Prefix.TZ1:
-            return '00' + prefixEncoder(Prefix.TZ1)(val);
+            return '00' + prefixEncoder$1(Prefix.TZ1)(val);
         case Prefix.TZ2:
-            return '01' + prefixEncoder(Prefix.TZ2)(val);
+            return '01' + prefixEncoder$1(Prefix.TZ2)(val);
         case Prefix.TZ3:
-            return '02' + prefixEncoder(Prefix.TZ3)(val);
+            return '02' + prefixEncoder$1(Prefix.TZ3)(val);
         case Prefix.TZ4:
-            return '03' + prefixEncoder(Prefix.TZ4)(val);
+            return '03' + prefixEncoder$1(Prefix.TZ4)(val);
         default:
             throw new InvalidKeyHashError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
                 ` expecting one for the following "${Prefix.TZ1}", "${Prefix.TZ2}", "${Prefix.TZ3}" or "${Prefix.TZ4}".`);
     }
 };
-const publicKeyHashesEncoder = (val) => {
+const publicKeyHashesEncoder$1 = (val) => {
     if (!val) {
-        return boolEncoder(false);
+        return boolEncoder$1(false);
     }
     if (val.length === 0) {
-        return boolEncoder(true) + pad(0);
+        return boolEncoder$1(true) + pad(0);
     }
     const publicKeyHashes = val.reduce((prev, curr) => {
-        return prev + publicKeyHashEncoder(curr);
+        return prev + publicKeyHashEncoder$1(curr);
     }, '');
-    return boolEncoder(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
+    return boolEncoder$1(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
 };
-const publicKeyEncoder = (val) => {
+const publicKeyEncoder$1 = (val) => {
     const pubkeyPrefix = val.substring(0, 4);
     switch (pubkeyPrefix) {
         case Prefix.EDPK:
-            return '00' + prefixEncoder(Prefix.EDPK)(val);
+            return '00' + prefixEncoder$1(Prefix.EDPK)(val);
         case Prefix.SPPK:
-            return '01' + prefixEncoder(Prefix.SPPK)(val);
+            return '01' + prefixEncoder$1(Prefix.SPPK)(val);
         case Prefix.P2PK:
-            return '02' + prefixEncoder(Prefix.P2PK)(val);
+            return '02' + prefixEncoder$1(Prefix.P2PK)(val);
+        case Prefix.BLPK:
+            return '03' + prefixEncoder$1(Prefix.BLPK)(val);
         default:
             throw new InvalidPublicKeyError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
                 ` expecting one of the following '${Prefix.EDPK}', '${Prefix.SPPK}', '${Prefix.P2PK}' or '${Prefix.BLPK}'.`);
     }
 };
-const addressEncoder = (val) => {
+const addressEncoder$1 = (val) => {
     const pubkeyPrefix = val.substring(0, 3);
     switch (pubkeyPrefix) {
         case Prefix.TZ1:
         case Prefix.TZ2:
         case Prefix.TZ3:
         case Prefix.TZ4:
-            return '00' + publicKeyHashEncoder(val);
+            return '00' + publicKeyHashEncoder$1(val);
         case Prefix.KT1:
-            return '01' + prefixEncoder(Prefix.KT1)(val) + '00';
+            return '01' + prefixEncoder$1(Prefix.KT1)(val) + '00';
         default:
             throw new InvalidAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
                 ` expecting one of the following prefix '${Prefix.TZ1}', ${Prefix.TZ2}', '${Prefix.TZ3}', '${Prefix.TZ4}' or '${Prefix.KT1}'.`);
     }
 };
-const smartRollupAddressEncoder = (val) => {
+const smartRollupAddressEncoder$1 = (val) => {
     if (val.substring(0, 3) !== Prefix.SR1) {
         throw new InvalidSmartRollupAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SR1}'.`);
     }
-    return prefixEncoder(Prefix.SR1)(val);
+    return prefixEncoder$1(Prefix.SR1)(val);
 };
-const smartContractAddressEncoder = (val) => {
+const smartContractAddressEncoder$1 = (val) => {
     const prefix = val.substring(0, 3);
     if (prefix === Prefix.KT1) {
-        return '01' + prefixEncoder(Prefix.KT1)(val) + '00';
+        return '01' + prefixEncoder$1(Prefix.KT1)(val) + '00';
     }
     throw new InvalidContractAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.KT1}'.`);
 };
-const publicKeyDecoder = (val) => {
+const publicKeyDecoder$1 = (val) => {
     const preamble = val.consume(1);
     switch (preamble[0]) {
         case 0x00:
-            return prefixDecoder(Prefix.EDPK)(val);
+            return prefixDecoder$1(Prefix.EDPK)(val);
         case 0x01:
-            return prefixDecoder(Prefix.SPPK)(val);
+            return prefixDecoder$1(Prefix.SPPK)(val);
         case 0x02:
-            return prefixDecoder(Prefix.P2PK)(val);
+            return prefixDecoder$1(Prefix.P2PK)(val);
+        case 0x03:
+            return prefixDecoder$1(Prefix.BLPK)(val);
         default:
             throw new InvalidPublicKeyError(val.toString(), invalidDetail(ValidationResult.NO_PREFIX_MATCHED));
     }
 };
-const smartRollupCommitmentHashEncoder = (val) => {
+const smartRollupCommitmentHashEncoder$1 = (val) => {
     const prefix = val.substring(0, 4);
     if (prefix === Prefix.SRC1) {
-        return prefixEncoder(Prefix.SRC1)(val);
+        return prefixEncoder$1(Prefix.SRC1)(val);
     }
     throw new InvalidSmartRollupCommitmentHashError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SRC1}'`);
 };
-const addressDecoder = (val) => {
+const addressDecoder$1 = (val) => {
     const preamble = val.consume(1);
     switch (preamble[0]) {
         case 0x00:
-            return publicKeyHashDecoder(val);
+            return publicKeyHashDecoder$1(val);
         case 0x01: {
-            const address = prefixDecoder(Prefix.KT1)(val);
+            const address = prefixDecoder$1(Prefix.KT1)(val);
             val.consume(1);
             return address;
         }
@@ -994,30 +1002,30 @@ const addressDecoder = (val) => {
             throw new InvalidAddressError(val.toString(), ': Unable to decode.');
     }
 };
-const smartRollupAddressDecoder = (val) => {
-    const address = prefixDecoder(Prefix.SR1)(val);
+const smartRollupAddressDecoder$1 = (val) => {
+    const address = prefixDecoder$1(Prefix.SR1)(val);
     if (address.substring(0, 3) !== Prefix.SR1) {
         throw new InvalidSmartRollupAddressError(address, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SR1}'.`);
     }
     return address;
 };
-const smartContractAddressDecoder = (val) => {
+const smartContractAddressDecoder$1 = (val) => {
     const preamble = val.consume(1);
     if (preamble[0] === 0x01) {
-        const scAddress = prefixDecoder(Prefix.KT1)(val);
+        const scAddress = prefixDecoder$1(Prefix.KT1)(val);
         val.consume(1);
         return scAddress;
     }
     throw new InvalidContractAddressError(val.toString(), invalidDetail(ValidationResult.NO_PREFIX_MATCHED));
 };
-const smartRollupCommitmentHashDecoder = (val) => {
-    const address = prefixDecoder(Prefix.SRC1)(val);
+const smartRollupCommitmentHashDecoder$1 = (val) => {
+    const address = prefixDecoder$1(Prefix.SRC1)(val);
     if (address.substring(0, 4) !== Prefix.SRC1) {
         throw new InvalidSmartRollupCommitmentHashError(address, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SRC1}'`);
     }
     return address;
 };
-const zarithEncoder = (n) => {
+const zarithEncoder$1 = (n) => {
     const fn = [];
     let nn = new BigNumber$1(n, 10);
     if (nn.isNaN()) {
@@ -1041,7 +1049,7 @@ const zarithEncoder = (n) => {
     }
     return fn.join('');
 };
-const zarithDecoder = (n) => {
+const zarithDecoder$1 = (n) => {
     let mostSignificantByte = 0;
     while (mostSignificantByte < n.length() && (n.get(mostSignificantByte) & 128) !== 0) {
         mostSignificantByte += 1;
@@ -1055,27 +1063,27 @@ const zarithDecoder = (n) => {
     n.consume(mostSignificantByte + 1);
     return new BigNumber$1(num).toString();
 };
-const entrypointDecoder = (value) => {
+const entrypointDecoder$1 = (value) => {
     const preamble = pad(value.consume(1)[0], 2);
-    if (preamble in entrypointMapping) {
-        return entrypointMapping[preamble];
+    if (preamble in entrypointMapping$1) {
+        return entrypointMapping$1[preamble];
     }
     else {
         const entry = extractRequiredLen(value, 1);
         const entrypoint = Buffer.from(entry).toString('utf8');
-        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
+        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
             throw new OversizedEntryPointError(entrypoint);
         }
         return entrypoint;
     }
 };
-const parametersDecoder = (val) => {
+const parametersDecoder$1 = (val) => {
     const preamble = val.consume(1);
     if (preamble[0] === 0x00) {
         return;
     }
     else {
-        const encodedEntrypoint = entrypointDecoder(val);
+        const encodedEntrypoint = entrypointDecoder$1(val);
         const params = extractRequiredLen(val);
         const parameters = valueDecoder(new Uint8ArrayConsumer(params));
         return {
@@ -1084,171 +1092,1227 @@ const parametersDecoder = (val) => {
         };
     }
 };
-const entrypointEncoder = (entrypoint) => {
-    if (entrypoint in entrypointMappingReverse) {
-        return `${entrypointMappingReverse[entrypoint]}`;
+const entrypointEncoder$1 = (entrypoint) => {
+    if (entrypoint in entrypointMappingReverse$1) {
+        return `${entrypointMappingReverse$1[entrypoint]}`;
     }
     else {
-        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
+        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
             throw new OversizedEntryPointError(entrypoint);
         }
         const value = { string: entrypoint };
         return `ff${valueEncoder(value).slice(8)}`;
     }
 };
-const parametersEncoder = (val) => {
+const parametersEncoder$1 = (val) => {
     if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
         return '00';
     }
-    const encodedEntrypoint = entrypointEncoder(val.entrypoint);
+    const encodedEntrypoint = entrypointEncoder$1(val.entrypoint);
     const parameters = valueEncoder(val.value);
     const length = pad(parameters.length / 2);
     return `ff${encodedEntrypoint}${length}${parameters}`;
 };
-const valueParameterEncoder = (value) => {
+const valueParameterEncoder$1 = (value) => {
     const valueEncoded = valueEncoder(value);
     return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
 };
-const valueParameterDecoder = (val) => {
+const valueParameterDecoder$1 = (val) => {
     const value = extractRequiredLen(val);
     return valueDecoder(new Uint8ArrayConsumer(value));
 };
-const blockPayloadHashEncoder = prefixEncoder(Prefix.VH);
-const blockPayloadHashDecoder = prefixDecoder(Prefix.VH);
-const entrypointNameEncoder = (entrypoint) => {
+const blockPayloadHashEncoder$1 = prefixEncoder$1(Prefix.VH);
+const blockPayloadHashDecoder$1 = prefixDecoder$1(Prefix.VH);
+const entrypointNameEncoder$1 = (entrypoint) => {
     const value = { string: entrypoint };
     return `${valueEncoder(value).slice(2)}`;
 };
-const entrypointNameDecoder = (val) => {
+const entrypointNameDecoder$1 = (val) => {
     const entry = extractRequiredLen(val);
     return Buffer.from(entry).toString('utf8');
 };
-const burnLimitEncoder = (val) => {
-    return !val ? '00' : `ff${zarithEncoder(val)}`;
+const burnLimitEncoder$1 = (val) => {
+    return !val ? '00' : `ff${zarithEncoder$1(val)}`;
 };
-const burnLimitDecoder = (value) => {
+const burnLimitDecoder$1 = (value) => {
     const prefix = value.consume(1);
     if (Buffer.from(prefix).toString('hex') !== '00') {
-        return zarithDecoder(value);
+        return zarithDecoder$1(value);
     }
 };
-const depositsLimitEncoder = (val) => {
-    return !val ? '00' : `ff${zarithEncoder(val)}`;
+const depositsLimitEncoder$1 = (val) => {
+    return !val ? '00' : `ff${zarithEncoder$1(val)}`;
 };
-const depositsLimitDecoder = (value) => {
+const depositsLimitDecoder$1 = (value) => {
     const prefix = value.consume(1);
     if (Buffer.from(prefix).toString('hex') !== '00') {
-        return zarithDecoder(value);
+        return zarithDecoder$1(value);
+    }
+};
+const signatureV1Encoder = (val) => {
+    const signaturePrefix = val.substring(0, 5);
+    switch (signaturePrefix) {
+        case Prefix.EDSIG:
+            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.EDSIG)(val));
+        case Prefix.SPSIG:
+            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.SPSIG)(val));
+        case Prefix.P2SIG:
+            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.P2SIG)(val));
+        case Prefix.BLSIG:
+            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.BLSIG)(val));
+        default:
+            throw new InvalidSignatureError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
+                ` expecting one of the following '${Prefix.EDSIG}', '${Prefix.SPSIG}', '${Prefix.P2SIG}' or '${Prefix.BLSIG}'.`);
     }
 };
-const paddedBytesEncoder = (val, paddingLength = 8) => {
+const signatureV1Decoder = (val) => {
+    val.consume(4);
+    if (val.length().toString() === '96') {
+        return prefixDecoder$1(Prefix.BLSIG)(val);
+    }
+    else {
+        throw new ProhibitedActionError('currently we only support decoding of BLSIG signatures');
+    }
+};
+const signatureProofEncoder = (val) => {
+    if (val) {
+        return boolEncoder$1(true) + signatureV1Encoder(val);
+    }
+    else {
+        return boolEncoder$1(false);
+    }
+};
+const signatureProofDecoder = (value) => {
+    const hasProof = boolDecoder$1(value);
+    if (hasProof) {
+        return signatureV1Decoder(value);
+    }
+};
+const paddedBytesEncoder$1 = (val, paddingLength = 8) => {
     return `${pad(val.length / 2, paddingLength)}${val}`;
 };
-const paddedBytesDecoder = (val) => {
+const paddedBytesDecoder$1 = (val) => {
     const value = extractRequiredLen(val);
     return Buffer.from(value).toString('hex');
 };
-const smartRollupMessageEncoder = (val) => {
+const smartRollupMessageEncoder$1 = (val) => {
     const message = val.reduce((prev, curr) => {
         return prev + `${pad(curr.length / 2)}${curr}`;
     }, '');
     return `${pad(message.length / 2)}${message}`;
 };
-const smartRollupMessageDecoder = (val) => {
+const smartRollupMessageDecoder$1 = (val) => {
     const valueArray = extractRequiredLen(val);
     const ret = stripLengthPrefixFromBytes(new Uint8ArrayConsumer(valueArray));
     return ret.map((value) => Buffer.from(value).toString('hex'));
 };
-const dalCommitmentEncoder = (val) => {
+const dalCommitmentEncoder$1 = (val) => {
     const prefix = val.substring(0, 2);
     if (prefix === Prefix.SH) {
-        return prefixEncoder(Prefix.SH)(val);
+        return prefixEncoder$1(Prefix.SH)(val);
     }
     throw new InvalidDalCommitmentError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
 };
-const dalCommitmentDecoder = (val) => {
-    const commitment = prefixDecoder(Prefix.SH)(val);
+const dalCommitmentDecoder$1 = (val) => {
+    const commitment = prefixDecoder$1(Prefix.SH)(val);
     if (commitment.substring(0, 2) !== Prefix.SH) {
         throw new InvalidDalCommitmentError(commitment, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
     }
     return commitment;
 };
-const slotHeaderEncoder = (val) => {
-    return pad(val.slot_index, 2) + dalCommitmentEncoder(val.commitment) + val.commitment_proof;
+const slotHeaderEncoder$1 = (val) => {
+    return pad(val.slot_index, 2) + dalCommitmentEncoder$1(val.commitment) + val.commitment_proof;
 };
-const slotHeaderDecoder = (val) => {
+const slotHeaderDecoder$1 = (val) => {
     const preamble = val.consume(1);
     return {
         slot_index: Number(preamble[0].toString(10)),
-        commitment: dalCommitmentDecoder(val),
+        commitment: dalCommitmentDecoder$1(val),
         commitment_proof: toHexString(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
     };
 };
 
-const ManagerOperationSchema = {
-    branch: CODEC.BRANCH,
-    contents: [CODEC.OPERATION],
-};
-const ActivationSchema = {
-    pkh: CODEC.TZ1,
-    secret: CODEC.SECRET,
-};
-const RevealSchema = {
-    source: CODEC.PKH,
-    fee: CODEC.ZARITH,
-    counter: CODEC.ZARITH,
-    gas_limit: CODEC.ZARITH,
-    storage_limit: CODEC.ZARITH,
-    public_key: CODEC.PUBLIC_KEY,
-};
-const DelegationSchema = {
-    source: CODEC.PKH,
-    fee: CODEC.ZARITH,
-    counter: CODEC.ZARITH,
-    gas_limit: CODEC.ZARITH,
-    storage_limit: CODEC.ZARITH,
-    delegate: CODEC.DELEGATE,
-};
-const TransactionSchema = {
-    source: CODEC.PKH,
-    fee: CODEC.ZARITH,
-    counter: CODEC.ZARITH,
-    gas_limit: CODEC.ZARITH,
-    storage_limit: CODEC.ZARITH,
-    amount: CODEC.ZARITH,
-    destination: CODEC.ADDRESS,
-    parameters: CODEC.PARAMETERS,
-};
-const OriginationSchema = {
-    source: CODEC.PKH,
-    fee: CODEC.ZARITH,
-    counter: CODEC.ZARITH,
-    gas_limit: CODEC.ZARITH,
-    storage_limit: CODEC.ZARITH,
-    balance: CODEC.ZARITH,
-    delegate: CODEC.DELEGATE,
-    script: CODEC.SCRIPT,
+const ManagerOperationSchema$1 = {
+    branch: CODEC$1.BRANCH,
+    contents: [CODEC$1.OPERATION],
+};
+const ActivationSchema$1 = {
+    pkh: CODEC$1.TZ1,
+    secret: CODEC$1.SECRET,
+};
+const RevealSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    public_key: CODEC$1.PUBLIC_KEY,
+};
+const DelegationSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    delegate: CODEC$1.DELEGATE,
+};
+const TransactionSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    amount: CODEC$1.ZARITH,
+    destination: CODEC$1.ADDRESS,
+    parameters: CODEC$1.PARAMETERS,
+};
+const OriginationSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    balance: CODEC$1.ZARITH,
+    delegate: CODEC$1.DELEGATE,
+    script: CODEC$1.SCRIPT,
+};
+const BallotSchema$1 = {
+    source: CODEC$1.PKH,
+    period: CODEC$1.INT32,
+    proposal: CODEC$1.PROPOSAL,
+    ballot: CODEC$1.BALLOT_STATEMENT,
+};
+const AttestationSchema$1 = {
+    slot: CODEC$1.INT16,
+    level: CODEC$1.INT32,
+    round: CODEC$1.INT32,
+    block_payload_hash: CODEC$1.BLOCK_PAYLOAD_HASH,
+};
+const AttestationWithDalSchema$1 = {
+    slot: CODEC$1.INT16,
+    level: CODEC$1.INT32,
+    round: CODEC$1.INT32,
+    block_payload_hash: CODEC$1.BLOCK_PAYLOAD_HASH,
+    dal_attestation: CODEC$1.ZARITH,
+};
+const SeedNonceRevelationSchema$1 = {
+    level: CODEC$1.INT32,
+    nonce: CODEC$1.RAW,
+};
+const ProposalsSchema$1 = {
+    source: CODEC$1.PKH,
+    period: CODEC$1.INT32,
+    proposals: CODEC$1.PROPOSAL_ARR,
+};
+const RegisterGlobalConstantSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    value: CODEC$1.VALUE,
+};
+const TransferTicketSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    ticket_contents: CODEC$1.VALUE,
+    ticket_ty: CODEC$1.VALUE,
+    ticket_ticketer: CODEC$1.ADDRESS,
+    ticket_amount: CODEC$1.ZARITH,
+    destination: CODEC$1.ADDRESS,
+    entrypoint: CODEC$1.ENTRYPOINT,
+};
+const IncreasePaidStorageSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    amount: CODEC$1.ZARITH,
+    destination: CODEC$1.SMART_CONTRACT_ADDRESS,
+};
+const UpdateConsensusKeySchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    pk: CODEC$1.PUBLIC_KEY,
+    proof: CODEC$1.SIGNATURE_PROOF,
+};
+const DrainDelegateSchema$1 = {
+    consensus_key: CODEC$1.PKH,
+    delegate: CODEC$1.PKH,
+    destination: CODEC$1.PKH,
+};
+const SetDepositsLimitSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    limit: CODEC$1.DEPOSITS_LIMIT,
+};
+const SmartRollupOriginateSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    pvm_kind: CODEC$1.PVM_KIND,
+    kernel: CODEC$1.PADDED_BYTES,
+    parameters_ty: CODEC$1.VALUE,
+    whitelist: CODEC$1.PKH_ARR,
+};
+const SmartRollupAddMessagesSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    message: CODEC$1.SMART_ROLLUP_MESSAGE,
+};
+const SmartRollupExecuteOutboxMessageSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    rollup: CODEC$1.SMART_ROLLUP_ADDRESS,
+    cemented_commitment: CODEC$1.SMART_ROLLUP_COMMITMENT_HASH,
+    output_proof: CODEC$1.PADDED_BYTES,
+};
+const DalPublishCommitmentSchema$1 = {
+    source: CODEC$1.PKH,
+    fee: CODEC$1.ZARITH,
+    counter: CODEC$1.ZARITH,
+    gas_limit: CODEC$1.ZARITH,
+    storage_limit: CODEC$1.ZARITH,
+    slot_header: CODEC$1.SLOT_HEADER,
+};
+const FailingNoopSchema$1 = {
+    arbitrary: CODEC$1.PADDED_BYTES,
+};
+const operationEncoder$1 = (encoders) => (operation) => {
+    if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse$1)) {
+        throw new InvalidOperationKindError(operation.kind);
+    }
+    return kindMappingReverse$1[operation.kind] + encoders[operation.kind](operation);
 };
-const BallotSchema = {
-    source: CODEC.PKH,
-    period: CODEC.INT32,
-    proposal: CODEC.PROPOSAL,
-    ballot: CODEC.BALLOT_STATEMENT,
+const operationDecoder$1 = (decoders) => (value) => {
+    const op = value.consume(1);
+    const operationName = kindMapping$1[op[0]];
+    if (operationName === undefined) {
+        throw new UnsupportedOperationError(op[0].toString());
+    }
+    const decodedObj = decoders[operationName](value);
+    if (typeof decodedObj !== 'object') {
+        throw new OperationDecodingError('Invalid operation, cannot be decoded.');
+    }
+    return Object.assign({ kind: operationName }, decodedObj);
 };
-const AttestationSchema = {
-    slot: CODEC.INT16,
-    level: CODEC.INT32,
-    round: CODEC.INT32,
-    block_payload_hash: CODEC.BLOCK_PAYLOAD_HASH,
+const schemaEncoder$1 = (encoders) => (schema) => (value) => {
+    const keys = Object.keys(schema);
+    return keys.reduce((prev, key) => {
+        const valueToEncode = schema[key];
+        if (value && Array.isArray(valueToEncode)) {
+            const encoder = encoders[valueToEncode[0]];
+            const values = value[key];
+            if (!Array.isArray(values)) {
+                throw new OperationEncodingError(`Invalid operation value "${JSON.stringify(values)}" of key "${key}, expected value to be Array.`);
+            }
+            return (prev + values.reduce((prevBytes, current) => prevBytes + encoder(current), ''));
+        }
+        else {
+            const encoder = encoders[valueToEncode];
+            return prev + encoder(value[key]);
+        }
+    }, '');
 };
-const AttestationWithDalSchema = {
-    slot: CODEC.INT16,
-    level: CODEC.INT32,
-    round: CODEC.INT32,
-    block_payload_hash: CODEC.BLOCK_PAYLOAD_HASH,
-    dal_attestation: CODEC.ZARITH,
+const schemaDecoder$1 = (decoders) => (schema) => (value) => {
+    const keys = Object.keys(schema);
+    return keys.reduce((prev, key) => {
+        const valueToEncode = schema[key];
+        if (Array.isArray(valueToEncode)) {
+            const decoder = decoders[valueToEncode[0]];
+            const decoded = [];
+            const lastLength = value.length();
+            while (value.length() > 0) {
+                decoded.push(decoder(value));
+                if (lastLength === value.length()) {
+                    throw new OperationDecodingError('Unable to decode value');
+                }
+            }
+            return Object.assign(Object.assign({}, prev), { [key]: decoded });
+        }
+        else {
+            const decoder = decoders[valueToEncode];
+            const result = decoder(value);
+            if (typeof result !== 'undefined') {
+                return Object.assign(Object.assign({}, prev), { [key]: result });
+            }
+            else {
+                return Object.assign({}, prev);
+            }
+        }
+    }, {});
 };
-const SeedNonceRevelationSchema = {
+
+const decoders = {
+    [CODEC$1.SECRET]: (val) => toHexString(val.consume(20)),
+    [CODEC$1.RAW]: (val) => toHexString(val.consume(32)),
+    [CODEC$1.TZ1]: tz1Decoder$1,
+    [CODEC$1.BRANCH]: branchDecoder$1,
+    [CODEC$1.ZARITH]: zarithDecoder$1,
+    [CODEC$1.PUBLIC_KEY]: publicKeyDecoder$1,
+    [CODEC$1.PKH]: publicKeyHashDecoder$1,
+    [CODEC$1.PKH_ARR]: publicKeyHashesDecoder$1,
+    [CODEC$1.DELEGATE]: delegateDecoder$1,
+    [CODEC$1.INT32]: int32Decoder$1,
+    [CODEC$1.SCRIPT]: scriptDecoder,
+    [CODEC$1.BALLOT_STATEMENT]: ballotDecoder$1,
+    [CODEC$1.PROPOSAL]: proposalDecoder$1,
+    [CODEC$1.PROPOSAL_ARR]: proposalsDecoder$1,
+    [CODEC$1.PARAMETERS]: parametersDecoder$1,
+    [CODEC$1.ADDRESS]: addressDecoder$1,
+    [CODEC$1.SMART_ROLLUP_ADDRESS]: smartRollupAddressDecoder$1,
+    [CODEC$1.SMART_CONTRACT_ADDRESS]: smartContractAddressDecoder$1,
+    [CODEC$1.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashDecoder$1,
+    [CODEC$1.VALUE]: valueParameterDecoder$1,
+    [CODEC$1.INT16]: int16Decoder$1,
+    [CODEC$1.BLOCK_PAYLOAD_HASH]: blockPayloadHashDecoder$1,
+    [CODEC$1.ENTRYPOINT]: entrypointNameDecoder$1,
+    [CODEC$1.BURN_LIMIT]: burnLimitDecoder$1,
+    [CODEC$1.DEPOSITS_LIMIT]: depositsLimitDecoder$1,
+    [CODEC$1.SIGNATURE_PROOF]: signatureProofDecoder,
+    [CODEC$1.PVM_KIND]: pvmKindDecoder$1,
+    [CODEC$1.PADDED_BYTES]: paddedBytesDecoder$1,
+    [CODEC$1.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder$1,
+    [CODEC$1.SLOT_HEADER]: slotHeaderDecoder$1,
+};
+decoders[CODEC$1.OPERATION] = operationDecoder$1(decoders);
+decoders[CODEC$1.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder$1(decoders)(ActivationSchema$1)(val);
+decoders[CODEC$1.OP_FAILING_NOOP] = (val) => schemaDecoder$1(decoders)(FailingNoopSchema$1)(val);
+decoders[CODEC$1.OP_DELEGATION] = (val) => schemaDecoder$1(decoders)(DelegationSchema$1)(val);
+decoders[CODEC$1.OP_TRANSACTION] = (val) => schemaDecoder$1(decoders)(TransactionSchema$1)(val);
+decoders[CODEC$1.OP_ORIGINATION] = (val) => schemaDecoder$1(decoders)(OriginationSchema$1)(val);
+decoders[CODEC$1.OP_BALLOT] = (val) => schemaDecoder$1(decoders)(BallotSchema$1)(val);
+decoders[CODEC$1.OP_ATTESTATION] = (val) => schemaDecoder$1(decoders)(AttestationSchema$1)(val);
+decoders[CODEC$1.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder$1(decoders)(AttestationWithDalSchema$1)(val);
+decoders[CODEC$1.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder$1(decoders)(SeedNonceRevelationSchema$1)(val);
+decoders[CODEC$1.OP_PROPOSALS] = (val) => schemaDecoder$1(decoders)(ProposalsSchema$1)(val);
+decoders[CODEC$1.OP_REVEAL] = (val) => schemaDecoder$1(decoders)(RevealSchema$1)(val);
+decoders[CODEC$1.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder$1(decoders)(RegisterGlobalConstantSchema$1)(val);
+decoders[CODEC$1.OP_TRANSFER_TICKET] = (val) => schemaDecoder$1(decoders)(TransferTicketSchema$1)(val);
+decoders[CODEC$1.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder$1(decoders)(IncreasePaidStorageSchema$1)(val);
+decoders[CODEC$1.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder$1(decoders)(UpdateConsensusKeySchema$1)(val);
+decoders[CODEC$1.OP_DRAIN_DELEGATE] = (val) => schemaDecoder$1(decoders)(DrainDelegateSchema$1)(val);
+decoders[CODEC$1.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder$1(decoders)(SmartRollupOriginateSchema$1)(val);
+decoders[CODEC$1.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder$1(decoders)(SmartRollupAddMessagesSchema$1)(val);
+decoders[CODEC$1.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder$1(decoders)(SmartRollupExecuteOutboxMessageSchema$1)(val);
+decoders[CODEC$1.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder$1(decoders)(DalPublishCommitmentSchema$1)(val);
+decoders[CODEC$1.MANAGER] = schemaDecoder$1(decoders)(ManagerOperationSchema$1);
+decoders[CODEC$1.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder$1(decoders)(SetDepositsLimitSchema$1)(val);
+
+/*
+ * Some code in this file is originally from sotez
+ * Copyright (c) 2018 Andrew Kishino
+ */
+// See: https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
+const ENTRYPOINT_MAX_LENGTH = 31;
+var CODEC;
+(function (CODEC) {
+    CODEC["SECRET"] = "secret";
+    CODEC["RAW"] = "raw";
+    CODEC["TZ1"] = "tz1";
+    CODEC["BRANCH"] = "branch";
+    CODEC["ZARITH"] = "zarith";
+    CODEC["PUBLIC_KEY"] = "public_key";
+    CODEC["PKH"] = "pkh";
+    CODEC["PKH_ARR"] = "pkhArr";
+    CODEC["DELEGATE"] = "delegate";
+    CODEC["SCRIPT"] = "script";
+    CODEC["BALLOT_STATEMENT"] = "ballotStmt";
+    CODEC["PROPOSAL"] = "proposal";
+    CODEC["PROPOSAL_ARR"] = "proposalArr";
+    CODEC["INT32"] = "int32";
+    CODEC["INT16"] = "int16";
+    CODEC["PARAMETERS"] = "parameters";
+    CODEC["ADDRESS"] = "address";
+    CODEC["SMART_CONTRACT_ADDRESS"] = "smart_contract_address";
+    CODEC["SMART_ROLLUP_ADDRESS"] = "smart_rollup_address";
+    CODEC["SMART_ROLLUP_COMMITMENT_HASH"] = "smart_rollup_commitment_hash";
+    CODEC["VALUE"] = "value";
+    CODEC["PADDED_BYTES"] = "padded_bytes";
+    CODEC["SMART_ROLLUP_MESSAGE"] = "smart_rollup_message";
+    CODEC["MANAGER"] = "manager";
+    CODEC["BLOCK_PAYLOAD_HASH"] = "blockPayloadHash";
+    CODEC["ENTRYPOINT"] = "entrypoint";
+    CODEC["OPERATION"] = "operation";
+    CODEC["OP_ACTIVATE_ACCOUNT"] = "activate_account";
+    CODEC["OP_DELEGATION"] = "delegation";
+    CODEC["OP_TRANSACTION"] = "transaction";
+    CODEC["OP_ORIGINATION"] = "origination";
+    CODEC["OP_BALLOT"] = "ballot";
+    CODEC["OP_FAILING_NOOP"] = "failing_noop";
+    CODEC["OP_ATTESTATION"] = "attestation";
+    CODEC["OP_ATTESTATION_WITH_DAL"] = "attestation_with_dal";
+    CODEC["OP_SEED_NONCE_REVELATION"] = "seed_nonce_revelation";
+    CODEC["OP_REVEAL"] = "reveal";
+    CODEC["OP_PROPOSALS"] = "proposals";
+    CODEC["OP_REGISTER_GLOBAL_CONSTANT"] = "register_global_constant";
+    CODEC["OP_TRANSFER_TICKET"] = "transfer_ticket";
+    CODEC["BURN_LIMIT"] = "burn_limit";
+    CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
+    CODEC["OP_UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
+    CODEC["OP_DRAIN_DELEGATE"] = "drain_delegate";
+    CODEC["DEPOSITS_LIMIT"] = "deposits_limit";
+    CODEC["OP_SET_DEPOSITS_LIMIT"] = "set_deposits_limit";
+    CODEC["OP_SMART_ROLLUP_ORIGINATE"] = "smart_rollup_originate";
+    CODEC["PVM_KIND"] = "pvm_kind";
+    CODEC["OP_SMART_ROLLUP_ADD_MESSAGES"] = "smart_rollup_add_messages";
+    CODEC["OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE"] = "smart_rollup_execute_outbox_message";
+    CODEC["OP_DAL_PUBLISH_COMMITMENT"] = "dal_publish_commitment";
+    CODEC["SLOT_HEADER"] = "slot_header";
+})(CODEC || (CODEC = {}));
+// See https://tezos.gitlab.io/shell/p2p_api.html#alpha-michelson-v1-primitives-enumeration-unsigned-8-bit-integer
+const opMapping = {
+    '00': 'parameter',
+    '01': 'storage',
+    '02': 'code',
+    '03': 'False',
+    '04': 'Elt',
+    '05': 'Left',
+    '06': 'None',
+    '07': 'Pair',
+    '08': 'Right',
+    '09': 'Some',
+    '0a': 'True',
+    '0b': 'Unit',
+    '0c': 'PACK',
+    '0d': 'UNPACK',
+    '0e': 'BLAKE2B',
+    '0f': 'SHA256',
+    '10': 'SHA512',
+    '11': 'ABS',
+    '12': 'ADD',
+    '13': 'AMOUNT',
+    '14': 'AND',
+    '15': 'BALANCE',
+    '16': 'CAR',
+    '17': 'CDR',
+    '18': 'CHECK_SIGNATURE',
+    '19': 'COMPARE',
+    '1a': 'CONCAT',
+    '1b': 'CONS',
+    '1c': 'CREATE_ACCOUNT', // Removed in Edo
+    '1d': 'CREATE_CONTRACT', // Removed in Edo
+    '1e': 'IMPLICIT_ACCOUNT',
+    '1f': 'DIP',
+    '20': 'DROP',
+    '21': 'DUP',
+    '22': 'EDIV',
+    '23': 'EMPTY_MAP',
+    '24': 'EMPTY_SET',
+    '25': 'EQ',
+    '26': 'EXEC',
+    '27': 'FAILWITH',
+    '28': 'GE',
+    '29': 'GET',
+    '2a': 'GT',
+    '2b': 'HASH_KEY',
+    '2c': 'IF',
+    '2d': 'IF_CONS',
+    '2e': 'IF_LEFT',
+    '2f': 'IF_NONE',
+    '30': 'INT',
+    '31': 'LAMBDA',
+    '32': 'LE',
+    '33': 'LEFT',
+    '34': 'LOOP',
+    '35': 'LSL',
+    '36': 'LSR',
+    '37': 'LT',
+    '38': 'MAP',
+    '39': 'MEM',
+    '3a': 'MUL',
+    '3b': 'NEG',
+    '3c': 'NEQ',
+    '3d': 'NIL',
+    '3e': 'NONE',
+    '3f': 'NOT',
+    '40': 'NOW',
+    '41': 'OR',
+    '42': 'PAIR',
+    '43': 'PUSH',
+    '44': 'RIGHT',
+    '45': 'SIZE',
+    '46': 'SOME',
+    '47': 'SOURCE',
+    '48': 'SENDER',
+    '49': 'SELF',
+    '4a': 'STEPS_TO_QUOTA', // Removed in Edo
+    '4b': 'SUB',
+    '4c': 'SWAP',
+    '4d': 'TRANSFER_TOKENS',
+    '4e': 'SET_DELEGATE',
+    '4f': 'UNIT',
+    '50': 'UPDATE',
+    '51': 'XOR',
+    '52': 'ITER',
+    '53': 'LOOP_LEFT',
+    '54': 'ADDRESS',
+    '55': 'CONTRACT',
+    '56': 'ISNAT',
+    '57': 'CAST',
+    '58': 'RENAME',
+    '59': 'bool',
+    '5a': 'contract',
+    '5b': 'int',
+    '5c': 'key',
+    '5d': 'key_hash',
+    '5e': 'lambda',
+    '5f': 'list',
+    '60': 'map',
+    '61': 'big_map',
+    '62': 'nat',
+    '63': 'option',
+    '64': 'or',
+    '65': 'pair',
+    '66': 'set',
+    '67': 'signature',
+    '68': 'string',
+    '69': 'bytes',
+    '6a': 'mutez',
+    '6b': 'timestamp',
+    '6c': 'unit',
+    '6d': 'operation',
+    '6e': 'address',
+    '6f': 'SLICE',
+    '70': 'DIG',
+    '71': 'DUG',
+    '72': 'EMPTY_BIG_MAP',
+    '73': 'APPLY',
+    '74': 'chain_id',
+    '75': 'CHAIN_ID',
+    '76': 'LEVEL',
+    '77': 'SELF_ADDRESS',
+    '78': 'never',
+    '79': 'NEVER',
+    '7a': 'UNPAIR',
+    '7b': 'VOTING_POWER',
+    '7c': 'TOTAL_VOTING_POWER',
+    '7d': 'KECCAK',
+    '7e': 'SHA3',
+    '7f': 'PAIRING_CHECK',
+    '80': 'bls12_381_g1',
+    '81': 'bls12_381_g2',
+    '82': 'bls12_381_fr',
+    '83': 'sapling_state',
+    '84': 'sapling_transaction_deprecated',
+    '85': 'SAPLING_EMPTY_STATE',
+    '86': 'SAPLING_VERIFY_UPDATE',
+    '87': 'ticket',
+    '88': 'TICKET_DEPRECATED',
+    '89': 'READ_TICKET',
+    '8a': 'SPLIT_TICKET',
+    '8b': 'JOIN_TICKETS',
+    '8c': 'GET_AND_UPDATE',
+    '8d': 'chest',
+    '8e': 'chest_key',
+    '8f': 'OPEN_CHEST',
+    '90': 'VIEW',
+    '91': 'view',
+    '92': 'constant',
+    '93': 'SUB_MUTEZ',
+    '94': 'tx_rollup_l2_address',
+    '95': 'MIN_BLOCK_TIME',
+    '96': 'sapling_transaction',
+    '97': 'EMIT',
+    '98': 'Lambda_rec',
+    '99': 'LAMBDA_REC',
+    '9a': 'TICKET',
+    '9b': 'BYTES',
+    '9c': 'NAT',
+    '9d': 'Ticket',
+};
+(() => {
+    const result = {};
+    Object.keys(opMapping).forEach((key) => {
+        result[opMapping[key]] = key;
+    });
+    return result;
+})();
+// See https://tezos.gitlab.io/shell/p2p_api.html
+const kindMapping = {
+    0x04: 'activate_account',
+    0x6b: 'reveal',
+    0x6e: 'delegation',
+    0x6c: 'transaction',
+    0x6d: 'origination',
+    0x06: 'ballot',
+    0x15: 'attestation',
+    0x17: 'attestation_with_dal',
+    0x01: 'seed_nonce_revelation',
+    0x05: 'proposals',
+    0x6f: 'register_global_constant',
+    0x9e: 'transfer_ticket',
+    0x70: 'set_deposits_limit',
+    0x71: 'increase_paid_storage',
+    0x72: 'update_consensus_key',
+    0x09: 'drain_delegate',
+    0xc8: 'smart_rollup_originate',
+    0xc9: 'smart_rollup_add_messages',
+    0xce: 'smart_rollup_execute_outbox_message',
+    0xe6: 'dal_publish_commitment',
+    0x11: 'failing_noop',
+};
+const kindMappingReverse = (() => {
+    const result = {};
+    Object.keys(kindMapping).forEach((key) => {
+        const keyNum = typeof key === 'string' ? parseInt(key, 10) : key;
+        result[kindMapping[keyNum]] = pad(keyNum, 2);
+    });
+    return result;
+})();
+// See https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
+const entrypointMapping = {
+    '00': 'default',
+    '01': 'root',
+    '02': 'do',
+    '03': 'set_delegate',
+    '04': 'remove_delegate',
+    '05': 'deposit',
+    '06': 'stake',
+    '07': 'unstake',
+    '08': 'finalize_unstake',
+    '09': 'set_delegate_parameters',
+};
+const entrypointMappingReverse = (() => {
+    const result = {};
+    Object.keys(entrypointMapping).forEach((key) => {
+        result[entrypointMapping[key]] = key;
+    });
+    return result;
+})();
+
+// https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
+const prefixEncoder = (prefix$1) => (str) => {
+    return buf2hex(Buffer.from(b58cdecode(str, prefix[prefix$1])));
+};
+const prefixDecoder = (pre) => (str) => {
+    const val = str.consume(prefixLength[pre]);
+    return b58cencode(val, prefix[pre]);
+};
+const tz1Decoder = prefixDecoder(Prefix.TZ1);
+const branchDecoder = prefixDecoder(Prefix.B);
+const publicKeyHashDecoder = (val) => {
+    const prefix = val.consume(1);
+    if (prefix[0] === 0x00) {
+        return prefixDecoder(Prefix.TZ1)(val);
+    }
+    else if (prefix[0] === 0x01) {
+        return prefixDecoder(Prefix.TZ2)(val);
+    }
+    else if (prefix[0] === 0x02) {
+        return prefixDecoder(Prefix.TZ3)(val);
+    }
+};
+const publicKeyHashesDecoder = (val) => {
+    if (!boolDecoder(val)) {
+        return undefined;
+    }
+    const publicKeyHashes = [];
+    val.consume(4);
+    while (val.length() > 0) {
+        publicKeyHashes.push(publicKeyHashDecoder(val));
+    }
+    return publicKeyHashes;
+};
+const branchEncoder = prefixEncoder(Prefix.B);
+const tz1Encoder = prefixEncoder(Prefix.TZ1);
+const boolEncoder = (bool) => (bool ? 'ff' : '00');
+const proposalEncoder = (proposal) => {
+    return prefixEncoder(Prefix.P)(proposal);
+};
+const proposalDecoder = (proposal) => {
+    return prefixDecoder(Prefix.P)(proposal);
+};
+const proposalsDecoder = (proposal) => {
+    const proposals = [];
+    proposal.consume(4);
+    while (proposal.length() > 0) {
+        proposals.push(proposalDecoder(proposal));
+    }
+    return proposals;
+};
+const proposalsEncoder = (proposals) => {
+    return pad(32 * proposals.length) + proposals.map((x) => proposalEncoder(x)).join('');
+};
+const ballotEncoder = (ballot) => {
+    switch (ballot) {
+        case 'yay':
+            return '00';
+        case 'nay':
+            return '01';
+        case 'pass':
+            return '02';
+        default:
+            throw new InvalidBallotValueError(ballot);
+    }
+};
+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 DecodeBallotValueError(value[0].toString());
+    }
+};
+const pvmKindEncoder = (pvm) => {
+    switch (pvm) {
+        case 'arith':
+            return '00';
+        case 'wasm_2_0_0':
+            return '01';
+        case 'riscv':
+            return '02';
+        default:
+            throw new UnsupportedPvmKindError(pvm);
+    }
+};
+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 DecodePvmKindError(value[0].toString());
+    }
+};
+const delegateEncoder = (val) => {
+    if (val) {
+        return boolEncoder(true) + publicKeyHashEncoder(val);
+    }
+    else {
+        return boolEncoder(false);
+    }
+};
+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');
+};
+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;
+};
+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');
+};
+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;
+};
+const boolDecoder = (val) => {
+    const bool = val.consume(1);
+    return bool[0] === 0xff;
+};
+const delegateDecoder = (val) => {
+    const hasDelegate = boolDecoder(val);
+    if (hasDelegate) {
+        return publicKeyHashDecoder(val);
+    }
+};
+const publicKeyHashEncoder = (val) => {
+    const pubkeyPrefix = val.substring(0, 3);
+    switch (pubkeyPrefix) {
+        case Prefix.TZ1:
+            return '00' + prefixEncoder(Prefix.TZ1)(val);
+        case Prefix.TZ2:
+            return '01' + prefixEncoder(Prefix.TZ2)(val);
+        case Prefix.TZ3:
+            return '02' + prefixEncoder(Prefix.TZ3)(val);
+        case Prefix.TZ4:
+            return '03' + prefixEncoder(Prefix.TZ4)(val);
+        default:
+            throw new InvalidKeyHashError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
+                ` expecting one for the following "${Prefix.TZ1}", "${Prefix.TZ2}", "${Prefix.TZ3}" or "${Prefix.TZ4}".`);
+    }
+};
+const publicKeyHashesEncoder = (val) => {
+    if (!val) {
+        return boolEncoder(false);
+    }
+    if (val.length === 0) {
+        return boolEncoder(true) + pad(0);
+    }
+    const publicKeyHashes = val.reduce((prev, curr) => {
+        return prev + publicKeyHashEncoder(curr);
+    }, '');
+    return boolEncoder(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
+};
+const publicKeyEncoder = (val) => {
+    const pubkeyPrefix = val.substring(0, 4);
+    switch (pubkeyPrefix) {
+        case Prefix.EDPK:
+            return '00' + prefixEncoder(Prefix.EDPK)(val);
+        case Prefix.SPPK:
+            return '01' + prefixEncoder(Prefix.SPPK)(val);
+        case Prefix.P2PK:
+            return '02' + prefixEncoder(Prefix.P2PK)(val);
+        default:
+            throw new InvalidPublicKeyError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
+                ` expecting one of the following '${Prefix.EDPK}', '${Prefix.SPPK}', '${Prefix.P2PK}' or '${Prefix.BLPK}'.`);
+    }
+};
+const addressEncoder = (val) => {
+    const pubkeyPrefix = val.substring(0, 3);
+    switch (pubkeyPrefix) {
+        case Prefix.TZ1:
+        case Prefix.TZ2:
+        case Prefix.TZ3:
+        case Prefix.TZ4:
+            return '00' + publicKeyHashEncoder(val);
+        case Prefix.KT1:
+            return '01' + prefixEncoder(Prefix.KT1)(val) + '00';
+        default:
+            throw new InvalidAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
+                ` expecting one of the following prefix '${Prefix.TZ1}', ${Prefix.TZ2}', '${Prefix.TZ3}', '${Prefix.TZ4}' or '${Prefix.KT1}'.`);
+    }
+};
+const smartRollupAddressEncoder = (val) => {
+    if (val.substring(0, 3) !== Prefix.SR1) {
+        throw new InvalidSmartRollupAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SR1}'.`);
+    }
+    return prefixEncoder(Prefix.SR1)(val);
+};
+const smartContractAddressEncoder = (val) => {
+    const prefix = val.substring(0, 3);
+    if (prefix === Prefix.KT1) {
+        return '01' + prefixEncoder(Prefix.KT1)(val) + '00';
+    }
+    throw new InvalidContractAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.KT1}'.`);
+};
+const publicKeyDecoder = (val) => {
+    const preamble = val.consume(1);
+    switch (preamble[0]) {
+        case 0x00:
+            return prefixDecoder(Prefix.EDPK)(val);
+        case 0x01:
+            return prefixDecoder(Prefix.SPPK)(val);
+        case 0x02:
+            return prefixDecoder(Prefix.P2PK)(val);
+        default:
+            throw new InvalidPublicKeyError(val.toString(), invalidDetail(ValidationResult.NO_PREFIX_MATCHED));
+    }
+};
+const smartRollupCommitmentHashEncoder = (val) => {
+    const prefix = val.substring(0, 4);
+    if (prefix === Prefix.SRC1) {
+        return prefixEncoder(Prefix.SRC1)(val);
+    }
+    throw new InvalidSmartRollupCommitmentHashError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SRC1}'`);
+};
+const addressDecoder = (val) => {
+    const preamble = val.consume(1);
+    switch (preamble[0]) {
+        case 0x00:
+            return publicKeyHashDecoder(val);
+        case 0x01: {
+            const address = prefixDecoder(Prefix.KT1)(val);
+            val.consume(1);
+            return address;
+        }
+        default:
+            throw new InvalidAddressError(val.toString(), ': Unable to decode.');
+    }
+};
+const smartRollupAddressDecoder = (val) => {
+    const address = prefixDecoder(Prefix.SR1)(val);
+    if (address.substring(0, 3) !== Prefix.SR1) {
+        throw new InvalidSmartRollupAddressError(address, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SR1}'.`);
+    }
+    return address;
+};
+const smartContractAddressDecoder = (val) => {
+    const preamble = val.consume(1);
+    if (preamble[0] === 0x01) {
+        const scAddress = prefixDecoder(Prefix.KT1)(val);
+        val.consume(1);
+        return scAddress;
+    }
+    throw new InvalidContractAddressError(val.toString(), invalidDetail(ValidationResult.NO_PREFIX_MATCHED));
+};
+const smartRollupCommitmentHashDecoder = (val) => {
+    const address = prefixDecoder(Prefix.SRC1)(val);
+    if (address.substring(0, 4) !== Prefix.SRC1) {
+        throw new InvalidSmartRollupCommitmentHashError(address, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SRC1}'`);
+    }
+    return address;
+};
+const zarithEncoder = (n) => {
+    const fn = [];
+    let nn = new BigNumber$1(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('');
+};
+const zarithDecoder = (n) => {
+    let mostSignificantByte = 0;
+    while (mostSignificantByte < n.length() && (n.get(mostSignificantByte) & 128) !== 0) {
+        mostSignificantByte += 1;
+    }
+    let num = new BigNumber$1(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$1(num).toString();
+};
+const entrypointDecoder = (value) => {
+    const preamble = pad(value.consume(1)[0], 2);
+    if (preamble in entrypointMapping) {
+        return entrypointMapping[preamble];
+    }
+    else {
+        const entry = extractRequiredLen(value, 1);
+        const entrypoint = Buffer.from(entry).toString('utf8');
+        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
+            throw new OversizedEntryPointError(entrypoint);
+        }
+        return entrypoint;
+    }
+};
+const parametersDecoder = (val) => {
+    const preamble = val.consume(1);
+    if (preamble[0] === 0x00) {
+        return;
+    }
+    else {
+        const encodedEntrypoint = entrypointDecoder(val);
+        const params = extractRequiredLen(val);
+        const parameters = valueDecoder(new Uint8ArrayConsumer(params));
+        return {
+            entrypoint: encodedEntrypoint,
+            value: parameters,
+        };
+    }
+};
+const entrypointEncoder = (entrypoint) => {
+    if (entrypoint in entrypointMappingReverse) {
+        return `${entrypointMappingReverse[entrypoint]}`;
+    }
+    else {
+        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
+            throw new OversizedEntryPointError(entrypoint);
+        }
+        const value = { string: entrypoint };
+        return `ff${valueEncoder(value).slice(8)}`;
+    }
+};
+const parametersEncoder = (val) => {
+    if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
+        return '00';
+    }
+    const encodedEntrypoint = entrypointEncoder(val.entrypoint);
+    const parameters = valueEncoder(val.value);
+    const length = pad(parameters.length / 2);
+    return `ff${encodedEntrypoint}${length}${parameters}`;
+};
+const valueParameterEncoder = (value) => {
+    const valueEncoded = valueEncoder(value);
+    return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
+};
+const valueParameterDecoder = (val) => {
+    const value = extractRequiredLen(val);
+    return valueDecoder(new Uint8ArrayConsumer(value));
+};
+const blockPayloadHashEncoder = prefixEncoder(Prefix.VH);
+const blockPayloadHashDecoder = prefixDecoder(Prefix.VH);
+const entrypointNameEncoder = (entrypoint) => {
+    const value = { string: entrypoint };
+    return `${valueEncoder(value).slice(2)}`;
+};
+const entrypointNameDecoder = (val) => {
+    const entry = extractRequiredLen(val);
+    return Buffer.from(entry).toString('utf8');
+};
+const burnLimitEncoder = (val) => {
+    return !val ? '00' : `ff${zarithEncoder(val)}`;
+};
+const burnLimitDecoder = (value) => {
+    const prefix = value.consume(1);
+    if (Buffer.from(prefix).toString('hex') !== '00') {
+        return zarithDecoder(value);
+    }
+};
+const depositsLimitEncoder = (val) => {
+    return !val ? '00' : `ff${zarithEncoder(val)}`;
+};
+const depositsLimitDecoder = (value) => {
+    const prefix = value.consume(1);
+    if (Buffer.from(prefix).toString('hex') !== '00') {
+        return zarithDecoder(value);
+    }
+};
+const paddedBytesEncoder = (val, paddingLength = 8) => {
+    return `${pad(val.length / 2, paddingLength)}${val}`;
+};
+const paddedBytesDecoder = (val) => {
+    const value = extractRequiredLen(val);
+    return Buffer.from(value).toString('hex');
+};
+const smartRollupMessageEncoder = (val) => {
+    const message = val.reduce((prev, curr) => {
+        return prev + `${pad(curr.length / 2)}${curr}`;
+    }, '');
+    return `${pad(message.length / 2)}${message}`;
+};
+const smartRollupMessageDecoder = (val) => {
+    const valueArray = extractRequiredLen(val);
+    const ret = stripLengthPrefixFromBytes(new Uint8ArrayConsumer(valueArray));
+    return ret.map((value) => Buffer.from(value).toString('hex'));
+};
+const dalCommitmentEncoder = (val) => {
+    const prefix = val.substring(0, 2);
+    if (prefix === Prefix.SH) {
+        return prefixEncoder(Prefix.SH)(val);
+    }
+    throw new InvalidDalCommitmentError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
+};
+const dalCommitmentDecoder = (val) => {
+    const commitment = prefixDecoder(Prefix.SH)(val);
+    if (commitment.substring(0, 2) !== Prefix.SH) {
+        throw new InvalidDalCommitmentError(commitment, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
+    }
+    return commitment;
+};
+const slotHeaderEncoder = (val) => {
+    return pad(val.slot_index, 2) + dalCommitmentEncoder(val.commitment) + val.commitment_proof;
+};
+const slotHeaderDecoder = (val) => {
+    const preamble = val.consume(1);
+    return {
+        slot_index: Number(preamble[0].toString(10)),
+        commitment: dalCommitmentDecoder(val),
+        commitment_proof: toHexString(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
+    };
+};
+
+const ManagerOperationSchema = {
+    branch: CODEC.BRANCH,
+    contents: [CODEC.OPERATION],
+};
+const ActivationSchema = {
+    pkh: CODEC.TZ1,
+    secret: CODEC.SECRET,
+};
+const RevealSchema = {
+    source: CODEC.PKH,
+    fee: CODEC.ZARITH,
+    counter: CODEC.ZARITH,
+    gas_limit: CODEC.ZARITH,
+    storage_limit: CODEC.ZARITH,
+    public_key: CODEC.PUBLIC_KEY,
+};
+const DelegationSchema = {
+    source: CODEC.PKH,
+    fee: CODEC.ZARITH,
+    counter: CODEC.ZARITH,
+    gas_limit: CODEC.ZARITH,
+    storage_limit: CODEC.ZARITH,
+    delegate: CODEC.DELEGATE,
+};
+const TransactionSchema = {
+    source: CODEC.PKH,
+    fee: CODEC.ZARITH,
+    counter: CODEC.ZARITH,
+    gas_limit: CODEC.ZARITH,
+    storage_limit: CODEC.ZARITH,
+    amount: CODEC.ZARITH,
+    destination: CODEC.ADDRESS,
+    parameters: CODEC.PARAMETERS,
+};
+const OriginationSchema = {
+    source: CODEC.PKH,
+    fee: CODEC.ZARITH,
+    counter: CODEC.ZARITH,
+    gas_limit: CODEC.ZARITH,
+    storage_limit: CODEC.ZARITH,
+    balance: CODEC.ZARITH,
+    delegate: CODEC.DELEGATE,
+    script: CODEC.SCRIPT,
+};
+const BallotSchema = {
+    source: CODEC.PKH,
+    period: CODEC.INT32,
+    proposal: CODEC.PROPOSAL,
+    ballot: CODEC.BALLOT_STATEMENT,
+};
+const AttestationSchema = {
+    slot: CODEC.INT16,
+    level: CODEC.INT32,
+    round: CODEC.INT32,
+    block_payload_hash: CODEC.BLOCK_PAYLOAD_HASH,
+};
+const AttestationWithDalSchema = {
+    slot: CODEC.INT16,
+    level: CODEC.INT32,
+    round: CODEC.INT32,
+    block_payload_hash: CODEC.BLOCK_PAYLOAD_HASH,
+    dal_attestation: CODEC.ZARITH,
+};
+const SeedNonceRevelationSchema = {
     level: CODEC.INT32,
     nonce: CODEC.RAW,
 };
@@ -1413,7 +2477,7 @@ const schemaDecoder = (decoders) => (schema) => (value) => {
     }, {});
 };
 
-const decoders = {
+const decodersProto021 = {
     [CODEC.SECRET]: (val) => toHexString(val.consume(20)),
     [CODEC.RAW]: (val) => toHexString(val.consume(32)),
     [CODEC.TZ1]: tz1Decoder,
@@ -1444,31 +2508,87 @@ const decoders = {
     [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder,
     [CODEC.SLOT_HEADER]: slotHeaderDecoder,
 };
-decoders[CODEC.OPERATION] = operationDecoder(decoders);
-decoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decoders)(ActivationSchema)(val);
-decoders[CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder(decoders)(FailingNoopSchema)(val);
-decoders[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decoders)(DelegationSchema)(val);
-decoders[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decoders)(TransactionSchema)(val);
-decoders[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decoders)(OriginationSchema)(val);
-decoders[CODEC.OP_BALLOT] = (val) => schemaDecoder(decoders)(BallotSchema)(val);
-decoders[CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decoders)(AttestationSchema)(val);
-decoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decoders)(AttestationWithDalSchema)(val);
-decoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decoders)(SeedNonceRevelationSchema)(val);
-decoders[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decoders)(ProposalsSchema)(val);
-decoders[CODEC.OP_REVEAL] = (val) => schemaDecoder(decoders)(RevealSchema)(val);
-decoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decoders)(RegisterGlobalConstantSchema)(val);
-decoders[CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decoders)(TransferTicketSchema)(val);
-decoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decoders)(IncreasePaidStorageSchema)(val);
-decoders[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder(decoders)(UpdateConsensusKeySchema)(val);
-decoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decoders)(DrainDelegateSchema)(val);
-decoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decoders)(SmartRollupOriginateSchema)(val);
-decoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decoders)(SmartRollupAddMessagesSchema)(val);
-decoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decoders)(SmartRollupExecuteOutboxMessageSchema)(val);
-decoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decoders)(DalPublishCommitmentSchema)(val);
-decoders[CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
-decoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decoders)(SetDepositsLimitSchema)(val);
+decodersProto021[CODEC.OPERATION] = operationDecoder(decodersProto021);
+decodersProto021[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decodersProto021)(ActivationSchema)(val);
+decodersProto021[CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder(decodersProto021)(FailingNoopSchema)(val);
+decodersProto021[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decodersProto021)(DelegationSchema)(val);
+decodersProto021[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decodersProto021)(TransactionSchema)(val);
+decodersProto021[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decodersProto021)(OriginationSchema)(val);
+decodersProto021[CODEC.OP_BALLOT] = (val) => schemaDecoder(decodersProto021)(BallotSchema)(val);
+decodersProto021[CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decodersProto021)(AttestationSchema)(val);
+decodersProto021[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decodersProto021)(AttestationWithDalSchema)(val);
+decodersProto021[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decodersProto021)(SeedNonceRevelationSchema)(val);
+decodersProto021[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decodersProto021)(ProposalsSchema)(val);
+decodersProto021[CODEC.OP_REVEAL] = (val) => schemaDecoder(decodersProto021)(RevealSchema)(val);
+decodersProto021[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decodersProto021)(RegisterGlobalConstantSchema)(val);
+decodersProto021[CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decodersProto021)(TransferTicketSchema)(val);
+decodersProto021[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decodersProto021)(IncreasePaidStorageSchema)(val);
+decodersProto021[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder(decodersProto021)(UpdateConsensusKeySchema)(val);
+decodersProto021[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decodersProto021)(DrainDelegateSchema)(val);
+decodersProto021[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decodersProto021)(SmartRollupOriginateSchema)(val);
+decodersProto021[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decodersProto021)(SmartRollupAddMessagesSchema)(val);
+decodersProto021[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decodersProto021)(SmartRollupExecuteOutboxMessageSchema)(val);
+decodersProto021[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decodersProto021)(DalPublishCommitmentSchema)(val);
+decodersProto021[CODEC.MANAGER] = schemaDecoder(decodersProto021)(ManagerOperationSchema);
+decodersProto021[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decodersProto021)(SetDepositsLimitSchema)(val);
 
 const encoders = {
+    [CODEC$1.SECRET]: (val) => val,
+    [CODEC$1.RAW]: (val) => val,
+    [CODEC$1.TZ1]: tz1Encoder$1,
+    [CODEC$1.BRANCH]: branchEncoder$1,
+    [CODEC$1.ZARITH]: zarithEncoder$1,
+    [CODEC$1.PUBLIC_KEY]: publicKeyEncoder$1,
+    [CODEC$1.PKH]: publicKeyHashEncoder$1,
+    [CODEC$1.PKH_ARR]: publicKeyHashesEncoder$1,
+    [CODEC$1.DELEGATE]: delegateEncoder$1,
+    [CODEC$1.SCRIPT]: scriptEncoder,
+    [CODEC$1.BALLOT_STATEMENT]: ballotEncoder$1,
+    [CODEC$1.PROPOSAL]: proposalEncoder$1,
+    [CODEC$1.PROPOSAL_ARR]: proposalsEncoder$1,
+    [CODEC$1.INT32]: int32Encoder$1,
+    [CODEC$1.PARAMETERS]: parametersEncoder$1,
+    [CODEC$1.ADDRESS]: addressEncoder$1,
+    [CODEC$1.SMART_ROLLUP_ADDRESS]: smartRollupAddressEncoder$1,
+    [CODEC$1.SMART_CONTRACT_ADDRESS]: smartContractAddressEncoder$1,
+    [CODEC$1.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashEncoder$1,
+    [CODEC$1.VALUE]: valueParameterEncoder$1,
+    [CODEC$1.INT16]: int16Encoder$1,
+    [CODEC$1.BLOCK_PAYLOAD_HASH]: blockPayloadHashEncoder$1,
+    [CODEC$1.ENTRYPOINT]: entrypointNameEncoder$1,
+    [CODEC$1.BURN_LIMIT]: burnLimitEncoder$1,
+    [CODEC$1.DEPOSITS_LIMIT]: depositsLimitEncoder$1,
+    [CODEC$1.SIGNATURE_PROOF]: signatureProofEncoder,
+    [CODEC$1.PVM_KIND]: pvmKindEncoder$1,
+    [CODEC$1.PADDED_BYTES]: paddedBytesEncoder$1,
+    [CODEC$1.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder$1,
+    [CODEC$1.SLOT_HEADER]: slotHeaderEncoder$1,
+};
+encoders[CODEC$1.OPERATION] = operationEncoder$1(encoders);
+encoders[CODEC$1.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder$1(encoders)(ActivationSchema$1)(val);
+encoders[CODEC$1.OP_DELEGATION] = (val) => schemaEncoder$1(encoders)(DelegationSchema$1)(val);
+encoders[CODEC$1.OP_TRANSACTION] = (val) => schemaEncoder$1(encoders)(TransactionSchema$1)(val);
+encoders[CODEC$1.OP_ORIGINATION] = (val) => schemaEncoder$1(encoders)(OriginationSchema$1)(val);
+encoders[CODEC$1.OP_BALLOT] = (val) => schemaEncoder$1(encoders)(BallotSchema$1)(val);
+encoders[CODEC$1.OP_ATTESTATION] = (val) => schemaEncoder$1(encoders)(AttestationSchema$1)(val);
+encoders[CODEC$1.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder$1(encoders)(AttestationWithDalSchema$1)(val);
+encoders[CODEC$1.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder$1(encoders)(SeedNonceRevelationSchema$1)(val);
+encoders[CODEC$1.OP_PROPOSALS] = (val) => schemaEncoder$1(encoders)(ProposalsSchema$1)(val);
+encoders[CODEC$1.OP_REVEAL] = (val) => schemaEncoder$1(encoders)(RevealSchema$1)(val);
+encoders[CODEC$1.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder$1(encoders)(RegisterGlobalConstantSchema$1)(val);
+encoders[CODEC$1.OP_TRANSFER_TICKET] = (val) => schemaEncoder$1(encoders)(TransferTicketSchema$1)(val);
+encoders[CODEC$1.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder$1(encoders)(IncreasePaidStorageSchema$1)(val);
+encoders[CODEC$1.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder$1(encoders)(UpdateConsensusKeySchema$1)(val);
+encoders[CODEC$1.OP_DRAIN_DELEGATE] = (val) => schemaEncoder$1(encoders)(DrainDelegateSchema$1)(val);
+encoders[CODEC$1.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder$1(encoders)(SmartRollupOriginateSchema$1)(val);
+encoders[CODEC$1.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder$1(encoders)(SmartRollupAddMessagesSchema$1)(val);
+encoders[CODEC$1.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder$1(encoders)(SmartRollupExecuteOutboxMessageSchema$1)(val);
+encoders[CODEC$1.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder$1(encoders)(DalPublishCommitmentSchema$1)(val);
+encoders[CODEC$1.MANAGER] = schemaEncoder$1(encoders)(ManagerOperationSchema$1);
+encoders[CODEC$1.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder$1(encoders)(SetDepositsLimitSchema$1)(val);
+encoders[CODEC$1.OP_FAILING_NOOP] = (val) => schemaEncoder$1(encoders)(FailingNoopSchema$1)(val);
+
+const encodersProto021 = {
     [CODEC.SECRET]: (val) => val,
     [CODEC.RAW]: (val) => val,
     [CODEC.TZ1]: tz1Encoder,
@@ -1499,52 +2619,52 @@ const encoders = {
     [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder,
     [CODEC.SLOT_HEADER]: slotHeaderEncoder,
 };
-encoders[CODEC.OPERATION] = operationEncoder(encoders);
-encoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encoders)(ActivationSchema)(val);
-encoders[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encoders)(DelegationSchema)(val);
-encoders[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encoders)(TransactionSchema)(val);
-encoders[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encoders)(OriginationSchema)(val);
-encoders[CODEC.OP_BALLOT] = (val) => schemaEncoder(encoders)(BallotSchema)(val);
-encoders[CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encoders)(AttestationSchema)(val);
-encoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encoders)(AttestationWithDalSchema)(val);
-encoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encoders)(SeedNonceRevelationSchema)(val);
-encoders[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encoders)(ProposalsSchema)(val);
-encoders[CODEC.OP_REVEAL] = (val) => schemaEncoder(encoders)(RevealSchema)(val);
-encoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encoders)(RegisterGlobalConstantSchema)(val);
-encoders[CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encoders)(TransferTicketSchema)(val);
-encoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encoders)(IncreasePaidStorageSchema)(val);
-encoders[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder(encoders)(UpdateConsensusKeySchema)(val);
-encoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encoders)(DrainDelegateSchema)(val);
-encoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encoders)(SmartRollupOriginateSchema)(val);
-encoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encoders)(SmartRollupAddMessagesSchema)(val);
-encoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encoders)(SmartRollupExecuteOutboxMessageSchema)(val);
-encoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encoders)(DalPublishCommitmentSchema)(val);
-encoders[CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
-encoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encoders)(SetDepositsLimitSchema)(val);
-encoders[CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encoders)(FailingNoopSchema)(val);
+encodersProto021[CODEC.OPERATION] = operationEncoder(encodersProto021);
+encodersProto021[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encodersProto021)(ActivationSchema)(val);
+encodersProto021[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encodersProto021)(DelegationSchema)(val);
+encodersProto021[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encodersProto021)(TransactionSchema)(val);
+encodersProto021[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encodersProto021)(OriginationSchema)(val);
+encodersProto021[CODEC.OP_BALLOT] = (val) => schemaEncoder(encodersProto021)(BallotSchema)(val);
+encodersProto021[CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encodersProto021)(AttestationSchema)(val);
+encodersProto021[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encodersProto021)(AttestationWithDalSchema)(val);
+encodersProto021[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encodersProto021)(SeedNonceRevelationSchema)(val);
+encodersProto021[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encodersProto021)(ProposalsSchema)(val);
+encodersProto021[CODEC.OP_REVEAL] = (val) => schemaEncoder(encodersProto021)(RevealSchema)(val);
+encodersProto021[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encodersProto021)(RegisterGlobalConstantSchema)(val);
+encodersProto021[CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encodersProto021)(TransferTicketSchema)(val);
+encodersProto021[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encodersProto021)(IncreasePaidStorageSchema)(val);
+encodersProto021[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder(encodersProto021)(UpdateConsensusKeySchema)(val);
+encodersProto021[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encodersProto021)(DrainDelegateSchema)(val);
+encodersProto021[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encodersProto021)(SmartRollupOriginateSchema)(val);
+encodersProto021[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encodersProto021)(SmartRollupAddMessagesSchema)(val);
+encodersProto021[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encodersProto021)(SmartRollupExecuteOutboxMessageSchema)(val);
+encodersProto021[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encodersProto021)(DalPublishCommitmentSchema)(val);
+encodersProto021[CODEC.MANAGER] = schemaEncoder(encodersProto021)(ManagerOperationSchema);
+encodersProto021[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encodersProto021)(SetDepositsLimitSchema)(val);
+encodersProto021[CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encodersProto021)(FailingNoopSchema)(val);
 
 const OperationKindMapping = {
-    activate_account: ActivationSchema,
-    reveal: RevealSchema,
-    delegation: DelegationSchema,
-    transaction: TransactionSchema,
-    origination: OriginationSchema,
-    ballot: BallotSchema,
-    attestation: AttestationSchema,
-    attestation_with_dal: AttestationWithDalSchema,
-    seed_nonce_revelation: SeedNonceRevelationSchema,
-    proposals: ProposalsSchema,
-    register_global_constant: RegisterGlobalConstantSchema,
-    transfer_ticket: TransferTicketSchema,
-    increase_paid_storage: IncreasePaidStorageSchema,
-    update_consensus_key: UpdateConsensusKeySchema,
-    drain_delegate: DrainDelegateSchema,
-    set_deposits_limit: SetDepositsLimitSchema,
-    smart_rollup_originate: SmartRollupOriginateSchema,
-    smart_rollup_add_messages: SmartRollupAddMessagesSchema,
-    smart_rollup_execute_outbox_message: SmartRollupExecuteOutboxMessageSchema,
-    dal_publish_commitment: DalPublishCommitmentSchema,
-    failing_noop: FailingNoopSchema,
+    activate_account: ActivationSchema$1,
+    reveal: RevealSchema$1,
+    delegation: DelegationSchema$1,
+    transaction: TransactionSchema$1,
+    origination: OriginationSchema$1,
+    ballot: BallotSchema$1,
+    attestation: AttestationSchema$1,
+    attestation_with_dal: AttestationWithDalSchema$1,
+    seed_nonce_revelation: SeedNonceRevelationSchema$1,
+    proposals: ProposalsSchema$1,
+    register_global_constant: RegisterGlobalConstantSchema$1,
+    transfer_ticket: TransferTicketSchema$1,
+    increase_paid_storage: IncreasePaidStorageSchema$1,
+    update_consensus_key: UpdateConsensusKeySchema$1,
+    drain_delegate: DrainDelegateSchema$1,
+    set_deposits_limit: SetDepositsLimitSchema$1,
+    smart_rollup_originate: SmartRollupOriginateSchema$1,
+    smart_rollup_add_messages: SmartRollupAddMessagesSchema$1,
+    smart_rollup_execute_outbox_message: SmartRollupExecuteOutboxMessageSchema$1,
+    dal_publish_commitment: DalPublishCommitmentSchema$1,
+    failing_noop: FailingNoopSchema$1,
 };
 // Asymmetric difference: only account for things in arr2 that are not present in arr1, not vice versa
 const getArrayDifference = (arr1, arr2) => {
@@ -1596,34 +2716,81 @@ var ProtocolsHash;
     ProtocolsHash["PtParisBx"] = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ";
     ProtocolsHash["PsParisCZ"] = "PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi";
     ProtocolsHash["PsQuebecn"] = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg";
+    ProtocolsHash["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
     ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(ProtocolsHash || (ProtocolsHash = {}));
+const protoLevel = {
+    Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd: 4,
+    PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU: 5,
+    PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS: 5,
+    PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb: 6,
+    PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo: 7,
+    PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA: 8,
+    PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i: 9,
+    PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV: 10,
+    PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx: 11,
+    Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A: 12,
+    PtJakart2xVj7pYXJBXrqHgd82rdkLey5ZeeGwDgPp9rhQUbSqY: 13,
+    PtKathmankSpLLDALzWw7CGD2j2MtyveTwboEYokqUCP4a1LxMg: 14,
+    PtLimaPtLMwfNinJi9rCfDPWea8dFgTZ1MeJ9f1m2SRic6ayiwW: 15,
+    PtMumbaiiFFEGbew1rRjzSPyzRbA51Tm3RVZL5suHPxSZYDhCEc: 16,
+    PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1: 16,
+    PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf: 17,
+    ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH: 19,
+    PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ: 20,
+    PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi: 20,
+    PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg: 21,
+    PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7: 22,
+    ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 23,
+};
+function ProtoInferiorTo(a, b) {
+    return protoLevel[a] < protoLevel[b];
+}
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "e6ffa3acf4671ff5b05a0784ea773fc17da95088",
-    "version": "21.0.5"
+    "commitHash": "6936d6bc71e6a805f6d5568b60b1a0f6595a375d",
+    "version": "22.0.0-RC.0"
 };
 
 /**
  * @packageDocumentation
  * @module @taquito/local-forging
  */
-const PROTOCOL_CURRENT = ProtocolsHash.PsQuebecn;
+const PROTOCOL_CURRENT = ProtocolsHash.PsRiotuma;
 function getCodec(codec, _proto) {
-    return {
-        encoder: encoders[codec],
-        decoder: (hex) => {
-            const consumer = Uint8ArrayConsumer.fromHexString(hex);
-            return decoders[codec](consumer);
-        },
-    };
+    // use encodersProto021 & decodersProto021 if it's quebec or prior
+    if (_proto === ProtocolsHash.PsQuebecn || ProtoInferiorTo(_proto, ProtocolsHash.PsQuebecn)) {
+        return {
+            encoder: encodersProto021[codec],
+            decoder: (hex) => {
+                const consumer = Uint8ArrayConsumer.fromHexString(hex);
+                return decodersProto021[codec](consumer);
+            },
+        };
+    }
+    else {
+        return {
+            encoder: encoders[codec],
+            decoder: (hex) => {
+                const consumer = Uint8ArrayConsumer.fromHexString(hex);
+                return decoders[codec](consumer);
+            },
+        };
+    }
+    // TODO: Remove above if else once mainnet migrated into rio protocol and uncommon the return block below
+    // return {
+    //   encoder: encoders[codec],
+    //   decoder: (hex: string) => {
+    //     const consumer = Uint8ArrayConsumer.fromHexString(hex);
+    //     return decoders[codec](consumer) as any;
+    //   },
+    // };
 }
-//
 class LocalForger {
     constructor(protocolHash = PROTOCOL_CURRENT) {
         this.protocolHash = protocolHash;
-        this.codec = getCodec(CODEC.MANAGER, this.protocolHash);
+        this.codec = getCodec(CODEC$1.MANAGER, this.protocolHash);
     }
     forge(params) {
         const branchValidation = validateBlock(params.branch);
@@ -1651,6 +2818,9 @@ class LocalForger {
                 else if (content.kind === 'smart_rollup_originate' && diff[0] === 'whitelist') {
                     continue;
                 }
+                else if (content.kind === 'update_consensus_key' && diff[0] === 'proof') {
+                    continue;
+                }
                 else {
                     throw new InvalidOperationSchemaError(content, `missing properties "${diff.join(', ')}"`);
                 }
@@ -1668,5 +2838,5 @@ class LocalForger {
 }
 const localForger = new LocalForger();
 
-export { CODEC, LocalForger, ProtocolsHash, Uint8ArrayConsumer, VERSION, decoders, encoders, getCodec, localForger, opMapping, opMappingReverse };
+export { CODEC$1 as CODEC, LocalForger, ProtocolsHash, Uint8ArrayConsumer, VERSION, decoders, encoders, getCodec, localForger, opMapping$1 as opMapping, opMappingReverse };
 //# sourceMappingURL=taquito-local-forging.es6.js.map