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

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

@@ -1,6 +1,6 @@
 import 'fast-text-encoding';
-import { PrefixV2, b58DecodeAndCheckPrefix, buf2hex, payloadLength, b58Encode, b58DecodePublicKeyHash, b58DecodePublicKey, InvalidPublicKeyError, b58DecodeAddress, ValidationResult, signaturePrefixes, Prefix, b58cdecode, prefix, prefixLength, b58cencode, InvalidKeyHashError as InvalidKeyHashError$1, invalidDetail, validateBlock } from '@taquito/utils';
-import { ParameterValidationError, InvalidHexStringError, InvalidKeyHashError, InvalidAddressError, InvalidContractAddressError, ProhibitedActionError, InvalidSignatureError, InvalidOperationKindError, InvalidBlockHashError } from '@taquito/core';
+import { PrefixV2, payloadLength, b58Encode, b58DecodeAndCheckPrefix, buf2hex, ValidationResult, InvalidPublicKeyError, b58DecodeAddress, b58DecodePublicKeyHash, b58DecodePublicKey, signaturePrefixes, validateBlock } from '@taquito/utils';
+import { ParameterValidationError, InvalidHexStringError, InvalidContractAddressError, InvalidAddressError, ProhibitedActionError, InvalidKeyHashError, InvalidSignatureError, InvalidOperationKindError, InvalidBlockHashError } from '@taquito/core';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 
 const toHexString = (bytes) => bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
