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

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

@@ -14,7 +14,7 @@
    * Copyright (c) 2018 Andrew Kishino
    */
   // See: https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
-  const ENTRYPOINT_MAX_LENGTH$1 = 31;
+  const ENTRYPOINT_MAX_LENGTH = 31;
   exports.CODEC = void 0;
   (function (CODEC) {
       CODEC["SECRET"] = "secret";
@@ -73,7 +73,7 @@
       CODEC["SLOT_HEADER"] = "slot_header";
   })(exports.CODEC || (exports.CODEC = {}));
   // See https://tezos.gitlab.io/shell/p2p_api.html#alpha-michelson-v1-primitives-enumeration-unsigned-8-bit-integer
-  const opMapping$1 = {
+  const opMapping = {
       '00': 'parameter',
       '01': 'storage',
       '02': 'code',
@@ -233,16 +233,18 @@
       '9c': 'NAT',
       '9d': 'Ticket',
       '9e': 'IS_IMPLICIT_ACCOUNT',
+      '9f': 'INDEX_ADDRESS',
+      'a0': 'GET_ADDRESS_INDEX',
   };
-  const opMappingReverse$1 = (() => {
+  const opMappingReverse = (() => {
       const result = {};
-      Object.keys(opMapping$1).forEach((key) => {
-          result[opMapping$1[key]] = key;
+      Object.keys(opMapping).forEach((key) => {
+          result[opMapping[key]] = key;
       });
       return result;
   })();
   // See https://tezos.gitlab.io/shell/p2p_api.html
-  const kindMapping$1 = {
+  const kindMapping = {
       0x04: 'activate_account',
       0x6b: 'reveal',
       0x6e: 'delegation',
@@ -266,16 +268,16 @@
       0xe6: 'dal_publish_commitment',
       0x11: 'failing_noop',
   };
-  const kindMappingReverse$1 = (() => {
+  const kindMappingReverse = (() => {
       const result = {};
-      Object.keys(kindMapping$1).forEach((key) => {
+      Object.keys(kindMapping).forEach((key) => {
           const keyNum = typeof key === 'string' ? parseInt(key, 10) : key;
-          result[kindMapping$1[keyNum]] = pad(keyNum, 2);
+          result[kindMapping[keyNum]] = pad(keyNum, 2);
       });
       return result;
   })();
   // See https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
-  const entrypointMapping$1 = {
+  const entrypointMapping = {
       '00': 'default',
       '01': 'root',
       '02': 'do',
@@ -287,10 +289,10 @@
       '08': 'finalize_unstake',
       '09': 'set_delegate_parameters',
   };
-  const entrypointMappingReverse$1 = (() => {
+  const entrypointMappingReverse = (() => {
       const result = {};
-      Object.keys(entrypointMapping$1).forEach((key) => {
-          result[entrypointMapping$1[key]] = key;
+      Object.keys(entrypointMapping).forEach((key) => {
+          result[entrypointMapping[key]] = key;
       });
       return result;
   })();
@@ -317,7 +319,7 @@
           super();
           this.entrypoint = entrypoint;
           this.name = 'OversizedEntryPointError';
-          this.message = `Invalid entrypoint length "${entrypoint.length}", maximum length is "${ENTRYPOINT_MAX_LENGTH$1}".`;
+          this.message = `Invalid entrypoint length "${entrypoint.length}", maximum length is "${ENTRYPOINT_MAX_LENGTH}".`;
       }
   }
   /**
@@ -488,73 +490,73 @@
       }
   }
 
-  const isPrim$1 = (value) => {
+  const isPrim = (value) => {
       return 'prim' in value;
   };
-  const isBytes$1 = (value) => {
+  const isBytes = (value) => {
       return 'bytes' in value && typeof value.bytes === 'string';
   };
-  const isString$1 = (value) => {
+  const isString = (value) => {
       return 'string' in value && typeof value.string === 'string';
   };
-  const isInt$1 = (value) => {
+  const isInt = (value) => {
       return 'int' in value && typeof value.int === 'string';
   };
-  const scriptEncoder$1 = (script) => {
-      const code = valueEncoder$1(script.code);
-      const storage = valueEncoder$1(script.storage);
+  const scriptEncoder = (script) => {
+      const code = valueEncoder(script.code);
+      const storage = valueEncoder(script.storage);
       return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
   };
-  const scriptDecoder$1 = (value) => {
-      const code = extractRequiredLen$1(value);
-      const storage = extractRequiredLen$1(value);
+  const scriptDecoder = (value) => {
+      const code = extractRequiredLen(value);
+      const storage = extractRequiredLen(value);
       return {
-          code: valueDecoder$1(new Uint8ArrayConsumer(code)),
-          storage: valueDecoder$1(new Uint8ArrayConsumer(storage)),
+          code: valueDecoder(new Uint8ArrayConsumer(code)),
+          storage: valueDecoder(new Uint8ArrayConsumer(storage)),
       };
   };
-  const valueEncoder$1 = (value) => {
+  const valueEncoder = (value) => {
       if (Array.isArray(value)) {
-          const encoded = value.map((x) => valueEncoder$1(x)).join('');
+          const encoded = value.map((x) => valueEncoder(x)).join('');
           const len = encoded.length / 2;
           return `02${pad(len)}${encoded}`;
       }
-      else if (isPrim$1(value)) {
-          return primEncoder$1(value);
+      else if (isPrim(value)) {
+          return primEncoder(value);
       }
-      else if (isBytes$1(value)) {
-          return bytesEncoder$1(value);
+      else if (isBytes(value)) {
+          return bytesEncoder(value);
       }
-      else if (isString$1(value)) {
-          return stringEncoder$1(value);
+      else if (isString(value)) {
+          return stringEncoder(value);
       }
-      else if (isInt$1(value)) {
-          return intEncoder$1(value);
+      else if (isInt(value)) {
+          return intEncoder(value);
       }
       throw new UnexpectedMichelsonValueError(JSON.stringify(value));
   };
-  const valueDecoder$1 = (value) => {
+  const valueDecoder = (value) => {
       const preamble = value.consume(1);
       switch (preamble[0]) {
           case 0x0a:
-              return bytesDecoder$1(value);
+              return bytesDecoder(value);
           case 0x01:
-              return stringDecoder$1(value);
+              return stringDecoder(value);
           case 0x00:
-              return intDecoder$1(value);
+              return intDecoder(value);
           case 0x02: {
-              const val = new Uint8ArrayConsumer(extractRequiredLen$1(value));
+              const val = new Uint8ArrayConsumer(extractRequiredLen(value));
               const results = [];
               while (val.length() > 0) {
-                  results.push(valueDecoder$1(val));
+                  results.push(valueDecoder(val));
               }
               return results;
           }
           default:
-              return primDecoder$1(value, preamble);
+              return primDecoder(value, preamble);
       }
   };
-  const extractRequiredLen$1 = (value, bytesLength = 4) => {
+  const extractRequiredLen = (value, bytesLength = 4) => {
       const len = value.consume(bytesLength);
       const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
       return value.consume(valueLen);
@@ -565,7 +567,7 @@
    * @param bytesLength default 4 bytes for length of variable bytes
    * @returns array of Uint8Array values for each array item
    */
-  const stripLengthPrefixFromBytes$1 = (value, bytesLength = 4) => {
+  const stripLengthPrefixFromBytes = (value, bytesLength = 4) => {
       const ret = [];
       let values = value;
       while (values.length()) {
@@ -576,31 +578,31 @@
       }
       return ret;
   };
-  const bytesEncoder$1 = (value) => {
+  const bytesEncoder = (value) => {
       if (!/^([A-Fa-f0-9]{2})*$/.test(value.bytes)) {
           throw new core.InvalidHexStringError(value.bytes);
       }
       const len = value.bytes.length / 2;
       return `0a${pad(len)}${value.bytes}`;
   };
-  const bytesDecoder$1 = (value) => {
-      const bytes = extractRequiredLen$1(value);
+  const bytesDecoder = (value) => {
+      const bytes = extractRequiredLen(value);
       return {
           bytes: Buffer.from(bytes).toString('hex'),
       };
   };
-  const stringEncoder$1 = (value) => {
+  const stringEncoder = (value) => {
       const str = Buffer.from(value.string, 'utf8').toString('hex');
       const hexLength = str.length / 2;
       return `01${pad(hexLength)}${str}`;
   };
-  const stringDecoder$1 = (value) => {
-      const str = extractRequiredLen$1(value);
+  const stringDecoder = (value) => {
+      const str = extractRequiredLen(value);
       return {
           string: Buffer.from(str).toString('utf8'),
       };
   };
-  const intEncoder$1 = ({ int }) => {
+  const intEncoder = ({ int }) => {
       const num = new BigNumber.BigNumber(int, 10);
       const positiveMark = num.toString(2)[0] === '-' ? '1' : '0';
       const binary = num.toString(2).replace(/-/g, '');
@@ -620,7 +622,7 @@
           .padStart(2, '0'));
       return `00${numHex.join('')}`;
   };
-  const intDecoder$1 = (value) => {
+  const intDecoder = (value) => {
       let c = value.consume(1)[0];
       const hexNumber = [];
       const isNotLastChunkMask = 1 << 7;
@@ -645,14 +647,14 @@
           int: num.toFixed(),
       };
   };
-  const primEncoder$1 = (value) => {
+  const primEncoder = (value) => {
       const hasAnnot = +Array.isArray(value.annots);
       const argsCount = Array.isArray(value.args) ? value.args.length : 0;
       // Specify the number of args max is 3 without annotation
       const preamble = pad(Math.min(2 * argsCount + hasAnnot + 0x03, 9), 2);
-      const op = opMappingReverse$1[value.prim];
-      let encodedArgs = (value.args || []).map((arg) => valueEncoder$1(arg)).join('');
-      const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots$1(value.annots) : '';
+      const op = opMappingReverse[value.prim];
+      let encodedArgs = (value.args || []).map((arg) => valueEncoder(arg)).join('');
+      const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
       if ((value.prim === 'LAMBDA' || value.prim === 'LAMBDA_REC') && argsCount) {
           encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
       }
@@ -667,19 +669,19 @@
       }
       return `${preamble}${op}${encodedArgs}${encodedAnnots}`;
   };
-  const primDecoder$1 = (value, preamble) => {
+  const primDecoder = (value, preamble) => {
       const hasAnnot = (preamble[0] - 0x03) % 2 === 1;
       let argsCount = Math.floor((preamble[0] - 0x03) / 2);
       const op = value.consume(1)[0].toString(16).padStart(2, '0');
       const result = {
-          prim: opMapping$1[op],
+          prim: opMapping[op],
       };
-      if (opMapping$1[op] === 'LAMBDA' || opMapping$1[op] === 'LAMBDA_REC') {
+      if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
           value.consume(4);
       }
-      if (opMapping$1[op] === 'view') {
+      if (opMapping[op] === 'view') {
           if (argsCount != 0) {
-              return primViewDecoder$1(value, result);
+              return primViewDecoder(value, result);
           }
           else {
               return result;
@@ -687,13 +689,13 @@
       }
       let combPairArgs;
       let combPairAnnots;
-      if ((opMapping$1[op] === 'pair' || opMapping$1[op] === 'Pair') && argsCount > 2) {
-          combPairArgs = decodeCombPair$1(value);
+      if ((opMapping[op] === 'pair' || opMapping[op] === 'Pair') && argsCount > 2) {
+          combPairArgs = decodeCombPair(value);
           argsCount = 0;
-          combPairAnnots = decodeAnnots$1(value);
+          combPairAnnots = decodeAnnots(value);
       }
-      const args = new Array(argsCount).fill(0).map(() => valueDecoder$1(value));
-      if (opMapping$1[op] === 'LAMBDA' || opMapping$1[op] === 'LAMBDA_REC') {
+      const args = new Array(argsCount).fill(0).map(() => valueDecoder(value));
+      if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
           value.consume(4);
       }
       if (combPairArgs) {
@@ -706,25 +708,25 @@
           result['annots'] = combPairAnnots;
       }
       else if (hasAnnot) {
-          result['annots'] = decodeAnnots$1(value);
+          result['annots'] = decodeAnnots(value);
       }
       return result;
   };
-  const primViewDecoder$1 = (value, result) => {
+  const primViewDecoder = (value, result) => {
       value.consume(4);
-      result['args'] = new Array(4).fill(0).map(() => valueDecoder$1(value));
+      result['args'] = new Array(4).fill(0).map(() => valueDecoder(value));
       value.consume(4);
       return result;
   };
-  const decodeCombPair$1 = (val) => {
-      const array = new Uint8ArrayConsumer(extractRequiredLen$1(val));
+  const decodeCombPair = (val) => {
+      const array = new Uint8ArrayConsumer(extractRequiredLen(val));
       const args = [];
       while (array.length() > 0) {
-          args.push(valueDecoder$1(array));
+          args.push(valueDecoder(array));
       }
       return args;
   };
-  const encodeAnnots$1 = (value) => {
+  const encodeAnnots = (value) => {
       const mergedAnnot = value
           .map((x) => {
           return Buffer.from(x, 'utf8').toString('hex');
@@ -733,7 +735,7 @@
       const len = mergedAnnot.length / 2;
       return `${pad(len)}${mergedAnnot}`;
   };
-  const decodeAnnots$1 = (val) => {
+  const decodeAnnots = (val) => {
       const len = val.consume(4);
       const annotLen = parseInt(Buffer.from(len).toString('hex'), 16);
       const restOfAnnot = val.consume(annotLen);
@@ -742,63 +744,63 @@
   };
 
   // https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
-  const prefixEncoder$1 = (prefix) => (str) => {
+  const prefixEncoder = (prefix) => (str) => {
       const [pl] = utils.b58DecodeAndCheckPrefix(str, [prefix]);
       return utils.buf2hex(pl);
   };
-  const prefixDecoder$1 = (pre) => (str) => {
+  const prefixDecoder = (pre) => (str) => {
       const val = str.consume(utils.payloadLength[pre]);
       return utils.b58Encode(val, pre);
   };
-  const tz1Decoder$1 = prefixDecoder$1(utils.PrefixV2.Ed25519PublicKeyHash);
-  const branchDecoder$1 = prefixDecoder$1(utils.PrefixV2.BlockHash);
-  const publicKeyHashDecoder$1 = (val) => {
+  const tz1Decoder = prefixDecoder(utils.PrefixV2.Ed25519PublicKeyHash);
+  const branchDecoder = prefixDecoder(utils.PrefixV2.BlockHash);
+  const publicKeyHashDecoder = (val) => {
       const prefix = val.consume(1);
       if (prefix[0] === 0x00) {
-          return prefixDecoder$1(utils.PrefixV2.Ed25519PublicKeyHash)(val);
+          return prefixDecoder(utils.PrefixV2.Ed25519PublicKeyHash)(val);
       }
       else if (prefix[0] === 0x01) {
-          return prefixDecoder$1(utils.PrefixV2.Secp256k1PublicKeyHash)(val);
+          return prefixDecoder(utils.PrefixV2.Secp256k1PublicKeyHash)(val);
       }
       else if (prefix[0] === 0x02) {
-          return prefixDecoder$1(utils.PrefixV2.P256PublicKeyHash)(val);
+          return prefixDecoder(utils.PrefixV2.P256PublicKeyHash)(val);
       }
       else if (prefix[0] === 0x03) {
-          return prefixDecoder$1(utils.PrefixV2.BLS12_381PublicKeyHash)(val);
+          return prefixDecoder(utils.PrefixV2.BLS12_381PublicKeyHash)(val);
       }
   };
-  const publicKeyHashesDecoder$1 = (val) => {
-      if (!boolDecoder$1(val)) {
+  const publicKeyHashesDecoder = (val) => {
+      if (!boolDecoder(val)) {
           return;
       }
       const publicKeyHashes = [];
       val.consume(4);
       while (val.length() > 0) {
-          publicKeyHashes.push(publicKeyHashDecoder$1(val));
+          publicKeyHashes.push(publicKeyHashDecoder(val));
       }
       return publicKeyHashes;
   };
-  const branchEncoder$1 = prefixEncoder$1(utils.PrefixV2.BlockHash);
-  const tz1Encoder$1 = prefixEncoder$1(utils.PrefixV2.Ed25519PublicKeyHash);
-  const boolEncoder$1 = (bool) => (bool ? 'ff' : '00');
-  const proposalEncoder$1 = (proposal) => {
-      return prefixEncoder$1(utils.PrefixV2.ProtocolHash)(proposal);
+  const branchEncoder = prefixEncoder(utils.PrefixV2.BlockHash);
+  const tz1Encoder = prefixEncoder(utils.PrefixV2.Ed25519PublicKeyHash);
+  const boolEncoder = (bool) => (bool ? 'ff' : '00');
+  const proposalEncoder = (proposal) => {
+      return prefixEncoder(utils.PrefixV2.ProtocolHash)(proposal);
   };
-  const proposalDecoder$1 = (proposal) => {
-      return prefixDecoder$1(utils.PrefixV2.ProtocolHash)(proposal);
+  const proposalDecoder = (proposal) => {
+      return prefixDecoder(utils.PrefixV2.ProtocolHash)(proposal);
   };
-  const proposalsDecoder$1 = (proposal) => {
+  const proposalsDecoder = (proposal) => {
       const proposals = [];
       proposal.consume(4);
       while (proposal.length() > 0) {
-          proposals.push(proposalDecoder$1(proposal));
+          proposals.push(proposalDecoder(proposal));
       }
       return proposals;
   };
-  const proposalsEncoder$1 = (proposals) => {
-      return pad(32 * proposals.length) + proposals.map((x) => proposalEncoder$1(x)).join('');
+  const proposalsEncoder = (proposals) => {
+      return pad(32 * proposals.length) + proposals.map((x) => proposalEncoder(x)).join('');
   };
-  const ballotEncoder$1 = (ballot) => {
+  const ballotEncoder = (ballot) => {
       switch (ballot) {
           case 'yay':
               return '00';
@@ -810,7 +812,7 @@
               throw new InvalidBallotValueError(ballot);
       }
   };
-  const ballotDecoder$1 = (ballot) => {
+  const ballotDecoder = (ballot) => {
       const value = ballot.consume(1);
       switch (value[0]) {
           case 0x00:
@@ -823,7 +825,7 @@
               throw new DecodeBallotValueError(value[0].toString());
       }
   };
-  const pvmKindEncoder$1 = (pvm) => {
+  const pvmKindEncoder = (pvm) => {
       switch (pvm) {
           case 'arith':
               return '00';
@@ -835,7 +837,7 @@
               throw new UnsupportedPvmKindError(pvm);
       }
   };
-  const pvmKindDecoder$1 = (pvm) => {
+  const pvmKindDecoder = (pvm) => {
       const value = pvm.consume(1);
       switch (value[0]) {
           case 0x00:
@@ -848,15 +850,15 @@
               throw new DecodePvmKindError(value[0].toString());
       }
   };
-  const delegateEncoder$1 = (val) => {
+  const delegateEncoder = (val) => {
       if (val) {
-          return boolEncoder$1(true) + publicKeyHashEncoder$1(val);
+          return boolEncoder(true) + publicKeyHashEncoder(val);
       }
       else {
-          return boolEncoder$1(false);
+          return boolEncoder(false);
       }
   };
-  const int32Encoder$1 = (val) => {
+  const int32Encoder = (val) => {
       const num = parseInt(String(val), 10);
       const byte = [];
       for (let i = 0; i < 4; i++) {
@@ -865,7 +867,7 @@
       }
       return Buffer.from(byte).toString('hex');
   };
-  const int32Decoder$1 = (val) => {
+  const int32Decoder = (val) => {
       const num = val.consume(4);
       let finalNum = 0;
       for (let i = 0; i < num.length; i++) {
@@ -873,7 +875,7 @@
       }
       return finalNum;
   };
-  const int16Encoder$1 = (val) => {
+  const int16Encoder = (val) => {
       const num = parseInt(String(val), 10);
       const byte = [];
       for (let i = 0; i < 2; i++) {
@@ -882,7 +884,7 @@
       }
       return Buffer.from(byte).toString('hex');
   };
-  const int16Decoder$1 = (val) => {
+  const int16Decoder = (val) => {
       const num = val.consume(2);
       let finalNum = 0;
       for (let i = 0; i < num.length; i++) {
@@ -890,17 +892,17 @@
       }
       return finalNum;
   };
-  const boolDecoder$1 = (val) => {
+  const boolDecoder = (val) => {
       const bool = val.consume(1);
       return bool[0] === 0xff;
   };
-  const delegateDecoder$1 = (val) => {
-      const hasDelegate = boolDecoder$1(val);
+  const delegateDecoder = (val) => {
+      const hasDelegate = boolDecoder(val);
       if (hasDelegate) {
-          return publicKeyHashDecoder$1(val);
+          return publicKeyHashDecoder(val);
       }
   };
-  const publicKeyHashEncoder$1 = (val) => {
+  const publicKeyHashEncoder = (val) => {
       try {
           return utils.b58DecodePublicKeyHash(val);
       }
@@ -908,19 +910,19 @@
           throw new core.InvalidKeyHashError(val, err instanceof core.ParameterValidationError ? err.result : undefined);
       }
   };
-  const publicKeyHashesEncoder$1 = (val) => {
+  const publicKeyHashesEncoder = (val) => {
       if (!val) {
-          return boolEncoder$1(false);
+          return boolEncoder(false);
       }
       if (val.length === 0) {
-          return boolEncoder$1(true) + pad(0);
+          return boolEncoder(true) + pad(0);
       }
       const publicKeyHashes = val.reduce((prev, curr) => {
-          return prev + publicKeyHashEncoder$1(curr);
+          return prev + publicKeyHashEncoder(curr);
       }, '');
-      return boolEncoder$1(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
+      return boolEncoder(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
   };
-  const publicKeyEncoder$1 = (val) => {
+  const publicKeyEncoder = (val) => {
       try {
           return utils.b58DecodePublicKey(val);
       }
@@ -928,12 +930,12 @@
           throw new utils.InvalidPublicKeyError(val, err instanceof core.ParameterValidationError ? err.result : undefined);
       }
   };
-  const addressEncoder$1 = (val) => {
+  const addressEncoder = (val) => {
       return utils.b58DecodeAddress(val);
   };
-  const smartRollupAddressEncoder$1 = (val) => {
+  const smartRollupAddressEncoder = (val) => {
       try {
-          return prefixEncoder$1(utils.PrefixV2.SmartRollupHash)(val);
+          return prefixEncoder(utils.PrefixV2.SmartRollupHash)(val);
       }
       catch (err) {
           if (err instanceof core.ParameterValidationError) {
@@ -944,25 +946,25 @@
           }
       }
   };
-  const smartContractAddressEncoder$1 = (val) => utils.b58DecodeAddress(val);
-  const publicKeyDecoder$1 = (val) => {
+  const smartContractAddressEncoder = (val) => utils.b58DecodeAddress(val);
+  const publicKeyDecoder = (val) => {
       const preamble = val.consume(1);
       switch (preamble[0]) {
           case 0x00:
-              return prefixDecoder$1(utils.PrefixV2.Ed25519PublicKey)(val);
+              return prefixDecoder(utils.PrefixV2.Ed25519PublicKey)(val);
           case 0x01:
-              return prefixDecoder$1(utils.PrefixV2.Secp256k1PublicKey)(val);
+              return prefixDecoder(utils.PrefixV2.Secp256k1PublicKey)(val);
           case 0x02:
-              return prefixDecoder$1(utils.PrefixV2.P256PublicKey)(val);
+              return prefixDecoder(utils.PrefixV2.P256PublicKey)(val);
           case 0x03:
-              return prefixDecoder$1(utils.PrefixV2.BLS12_381PublicKey)(val);
+              return prefixDecoder(utils.PrefixV2.BLS12_381PublicKey)(val);
           default:
               throw new utils.InvalidPublicKeyError(undefined, utils.ValidationResult.NO_PREFIX_MATCHED);
       }
   };
-  const smartRollupCommitmentHashEncoder$1 = (val) => {
+  const smartRollupCommitmentHashEncoder = (val) => {
       try {
-          return prefixEncoder$1(utils.PrefixV2.SmartRollupCommitmentHash)(val);
+          return prefixEncoder(utils.PrefixV2.SmartRollupCommitmentHash)(val);
       }
       catch (err) {
           if (err instanceof core.ParameterValidationError) {
@@ -973,13 +975,13 @@
           }
       }
   };
-  const addressDecoder$1 = (val) => {
+  const addressDecoder = (val) => {
       const preamble = val.consume(1);
       switch (preamble[0]) {
           case 0x00:
-              return publicKeyHashDecoder$1(val);
+              return publicKeyHashDecoder(val);
           case 0x01: {
-              const address = prefixDecoder$1(utils.PrefixV2.ContractHash)(val);
+              const address = prefixDecoder(utils.PrefixV2.ContractHash)(val);
               val.consume(1);
               return address;
           }
@@ -987,22 +989,22 @@
               throw new core.InvalidAddressError(val.toString(), ': Unable to decode.');
       }
   };
-  const smartRollupAddressDecoder$1 = (val) => {
-      return prefixDecoder$1(utils.PrefixV2.SmartRollupHash)(val);
+  const smartRollupAddressDecoder = (val) => {
+      return prefixDecoder(utils.PrefixV2.SmartRollupHash)(val);
   };
-  const smartContractAddressDecoder$1 = (val) => {
+  const smartContractAddressDecoder = (val) => {
       const preamble = val.consume(1);
       if (preamble[0] === 0x01) {
-          const scAddress = prefixDecoder$1(utils.PrefixV2.ContractHash)(val);
+          const scAddress = prefixDecoder(utils.PrefixV2.ContractHash)(val);
           val.consume(1);
           return scAddress;
       }
       throw new core.InvalidContractAddressError(val.toString(), utils.ValidationResult.NO_PREFIX_MATCHED);
   };
-  const smartRollupCommitmentHashDecoder$1 = (val) => {
-      return prefixDecoder$1(utils.PrefixV2.SmartRollupCommitmentHash)(val);
+  const smartRollupCommitmentHashDecoder = (val) => {
+      return prefixDecoder(utils.PrefixV2.SmartRollupCommitmentHash)(val);
   };
-  const zarithEncoder$1 = (n) => {
+  const zarithEncoder = (n) => {
       const fn = [];
       let nn = new BigNumber(n, 10);
       if (nn.isNaN()) {
@@ -1026,7 +1028,7 @@
       }
       return fn.join('');
   };
-  const zarithDecoder$1 = (n) => {
+  const zarithDecoder = (n) => {
       let mostSignificantByte = 0;
       while (mostSignificantByte < n.length() && (n.get(mostSignificantByte) & 128) !== 0) {
           mostSignificantByte += 1;
@@ -1040,97 +1042,97 @@
       n.consume(mostSignificantByte + 1);
       return new BigNumber(num).toString();
   };
-  const entrypointDecoder$1 = (value) => {
+  const entrypointDecoder = (value) => {
       const preamble = pad(value.consume(1)[0], 2);
-      if (preamble in entrypointMapping$1) {
-          return entrypointMapping$1[preamble];
+      if (preamble in entrypointMapping) {
+          return entrypointMapping[preamble];
       }
       else {
-          const entry = extractRequiredLen$1(value, 1);
+          const entry = extractRequiredLen(value, 1);
           const entrypoint = Buffer.from(entry).toString('utf8');
-          if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
+          if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
               throw new OversizedEntryPointError(entrypoint);
           }
           return entrypoint;
       }
   };
-  const parametersDecoder$1 = (val) => {
+  const parametersDecoder = (val) => {
       const preamble = val.consume(1);
       if (preamble[0] === 0x00) {
           return;
       }
       else {
-          const encodedEntrypoint = entrypointDecoder$1(val);
-          const params = extractRequiredLen$1(val);
-          const parameters = valueDecoder$1(new Uint8ArrayConsumer(params));
+          const encodedEntrypoint = entrypointDecoder(val);
+          const params = extractRequiredLen(val);
+          const parameters = valueDecoder(new Uint8ArrayConsumer(params));
           return {
               entrypoint: encodedEntrypoint,
               value: parameters,
           };
       }
   };
-  const entrypointEncoder$1 = (entrypoint) => {
-      if (entrypoint in entrypointMappingReverse$1) {
-          return `${entrypointMappingReverse$1[entrypoint]}`;
+  const entrypointEncoder = (entrypoint) => {
+      if (entrypoint in entrypointMappingReverse) {
+          return `${entrypointMappingReverse[entrypoint]}`;
       }
       else {
-          if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
+          if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
               throw new OversizedEntryPointError(entrypoint);
           }
           const value = { string: entrypoint };
-          return `ff${valueEncoder$1(value).slice(8)}`;
+          return `ff${valueEncoder(value).slice(8)}`;
       }
   };
-  const parametersEncoder$1 = (val) => {
+  const parametersEncoder = (val) => {
       if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
           return '00';
       }
-      const encodedEntrypoint = entrypointEncoder$1(val.entrypoint);
-      const parameters = valueEncoder$1(val.value);
+      const encodedEntrypoint = entrypointEncoder(val.entrypoint);
+      const parameters = valueEncoder(val.value);
       const length = pad(parameters.length / 2);
       return `ff${encodedEntrypoint}${length}${parameters}`;
   };
-  const valueParameterEncoder$1 = (value) => {
-      const valueEncoded = valueEncoder$1(value);
+  const valueParameterEncoder = (value) => {
+      const valueEncoded = valueEncoder(value);
       return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
   };
-  const valueParameterDecoder$1 = (val) => {
-      const value = extractRequiredLen$1(val);
-      return valueDecoder$1(new Uint8ArrayConsumer(value));
+  const valueParameterDecoder = (val) => {
+      const value = extractRequiredLen(val);
+      return valueDecoder(new Uint8ArrayConsumer(value));
   };
-  const blockPayloadHashEncoder$1 = prefixEncoder$1(utils.PrefixV2.ValueHash);
-  const blockPayloadHashDecoder$1 = prefixDecoder$1(utils.PrefixV2.ValueHash);
-  const entrypointNameEncoder$1 = (entrypoint) => {
+  const blockPayloadHashEncoder = prefixEncoder(utils.PrefixV2.ValueHash);
+  const blockPayloadHashDecoder = prefixDecoder(utils.PrefixV2.ValueHash);
+  const entrypointNameEncoder = (entrypoint) => {
       const value = { string: entrypoint };
-      return `${valueEncoder$1(value).slice(2)}`;
+      return `${valueEncoder(value).slice(2)}`;
   };
-  const entrypointNameDecoder$1 = (val) => {
-      const entry = extractRequiredLen$1(val);
+  const entrypointNameDecoder = (val) => {
+      const entry = extractRequiredLen(val);
       return Buffer.from(entry).toString('utf8');
   };
-  const burnLimitEncoder$1 = (val) => {
-      return !val ? '00' : `ff${zarithEncoder$1(val)}`;
+  const burnLimitEncoder = (val) => {
+      return !val ? '00' : `ff${zarithEncoder(val)}`;
   };
-  const burnLimitDecoder$1 = (value) => {
+  const burnLimitDecoder = (value) => {
       const prefix = value.consume(1);
       if (Buffer.from(prefix).toString('hex') !== '00') {
-          return zarithDecoder$1(value);
+          return zarithDecoder(value);
       }
   };
-  const depositsLimitEncoder$1 = (val) => {
-      return !val ? '00' : `ff${zarithEncoder$1(val)}`;
+  const depositsLimitEncoder = (val) => {
+      return !val ? '00' : `ff${zarithEncoder(val)}`;
   };
-  const depositsLimitDecoder$1 = (value) => {
+  const depositsLimitDecoder = (value) => {
       const prefix = value.consume(1);
       if (Buffer.from(prefix).toString('hex') !== '00') {
-          return zarithDecoder$1(value);
+          return zarithDecoder(value);
       }
   };
-  const signatureV1Encoder$1 = (val) => {
+  const signatureV1Encoder = (val) => {
       try {
           const [data, pre] = utils.b58DecodeAndCheckPrefix(val, utils.signaturePrefixes);
           if (pre === utils.PrefixV2.BLS12_381Signature) {
-              return paddedBytesEncoder$1(utils.buf2hex(data));
+              return paddedBytesEncoder(utils.buf2hex(data));
           }
           else {
               throw new core.ProhibitedActionError('we only support encoding of BLSIG signatures from protocol Seoul');
@@ -1145,50 +1147,50 @@
           }
       }
   };
-  const signatureV1Decoder$1 = (val) => {
+  const signatureV1Decoder = (val) => {
       val.consume(4);
       if (val.length().toString() === '96') {
-          return prefixDecoder$1(utils.PrefixV2.BLS12_381Signature)(val);
+          return prefixDecoder(utils.PrefixV2.BLS12_381Signature)(val);
       }
       else {
           throw new core.ProhibitedActionError('we only support decoding of BLSIG signatures');
       }
   };
-  const signatureProofEncoder$1 = (val) => {
+  const signatureProofEncoder = (val) => {
       if (val) {
-          return boolEncoder$1(true) + signatureV1Encoder$1(val);
+          return boolEncoder(true) + signatureV1Encoder(val);
       }
       else {
-          return boolEncoder$1(false);
+          return boolEncoder(false);
       }
   };
-  const signatureProofDecoder$1 = (value) => {
-      const hasProof = boolDecoder$1(value);
+  const signatureProofDecoder = (value) => {
+      const hasProof = boolDecoder(value);
       if (hasProof) {
-          return signatureV1Decoder$1(value);
+          return signatureV1Decoder(value);
       }
   };
-  const paddedBytesEncoder$1 = (val, paddingLength = 8) => {
+  const paddedBytesEncoder = (val, paddingLength = 8) => {
       return `${pad(val.length / 2, paddingLength)}${val}`;
   };
-  const paddedBytesDecoder$1 = (val) => {
-      const value = extractRequiredLen$1(val);
+  const paddedBytesDecoder = (val) => {
+      const value = extractRequiredLen(val);
       return Buffer.from(value).toString('hex');
   };
-  const smartRollupMessageEncoder$1 = (val) => {
+  const smartRollupMessageEncoder = (val) => {
       const message = val.reduce((prev, curr) => {
           return prev + `${pad(curr.length / 2)}${curr}`;
       }, '');
       return `${pad(message.length / 2)}${message}`;
   };
-  const smartRollupMessageDecoder$1 = (val) => {
-      const valueArray = extractRequiredLen$1(val);
-      const ret = stripLengthPrefixFromBytes$1(new Uint8ArrayConsumer(valueArray));
+  const smartRollupMessageDecoder = (val) => {
+      const valueArray = extractRequiredLen(val);
+      const ret = stripLengthPrefixFromBytes(new Uint8ArrayConsumer(valueArray));
       return ret.map((value) => Buffer.from(value).toString('hex'));
   };
-  const dalCommitmentEncoder$1 = (val) => {
+  const dalCommitmentEncoder = (val) => {
       try {
-          return prefixEncoder$1(utils.PrefixV2.SlotHeader)(val);
+          return prefixEncoder(utils.PrefixV2.SlotHeader)(val);
       }
       catch (err) {
           if (err instanceof core.ParameterValidationError) {
@@ -1199,30 +1201,30 @@
           }
       }
   };
-  const dalCommitmentDecoder$1 = (val) => {
-      return prefixDecoder$1(utils.PrefixV2.SlotHeader)(val);
+  const dalCommitmentDecoder = (val) => {
+      return prefixDecoder(utils.PrefixV2.SlotHeader)(val);
   };
-  const slotHeaderEncoder$1 = (val) => {
-      return pad(val.slot_index, 2) + dalCommitmentEncoder$1(val.commitment) + val.commitment_proof;
+  const slotHeaderEncoder = (val) => {
+      return pad(val.slot_index, 2) + dalCommitmentEncoder(val.commitment) + val.commitment_proof;
   };
-  const slotHeaderDecoder$1 = (val) => {
+  const slotHeaderDecoder = (val) => {
       const preamble = val.consume(1);
       return {
           slot_index: Number(preamble[0].toString(10)),
-          commitment: dalCommitmentDecoder$1(val),
+          commitment: dalCommitmentDecoder(val),
           commitment_proof: toHexString(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
       };
   };
 
-  const ManagerOperationSchema$1 = {
+  const ManagerOperationSchema = {
       branch: exports.CODEC.BRANCH,
       contents: [exports.CODEC.OPERATION],
   };
-  const ActivationSchema$1 = {
+  const ActivationSchema = {
       pkh: exports.CODEC.TZ1,
       secret: exports.CODEC.SECRET,
   };
-  const RevealSchema$1 = {
+  const RevealSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1231,7 +1233,7 @@
       public_key: exports.CODEC.PUBLIC_KEY,
       proof: exports.CODEC.SIGNATURE_PROOF,
   };
-  const DelegationSchema$1 = {
+  const DelegationSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1239,7 +1241,7 @@
       storage_limit: exports.CODEC.ZARITH,
       delegate: exports.CODEC.DELEGATE,
   };
-  const TransactionSchema$1 = {
+  const TransactionSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1249,7 +1251,7 @@
       destination: exports.CODEC.ADDRESS,
       parameters: exports.CODEC.PARAMETERS,
   };
-  const OriginationSchema$1 = {
+  const OriginationSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1259,35 +1261,35 @@
       delegate: exports.CODEC.DELEGATE,
       script: exports.CODEC.SCRIPT,
   };
-  const BallotSchema$1 = {
+  const BallotSchema = {
       source: exports.CODEC.PKH,
       period: exports.CODEC.INT32,
       proposal: exports.CODEC.PROPOSAL,
       ballot: exports.CODEC.BALLOT_STATEMENT,
   };
-  const AttestationSchema$1 = {
+  const AttestationSchema = {
       slot: exports.CODEC.INT16,
       level: exports.CODEC.INT32,
       round: exports.CODEC.INT32,
       block_payload_hash: exports.CODEC.BLOCK_PAYLOAD_HASH,
   };
-  const AttestationWithDalSchema$1 = {
+  const AttestationWithDalSchema = {
       slot: exports.CODEC.INT16,
       level: exports.CODEC.INT32,
       round: exports.CODEC.INT32,
       block_payload_hash: exports.CODEC.BLOCK_PAYLOAD_HASH,
       dal_attestation: exports.CODEC.ZARITH,
   };
-  const SeedNonceRevelationSchema$1 = {
+  const SeedNonceRevelationSchema = {
       level: exports.CODEC.INT32,
       nonce: exports.CODEC.RAW,
   };
-  const ProposalsSchema$1 = {
+  const ProposalsSchema = {
       source: exports.CODEC.PKH,
       period: exports.CODEC.INT32,
       proposals: exports.CODEC.PROPOSAL_ARR,
   };
-  const RegisterGlobalConstantSchema$1 = {
+  const RegisterGlobalConstantSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1295,7 +1297,7 @@
       storage_limit: exports.CODEC.ZARITH,
       value: exports.CODEC.VALUE,
   };
-  const TransferTicketSchema$1 = {
+  const TransferTicketSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1308,7 +1310,7 @@
       destination: exports.CODEC.ADDRESS,
       entrypoint: exports.CODEC.ENTRYPOINT,
   };
-  const IncreasePaidStorageSchema$1 = {
+  const IncreasePaidStorageSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1317,7 +1319,7 @@
       amount: exports.CODEC.ZARITH,
       destination: exports.CODEC.SMART_CONTRACT_ADDRESS,
   };
-  const UpdateConsensusKeySchema$1 = {
+  const UpdateConsensusKeySchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1335,12 +1337,12 @@
       pk: exports.CODEC.PUBLIC_KEY,
       proof: exports.CODEC.SIGNATURE_PROOF,
   };
-  const DrainDelegateSchema$1 = {
+  const DrainDelegateSchema = {
       consensus_key: exports.CODEC.PKH,
       delegate: exports.CODEC.PKH,
       destination: exports.CODEC.PKH,
   };
-  const SetDepositsLimitSchema$1 = {
+  const SetDepositsLimitSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1348,7 +1350,7 @@
       storage_limit: exports.CODEC.ZARITH,
       limit: exports.CODEC.DEPOSITS_LIMIT,
   };
-  const SmartRollupOriginateSchema$1 = {
+  const SmartRollupOriginateSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1359,7 +1361,7 @@
       parameters_ty: exports.CODEC.VALUE,
       whitelist: exports.CODEC.PKH_ARR,
   };
-  const SmartRollupAddMessagesSchema$1 = {
+  const SmartRollupAddMessagesSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1367,7 +1369,7 @@
       storage_limit: exports.CODEC.ZARITH,
       message: exports.CODEC.SMART_ROLLUP_MESSAGE,
   };
-  const SmartRollupExecuteOutboxMessageSchema$1 = {
+  const SmartRollupExecuteOutboxMessageSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1377,7 +1379,7 @@
       cemented_commitment: exports.CODEC.SMART_ROLLUP_COMMITMENT_HASH,
       output_proof: exports.CODEC.PADDED_BYTES,
   };
-  const DalPublishCommitmentSchema$1 = {
+  const DalPublishCommitmentSchema = {
       source: exports.CODEC.PKH,
       fee: exports.CODEC.ZARITH,
       counter: exports.CODEC.ZARITH,
@@ -1385,18 +1387,18 @@
       storage_limit: exports.CODEC.ZARITH,
       slot_header: exports.CODEC.SLOT_HEADER,
   };
-  const FailingNoopSchema$1 = {
+  const FailingNoopSchema = {
       arbitrary: exports.CODEC.PADDED_BYTES,
   };
-  const operationEncoder$1 = (encoders) => (operation) => {
-      if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse$1)) {
+  const operationEncoder = (encoders) => (operation) => {
+      if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse)) {
           throw new core.InvalidOperationKindError(operation.kind);
       }
-      return kindMappingReverse$1[operation.kind] + encoders[operation.kind](operation);
+      return kindMappingReverse[operation.kind] + encoders[operation.kind](operation);
   };
-  const operationDecoder$1 = (decoders) => (value) => {
+  const operationDecoder = (decoders) => (value) => {
       const op = value.consume(1);
-      const operationName = kindMapping$1[op[0]];
+      const operationName = kindMapping[op[0]];
       if (operationName === undefined) {
           throw new UnsupportedOperationError(op[0].toString());
       }
@@ -1406,7 +1408,7 @@
       }
       return Object.assign({ kind: operationName }, decodedObj);
   };
-  const schemaEncoder$1 = (encoders) => (schema) => (value) => {
+  const schemaEncoder = (encoders) => (schema) => (value) => {
       const keys = Object.keys(schema);
       return keys.reduce((prev, key) => {
           const valueToEncode = schema[key];
@@ -1424,7 +1426,7 @@
           }
       }, '');
   };
-  const schemaDecoder$1 = (decoders) => (schema) => (value) => {
+  const schemaDecoder = (decoders) => (schema) => (value) => {
       const keys = Object.keys(schema);
       return keys.reduce((prev, key) => {
           const valueToEncode = schema[key];
@@ -1453,1526 +1455,153 @@
       }, {});
   };
 
-  const decoders$1 = {
+  const decoders = {
       [exports.CODEC.SECRET]: (val) => toHexString(val.consume(20)),
       [exports.CODEC.RAW]: (val) => toHexString(val.consume(32)),
-      [exports.CODEC.TZ1]: tz1Decoder$1,
-      [exports.CODEC.BRANCH]: branchDecoder$1,
-      [exports.CODEC.ZARITH]: zarithDecoder$1,
-      [exports.CODEC.PUBLIC_KEY]: publicKeyDecoder$1,
-      [exports.CODEC.PKH]: publicKeyHashDecoder$1,
-      [exports.CODEC.PKH_ARR]: publicKeyHashesDecoder$1,
-      [exports.CODEC.DELEGATE]: delegateDecoder$1,
-      [exports.CODEC.INT32]: int32Decoder$1,
-      [exports.CODEC.SCRIPT]: scriptDecoder$1,
-      [exports.CODEC.BALLOT_STATEMENT]: ballotDecoder$1,
-      [exports.CODEC.PROPOSAL]: proposalDecoder$1,
-      [exports.CODEC.PROPOSAL_ARR]: proposalsDecoder$1,
-      [exports.CODEC.PARAMETERS]: parametersDecoder$1,
-      [exports.CODEC.ADDRESS]: addressDecoder$1,
-      [exports.CODEC.SMART_ROLLUP_ADDRESS]: smartRollupAddressDecoder$1,
-      [exports.CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressDecoder$1,
-      [exports.CODEC.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashDecoder$1,
-      [exports.CODEC.VALUE]: valueParameterDecoder$1,
-      [exports.CODEC.INT16]: int16Decoder$1,
-      [exports.CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashDecoder$1,
-      [exports.CODEC.ENTRYPOINT]: entrypointNameDecoder$1,
-      [exports.CODEC.BURN_LIMIT]: burnLimitDecoder$1,
-      [exports.CODEC.DEPOSITS_LIMIT]: depositsLimitDecoder$1,
-      [exports.CODEC.SIGNATURE_PROOF]: signatureProofDecoder$1,
-      [exports.CODEC.PVM_KIND]: pvmKindDecoder$1,
-      [exports.CODEC.PADDED_BYTES]: paddedBytesDecoder$1,
-      [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder$1,
-      [exports.CODEC.SLOT_HEADER]: slotHeaderDecoder$1,
-  };
-  decoders$1[exports.CODEC.OPERATION] = operationDecoder$1(decoders$1);
-  decoders$1[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder$1(decoders$1)(ActivationSchema$1)(val);
-  decoders$1[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder$1(decoders$1)(FailingNoopSchema$1)(val);
-  decoders$1[exports.CODEC.OP_DELEGATION] = (val) => schemaDecoder$1(decoders$1)(DelegationSchema$1)(val);
-  decoders$1[exports.CODEC.OP_TRANSACTION] = (val) => schemaDecoder$1(decoders$1)(TransactionSchema$1)(val);
-  decoders$1[exports.CODEC.OP_ORIGINATION] = (val) => schemaDecoder$1(decoders$1)(OriginationSchema$1)(val);
-  decoders$1[exports.CODEC.OP_BALLOT] = (val) => schemaDecoder$1(decoders$1)(BallotSchema$1)(val);
-  decoders$1[exports.CODEC.OP_ATTESTATION] = (val) => schemaDecoder$1(decoders$1)(AttestationSchema$1)(val);
-  decoders$1[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder$1(decoders$1)(AttestationWithDalSchema$1)(val);
-  decoders$1[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder$1(decoders$1)(SeedNonceRevelationSchema$1)(val);
-  decoders$1[exports.CODEC.OP_PROPOSALS] = (val) => schemaDecoder$1(decoders$1)(ProposalsSchema$1)(val);
-  decoders$1[exports.CODEC.OP_REVEAL] = (val) => schemaDecoder$1(decoders$1)(RevealSchema$1)(val);
-  decoders$1[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder$1(decoders$1)(RegisterGlobalConstantSchema$1)(val);
-  decoders$1[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder$1(decoders$1)(TransferTicketSchema$1)(val);
-  decoders$1[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder$1(decoders$1)(IncreasePaidStorageSchema$1)(val);
-  decoders$1[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder$1(decoders$1)(UpdateConsensusKeySchema$1)(val);
-  decoders$1[exports.CODEC.OP_UPDATE_COMPANION_KEY] = (val) => schemaDecoder$1(decoders$1)(UpdateCompanionKeySchema)(val);
-  decoders$1[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder$1(decoders$1)(DrainDelegateSchema$1)(val);
-  decoders$1[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder$1(decoders$1)(SmartRollupOriginateSchema$1)(val);
-  decoders$1[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder$1(decoders$1)(SmartRollupAddMessagesSchema$1)(val);
-  decoders$1[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder$1(decoders$1)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-  decoders$1[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder$1(decoders$1)(DalPublishCommitmentSchema$1)(val);
-  decoders$1[exports.CODEC.MANAGER] = schemaDecoder$1(decoders$1)(ManagerOperationSchema$1);
-  decoders$1[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder$1(decoders$1)(SetDepositsLimitSchema$1)(val);
+      [exports.CODEC.TZ1]: tz1Decoder,
+      [exports.CODEC.BRANCH]: branchDecoder,
+      [exports.CODEC.ZARITH]: zarithDecoder,
+      [exports.CODEC.PUBLIC_KEY]: publicKeyDecoder,
+      [exports.CODEC.PKH]: publicKeyHashDecoder,
+      [exports.CODEC.PKH_ARR]: publicKeyHashesDecoder,
+      [exports.CODEC.DELEGATE]: delegateDecoder,
+      [exports.CODEC.INT32]: int32Decoder,
+      [exports.CODEC.SCRIPT]: scriptDecoder,
+      [exports.CODEC.BALLOT_STATEMENT]: ballotDecoder,
+      [exports.CODEC.PROPOSAL]: proposalDecoder,
+      [exports.CODEC.PROPOSAL_ARR]: proposalsDecoder,
+      [exports.CODEC.PARAMETERS]: parametersDecoder,
+      [exports.CODEC.ADDRESS]: addressDecoder,
+      [exports.CODEC.SMART_ROLLUP_ADDRESS]: smartRollupAddressDecoder,
+      [exports.CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressDecoder,
+      [exports.CODEC.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashDecoder,
+      [exports.CODEC.VALUE]: valueParameterDecoder,
+      [exports.CODEC.INT16]: int16Decoder,
+      [exports.CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashDecoder,
+      [exports.CODEC.ENTRYPOINT]: entrypointNameDecoder,
+      [exports.CODEC.BURN_LIMIT]: burnLimitDecoder,
+      [exports.CODEC.DEPOSITS_LIMIT]: depositsLimitDecoder,
+      [exports.CODEC.SIGNATURE_PROOF]: signatureProofDecoder,
+      [exports.CODEC.PVM_KIND]: pvmKindDecoder,
+      [exports.CODEC.PADDED_BYTES]: paddedBytesDecoder,
+      [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder,
+      [exports.CODEC.SLOT_HEADER]: slotHeaderDecoder,
+  };
+  decoders[exports.CODEC.OPERATION] = operationDecoder(decoders);
+  decoders[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decoders)(ActivationSchema)(val);
+  decoders[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder(decoders)(FailingNoopSchema)(val);
+  decoders[exports.CODEC.OP_DELEGATION] = (val) => schemaDecoder(decoders)(DelegationSchema)(val);
+  decoders[exports.CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decoders)(TransactionSchema)(val);
+  decoders[exports.CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decoders)(OriginationSchema)(val);
+  decoders[exports.CODEC.OP_BALLOT] = (val) => schemaDecoder(decoders)(BallotSchema)(val);
+  decoders[exports.CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decoders)(AttestationSchema)(val);
+  decoders[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decoders)(AttestationWithDalSchema)(val);
+  decoders[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decoders)(SeedNonceRevelationSchema)(val);
+  decoders[exports.CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decoders)(ProposalsSchema)(val);
+  decoders[exports.CODEC.OP_REVEAL] = (val) => schemaDecoder(decoders)(RevealSchema)(val);
+  decoders[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decoders)(RegisterGlobalConstantSchema)(val);
+  decoders[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decoders)(TransferTicketSchema)(val);
+  decoders[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decoders)(IncreasePaidStorageSchema)(val);
+  decoders[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder(decoders)(UpdateConsensusKeySchema)(val);
+  decoders[exports.CODEC.OP_UPDATE_COMPANION_KEY] = (val) => schemaDecoder(decoders)(UpdateCompanionKeySchema)(val);
+  decoders[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decoders)(DrainDelegateSchema)(val);
+  decoders[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decoders)(SmartRollupOriginateSchema)(val);
+  decoders[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decoders)(SmartRollupAddMessagesSchema)(val);
+  decoders[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+  decoders[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decoders)(DalPublishCommitmentSchema)(val);
+  decoders[exports.CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
+  decoders[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decoders)(SetDepositsLimitSchema)(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["SIGNATURE_PROOF"] = "signature_proof";
-      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 opMappingReverse = (() => {
-      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;
-  })();
-
-  const isPrim = (value) => {
-      return 'prim' in value;
-  };
-  const isBytes = (value) => {
-      return 'bytes' in value && typeof value.bytes === 'string';
-  };
-  const isString = (value) => {
-      return 'string' in value && typeof value.string === 'string';
-  };
-  const isInt = (value) => {
-      return 'int' in value && typeof value.int === 'string';
-  };
-  const scriptEncoder = (script) => {
-      const code = valueEncoder(script.code);
-      const storage = valueEncoder(script.storage);
-      return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
-  };
-  const scriptDecoder = (value) => {
-      const code = extractRequiredLen(value);
-      const storage = extractRequiredLen(value);
-      return {
-          code: valueDecoder(new Uint8ArrayConsumer(code)),
-          storage: valueDecoder(new Uint8ArrayConsumer(storage)),
-      };
-  };
-  const valueEncoder = (value) => {
-      if (Array.isArray(value)) {
-          const encoded = value.map((x) => valueEncoder(x)).join('');
-          const len = encoded.length / 2;
-          return `02${pad(len)}${encoded}`;
-      }
-      else if (isPrim(value)) {
-          return primEncoder(value);
-      }
-      else if (isBytes(value)) {
-          return bytesEncoder(value);
-      }
-      else if (isString(value)) {
-          return stringEncoder(value);
-      }
-      else if (isInt(value)) {
-          return intEncoder(value);
-      }
-      throw new UnexpectedMichelsonValueError(JSON.stringify(value));
-  };
-  const valueDecoder = (value) => {
-      const preamble = value.consume(1);
-      switch (preamble[0]) {
-          case 0x0a:
-              return bytesDecoder(value);
-          case 0x01:
-              return stringDecoder(value);
-          case 0x00:
-              return intDecoder(value);
-          case 0x02: {
-              const val = new Uint8ArrayConsumer(extractRequiredLen(value));
-              const results = [];
-              while (val.length() > 0) {
-                  results.push(valueDecoder(val));
-              }
-              return results;
-          }
-          default:
-              return primDecoder(value, preamble);
-      }
-  };
-  const extractRequiredLen = (value, bytesLength = 4) => {
-      const len = value.consume(bytesLength);
-      const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
-      return value.consume(valueLen);
-  };
-  /**
-   * @description parse bytes into multiple items of an array
-   * @param value Uint8ArrayConsumer class of forged segment to parse
-   * @param bytesLength default 4 bytes for length of variable bytes
-   * @returns array of Uint8Array values for each array item
-   */
-  const stripLengthPrefixFromBytes = (value, bytesLength = 4) => {
-      const ret = [];
-      let values = value;
-      while (values.length()) {
-          const len = values.consume(bytesLength);
-          const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
-          ret.push(values.consume(valueLen));
-          values = values.slice(valueLen + bytesLength);
-      }
-      return ret;
-  };
-  const bytesEncoder = (value) => {
-      if (!/^([A-Fa-f0-9]{2})*$/.test(value.bytes)) {
-          throw new core.InvalidHexStringError(value.bytes);
-      }
-      const len = value.bytes.length / 2;
-      return `0a${pad(len)}${value.bytes}`;
-  };
-  const bytesDecoder = (value) => {
-      const bytes = extractRequiredLen(value);
-      return {
-          bytes: Buffer.from(bytes).toString('hex'),
-      };
-  };
-  const stringEncoder = (value) => {
-      const str = Buffer.from(value.string, 'utf8').toString('hex');
-      const hexLength = str.length / 2;
-      return `01${pad(hexLength)}${str}`;
-  };
-  const stringDecoder = (value) => {
-      const str = extractRequiredLen(value);
-      return {
-          string: Buffer.from(str).toString('utf8'),
-      };
-  };
-  const intEncoder = ({ int }) => {
-      const num = new BigNumber.BigNumber(int, 10);
-      const positiveMark = num.toString(2)[0] === '-' ? '1' : '0';
-      const binary = num.toString(2).replace(/-/g, '');
-      const pad = binary.length <= 6
-          ? 6
-          : (binary.length - 6) % 7
-              ? binary.length + 7 - ((binary.length - 6) % 7)
-              : binary.length;
-      const splitted = binary.padStart(pad, '0').match(/\d{6,7}/g);
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const reversed = splitted.reverse();
-      reversed[0] = positiveMark + reversed[0];
-      const numHex = reversed.map((x, i) => 
-      // Add one to the last chunk
-      parseInt((i === reversed.length - 1 ? '0' : '1') + x, 2)
-          .toString(16)
-          .padStart(2, '0'));
-      return `00${numHex.join('')}`;
-  };
-  const intDecoder = (value) => {
-      let c = value.consume(1)[0];
-      const hexNumber = [];
-      const isNotLastChunkMask = 1 << 7;
-      while (c & isNotLastChunkMask) {
-          hexNumber.push(c);
-          c = value.consume(1)[0];
-      }
-      hexNumber.push(c);
-      const isNegative = !!((1 << 6) & hexNumber[0]);
-      hexNumber[0] = hexNumber[0] & 0b1111111;
-      const numBin = hexNumber
-          .map((x, i) => x
-          .toString(2)
-          .slice(i === 0 ? -6 : -7)
-          .padStart(i === 0 ? 6 : 7, '0'))
-          .reverse();
-      let num = new BigNumber.BigNumber(numBin.join(''), 2);
-      if (isNegative) {
-          num = num.times(-1);
-      }
-      return {
-          int: num.toFixed(),
-      };
-  };
-  const primEncoder = (value) => {
-      const hasAnnot = +Array.isArray(value.annots);
-      const argsCount = Array.isArray(value.args) ? value.args.length : 0;
-      // Specify the number of args max is 3 without annotation
-      const preamble = pad(Math.min(2 * argsCount + hasAnnot + 0x03, 9), 2);
-      const op = opMappingReverse[value.prim];
-      let encodedArgs = (value.args || []).map((arg) => valueEncoder(arg)).join('');
-      const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
-      if ((value.prim === 'LAMBDA' || value.prim === 'LAMBDA_REC') && argsCount) {
-          encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
-      }
-      if ((value.prim === 'pair' || value.prim === 'Pair') && argsCount > 2) {
-          encodedArgs =
-              encodedAnnots === ''
-                  ? pad(encodedArgs.length / 2) + encodedArgs + pad(0)
-                  : pad(encodedArgs.length / 2) + encodedArgs;
-      }
-      if (value.prim === 'view' && value.args) {
-          encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
-      }
-      return `${preamble}${op}${encodedArgs}${encodedAnnots}`;
-  };
-  const primDecoder = (value, preamble) => {
-      const hasAnnot = (preamble[0] - 0x03) % 2 === 1;
-      let argsCount = Math.floor((preamble[0] - 0x03) / 2);
-      const op = value.consume(1)[0].toString(16).padStart(2, '0');
-      const result = {
-          prim: opMapping[op],
-      };
-      if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
-          value.consume(4);
-      }
-      if (opMapping[op] === 'view') {
-          if (argsCount != 0) {
-              return primViewDecoder(value, result);
-          }
-          else {
-              return result;
-          }
-      }
-      let combPairArgs;
-      let combPairAnnots;
-      if ((opMapping[op] === 'pair' || opMapping[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') {
-          value.consume(4);
-      }
-      if (combPairArgs) {
-          result['args'] = combPairArgs;
-      }
-      else if (args.length) {
-          result['args'] = args;
-      }
-      if (combPairAnnots && combPairAnnots[0] !== '') {
-          result['annots'] = combPairAnnots;
-      }
-      else if (hasAnnot) {
-          result['annots'] = decodeAnnots(value);
-      }
-      return result;
-  };
-  const primViewDecoder = (value, result) => {
-      value.consume(4);
-      result['args'] = new Array(4).fill(0).map(() => valueDecoder(value));
-      value.consume(4);
-      return result;
-  };
-  const decodeCombPair = (val) => {
-      const array = new Uint8ArrayConsumer(extractRequiredLen(val));
-      const args = [];
-      while (array.length() > 0) {
-          args.push(valueDecoder(array));
-      }
-      return args;
-  };
-  const encodeAnnots = (value) => {
-      const mergedAnnot = value
-          .map((x) => {
-          return Buffer.from(x, 'utf8').toString('hex');
-      })
-          .join('20');
-      const len = mergedAnnot.length / 2;
-      return `${pad(len)}${mergedAnnot}`;
-  };
-  const decodeAnnots = (val) => {
-      const len = val.consume(4);
-      const annotLen = parseInt(Buffer.from(len).toString('hex'), 16);
-      const restOfAnnot = val.consume(annotLen);
-      const restOfAnnotHex = Buffer.from(restOfAnnot).toString('hex');
-      return restOfAnnotHex.split('20').map((x) => Buffer.from(x, 'hex').toString('utf8'));
-  };
-
-  // https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
-  const prefixEncoder = (prefix) => (str) => {
-      return utils.buf2hex(Buffer.from(utils.b58cdecode(str, utils.prefix[prefix])));
-  };
-  const prefixDecoder = (pre) => (str) => {
-      const val = str.consume(utils.prefixLength[pre]);
-      return utils.b58cencode(val, utils.prefix[pre]);
-  };
-  const tz1Decoder = prefixDecoder(utils.Prefix.TZ1);
-  const branchDecoder = prefixDecoder(utils.Prefix.B);
-  const publicKeyHashDecoder = (val) => {
-      const prefix = val.consume(1);
-      if (prefix[0] === 0x00) {
-          return prefixDecoder(utils.Prefix.TZ1)(val);
-      }
-      else if (prefix[0] === 0x01) {
-          return prefixDecoder(utils.Prefix.TZ2)(val);
-      }
-      else if (prefix[0] === 0x02) {
-          return prefixDecoder(utils.Prefix.TZ3)(val);
-      }
-      else if (prefix[0] === 0x03) {
-          return prefixDecoder(utils.Prefix.TZ4)(val);
-      }
-  };
-  const publicKeyHashesDecoder = (val) => {
-      if (!boolDecoder(val)) {
-          return;
-      }
-      const publicKeyHashes = [];
-      val.consume(4);
-      while (val.length() > 0) {
-          publicKeyHashes.push(publicKeyHashDecoder(val));
-      }
-      return publicKeyHashes;
-  };
-  const branchEncoder = prefixEncoder(utils.Prefix.B);
-  const tz1Encoder = prefixEncoder(utils.Prefix.TZ1);
-  const boolEncoder = (bool) => (bool ? 'ff' : '00');
-  const proposalEncoder = (proposal) => {
-      return prefixEncoder(utils.Prefix.P)(proposal);
-  };
-  const proposalDecoder = (proposal) => {
-      return prefixDecoder(utils.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 utils.Prefix.TZ1:
-              return '00' + prefixEncoder(utils.Prefix.TZ1)(val);
-          case utils.Prefix.TZ2:
-              return '01' + prefixEncoder(utils.Prefix.TZ2)(val);
-          case utils.Prefix.TZ3:
-              return '02' + prefixEncoder(utils.Prefix.TZ3)(val);
-          case utils.Prefix.TZ4:
-              return '03' + prefixEncoder(utils.Prefix.TZ4)(val);
-          default:
-              throw new utils.InvalidKeyHashError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one for the following "${utils.Prefix.TZ1}", "${utils.Prefix.TZ2}", "${utils.Prefix.TZ3}" or "${utils.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 utils.Prefix.EDPK:
-              return '00' + prefixEncoder(utils.Prefix.EDPK)(val);
-          case utils.Prefix.SPPK:
-              return '01' + prefixEncoder(utils.Prefix.SPPK)(val);
-          case utils.Prefix.P2PK:
-              return '02' + prefixEncoder(utils.Prefix.P2PK)(val);
-          case utils.Prefix.BLPK:
-              return '03' + prefixEncoder(utils.Prefix.BLPK)(val);
-          default:
-              throw new utils.InvalidPublicKeyError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one of the following '${utils.Prefix.EDPK}', '${utils.Prefix.SPPK}', '${utils.Prefix.P2PK}' or '${utils.Prefix.BLPK}'.`);
-      }
-  };
-  const addressEncoder = (val) => {
-      const pubkeyPrefix = val.substring(0, 3);
-      switch (pubkeyPrefix) {
-          case utils.Prefix.TZ1:
-          case utils.Prefix.TZ2:
-          case utils.Prefix.TZ3:
-          case utils.Prefix.TZ4:
-              return '00' + publicKeyHashEncoder(val);
-          case utils.Prefix.KT1:
-              return '01' + prefixEncoder(utils.Prefix.KT1)(val) + '00';
-          default:
-              throw new core.InvalidAddressError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one of the following prefix '${utils.Prefix.TZ1}', ${utils.Prefix.TZ2}', '${utils.Prefix.TZ3}', '${utils.Prefix.TZ4}' or '${utils.Prefix.KT1}'.`);
-      }
-  };
-  const smartRollupAddressEncoder = (val) => {
-      if (val.substring(0, 3) !== utils.Prefix.SR1) {
-          throw new InvalidSmartRollupAddressError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SR1}'.`);
-      }
-      return prefixEncoder(utils.Prefix.SR1)(val);
-  };
-  const smartContractAddressEncoder = (val) => {
-      const prefix = val.substring(0, 3);
-      if (prefix === utils.Prefix.KT1) {
-          return '01' + prefixEncoder(utils.Prefix.KT1)(val) + '00';
-      }
-      throw new core.InvalidContractAddressError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.KT1}'.`);
-  };
-  const publicKeyDecoder = (val) => {
-      const preamble = val.consume(1);
-      switch (preamble[0]) {
-          case 0x00:
-              return prefixDecoder(utils.Prefix.EDPK)(val);
-          case 0x01:
-              return prefixDecoder(utils.Prefix.SPPK)(val);
-          case 0x02:
-              return prefixDecoder(utils.Prefix.P2PK)(val);
-          case 0x03:
-              return prefixDecoder(utils.Prefix.BLPK)(val);
-          default:
-              throw new utils.InvalidPublicKeyError(val.toString(), utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED));
-      }
-  };
-  const smartRollupCommitmentHashEncoder = (val) => {
-      const prefix = val.substring(0, 4);
-      if (prefix === utils.Prefix.SRC1) {
-          return prefixEncoder(utils.Prefix.SRC1)(val);
-      }
-      throw new InvalidSmartRollupCommitmentHashError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SRC1}'`);
-  };
-  const addressDecoder = (val) => {
-      const preamble = val.consume(1);
-      switch (preamble[0]) {
-          case 0x00:
-              return publicKeyHashDecoder(val);
-          case 0x01: {
-              const address = prefixDecoder(utils.Prefix.KT1)(val);
-              val.consume(1);
-              return address;
-          }
-          default:
-              throw new core.InvalidAddressError(val.toString(), ': Unable to decode.');
-      }
-  };
-  const smartRollupAddressDecoder = (val) => {
-      const address = prefixDecoder(utils.Prefix.SR1)(val);
-      if (address.substring(0, 3) !== utils.Prefix.SR1) {
-          throw new InvalidSmartRollupAddressError(address, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SR1}'.`);
-      }
-      return address;
-  };
-  const smartContractAddressDecoder = (val) => {
-      const preamble = val.consume(1);
-      if (preamble[0] === 0x01) {
-          const scAddress = prefixDecoder(utils.Prefix.KT1)(val);
-          val.consume(1);
-          return scAddress;
-      }
-      throw new core.InvalidContractAddressError(val.toString(), utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED));
-  };
-  const smartRollupCommitmentHashDecoder = (val) => {
-      const address = prefixDecoder(utils.Prefix.SRC1)(val);
-      if (address.substring(0, 4) !== utils.Prefix.SRC1) {
-          throw new InvalidSmartRollupCommitmentHashError(address, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SRC1}'`);
-      }
-      return address;
-  };
-  const zarithEncoder = (n) => {
-      const fn = [];
-      let nn = new BigNumber(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(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(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(utils.Prefix.VH);
-  const blockPayloadHashDecoder = prefixDecoder(utils.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 signatureV1Encoder = (val) => {
-      const signaturePrefix = val.substring(0, 5);
-      switch (signaturePrefix) {
-          case utils.Prefix.EDSIG:
-              return paddedBytesEncoder(prefixEncoder(utils.Prefix.EDSIG)(val));
-          case utils.Prefix.SPSIG:
-              return paddedBytesEncoder(prefixEncoder(utils.Prefix.SPSIG)(val));
-          case utils.Prefix.P2SIG:
-              return paddedBytesEncoder(prefixEncoder(utils.Prefix.P2SIG)(val));
-          case utils.Prefix.BLSIG:
-              return paddedBytesEncoder(prefixEncoder(utils.Prefix.BLSIG)(val));
-          default:
-              throw new core.InvalidSignatureError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one of the following '${utils.Prefix.EDSIG}', '${utils.Prefix.SPSIG}', '${utils.Prefix.P2SIG}' or '${utils.Prefix.BLSIG}'.`);
-      }
-  };
-  const signatureV1Decoder = (val) => {
-      val.consume(4);
-      if (val.length().toString() === '96') {
-          return prefixDecoder(utils.Prefix.BLSIG)(val);
-      }
-      else {
-          throw new core.ProhibitedActionError('currently we only support decoding of BLSIG signatures');
-      }
-  };
-  const signatureProofEncoder = (val) => {
-      if (val) {
-          return boolEncoder(true) + signatureV1Encoder(val);
-      }
-      else {
-          return boolEncoder(false);
-      }
-  };
-  const signatureProofDecoder = (value) => {
-      const hasProof = boolDecoder(value);
-      if (hasProof) {
-          return signatureV1Decoder(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 === utils.Prefix.SH) {
-          return prefixEncoder(utils.Prefix.SH)(val);
-      }
-      throw new InvalidDalCommitmentError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SH}'`);
-  };
-  const dalCommitmentDecoder = (val) => {
-      const commitment = prefixDecoder(utils.Prefix.SH)(val);
-      if (commitment.substring(0, 2) !== utils.Prefix.SH) {
-          throw new InvalidDalCommitmentError(commitment, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.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,
-  };
-  const ProposalsSchema = {
-      source: CODEC.PKH,
-      period: CODEC.INT32,
-      proposals: CODEC.PROPOSAL_ARR,
-  };
-  const RegisterGlobalConstantSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      value: CODEC.VALUE,
-  };
-  const TransferTicketSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      ticket_contents: CODEC.VALUE,
-      ticket_ty: CODEC.VALUE,
-      ticket_ticketer: CODEC.ADDRESS,
-      ticket_amount: CODEC.ZARITH,
-      destination: CODEC.ADDRESS,
-      entrypoint: CODEC.ENTRYPOINT,
-  };
-  const IncreasePaidStorageSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      amount: CODEC.ZARITH,
-      destination: CODEC.SMART_CONTRACT_ADDRESS,
-  };
-  const UpdateConsensusKeySchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      pk: CODEC.PUBLIC_KEY,
-      proof: CODEC.SIGNATURE_PROOF,
-  };
-  const DrainDelegateSchema = {
-      consensus_key: CODEC.PKH,
-      delegate: CODEC.PKH,
-      destination: CODEC.PKH,
-  };
-  const SetDepositsLimitSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      limit: CODEC.DEPOSITS_LIMIT,
-  };
-  const SmartRollupOriginateSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      pvm_kind: CODEC.PVM_KIND,
-      kernel: CODEC.PADDED_BYTES,
-      parameters_ty: CODEC.VALUE,
-      whitelist: CODEC.PKH_ARR,
-  };
-  const SmartRollupAddMessagesSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      message: CODEC.SMART_ROLLUP_MESSAGE,
-  };
-  const SmartRollupExecuteOutboxMessageSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      rollup: CODEC.SMART_ROLLUP_ADDRESS,
-      cemented_commitment: CODEC.SMART_ROLLUP_COMMITMENT_HASH,
-      output_proof: CODEC.PADDED_BYTES,
-  };
-  const DalPublishCommitmentSchema = {
-      source: CODEC.PKH,
-      fee: CODEC.ZARITH,
-      counter: CODEC.ZARITH,
-      gas_limit: CODEC.ZARITH,
-      storage_limit: CODEC.ZARITH,
-      slot_header: CODEC.SLOT_HEADER,
-  };
-  const FailingNoopSchema = {
-      arbitrary: CODEC.PADDED_BYTES,
-  };
-  const operationEncoder = (encoders) => (operation) => {
-      if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse)) {
-          throw new core.InvalidOperationKindError(operation.kind);
-      }
-      return kindMappingReverse[operation.kind] + encoders[operation.kind](operation);
-  };
-  const operationDecoder = (decoders) => (value) => {
-      const op = value.consume(1);
-      const operationName = kindMapping[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 schemaEncoder = (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 schemaDecoder = (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 decoders = {
-      [CODEC.SECRET]: (val) => toHexString(val.consume(20)),
-      [CODEC.RAW]: (val) => toHexString(val.consume(32)),
-      [CODEC.TZ1]: tz1Decoder,
-      [CODEC.BRANCH]: branchDecoder,
-      [CODEC.ZARITH]: zarithDecoder,
-      [CODEC.PUBLIC_KEY]: publicKeyDecoder,
-      [CODEC.PKH]: publicKeyHashDecoder,
-      [CODEC.PKH_ARR]: publicKeyHashesDecoder,
-      [CODEC.DELEGATE]: delegateDecoder,
-      [CODEC.INT32]: int32Decoder,
-      [CODEC.SCRIPT]: scriptDecoder,
-      [CODEC.BALLOT_STATEMENT]: ballotDecoder,
-      [CODEC.PROPOSAL]: proposalDecoder,
-      [CODEC.PROPOSAL_ARR]: proposalsDecoder,
-      [CODEC.PARAMETERS]: parametersDecoder,
-      [CODEC.ADDRESS]: addressDecoder,
-      [CODEC.SMART_ROLLUP_ADDRESS]: smartRollupAddressDecoder,
-      [CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressDecoder,
-      [CODEC.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashDecoder,
-      [CODEC.VALUE]: valueParameterDecoder,
-      [CODEC.INT16]: int16Decoder,
-      [CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashDecoder,
-      [CODEC.ENTRYPOINT]: entrypointNameDecoder,
-      [CODEC.BURN_LIMIT]: burnLimitDecoder,
-      [CODEC.DEPOSITS_LIMIT]: depositsLimitDecoder,
-      [CODEC.SIGNATURE_PROOF]: signatureProofDecoder,
-      [CODEC.PVM_KIND]: pvmKindDecoder,
-      [CODEC.PADDED_BYTES]: paddedBytesDecoder,
-      [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);
-
-  const encoders$1 = {
-      [exports.CODEC.SECRET]: (val) => val,
-      [exports.CODEC.RAW]: (val) => val,
-      [exports.CODEC.TZ1]: tz1Encoder$1,
-      [exports.CODEC.BRANCH]: branchEncoder$1,
-      [exports.CODEC.ZARITH]: zarithEncoder$1,
-      [exports.CODEC.PUBLIC_KEY]: publicKeyEncoder$1,
-      [exports.CODEC.PKH]: publicKeyHashEncoder$1,
-      [exports.CODEC.PKH_ARR]: publicKeyHashesEncoder$1,
-      [exports.CODEC.DELEGATE]: delegateEncoder$1,
-      [exports.CODEC.SCRIPT]: scriptEncoder$1,
-      [exports.CODEC.BALLOT_STATEMENT]: ballotEncoder$1,
-      [exports.CODEC.PROPOSAL]: proposalEncoder$1,
-      [exports.CODEC.PROPOSAL_ARR]: proposalsEncoder$1,
-      [exports.CODEC.INT32]: int32Encoder$1,
-      [exports.CODEC.PARAMETERS]: parametersEncoder$1,
-      [exports.CODEC.ADDRESS]: addressEncoder$1,
-      [exports.CODEC.SMART_ROLLUP_ADDRESS]: smartRollupAddressEncoder$1,
-      [exports.CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressEncoder$1,
-      [exports.CODEC.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashEncoder$1,
-      [exports.CODEC.VALUE]: valueParameterEncoder$1,
-      [exports.CODEC.INT16]: int16Encoder$1,
-      [exports.CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashEncoder$1,
-      [exports.CODEC.ENTRYPOINT]: entrypointNameEncoder$1,
-      [exports.CODEC.BURN_LIMIT]: burnLimitEncoder$1,
-      [exports.CODEC.DEPOSITS_LIMIT]: depositsLimitEncoder$1,
-      [exports.CODEC.SIGNATURE_PROOF]: signatureProofEncoder$1,
-      [exports.CODEC.PVM_KIND]: pvmKindEncoder$1,
-      [exports.CODEC.PADDED_BYTES]: paddedBytesEncoder$1,
-      [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder$1,
-      [exports.CODEC.SLOT_HEADER]: slotHeaderEncoder$1,
-  };
-  encoders$1[exports.CODEC.OPERATION] = operationEncoder$1(encoders$1);
-  encoders$1[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder$1(encoders$1)(ActivationSchema$1)(val);
-  encoders$1[exports.CODEC.OP_DELEGATION] = (val) => schemaEncoder$1(encoders$1)(DelegationSchema$1)(val);
-  encoders$1[exports.CODEC.OP_TRANSACTION] = (val) => schemaEncoder$1(encoders$1)(TransactionSchema$1)(val);
-  encoders$1[exports.CODEC.OP_ORIGINATION] = (val) => schemaEncoder$1(encoders$1)(OriginationSchema$1)(val);
-  encoders$1[exports.CODEC.OP_BALLOT] = (val) => schemaEncoder$1(encoders$1)(BallotSchema$1)(val);
-  encoders$1[exports.CODEC.OP_ATTESTATION] = (val) => schemaEncoder$1(encoders$1)(AttestationSchema$1)(val);
-  encoders$1[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder$1(encoders$1)(AttestationWithDalSchema$1)(val);
-  encoders$1[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder$1(encoders$1)(SeedNonceRevelationSchema$1)(val);
-  encoders$1[exports.CODEC.OP_PROPOSALS] = (val) => schemaEncoder$1(encoders$1)(ProposalsSchema$1)(val);
-  encoders$1[exports.CODEC.OP_REVEAL] = (val) => schemaEncoder$1(encoders$1)(RevealSchema$1)(val);
-  encoders$1[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder$1(encoders$1)(RegisterGlobalConstantSchema$1)(val);
-  encoders$1[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder$1(encoders$1)(TransferTicketSchema$1)(val);
-  encoders$1[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder$1(encoders$1)(IncreasePaidStorageSchema$1)(val);
-  encoders$1[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder$1(encoders$1)(UpdateConsensusKeySchema$1)(val);
-  encoders$1[exports.CODEC.OP_UPDATE_COMPANION_KEY] = (val) => schemaEncoder$1(encoders$1)(UpdateCompanionKeySchema)(val);
-  encoders$1[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder$1(encoders$1)(DrainDelegateSchema$1)(val);
-  encoders$1[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder$1(encoders$1)(SmartRollupOriginateSchema$1)(val);
-  encoders$1[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder$1(encoders$1)(SmartRollupAddMessagesSchema$1)(val);
-  encoders$1[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder$1(encoders$1)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-  encoders$1[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder$1(encoders$1)(DalPublishCommitmentSchema$1)(val);
-  encoders$1[exports.CODEC.MANAGER] = schemaEncoder$1(encoders$1)(ManagerOperationSchema$1);
-  encoders$1[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder$1(encoders$1)(SetDepositsLimitSchema$1)(val);
-  encoders$1[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder$1(encoders$1)(FailingNoopSchema$1)(val);
-
-  const encoders = {
-      [CODEC.SECRET]: (val) => val,
-      [CODEC.RAW]: (val) => val,
-      [CODEC.TZ1]: tz1Encoder,
-      [CODEC.BRANCH]: branchEncoder,
-      [CODEC.ZARITH]: zarithEncoder,
-      [CODEC.PUBLIC_KEY]: publicKeyEncoder,
-      [CODEC.PKH]: publicKeyHashEncoder,
-      [CODEC.PKH_ARR]: publicKeyHashesEncoder,
-      [CODEC.DELEGATE]: delegateEncoder,
-      [CODEC.SCRIPT]: scriptEncoder,
-      [CODEC.BALLOT_STATEMENT]: ballotEncoder,
-      [CODEC.PROPOSAL]: proposalEncoder,
-      [CODEC.PROPOSAL_ARR]: proposalsEncoder,
-      [CODEC.INT32]: int32Encoder,
-      [CODEC.PARAMETERS]: parametersEncoder,
-      [CODEC.ADDRESS]: addressEncoder,
-      [CODEC.SMART_ROLLUP_ADDRESS]: smartRollupAddressEncoder,
-      [CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressEncoder,
-      [CODEC.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashEncoder,
-      [CODEC.VALUE]: valueParameterEncoder,
-      [CODEC.INT16]: int16Encoder,
-      [CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashEncoder,
-      [CODEC.ENTRYPOINT]: entrypointNameEncoder,
-      [CODEC.BURN_LIMIT]: burnLimitEncoder,
-      [CODEC.DEPOSITS_LIMIT]: depositsLimitEncoder,
-      [CODEC.SIGNATURE_PROOF]: signatureProofEncoder,
-      [CODEC.PVM_KIND]: pvmKindEncoder,
-      [CODEC.PADDED_BYTES]: paddedBytesEncoder,
-      [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);
-
-  const OperationKindMapping = {
-      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,
-      update_companion_key: UpdateCompanionKeySchema,
-      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) => {
-      return arr2.filter((x) => !arr1.includes(x));
-  };
-  const deleteArrayElementByValue = (array, item) => {
-      return array.filter((e) => e !== item);
-  };
-  /**
-   * @returns A boolean value to indicate whether the operation kind is valid or not
+  const encoders = {
+      [exports.CODEC.SECRET]: (val) => val,
+      [exports.CODEC.RAW]: (val) => val,
+      [exports.CODEC.TZ1]: tz1Encoder,
+      [exports.CODEC.BRANCH]: branchEncoder,
+      [exports.CODEC.ZARITH]: zarithEncoder,
+      [exports.CODEC.PUBLIC_KEY]: publicKeyEncoder,
+      [exports.CODEC.PKH]: publicKeyHashEncoder,
+      [exports.CODEC.PKH_ARR]: publicKeyHashesEncoder,
+      [exports.CODEC.DELEGATE]: delegateEncoder,
+      [exports.CODEC.SCRIPT]: scriptEncoder,
+      [exports.CODEC.BALLOT_STATEMENT]: ballotEncoder,
+      [exports.CODEC.PROPOSAL]: proposalEncoder,
+      [exports.CODEC.PROPOSAL_ARR]: proposalsEncoder,
+      [exports.CODEC.INT32]: int32Encoder,
+      [exports.CODEC.PARAMETERS]: parametersEncoder,
+      [exports.CODEC.ADDRESS]: addressEncoder,
+      [exports.CODEC.SMART_ROLLUP_ADDRESS]: smartRollupAddressEncoder,
+      [exports.CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressEncoder,
+      [exports.CODEC.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashEncoder,
+      [exports.CODEC.VALUE]: valueParameterEncoder,
+      [exports.CODEC.INT16]: int16Encoder,
+      [exports.CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashEncoder,
+      [exports.CODEC.ENTRYPOINT]: entrypointNameEncoder,
+      [exports.CODEC.BURN_LIMIT]: burnLimitEncoder,
+      [exports.CODEC.DEPOSITS_LIMIT]: depositsLimitEncoder,
+      [exports.CODEC.SIGNATURE_PROOF]: signatureProofEncoder,
+      [exports.CODEC.PVM_KIND]: pvmKindEncoder,
+      [exports.CODEC.PADDED_BYTES]: paddedBytesEncoder,
+      [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder,
+      [exports.CODEC.SLOT_HEADER]: slotHeaderEncoder,
+  };
+  encoders[exports.CODEC.OPERATION] = operationEncoder(encoders);
+  encoders[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encoders)(ActivationSchema)(val);
+  encoders[exports.CODEC.OP_DELEGATION] = (val) => schemaEncoder(encoders)(DelegationSchema)(val);
+  encoders[exports.CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encoders)(TransactionSchema)(val);
+  encoders[exports.CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encoders)(OriginationSchema)(val);
+  encoders[exports.CODEC.OP_BALLOT] = (val) => schemaEncoder(encoders)(BallotSchema)(val);
+  encoders[exports.CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encoders)(AttestationSchema)(val);
+  encoders[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encoders)(AttestationWithDalSchema)(val);
+  encoders[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encoders)(SeedNonceRevelationSchema)(val);
+  encoders[exports.CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encoders)(ProposalsSchema)(val);
+  encoders[exports.CODEC.OP_REVEAL] = (val) => schemaEncoder(encoders)(RevealSchema)(val);
+  encoders[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encoders)(RegisterGlobalConstantSchema)(val);
+  encoders[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encoders)(TransferTicketSchema)(val);
+  encoders[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encoders)(IncreasePaidStorageSchema)(val);
+  encoders[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder(encoders)(UpdateConsensusKeySchema)(val);
+  encoders[exports.CODEC.OP_UPDATE_COMPANION_KEY] = (val) => schemaEncoder(encoders)(UpdateCompanionKeySchema)(val);
+  encoders[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encoders)(DrainDelegateSchema)(val);
+  encoders[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encoders)(SmartRollupOriginateSchema)(val);
+  encoders[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encoders)(SmartRollupAddMessagesSchema)(val);
+  encoders[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+  encoders[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encoders)(DalPublishCommitmentSchema)(val);
+  encoders[exports.CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
+  encoders[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encoders)(SetDepositsLimitSchema)(val);
+  encoders[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encoders)(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,
+      update_companion_key: UpdateCompanionKeySchema,
+      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,
+  };
+  // Asymmetric difference: only account for things in arr2 that are not present in arr1, not vice versa
+  const getArrayDifference = (arr1, arr2) => {
+      return arr2.filter((x) => !arr1.includes(x));
+  };
+  const deleteArrayElementByValue = (array, item) => {
+      return array.filter((e) => e !== item);
+  };
+  /**
+   * @returns A boolean value to indicate whether the operation kind is valid or not
    */
   const validateOperationKind = (opKind) => {
       const opKindList = Object.keys(OperationKindMapping);
@@ -3016,41 +1645,14 @@
       ProtocolsHash["PsQuebecn"] = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg";
       ProtocolsHash["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
       ProtocolsHash["PtSeouLou"] = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh";
+      ProtocolsHash["PtTALLiNt"] = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu";
       ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
   })(exports.ProtocolsHash || (exports.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,
-      PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh: 23,
-      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": "42048d039f6d4345fc59d04b03650bcb8e27bb62",
-      "version": "23.0.3"
+      "commitHash": "0e66f21b0164a7add990b5c0d60698086daece99",
+      "version": "24.0.0-RC.0"
   };
 
   /**
@@ -3063,35 +1665,15 @@
   if (typeof globalThis.TextDecoder === 'undefined') {
       globalThis.TextDecoder = TextDecoder;
   }
-  const PROTOCOL_CURRENT = exports.ProtocolsHash.PtSeouLou;
+  const PROTOCOL_CURRENT = exports.ProtocolsHash.PtTALLiNt;
   function getCodec(codec, _proto) {
-      // use encodersProto022 & decodersProto022 if it's rio or prior
-      if (_proto === exports.ProtocolsHash.PsRiotuma || ProtoInferiorTo(_proto, exports.ProtocolsHash.PsRiotuma)) {
-          return {
-              encoder: encoders[codec],
-              decoder: (hex) => {
-                  const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                  return decoders[codec](consumer);
-              },
-          };
-      }
-      else {
-          return {
-              encoder: encoders$1[codec],
-              decoder: (hex) => {
-                  const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                  return decoders$1[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;
-      //   },
-      // };
+      return {
+          encoder: encoders[codec],
+          decoder: (hex) => {
+              const consumer = Uint8ArrayConsumer.fromHexString(hex);
+              return decoders[codec](consumer);
+          },
+      };
   }
   class LocalForger {
       constructor(protocolHash = PROTOCOL_CURRENT) {
@@ -3153,12 +1735,12 @@
   exports.LocalForger = LocalForger;
   exports.Uint8ArrayConsumer = Uint8ArrayConsumer;
   exports.VERSION = VERSION;
-  exports.decoders = decoders$1;
-  exports.encoders = encoders$1;
+  exports.decoders = decoders;
+  exports.encoders = encoders;
   exports.getCodec = getCodec;
   exports.localForger = localForger;
-  exports.opMapping = opMapping$1;
-  exports.opMappingReverse = opMappingReverse$1;
+  exports.opMapping = opMapping;
+  exports.opMappingReverse = opMappingReverse;
 
 }));
 //# sourceMappingURL=taquito-local-forging.umd.js.map