@@ -13,8 +13,8 @@ const pad = (num, paddingLen = 8) => {
  * Copyright (c) 2018 Andrew Kishino
  */
 // See: https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
-const ENTRYPOINT_MAX_LENGTH$1 = 31;
-var CODEC$1;
+const ENTRYPOINT_MAX_LENGTH = 31;
+var CODEC;
 (function (CODEC) {
     CODEC["SECRET"] = "secret";
     CODEC["RAW"] = "raw";
@@ -70,9 +70,9 @@ var CODEC$1;
     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$1 || (CODEC$1 = {}));
+})(CODEC || (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',
@@ -232,16 +232,18 @@ const opMapping$1 = {
     '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',
@@ -265,16 +267,16 @@ const kindMapping$1 = {
     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',
@@ -286,10 +288,10 @@ const entrypointMapping$1 = {
     '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;
 })();
@@ -316,1481 +318,176 @@ class OversizedEntryPointError extends ParameterValidationError {
         super();
         this.entrypoint = entrypoint;
         this.name = 'OversizedEntryPointError';
-        this.message = `Invalid entrypoint length "${entrypoint.length}", maximum length is "${ENTRYPOINT_MAX_LENGTH$1}".`;
-    }
-}
-/**
- *  @category Error
- *  @description Error that indicates an invalid ballot value being used
- */
-class InvalidBallotValueError extends ParameterValidationError {
-    constructor(ballotValue) {
-        super();
-        this.ballotValue = ballotValue;
-        this.name = 'InvalidBallotValueError';
-        this.message = `Invalid ballot value "${ballotValue}" expecting one of the following: "yay", "nay", "pass".`;
-    }
-}
-/**
- *  @category Error
- *  @description Error that indicates a failure when trying to decode ballot value
- */
-class DecodeBallotValueError extends ParameterValidationError {
-    constructor(ballotValue) {
-        super();
-        this.ballotValue = ballotValue;
-        this.name = 'DecodeBallotValueError';
-        this.message = `Invalid ballot value "${ballotValue}", cannot be decoded.`;
-    }
-}
-/**
- *  @category Error
- *  @description Error that indicates unexpected Michelson Value being passed or used
- */
-class UnexpectedMichelsonValueError extends ParameterValidationError {
-    constructor(value) {
-        super();
-        this.value = value;
-        this.name = 'UnexpectedMichelsonValueError';
-        this.message = `Invalid Michelson value "${value}", unalbe to encode.`;
-    }
-}
-/**
- *  @category Error
- *  @description Error that indicates a failure when trying to decode an operation
- */
-class OperationDecodingError extends ParameterValidationError {
-    constructor(message) {
-        super();
-        this.message = message;
-        this.name = 'OperationDecodingError';
-    }
-}
-/**
- *  @category Error
- *  @description Error that indicates a failure when trying to encode an operation
- */
-class OperationEncodingError extends ParameterValidationError {
-    constructor(message) {
-        super();
-        this.message = message;
-        this.name = 'OperationEncodingError';
-    }
-}
-/**
- *  @category Error
- *  @description Error that indicates an unsupported operation being passed or used
- */
-class UnsupportedOperationError extends ParameterValidationError {
-    constructor(op) {
-        super();
-        this.op = op;
-        this.name = 'UnsupportedOperationError';
-        this.message = `Unsupported operation "${op}", can submit an issue on our github for feature request.`;
-    }
-}
-/**
- * @cateogry Error
- * @description Error that indicates an unsupported pvm being passed or used
- */
-class UnsupportedPvmKindError extends ParameterValidationError {
-    constructor(pvm) {
-        super();
-        this.pvm = pvm;
-        this.name = 'UnsupportedPvmKindError';
-        this.message = `Invalid Pvm kind "${pvm}" expecting either "arith" or "wasm_2_0_0".`;
-    }
-}
-/**
- * @category Error
- * @description Error that indicates an unsupported pvm to decode
- */
-class DecodePvmKindError extends ParameterValidationError {
-    constructor(pvm) {
-        super();
-        this.pvm = pvm;
-        this.name = 'DecodePvmKindError';
-        this.message = `Invalid Pvm kind "${pvm}", cannot be decoded.`;
-    }
-}
-/**
- * @category Error
- * @description Error that indicates an invalid Smart Rollup Address (sr1)
- */
-class InvalidSmartRollupAddressError extends ParameterValidationError {
-    constructor(address, errorDetail) {
-        super();
-        this.address = address;
-        this.errorDetail = errorDetail;
-        this.name = 'InvalidSmartRollupAddress';
-        this.message = `Invalid smart rollup address "${address}"`;
-        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
-    }
-}
-/**
- * @category Error
- * @description Error that indicates an invalid Smart Rollup commitment hash (src1)
- */
-class InvalidSmartRollupCommitmentHashError extends ParameterValidationError {
-    constructor(hash, errorDetail) {
-        super();
-        this.hash = hash;
-        this.errorDetail = errorDetail;
-        this.name = 'InvalidSmartRollupCommitmentHashError';
-        this.message = `Invalid smart rollup commitment hash "${hash}"`;
-        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
-    }
-}
-/**
- * @category Error
- * @description Error that indicates an invalid dal commitment (sh)
- */
-class InvalidDalCommitmentError extends ParameterValidationError {
-    constructor(commitment, errorDetail) {
-        super();
-        this.commitment = commitment;
-        this.errorDetail = errorDetail;
-        this.name = 'InvalidDalCommitmentError';
-        this.message = `Invalid dal commitment "${commitment}"`;
-        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
-    }
-}
-
-class Uint8ArrayConsumer {
-    static fromHexString(hex) {
-        const lowHex = hex.toLowerCase();
-        if (/^(([a-f]|\d){2})*$/.test(lowHex)) {
-            const arr = new Uint8Array((lowHex.match(/([a-z]|\d){2}/g) || []).map((byte) => parseInt(byte, 16)));
-            return new Uint8ArrayConsumer(arr);
-        }
-        else {
-            throw new InvalidHexStringError(lowHex);
-        }
-    }
-    constructor(arr, offset = 0) {
-        this.arr = arr;
-        this.offset = offset;
-    }
-    consume(count) {
-        const subArr = this.arr.subarray(this.offset, this.offset + count);
-        this.offset += count;
-        return subArr;
-    }
-    get(idx) {
-        return this.arr[this.offset + idx];
-    }
-    length() {
-        return this.arr.length - this.offset;
-    }
-    slice(start, end) {
-        return new Uint8ArrayConsumer(this.arr.slice(start, end));
+        this.message = `Invalid entrypoint length "${entrypoint.length}", maximum length is "${ENTRYPOINT_MAX_LENGTH}".`;
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid ballot value being used
+ */
+class InvalidBallotValueError extends ParameterValidationError {
+    constructor(ballotValue) {
+        super();
+        this.ballotValue = ballotValue;
+        this.name = 'InvalidBallotValueError';
+        this.message = `Invalid ballot value "${ballotValue}" expecting one of the following: "yay", "nay", "pass".`;
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when trying to decode ballot value
+ */
+class DecodeBallotValueError extends ParameterValidationError {
+    constructor(ballotValue) {
+        super();
+        this.ballotValue = ballotValue;
+        this.name = 'DecodeBallotValueError';
+        this.message = `Invalid ballot value "${ballotValue}", cannot be decoded.`;
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates unexpected Michelson Value being passed or used
+ */
+class UnexpectedMichelsonValueError extends ParameterValidationError {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.name = 'UnexpectedMichelsonValueError';
+        this.message = `Invalid Michelson value "${value}", unalbe to encode.`;
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when trying to decode an operation
+ */
+class OperationDecodingError extends ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'OperationDecodingError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when trying to encode an operation
+ */
+class OperationEncodingError extends ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'OperationEncodingError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an unsupported operation being passed or used
+ */
+class UnsupportedOperationError extends ParameterValidationError {
+    constructor(op) {
+        super();
+        this.op = op;
+        this.name = 'UnsupportedOperationError';
+        this.message = `Unsupported operation "${op}", can submit an issue on our github for feature request.`;
+    }
+}
+/**
+ * @cateogry Error
+ * @description Error that indicates an unsupported pvm being passed or used
+ */
+class UnsupportedPvmKindError extends ParameterValidationError {
+    constructor(pvm) {
+        super();
+        this.pvm = pvm;
+        this.name = 'UnsupportedPvmKindError';
+        this.message = `Invalid Pvm kind "${pvm}" expecting either "arith" or "wasm_2_0_0".`;
+    }
+}
+/**
+ * @category Error
+ * @description Error that indicates an unsupported pvm to decode
+ */
+class DecodePvmKindError extends ParameterValidationError {
+    constructor(pvm) {
+        super();
+        this.pvm = pvm;
+        this.name = 'DecodePvmKindError';
+        this.message = `Invalid Pvm kind "${pvm}", cannot be decoded.`;
+    }
+}
+/**
+ * @category Error
+ * @description Error that indicates an invalid Smart Rollup Address (sr1)
+ */
+class InvalidSmartRollupAddressError extends ParameterValidationError {
+    constructor(address, errorDetail) {
+        super();
+        this.address = address;
+        this.errorDetail = errorDetail;
+        this.name = 'InvalidSmartRollupAddress';
+        this.message = `Invalid smart rollup address "${address}"`;
+        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
+    }
+}
+/**
+ * @category Error
+ * @description Error that indicates an invalid Smart Rollup commitment hash (src1)
+ */
+class InvalidSmartRollupCommitmentHashError extends ParameterValidationError {
+    constructor(hash, errorDetail) {
+        super();
+        this.hash = hash;
+        this.errorDetail = errorDetail;
+        this.name = 'InvalidSmartRollupCommitmentHashError';
+        this.message = `Invalid smart rollup commitment hash "${hash}"`;
+        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
+    }
+}
+/**
+ * @category Error
+ * @description Error that indicates an invalid dal commitment (sh)
+ */
+class InvalidDalCommitmentError extends ParameterValidationError {
+    constructor(commitment, errorDetail) {
+        super();
+        this.commitment = commitment;
+        this.errorDetail = errorDetail;
+        this.name = 'InvalidDalCommitmentError';
+        this.message = `Invalid dal commitment "${commitment}"`;
+        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
+    }
+}
+
+class Uint8ArrayConsumer {
+    static fromHexString(hex) {
+        const lowHex = hex.toLowerCase();
+        if (/^(([a-f]|\d){2})*$/.test(lowHex)) {
+            const arr = new Uint8Array((lowHex.match(/([a-z]|\d){2}/g) || []).map((byte) => parseInt(byte, 16)));
+            return new Uint8ArrayConsumer(arr);
+        }
+        else {
+            throw new InvalidHexStringError(lowHex);
+        }
+    }
+    constructor(arr, offset = 0) {
+        this.arr = arr;
+        this.offset = offset;
+    }
+    consume(count) {
+        const subArr = this.arr.subarray(this.offset, this.offset + count);
+        this.offset += count;
+        return subArr;
+    }
+    get(idx) {
+        return this.arr[this.offset + idx];
+    }
+    length() {
+        return this.arr.length - this.offset;
+    }
+    slice(start, end) {
+        return new Uint8ArrayConsumer(this.arr.slice(start, end));
     }
 }
-
-const isPrim$1 = (value) => {
-    return 'prim' in value;
-};
-const isBytes$1 = (value) => {
-    return 'bytes' in value && typeof value.bytes === 'string';
-};
-const isString$1 = (value) => {
-    return 'string' in value && typeof value.string === 'string';
-};
-const isInt$1 = (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);
-    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);
-    return {
-        code: valueDecoder$1(new Uint8ArrayConsumer(code)),
-        storage: valueDecoder$1(new Uint8ArrayConsumer(storage)),
-    };
-};
-const valueEncoder$1 = (value) => {
-    if (Array.isArray(value)) {
-        const encoded = value.map((x) => valueEncoder$1(x)).join('');
-        const len = encoded.length / 2;
-        return `02${pad(len)}${encoded}`;
-    }
-    else if (isPrim$1(value)) {
-        return primEncoder$1(value);
-    }
-    else if (isBytes$1(value)) {
-        return bytesEncoder$1(value);
-    }
-    else if (isString$1(value)) {
-        return stringEncoder$1(value);
-    }
-    else if (isInt$1(value)) {
-        return intEncoder$1(value);
-    }
-    throw new UnexpectedMichelsonValueError(JSON.stringify(value));
-};
-const valueDecoder$1 = (value) => {
-    const preamble = value.consume(1);
-    switch (preamble[0]) {
-        case 0x0a:
-            return bytesDecoder$1(value);
-        case 0x01:
-            return stringDecoder$1(value);
-        case 0x00:
-            return intDecoder$1(value);
-        case 0x02: {
-            const val = new Uint8ArrayConsumer(extractRequiredLen$1(value));
-            const results = [];
-            while (val.length() > 0) {
-                results.push(valueDecoder$1(val));
-            }
-            return results;
-        }
-        default:
-            return primDecoder$1(value, preamble);
-    }
-};
-const extractRequiredLen$1 = (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$1 = (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$1 = (value) => {
-    if (!/^([A-Fa-f0-9]{2})*$/.test(value.bytes)) {
-        throw new InvalidHexStringError(value.bytes);
-    }
-    const len = value.bytes.length / 2;
-    return `0a${pad(len)}${value.bytes}`;
-};
-const bytesDecoder$1 = (value) => {
-    const bytes = extractRequiredLen$1(value);
-    return {
-        bytes: Buffer.from(bytes).toString('hex'),
-    };
-};
-const stringEncoder$1 = (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);
-    return {
-        string: Buffer.from(str).toString('utf8'),
-    };
-};
-const intEncoder$1 = ({ int }) => {
-    const num = new 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$1 = (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(numBin.join(''), 2);
-    if (isNegative) {
-        num = num.times(-1);
-    }
-    return {
-        int: num.toFixed(),
-    };
-};
-const primEncoder$1 = (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) : '';
-    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$1 = (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],
-    };
-    if (opMapping$1[op] === 'LAMBDA' || opMapping$1[op] === 'LAMBDA_REC') {
-        value.consume(4);
-    }
-    if (opMapping$1[op] === 'view') {
-        if (argsCount != 0) {
-            return primViewDecoder$1(value, result);
-        }
-        else {
-            return result;
-        }
-    }
-    let combPairArgs;
-    let combPairAnnots;
-    if ((opMapping$1[op] === 'pair' || opMapping$1[op] === 'Pair') && argsCount > 2) {
-        combPairArgs = decodeCombPair$1(value);
-        argsCount = 0;
-        combPairAnnots = decodeAnnots$1(value);
-    }
-    const args = new Array(argsCount).fill(0).map(() => valueDecoder$1(value));
-    if (opMapping$1[op] === 'LAMBDA' || opMapping$1[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$1(value);
-    }
-    return result;
-};
-const primViewDecoder$1 = (value, result) => {
-    value.consume(4);
-    result['args'] = new Array(4).fill(0).map(() => valueDecoder$1(value));
-    value.consume(4);
-    return result;
-};
-const decodeCombPair$1 = (val) => {
-    const array = new Uint8ArrayConsumer(extractRequiredLen$1(val));
-    const args = [];
-    while (array.length() > 0) {
-        args.push(valueDecoder$1(array));
-    }
-    return args;
-};
-const encodeAnnots$1 = (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$1 = (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$1 = (prefix) => (str) => {
-    const [pl] = b58DecodeAndCheckPrefix(str, [prefix]);
-    return buf2hex(pl);
-};
-const prefixDecoder$1 = (pre) => (str) => {
-    const val = str.consume(payloadLength[pre]);
-    return b58Encode(val, pre);
-};
-const tz1Decoder$1 = prefixDecoder$1(PrefixV2.Ed25519PublicKeyHash);
-const branchDecoder$1 = prefixDecoder$1(PrefixV2.BlockHash);
-const publicKeyHashDecoder$1 = (val) => {
-    const prefix = val.consume(1);
-    if (prefix[0] === 0x00) {
-        return prefixDecoder$1(PrefixV2.Ed25519PublicKeyHash)(val);
-    }
-    else if (prefix[0] === 0x01) {
-        return prefixDecoder$1(PrefixV2.Secp256k1PublicKeyHash)(val);
-    }
-    else if (prefix[0] === 0x02) {
-        return prefixDecoder$1(PrefixV2.P256PublicKeyHash)(val);
-    }
-    else if (prefix[0] === 0x03) {
-        return prefixDecoder$1(PrefixV2.BLS12_381PublicKeyHash)(val);
-    }
-};
-const publicKeyHashesDecoder$1 = (val) => {
-    if (!boolDecoder$1(val)) {
-        return;
-    }
-    const publicKeyHashes = [];
-    val.consume(4);
-    while (val.length() > 0) {
-        publicKeyHashes.push(publicKeyHashDecoder$1(val));
-    }
-    return publicKeyHashes;
-};
-const branchEncoder$1 = prefixEncoder$1(PrefixV2.BlockHash);
-const tz1Encoder$1 = prefixEncoder$1(PrefixV2.Ed25519PublicKeyHash);
-const boolEncoder$1 = (bool) => (bool ? 'ff' : '00');
-const proposalEncoder$1 = (proposal) => {
-    return prefixEncoder$1(PrefixV2.ProtocolHash)(proposal);
-};
-const proposalDecoder$1 = (proposal) => {
-    return prefixDecoder$1(PrefixV2.ProtocolHash)(proposal);
-};
-const proposalsDecoder$1 = (proposal) => {
-    const proposals = [];
-    proposal.consume(4);
-    while (proposal.length() > 0) {
-        proposals.push(proposalDecoder$1(proposal));
-    }
-    return proposals;
-};
-const proposalsEncoder$1 = (proposals) => {
-    return pad(32 * proposals.length) + proposals.map((x) => proposalEncoder$1(x)).join('');
-};
-const ballotEncoder$1 = (ballot) => {
-    switch (ballot) {
-        case 'yay':
-            return '00';
-        case 'nay':
-            return '01';
-        case 'pass':
-            return '02';
-        default:
-            throw new InvalidBallotValueError(ballot);
-    }
-};
-const ballotDecoder$1 = (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$1 = (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$1 = (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$1 = (val) => {
-    if (val) {
-        return boolEncoder$1(true) + publicKeyHashEncoder$1(val);
-    }
-    else {
-        return boolEncoder$1(false);
-    }
-};
-const int32Encoder$1 = (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$1 = (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$1 = (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$1 = (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$1 = (val) => {
-    const bool = val.consume(1);
-    return bool[0] === 0xff;
-};
-const delegateDecoder$1 = (val) => {
-    const hasDelegate = boolDecoder$1(val);
-    if (hasDelegate) {
-        return publicKeyHashDecoder$1(val);
-    }
-};
-const publicKeyHashEncoder$1 = (val) => {
-    try {
-        return b58DecodePublicKeyHash(val);
-    }
-    catch (err) {
-        throw new InvalidKeyHashError(val, err instanceof ParameterValidationError ? err.result : undefined);
-    }
-};
-const publicKeyHashesEncoder$1 = (val) => {
-    if (!val) {
-        return boolEncoder$1(false);
-    }
-    if (val.length === 0) {
-        return boolEncoder$1(true) + pad(0);
-    }
-    const publicKeyHashes = val.reduce((prev, curr) => {
-        return prev + publicKeyHashEncoder$1(curr);
-    }, '');
-    return boolEncoder$1(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
-};
-const publicKeyEncoder$1 = (val) => {
-    try {
-        return b58DecodePublicKey(val);
-    }
-    catch (err) {
-        throw new InvalidPublicKeyError(val, err instanceof ParameterValidationError ? err.result : undefined);
-    }
-};
-const addressEncoder$1 = (val) => {
-    return b58DecodeAddress(val);
-};
-const smartRollupAddressEncoder$1 = (val) => {
-    try {
-        return prefixEncoder$1(PrefixV2.SmartRollupHash)(val);
-    }
-    catch (err) {
-        if (err instanceof ParameterValidationError) {
-            throw new InvalidSmartRollupAddressError(val);
-        }
-        else {
-            throw err;
-        }
-    }
-};
-const smartContractAddressEncoder$1 = (val) => b58DecodeAddress(val);
-const publicKeyDecoder$1 = (val) => {
-    const preamble = val.consume(1);
-    switch (preamble[0]) {
-        case 0x00:
-            return prefixDecoder$1(PrefixV2.Ed25519PublicKey)(val);
-        case 0x01:
-            return prefixDecoder$1(PrefixV2.Secp256k1PublicKey)(val);
-        case 0x02:
-            return prefixDecoder$1(PrefixV2.P256PublicKey)(val);
-        case 0x03:
-            return prefixDecoder$1(PrefixV2.BLS12_381PublicKey)(val);
-        default:
-            throw new InvalidPublicKeyError(undefined, ValidationResult.NO_PREFIX_MATCHED);
-    }
-};
-const smartRollupCommitmentHashEncoder$1 = (val) => {
-    try {
-        return prefixEncoder$1(PrefixV2.SmartRollupCommitmentHash)(val);
-    }
-    catch (err) {
-        if (err instanceof ParameterValidationError) {
-            throw new InvalidSmartRollupCommitmentHashError(val);
-        }
-        else {
-            throw err;
-        }
-    }
-};
-const addressDecoder$1 = (val) => {
-    const preamble = val.consume(1);
-    switch (preamble[0]) {
-        case 0x00:
-            return publicKeyHashDecoder$1(val);
-        case 0x01: {
-            const address = prefixDecoder$1(PrefixV2.ContractHash)(val);
-            val.consume(1);
-            return address;
-        }
-        default:
-            throw new InvalidAddressError(val.toString(), ': Unable to decode.');
-    }
-};
-const smartRollupAddressDecoder$1 = (val) => {
-    return prefixDecoder$1(PrefixV2.SmartRollupHash)(val);
-};
-const smartContractAddressDecoder$1 = (val) => {
-    const preamble = val.consume(1);
-    if (preamble[0] === 0x01) {
-        const scAddress = prefixDecoder$1(PrefixV2.ContractHash)(val);
-        val.consume(1);
-        return scAddress;
-    }
-    throw new InvalidContractAddressError(val.toString(), ValidationResult.NO_PREFIX_MATCHED);
-};
-const smartRollupCommitmentHashDecoder$1 = (val) => {
-    return prefixDecoder$1(PrefixV2.SmartRollupCommitmentHash)(val);
-};
-const zarithEncoder$1 = (n) => {
-    const fn = [];
-    let nn = new BigNumber$1(n, 10);
-    if (nn.isNaN()) {
-        throw new TypeError(`Invalid zarith number ${n}`);
-    }
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        if (nn.lt(128)) {
-            if (nn.lt(16))
-                fn.push('0');
-            fn.push(nn.toString(16));
-            break;
-        }
-        else {
-            let b = nn.mod(128);
-            nn = nn.minus(b);
-            nn = nn.dividedBy(128);
-            b = b.plus(128);
-            fn.push(b.toString(16));
-        }
-    }
-    return fn.join('');
-};
-const zarithDecoder$1 = (n) => {
-    let mostSignificantByte = 0;
-    while (mostSignificantByte < n.length() && (n.get(mostSignificantByte) & 128) !== 0) {
-        mostSignificantByte += 1;
-    }
-    let num = new BigNumber$1(0);
-    for (let i = mostSignificantByte; i >= 0; i -= 1) {
-        const tmp = n.get(i) & 0x7f;
-        num = num.multipliedBy(128);
-        num = num.plus(tmp);
-    }
-    n.consume(mostSignificantByte + 1);
-    return new BigNumber$1(num).toString();
-};
-const entrypointDecoder$1 = (value) => {
-    const preamble = pad(value.consume(1)[0], 2);
-    if (preamble in entrypointMapping$1) {
-        return entrypointMapping$1[preamble];
-    }
-    else {
-        const entry = extractRequiredLen$1(value, 1);
-        const entrypoint = Buffer.from(entry).toString('utf8');
-        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
-            throw new OversizedEntryPointError(entrypoint);
-        }
-        return entrypoint;
-    }
-};
-const parametersDecoder$1 = (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));
-        return {
-            entrypoint: encodedEntrypoint,
-            value: parameters,
-        };
-    }
-};
-const entrypointEncoder$1 = (entrypoint) => {
-    if (entrypoint in entrypointMappingReverse$1) {
-        return `${entrypointMappingReverse$1[entrypoint]}`;
-    }
-    else {
-        if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
-            throw new OversizedEntryPointError(entrypoint);
-        }
-        const value = { string: entrypoint };
-        return `ff${valueEncoder$1(value).slice(8)}`;
-    }
-};
-const parametersEncoder$1 = (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 length = pad(parameters.length / 2);
-    return `ff${encodedEntrypoint}${length}${parameters}`;
-};
-const valueParameterEncoder$1 = (value) => {
-    const valueEncoded = valueEncoder$1(value);
-    return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
-};
-const valueParameterDecoder$1 = (val) => {
-    const value = extractRequiredLen$1(val);
-    return valueDecoder$1(new Uint8ArrayConsumer(value));
-};
-const blockPayloadHashEncoder$1 = prefixEncoder$1(PrefixV2.ValueHash);
-const blockPayloadHashDecoder$1 = prefixDecoder$1(PrefixV2.ValueHash);
-const entrypointNameEncoder$1 = (entrypoint) => {
-    const value = { string: entrypoint };
-    return `${valueEncoder$1(value).slice(2)}`;
-};
-const entrypointNameDecoder$1 = (val) => {
-    const entry = extractRequiredLen$1(val);
-    return Buffer.from(entry).toString('utf8');
-};
-const burnLimitEncoder$1 = (val) => {
-    return !val ? '00' : `ff${zarithEncoder$1(val)}`;
-};
-const burnLimitDecoder$1 = (value) => {
-    const prefix = value.consume(1);
-    if (Buffer.from(prefix).toString('hex') !== '00') {
-        return zarithDecoder$1(value);
-    }
-};
-const depositsLimitEncoder$1 = (val) => {
-    return !val ? '00' : `ff${zarithEncoder$1(val)}`;
-};
-const depositsLimitDecoder$1 = (value) => {
-    const prefix = value.consume(1);
-    if (Buffer.from(prefix).toString('hex') !== '00') {
-        return zarithDecoder$1(value);
-    }
-};
-const signatureV1Encoder$1 = (val) => {
-    try {
-        const [data, pre] = b58DecodeAndCheckPrefix(val, signaturePrefixes);
-        if (pre === PrefixV2.BLS12_381Signature) {
-            return paddedBytesEncoder$1(buf2hex(data));
-        }
-        else {
-            throw new ProhibitedActionError('we only support encoding of BLSIG signatures from protocol Seoul');
-        }
-    }
-    catch (err) {
-        if (err instanceof ParameterValidationError) {
-            throw new InvalidSignatureError(val, err.result);
-        }
-        else {
-            throw err;
-        }
-    }
-};
-const signatureV1Decoder$1 = (val) => {
-    val.consume(4);
-    if (val.length().toString() === '96') {
-        return prefixDecoder$1(PrefixV2.BLS12_381Signature)(val);
-    }
-    else {
-        throw new ProhibitedActionError('we only support decoding of BLSIG signatures');
-    }
-};
-const signatureProofEncoder$1 = (val) => {
-    if (val) {
-        return boolEncoder$1(true) + signatureV1Encoder$1(val);
-    }
-    else {
-        return boolEncoder$1(false);
-    }
-};
-const signatureProofDecoder$1 = (value) => {
-    const hasProof = boolDecoder$1(value);
-    if (hasProof) {
-        return signatureV1Decoder$1(value);
-    }
-};
-const paddedBytesEncoder$1 = (val, paddingLength = 8) => {
-    return `${pad(val.length / 2, paddingLength)}${val}`;
-};
-const paddedBytesDecoder$1 = (val) => {
-    const value = extractRequiredLen$1(val);
-    return Buffer.from(value).toString('hex');
-};
-const smartRollupMessageEncoder$1 = (val) => {
-    const message = val.reduce((prev, curr) => {
-        return prev + `${pad(curr.length / 2)}${curr}`;
-    }, '');
-    return `${pad(message.length / 2)}${message}`;
-};
-const smartRollupMessageDecoder$1 = (val) => {
-    const valueArray = extractRequiredLen$1(val);
-    const ret = stripLengthPrefixFromBytes$1(new Uint8ArrayConsumer(valueArray));
-    return ret.map((value) => Buffer.from(value).toString('hex'));
-};
-const dalCommitmentEncoder$1 = (val) => {
-    try {
-        return prefixEncoder$1(PrefixV2.SlotHeader)(val);
-    }
-    catch (err) {
-        if (err instanceof ParameterValidationError) {
-            throw new InvalidDalCommitmentError(val);
-        }
-        else {
-            throw err;
-        }
-    }
-};
-const dalCommitmentDecoder$1 = (val) => {
-    return prefixDecoder$1(PrefixV2.SlotHeader)(val);
-};
-const slotHeaderEncoder$1 = (val) => {
-    return pad(val.slot_index, 2) + dalCommitmentEncoder$1(val.commitment) + val.commitment_proof;
-};
-const slotHeaderDecoder$1 = (val) => {
-    const preamble = val.consume(1);
-    return {
-        slot_index: Number(preamble[0].toString(10)),
-        commitment: dalCommitmentDecoder$1(val),
-        commitment_proof: toHexString(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
-    };
-};
-
-const ManagerOperationSchema$1 = {
-    branch: CODEC$1.BRANCH,
-    contents: [CODEC$1.OPERATION],
-};
-const ActivationSchema$1 = {
-    pkh: CODEC$1.TZ1,
-    secret: CODEC$1.SECRET,
-};
-const RevealSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    public_key: CODEC$1.PUBLIC_KEY,
-    proof: CODEC$1.SIGNATURE_PROOF,
-};
-const DelegationSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    delegate: CODEC$1.DELEGATE,
-};
-const TransactionSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    amount: CODEC$1.ZARITH,
-    destination: CODEC$1.ADDRESS,
-    parameters: CODEC$1.PARAMETERS,
-};
-const OriginationSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    balance: CODEC$1.ZARITH,
-    delegate: CODEC$1.DELEGATE,
-    script: CODEC$1.SCRIPT,
-};
-const BallotSchema$1 = {
-    source: CODEC$1.PKH,
-    period: CODEC$1.INT32,
-    proposal: CODEC$1.PROPOSAL,
-    ballot: CODEC$1.BALLOT_STATEMENT,
-};
-const AttestationSchema$1 = {
-    slot: CODEC$1.INT16,
-    level: CODEC$1.INT32,
-    round: CODEC$1.INT32,
-    block_payload_hash: CODEC$1.BLOCK_PAYLOAD_HASH,
-};
-const AttestationWithDalSchema$1 = {
-    slot: CODEC$1.INT16,
-    level: CODEC$1.INT32,
-    round: CODEC$1.INT32,
-    block_payload_hash: CODEC$1.BLOCK_PAYLOAD_HASH,
-    dal_attestation: CODEC$1.ZARITH,
-};
-const SeedNonceRevelationSchema$1 = {
-    level: CODEC$1.INT32,
-    nonce: CODEC$1.RAW,
-};
-const ProposalsSchema$1 = {
-    source: CODEC$1.PKH,
-    period: CODEC$1.INT32,
-    proposals: CODEC$1.PROPOSAL_ARR,
-};
-const RegisterGlobalConstantSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    value: CODEC$1.VALUE,
-};
-const TransferTicketSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    ticket_contents: CODEC$1.VALUE,
-    ticket_ty: CODEC$1.VALUE,
-    ticket_ticketer: CODEC$1.ADDRESS,
-    ticket_amount: CODEC$1.ZARITH,
-    destination: CODEC$1.ADDRESS,
-    entrypoint: CODEC$1.ENTRYPOINT,
-};
-const IncreasePaidStorageSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    amount: CODEC$1.ZARITH,
-    destination: CODEC$1.SMART_CONTRACT_ADDRESS,
-};
-const UpdateConsensusKeySchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    pk: CODEC$1.PUBLIC_KEY,
-    proof: CODEC$1.SIGNATURE_PROOF,
-};
-const UpdateCompanionKeySchema = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    pk: CODEC$1.PUBLIC_KEY,
-    proof: CODEC$1.SIGNATURE_PROOF,
-};
-const DrainDelegateSchema$1 = {
-    consensus_key: CODEC$1.PKH,
-    delegate: CODEC$1.PKH,
-    destination: CODEC$1.PKH,
-};
-const SetDepositsLimitSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    limit: CODEC$1.DEPOSITS_LIMIT,
-};
-const SmartRollupOriginateSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    pvm_kind: CODEC$1.PVM_KIND,
-    kernel: CODEC$1.PADDED_BYTES,
-    parameters_ty: CODEC$1.VALUE,
-    whitelist: CODEC$1.PKH_ARR,
-};
-const SmartRollupAddMessagesSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    message: CODEC$1.SMART_ROLLUP_MESSAGE,
-};
-const SmartRollupExecuteOutboxMessageSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    rollup: CODEC$1.SMART_ROLLUP_ADDRESS,
-    cemented_commitment: CODEC$1.SMART_ROLLUP_COMMITMENT_HASH,
-    output_proof: CODEC$1.PADDED_BYTES,
-};
-const DalPublishCommitmentSchema$1 = {
-    source: CODEC$1.PKH,
-    fee: CODEC$1.ZARITH,
-    counter: CODEC$1.ZARITH,
-    gas_limit: CODEC$1.ZARITH,
-    storage_limit: CODEC$1.ZARITH,
-    slot_header: CODEC$1.SLOT_HEADER,
-};
-const FailingNoopSchema$1 = {
-    arbitrary: CODEC$1.PADDED_BYTES,
-};
-const operationEncoder$1 = (encoders) => (operation) => {
-    if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse$1)) {
-        throw new InvalidOperationKindError(operation.kind);
-    }
-    return kindMappingReverse$1[operation.kind] + encoders[operation.kind](operation);
-};
-const operationDecoder$1 = (decoders) => (value) => {
-    const op = value.consume(1);
-    const operationName = kindMapping$1[op[0]];
-    if (operationName === undefined) {
-        throw new UnsupportedOperationError(op[0].toString());
-    }
-    const decodedObj = decoders[operationName](value);
-    if (typeof decodedObj !== 'object') {
-        throw new OperationDecodingError('Invalid operation, cannot be decoded.');
-    }
-    return Object.assign({ kind: operationName }, decodedObj);
-};
-const schemaEncoder$1 = (encoders) => (schema) => (value) => {
-    const keys = Object.keys(schema);
-    return keys.reduce((prev, key) => {
-        const valueToEncode = schema[key];
-        if (value && Array.isArray(valueToEncode)) {
-            const encoder = encoders[valueToEncode[0]];
-            const values = value[key];
-            if (!Array.isArray(values)) {
-                throw new OperationEncodingError(`Invalid operation value "${JSON.stringify(values)}" of key "${key}, expected value to be Array.`);
-            }
-            return (prev + values.reduce((prevBytes, current) => prevBytes + encoder(current), ''));
-        }
-        else {
-            const encoder = encoders[valueToEncode];
-            return prev + encoder(value[key]);
-        }
-    }, '');
-};
-const schemaDecoder$1 = (decoders) => (schema) => (value) => {
-    const keys = Object.keys(schema);
-    return keys.reduce((prev, key) => {
-        const valueToEncode = schema[key];
-        if (Array.isArray(valueToEncode)) {
-            const decoder = decoders[valueToEncode[0]];
-            const decoded = [];
-            const lastLength = value.length();
-            while (value.length() > 0) {
-                decoded.push(decoder(value));
-                if (lastLength === value.length()) {
-                    throw new OperationDecodingError('Unable to decode value');
-                }
-            }
-            return Object.assign(Object.assign({}, prev), { [key]: decoded });
-        }
-        else {
-            const decoder = decoders[valueToEncode];
-            const result = decoder(value);
-            if (typeof result !== 'undefined') {
-                return Object.assign(Object.assign({}, prev), { [key]: result });
-            }
-            else {
-                return Object.assign({}, prev);
-            }
-        }
-    }, {});
-};
-
-const decoders$1 = {
-    [CODEC$1.SECRET]: (val) => toHexString(val.consume(20)),
-    [CODEC$1.RAW]: (val) => toHexString(val.consume(32)),
-    [CODEC$1.TZ1]: tz1Decoder$1,
-    [CODEC$1.BRANCH]: branchDecoder$1,
-    [CODEC$1.ZARITH]: zarithDecoder$1,
-    [CODEC$1.PUBLIC_KEY]: publicKeyDecoder$1,
-    [CODEC$1.PKH]: publicKeyHashDecoder$1,
-    [CODEC$1.PKH_ARR]: publicKeyHashesDecoder$1,
-    [CODEC$1.DELEGATE]: delegateDecoder$1,
-    [CODEC$1.INT32]: int32Decoder$1,
-    [CODEC$1.SCRIPT]: scriptDecoder$1,
-    [CODEC$1.BALLOT_STATEMENT]: ballotDecoder$1,
-    [CODEC$1.PROPOSAL]: proposalDecoder$1,
-    [CODEC$1.PROPOSAL_ARR]: proposalsDecoder$1,
-    [CODEC$1.PARAMETERS]: parametersDecoder$1,
-    [CODEC$1.ADDRESS]: addressDecoder$1,
-    [CODEC$1.SMART_ROLLUP_ADDRESS]: smartRollupAddressDecoder$1,
-    [CODEC$1.SMART_CONTRACT_ADDRESS]: smartContractAddressDecoder$1,
-    [CODEC$1.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashDecoder$1,
-    [CODEC$1.VALUE]: valueParameterDecoder$1,
-    [CODEC$1.INT16]: int16Decoder$1,
-    [CODEC$1.BLOCK_PAYLOAD_HASH]: blockPayloadHashDecoder$1,
-    [CODEC$1.ENTRYPOINT]: entrypointNameDecoder$1,
-    [CODEC$1.BURN_LIMIT]: burnLimitDecoder$1,
-    [CODEC$1.DEPOSITS_LIMIT]: depositsLimitDecoder$1,
-    [CODEC$1.SIGNATURE_PROOF]: signatureProofDecoder$1,
-    [CODEC$1.PVM_KIND]: pvmKindDecoder$1,
-    [CODEC$1.PADDED_BYTES]: paddedBytesDecoder$1,
-    [CODEC$1.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder$1,
-    [CODEC$1.SLOT_HEADER]: slotHeaderDecoder$1,
-};
-decoders$1[CODEC$1.OPERATION] = operationDecoder$1(decoders$1);
-decoders$1[CODEC$1.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder$1(decoders$1)(ActivationSchema$1)(val);
-decoders$1[CODEC$1.OP_FAILING_NOOP] = (val) => schemaDecoder$1(decoders$1)(FailingNoopSchema$1)(val);
-decoders$1[CODEC$1.OP_DELEGATION] = (val) => schemaDecoder$1(decoders$1)(DelegationSchema$1)(val);
-decoders$1[CODEC$1.OP_TRANSACTION] = (val) => schemaDecoder$1(decoders$1)(TransactionSchema$1)(val);
-decoders$1[CODEC$1.OP_ORIGINATION] = (val) => schemaDecoder$1(decoders$1)(OriginationSchema$1)(val);
-decoders$1[CODEC$1.OP_BALLOT] = (val) => schemaDecoder$1(decoders$1)(BallotSchema$1)(val);
-decoders$1[CODEC$1.OP_ATTESTATION] = (val) => schemaDecoder$1(decoders$1)(AttestationSchema$1)(val);
-decoders$1[CODEC$1.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder$1(decoders$1)(AttestationWithDalSchema$1)(val);
-decoders$1[CODEC$1.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder$1(decoders$1)(SeedNonceRevelationSchema$1)(val);
-decoders$1[CODEC$1.OP_PROPOSALS] = (val) => schemaDecoder$1(decoders$1)(ProposalsSchema$1)(val);
-decoders$1[CODEC$1.OP_REVEAL] = (val) => schemaDecoder$1(decoders$1)(RevealSchema$1)(val);
-decoders$1[CODEC$1.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder$1(decoders$1)(RegisterGlobalConstantSchema$1)(val);
-decoders$1[CODEC$1.OP_TRANSFER_TICKET] = (val) => schemaDecoder$1(decoders$1)(TransferTicketSchema$1)(val);
-decoders$1[CODEC$1.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder$1(decoders$1)(IncreasePaidStorageSchema$1)(val);
-decoders$1[CODEC$1.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder$1(decoders$1)(UpdateConsensusKeySchema$1)(val);
-decoders$1[CODEC$1.OP_UPDATE_COMPANION_KEY] = (val) => schemaDecoder$1(decoders$1)(UpdateCompanionKeySchema)(val);
-decoders$1[CODEC$1.OP_DRAIN_DELEGATE] = (val) => schemaDecoder$1(decoders$1)(DrainDelegateSchema$1)(val);
-decoders$1[CODEC$1.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder$1(decoders$1)(SmartRollupOriginateSchema$1)(val);
-decoders$1[CODEC$1.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder$1(decoders$1)(SmartRollupAddMessagesSchema$1)(val);
-decoders$1[CODEC$1.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder$1(decoders$1)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-decoders$1[CODEC$1.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder$1(decoders$1)(DalPublishCommitmentSchema$1)(val);
-decoders$1[CODEC$1.MANAGER] = schemaDecoder$1(decoders$1)(ManagerOperationSchema$1);
-decoders$1[CODEC$1.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder$1(decoders$1)(SetDepositsLimitSchema$1)(val);
-
-/*
- * Some code in this file is originally from sotez
- * Copyright (c) 2018 Andrew Kishino
- */
-// See: https://tezos.gitlab.io/protocols/005_babylon.html#transactions-now-have-an-entrypoint
-const ENTRYPOINT_MAX_LENGTH = 31;
-var CODEC;
-(function (CODEC) {
-    CODEC["SECRET"] = "secret";
-    CODEC["RAW"] = "raw";
-    CODEC["TZ1"] = "tz1";
-    CODEC["BRANCH"] = "branch";
-    CODEC["ZARITH"] = "zarith";
-    CODEC["PUBLIC_KEY"] = "public_key";
-    CODEC["PKH"] = "pkh";
-    CODEC["PKH_ARR"] = "pkhArr";
-    CODEC["DELEGATE"] = "delegate";
-    CODEC["SCRIPT"] = "script";
-    CODEC["BALLOT_STATEMENT"] = "ballotStmt";
-    CODEC["PROPOSAL"] = "proposal";
-    CODEC["PROPOSAL_ARR"] = "proposalArr";
-    CODEC["INT32"] = "int32";
-    CODEC["INT16"] = "int16";
-    CODEC["PARAMETERS"] = "parameters";
-    CODEC["ADDRESS"] = "address";
-    CODEC["SMART_CONTRACT_ADDRESS"] = "smart_contract_address";
-    CODEC["SMART_ROLLUP_ADDRESS"] = "smart_rollup_address";
-    CODEC["SMART_ROLLUP_COMMITMENT_HASH"] = "smart_rollup_commitment_hash";
-    CODEC["VALUE"] = "value";
-    CODEC["PADDED_BYTES"] = "padded_bytes";
-    CODEC["SMART_ROLLUP_MESSAGE"] = "smart_rollup_message";
-    CODEC["MANAGER"] = "manager";
-    CODEC["BLOCK_PAYLOAD_HASH"] = "blockPayloadHash";
-    CODEC["ENTRYPOINT"] = "entrypoint";
-    CODEC["OPERATION"] = "operation";
-    CODEC["OP_ACTIVATE_ACCOUNT"] = "activate_account";
-    CODEC["OP_DELEGATION"] = "delegation";
-    CODEC["OP_TRANSACTION"] = "transaction";
-    CODEC["OP_ORIGINATION"] = "origination";
-    CODEC["OP_BALLOT"] = "ballot";
-    CODEC["OP_FAILING_NOOP"] = "failing_noop";
-    CODEC["OP_ATTESTATION"] = "attestation";
-    CODEC["OP_ATTESTATION_WITH_DAL"] = "attestation_with_dal";
-    CODEC["OP_SEED_NONCE_REVELATION"] = "seed_nonce_revelation";
-    CODEC["OP_REVEAL"] = "reveal";
-    CODEC["OP_PROPOSALS"] = "proposals";
-    CODEC["OP_REGISTER_GLOBAL_CONSTANT"] = "register_global_constant";
-    CODEC["OP_TRANSFER_TICKET"] = "transfer_ticket";
-    CODEC["BURN_LIMIT"] = "burn_limit";
-    CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
-    CODEC["OP_UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
-    CODEC["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;
@@ -2046,28 +743,29 @@ const decodeAnnots = (val) => {
 };
 
 // https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
-const prefixEncoder = (prefix$1) => (str) => {
-    return buf2hex(Buffer.from(b58cdecode(str, prefix[prefix$1])));
+const prefixEncoder = (prefix) => (str) => {
+    const [pl] = b58DecodeAndCheckPrefix(str, [prefix]);
+    return buf2hex(pl);
 };
 const prefixDecoder = (pre) => (str) => {
-    const val = str.consume(prefixLength[pre]);
-    return b58cencode(val, prefix[pre]);
+    const val = str.consume(payloadLength[pre]);
+    return b58Encode(val, pre);
 };
-const tz1Decoder = prefixDecoder(Prefix.TZ1);
-const branchDecoder = prefixDecoder(Prefix.B);
+const tz1Decoder = prefixDecoder(PrefixV2.Ed25519PublicKeyHash);
+const branchDecoder = prefixDecoder(PrefixV2.BlockHash);
 const publicKeyHashDecoder = (val) => {
     const prefix = val.consume(1);
     if (prefix[0] === 0x00) {
-        return prefixDecoder(Prefix.TZ1)(val);
+        return prefixDecoder(PrefixV2.Ed25519PublicKeyHash)(val);
     }
     else if (prefix[0] === 0x01) {
-        return prefixDecoder(Prefix.TZ2)(val);
+        return prefixDecoder(PrefixV2.Secp256k1PublicKeyHash)(val);
     }
     else if (prefix[0] === 0x02) {
-        return prefixDecoder(Prefix.TZ3)(val);
+        return prefixDecoder(PrefixV2.P256PublicKeyHash)(val);
     }
     else if (prefix[0] === 0x03) {
-        return prefixDecoder(Prefix.TZ4)(val);
+        return prefixDecoder(PrefixV2.BLS12_381PublicKeyHash)(val);
     }
 };
 const publicKeyHashesDecoder = (val) => {
@@ -2081,14 +779,14 @@ const publicKeyHashesDecoder = (val) => {
     }
     return publicKeyHashes;
 };
-const branchEncoder = prefixEncoder(Prefix.B);
-const tz1Encoder = prefixEncoder(Prefix.TZ1);
+const branchEncoder = prefixEncoder(PrefixV2.BlockHash);
+const tz1Encoder = prefixEncoder(PrefixV2.Ed25519PublicKeyHash);
 const boolEncoder = (bool) => (bool ? 'ff' : '00');
 const proposalEncoder = (proposal) => {
-    return prefixEncoder(Prefix.P)(proposal);
+    return prefixEncoder(PrefixV2.ProtocolHash)(proposal);
 };
 const proposalDecoder = (proposal) => {
-    return prefixDecoder(Prefix.P)(proposal);
+    return prefixDecoder(PrefixV2.ProtocolHash)(proposal);
 };
 const proposalsDecoder = (proposal) => {
     const proposals = [];
@@ -2204,19 +902,11 @@ const delegateDecoder = (val) => {
     }
 };
 const publicKeyHashEncoder = (val) => {
-    const pubkeyPrefix = val.substring(0, 3);
-    switch (pubkeyPrefix) {
-        case Prefix.TZ1:
-            return '00' + prefixEncoder(Prefix.TZ1)(val);
-        case Prefix.TZ2:
-            return '01' + prefixEncoder(Prefix.TZ2)(val);
-        case Prefix.TZ3:
-            return '02' + prefixEncoder(Prefix.TZ3)(val);
-        case Prefix.TZ4:
-            return '03' + prefixEncoder(Prefix.TZ4)(val);
-        default:
-            throw new InvalidKeyHashError$1(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one for the following "${Prefix.TZ1}", "${Prefix.TZ2}", "${Prefix.TZ3}" or "${Prefix.TZ4}".`);
+    try {
+        return b58DecodePublicKeyHash(val);
+    }
+    catch (err) {
+        throw new InvalidKeyHashError(val, err instanceof ParameterValidationError ? err.result : undefined);
     }
 };
 const publicKeyHashesEncoder = (val) => {
@@ -2232,70 +922,57 @@ const publicKeyHashesEncoder = (val) => {
     return boolEncoder(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
 };
 const publicKeyEncoder = (val) => {
-    const pubkeyPrefix = val.substring(0, 4);
-    switch (pubkeyPrefix) {
-        case Prefix.EDPK:
-            return '00' + prefixEncoder(Prefix.EDPK)(val);
-        case Prefix.SPPK:
-            return '01' + prefixEncoder(Prefix.SPPK)(val);
-        case Prefix.P2PK:
-            return '02' + prefixEncoder(Prefix.P2PK)(val);
-        case Prefix.BLPK:
-            return '03' + prefixEncoder(Prefix.BLPK)(val);
-        default:
-            throw new InvalidPublicKeyError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following '${Prefix.EDPK}', '${Prefix.SPPK}', '${Prefix.P2PK}' or '${Prefix.BLPK}'.`);
+    try {
+        return b58DecodePublicKey(val);
+    }
+    catch (err) {
+        throw new InvalidPublicKeyError(val, err instanceof ParameterValidationError ? err.result : undefined);
     }
 };
 const addressEncoder = (val) => {
-    const pubkeyPrefix = val.substring(0, 3);
-    switch (pubkeyPrefix) {
-        case Prefix.TZ1:
-        case Prefix.TZ2:
-        case Prefix.TZ3:
-        case Prefix.TZ4:
-            return '00' + publicKeyHashEncoder(val);
-        case Prefix.KT1:
-            return '01' + prefixEncoder(Prefix.KT1)(val) + '00';
-        default:
-            throw new InvalidAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following prefix '${Prefix.TZ1}', ${Prefix.TZ2}', '${Prefix.TZ3}', '${Prefix.TZ4}' or '${Prefix.KT1}'.`);
-    }
+    return b58DecodeAddress(val);
 };
 const smartRollupAddressEncoder = (val) => {
-    if (val.substring(0, 3) !== Prefix.SR1) {
-        throw new InvalidSmartRollupAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SR1}'.`);
+    try {
+        return prefixEncoder(PrefixV2.SmartRollupHash)(val);
     }
-    return prefixEncoder(Prefix.SR1)(val);
-};
-const smartContractAddressEncoder = (val) => {
-    const prefix = val.substring(0, 3);
-    if (prefix === Prefix.KT1) {
-        return '01' + prefixEncoder(Prefix.KT1)(val) + '00';
+    catch (err) {
+        if (err instanceof ParameterValidationError) {
+            throw new InvalidSmartRollupAddressError(val);
+        }
+        else {
+            throw err;
+        }
     }
-    throw new InvalidContractAddressError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.KT1}'.`);
 };
+const smartContractAddressEncoder = (val) => b58DecodeAddress(val);
 const publicKeyDecoder = (val) => {
     const preamble = val.consume(1);
     switch (preamble[0]) {
         case 0x00:
-            return prefixDecoder(Prefix.EDPK)(val);
+            return prefixDecoder(PrefixV2.Ed25519PublicKey)(val);
         case 0x01:
-            return prefixDecoder(Prefix.SPPK)(val);
+            return prefixDecoder(PrefixV2.Secp256k1PublicKey)(val);
         case 0x02:
-            return prefixDecoder(Prefix.P2PK)(val);
+            return prefixDecoder(PrefixV2.P256PublicKey)(val);
         case 0x03:
-            return prefixDecoder(Prefix.BLPK)(val);
+            return prefixDecoder(PrefixV2.BLS12_381PublicKey)(val);
         default:
-            throw new InvalidPublicKeyError(val.toString(), invalidDetail(ValidationResult.NO_PREFIX_MATCHED));
+            throw new InvalidPublicKeyError(undefined, ValidationResult.NO_PREFIX_MATCHED);
     }
 };
 const smartRollupCommitmentHashEncoder = (val) => {
-    const prefix = val.substring(0, 4);
-    if (prefix === Prefix.SRC1) {
-        return prefixEncoder(Prefix.SRC1)(val);
+    try {
+        return prefixEncoder(PrefixV2.SmartRollupCommitmentHash)(val);
+    }
+    catch (err) {
+        if (err instanceof ParameterValidationError) {
+            throw new InvalidSmartRollupCommitmentHashError(val);
+        }
+        else {
+            throw err;
+        }
     }
-    throw new InvalidSmartRollupCommitmentHashError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SRC1}'`);
 };
 const addressDecoder = (val) => {
     const preamble = val.consume(1);
@@ -2303,7 +980,7 @@ const addressDecoder = (val) => {
         case 0x00:
             return publicKeyHashDecoder(val);
         case 0x01: {
-            const address = prefixDecoder(Prefix.KT1)(val);
+            const address = prefixDecoder(PrefixV2.ContractHash)(val);
             val.consume(1);
             return address;
         }
@@ -2312,27 +989,19 @@ const addressDecoder = (val) => {
     }
 };
 const smartRollupAddressDecoder = (val) => {
-    const address = prefixDecoder(Prefix.SR1)(val);
-    if (address.substring(0, 3) !== Prefix.SR1) {
-        throw new InvalidSmartRollupAddressError(address, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SR1}'.`);
-    }
-    return address;
+    return prefixDecoder(PrefixV2.SmartRollupHash)(val);
 };
 const smartContractAddressDecoder = (val) => {
     const preamble = val.consume(1);
     if (preamble[0] === 0x01) {
-        const scAddress = prefixDecoder(Prefix.KT1)(val);
+        const scAddress = prefixDecoder(PrefixV2.ContractHash)(val);
         val.consume(1);
         return scAddress;
     }
-    throw new InvalidContractAddressError(val.toString(), invalidDetail(ValidationResult.NO_PREFIX_MATCHED));
+    throw new InvalidContractAddressError(val.toString(), ValidationResult.NO_PREFIX_MATCHED);
 };
 const smartRollupCommitmentHashDecoder = (val) => {
-    const address = prefixDecoder(Prefix.SRC1)(val);
-    if (address.substring(0, 4) !== Prefix.SRC1) {
-        throw new InvalidSmartRollupCommitmentHashError(address, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SRC1}'`);
-    }
-    return address;
+    return prefixDecoder(PrefixV2.SmartRollupCommitmentHash)(val);
 };
 const zarithEncoder = (n) => {
     const fn = [];
@@ -2430,8 +1099,8 @@ const valueParameterDecoder = (val) => {
     const value = extractRequiredLen(val);
     return valueDecoder(new Uint8ArrayConsumer(value));
 };
-const blockPayloadHashEncoder = prefixEncoder(Prefix.VH);
-const blockPayloadHashDecoder = prefixDecoder(Prefix.VH);
+const blockPayloadHashEncoder = prefixEncoder(PrefixV2.ValueHash);
+const blockPayloadHashDecoder = prefixDecoder(PrefixV2.ValueHash);
 const entrypointNameEncoder = (entrypoint) => {
     const value = { string: entrypoint };
     return `${valueEncoder(value).slice(2)}`;
@@ -2459,28 +1128,31 @@ const depositsLimitDecoder = (value) => {
     }
 };
 const signatureV1Encoder = (val) => {
-    const signaturePrefix = val.substring(0, 5);
-    switch (signaturePrefix) {
-        case Prefix.EDSIG:
-            return paddedBytesEncoder(prefixEncoder(Prefix.EDSIG)(val));
-        case Prefix.SPSIG:
-            return paddedBytesEncoder(prefixEncoder(Prefix.SPSIG)(val));
-        case Prefix.P2SIG:
-            return paddedBytesEncoder(prefixEncoder(Prefix.P2SIG)(val));
-        case Prefix.BLSIG:
-            return paddedBytesEncoder(prefixEncoder(Prefix.BLSIG)(val));
-        default:
-            throw new InvalidSignatureError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following '${Prefix.EDSIG}', '${Prefix.SPSIG}', '${Prefix.P2SIG}' or '${Prefix.BLSIG}'.`);
+    try {
+        const [data, pre] = b58DecodeAndCheckPrefix(val, signaturePrefixes);
+        if (pre === PrefixV2.BLS12_381Signature) {
+            return paddedBytesEncoder(buf2hex(data));
+        }
+        else {
+            throw new ProhibitedActionError('we only support encoding of BLSIG signatures from protocol Seoul');
+        }
+    }
+    catch (err) {
+        if (err instanceof ParameterValidationError) {
+            throw new InvalidSignatureError(val, err.result);
+        }
+        else {
+            throw err;
+        }
     }
 };
 const signatureV1Decoder = (val) => {
     val.consume(4);
     if (val.length().toString() === '96') {
-        return prefixDecoder(Prefix.BLSIG)(val);
+        return prefixDecoder(PrefixV2.BLS12_381Signature)(val);
     }
     else {
-        throw new ProhibitedActionError('currently we only support decoding of BLSIG signatures');
+        throw new ProhibitedActionError('we only support decoding of BLSIG signatures');
     }
 };
 const signatureProofEncoder = (val) => {
@@ -2516,18 +1188,20 @@ const smartRollupMessageDecoder = (val) => {
     return ret.map((value) => Buffer.from(value).toString('hex'));
 };
 const dalCommitmentEncoder = (val) => {
-    const prefix = val.substring(0, 2);
-    if (prefix === Prefix.SH) {
-        return prefixEncoder(Prefix.SH)(val);
+    try {
+        return prefixEncoder(PrefixV2.SlotHeader)(val);
+    }
+    catch (err) {
+        if (err instanceof ParameterValidationError) {
+            throw new InvalidDalCommitmentError(val);
+        }
+        else {
+            throw err;
+        }
     }
-    throw new InvalidDalCommitmentError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
 };
 const dalCommitmentDecoder = (val) => {
-    const commitment = prefixDecoder(Prefix.SH)(val);
-    if (commitment.substring(0, 2) !== Prefix.SH) {
-        throw new InvalidDalCommitmentError(commitment, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
-    }
-    return commitment;
+    return prefixDecoder(PrefixV2.SlotHeader)(val);
 };
 const slotHeaderEncoder = (val) => {
     return pad(val.slot_index, 2) + dalCommitmentEncoder(val.commitment) + val.commitment_proof;
@@ -2556,6 +1230,7 @@ const RevealSchema = {
     gas_limit: CODEC.ZARITH,
     storage_limit: CODEC.ZARITH,
     public_key: CODEC.PUBLIC_KEY,
+    proof: CODEC.SIGNATURE_PROOF,
 };
 const DelegationSchema = {
     source: CODEC.PKH,
@@ -2652,6 +1327,15 @@ const UpdateConsensusKeySchema = {
     pk: CODEC.PUBLIC_KEY,
     proof: CODEC.SIGNATURE_PROOF,
 };
+const UpdateCompanionKeySchema = {
+    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,
@@ -2818,6 +1502,7 @@ decoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decoders)(R
 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_UPDATE_COMPANION_KEY] = (val) => schemaDecoder(decoders)(UpdateCompanionKeySchema)(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);
@@ -2826,63 +1511,6 @@ decoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decoders)(Dal
 decoders[CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
 decoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decoders)(SetDepositsLimitSchema)(val);
 
-const encoders$1 = {
-    [CODEC$1.SECRET]: (val) => val,
-    [CODEC$1.RAW]: (val) => val,
-    [CODEC$1.TZ1]: tz1Encoder$1,
-    [CODEC$1.BRANCH]: branchEncoder$1,
-    [CODEC$1.ZARITH]: zarithEncoder$1,
-    [CODEC$1.PUBLIC_KEY]: publicKeyEncoder$1,
-    [CODEC$1.PKH]: publicKeyHashEncoder$1,
-    [CODEC$1.PKH_ARR]: publicKeyHashesEncoder$1,
-    [CODEC$1.DELEGATE]: delegateEncoder$1,
-    [CODEC$1.SCRIPT]: scriptEncoder$1,
-    [CODEC$1.BALLOT_STATEMENT]: ballotEncoder$1,
-    [CODEC$1.PROPOSAL]: proposalEncoder$1,
-    [CODEC$1.PROPOSAL_ARR]: proposalsEncoder$1,
-    [CODEC$1.INT32]: int32Encoder$1,
-    [CODEC$1.PARAMETERS]: parametersEncoder$1,
-    [CODEC$1.ADDRESS]: addressEncoder$1,
-    [CODEC$1.SMART_ROLLUP_ADDRESS]: smartRollupAddressEncoder$1,
-    [CODEC$1.SMART_CONTRACT_ADDRESS]: smartContractAddressEncoder$1,
-    [CODEC$1.SMART_ROLLUP_COMMITMENT_HASH]: smartRollupCommitmentHashEncoder$1,
-    [CODEC$1.VALUE]: valueParameterEncoder$1,
-    [CODEC$1.INT16]: int16Encoder$1,
-    [CODEC$1.BLOCK_PAYLOAD_HASH]: blockPayloadHashEncoder$1,
-    [CODEC$1.ENTRYPOINT]: entrypointNameEncoder$1,
-    [CODEC$1.BURN_LIMIT]: burnLimitEncoder$1,
-    [CODEC$1.DEPOSITS_LIMIT]: depositsLimitEncoder$1,
-    [CODEC$1.SIGNATURE_PROOF]: signatureProofEncoder$1,
-    [CODEC$1.PVM_KIND]: pvmKindEncoder$1,
-    [CODEC$1.PADDED_BYTES]: paddedBytesEncoder$1,
-    [CODEC$1.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder$1,
-    [CODEC$1.SLOT_HEADER]: slotHeaderEncoder$1,
-};
-encoders$1[CODEC$1.OPERATION] = operationEncoder$1(encoders$1);
-encoders$1[CODEC$1.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder$1(encoders$1)(ActivationSchema$1)(val);
-encoders$1[CODEC$1.OP_DELEGATION] = (val) => schemaEncoder$1(encoders$1)(DelegationSchema$1)(val);
-encoders$1[CODEC$1.OP_TRANSACTION] = (val) => schemaEncoder$1(encoders$1)(TransactionSchema$1)(val);
-encoders$1[CODEC$1.OP_ORIGINATION] = (val) => schemaEncoder$1(encoders$1)(OriginationSchema$1)(val);
-encoders$1[CODEC$1.OP_BALLOT] = (val) => schemaEncoder$1(encoders$1)(BallotSchema$1)(val);
-encoders$1[CODEC$1.OP_ATTESTATION] = (val) => schemaEncoder$1(encoders$1)(AttestationSchema$1)(val);
-encoders$1[CODEC$1.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder$1(encoders$1)(AttestationWithDalSchema$1)(val);
-encoders$1[CODEC$1.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder$1(encoders$1)(SeedNonceRevelationSchema$1)(val);
-encoders$1[CODEC$1.OP_PROPOSALS] = (val) => schemaEncoder$1(encoders$1)(ProposalsSchema$1)(val);
-encoders$1[CODEC$1.OP_REVEAL] = (val) => schemaEncoder$1(encoders$1)(RevealSchema$1)(val);
-encoders$1[CODEC$1.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder$1(encoders$1)(RegisterGlobalConstantSchema$1)(val);
-encoders$1[CODEC$1.OP_TRANSFER_TICKET] = (val) => schemaEncoder$1(encoders$1)(TransferTicketSchema$1)(val);
-encoders$1[CODEC$1.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder$1(encoders$1)(IncreasePaidStorageSchema$1)(val);
-encoders$1[CODEC$1.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder$1(encoders$1)(UpdateConsensusKeySchema$1)(val);
-encoders$1[CODEC$1.OP_UPDATE_COMPANION_KEY] = (val) => schemaEncoder$1(encoders$1)(UpdateCompanionKeySchema)(val);
-encoders$1[CODEC$1.OP_DRAIN_DELEGATE] = (val) => schemaEncoder$1(encoders$1)(DrainDelegateSchema$1)(val);
-encoders$1[CODEC$1.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder$1(encoders$1)(SmartRollupOriginateSchema$1)(val);
-encoders$1[CODEC$1.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder$1(encoders$1)(SmartRollupAddMessagesSchema$1)(val);
-encoders$1[CODEC$1.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder$1(encoders$1)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-encoders$1[CODEC$1.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder$1(encoders$1)(DalPublishCommitmentSchema$1)(val);
-encoders$1[CODEC$1.MANAGER] = schemaEncoder$1(encoders$1)(ManagerOperationSchema$1);
-encoders$1[CODEC$1.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder$1(encoders$1)(SetDepositsLimitSchema$1)(val);
-encoders$1[CODEC$1.OP_FAILING_NOOP] = (val) => schemaEncoder$1(encoders$1)(FailingNoopSchema$1)(val);
-
 const encoders = {
     [CODEC.SECRET]: (val) => val,
     [CODEC.RAW]: (val) => val,
@@ -2930,6 +1558,7 @@ encoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encoders)(R
 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_UPDATE_COMPANION_KEY] = (val) => schemaEncoder(encoders)(UpdateCompanionKeySchema)(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);
@@ -2940,28 +1569,28 @@ encoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encoders)(SetDepo
 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,
+    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$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,
+    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) => {
@@ -3015,41 +1644,14 @@ var ProtocolsHash;
     ProtocolsHash["PsQuebecn"] = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg";
     ProtocolsHash["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
     ProtocolsHash["PtSeouLou"] = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh";
+    ProtocolsHash["PtTALLiNt"] = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu";
     ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(ProtocolsHash || (ProtocolsHash = {}));
-const protoLevel = {
-    Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd: 4,
-    PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU: 5,
-    PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS: 5,
-    PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb: 6,
-    PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo: 7,
-    PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA: 8,
-    PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i: 9,
-    PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV: 10,
-    PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx: 11,
-    Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A: 12,
-    PtJakart2xVj7pYXJBXrqHgd82rdkLey5ZeeGwDgPp9rhQUbSqY: 13,
-    PtKathmankSpLLDALzWw7CGD2j2MtyveTwboEYokqUCP4a1LxMg: 14,
-    PtLimaPtLMwfNinJi9rCfDPWea8dFgTZ1MeJ9f1m2SRic6ayiwW: 15,
-    PtMumbaiiFFEGbew1rRjzSPyzRbA51Tm3RVZL5suHPxSZYDhCEc: 16,
-    PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1: 16,
-    PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf: 17,
-    ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH: 19,
-    PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ: 20,
-    PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi: 20,
-    PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg: 21,
-    PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7: 22,
-    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"
 };
 
 /**
@@ -3062,40 +1664,20 @@ if (typeof globalThis.TextEncoder === 'undefined') {
 if (typeof globalThis.TextDecoder === 'undefined') {
     globalThis.TextDecoder = TextDecoder;
 }
-const PROTOCOL_CURRENT = ProtocolsHash.PtSeouLou;
+const PROTOCOL_CURRENT = ProtocolsHash.PtTALLiNt;
 function getCodec(codec, _proto) {
-    // use encodersProto022 & decodersProto022 if it's rio or prior
-    if (_proto === ProtocolsHash.PsRiotuma || ProtoInferiorTo(_proto, 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) {
         this.protocolHash = protocolHash;
-        this.codec = getCodec(CODEC$1.MANAGER, this.protocolHash);
+        this.codec = getCodec(CODEC.MANAGER, this.protocolHash);
     }
     forge(params) {
         const branchValidation = validateBlock(params.branch);
@@ -3149,5 +1731,5 @@ class LocalForger {
 }
 const localForger = new LocalForger();
 
-export { CODEC$1 as CODEC, LocalForger, ProtocolsHash, Uint8ArrayConsumer, VERSION, decoders$1 as decoders, encoders$1 as encoders, getCodec, localForger, opMapping$1 as opMapping, opMappingReverse$1 as opMappingReverse };
+export { CODEC, LocalForger, ProtocolsHash, Uint8ArrayConsumer, VERSION, decoders, encoders, getCodec, localForger, opMapping, opMappingReverse };
 //# sourceMappingURL=taquito-local-forging.es6.js.map