@taquito/local-forging 13.0.0 → 14.0.0

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

@@ -1,4 +1,4 @@
-import { Prefix, prefixLength, b58cencode, prefix, buf2hex, b58cdecode, InvalidKeyHashError, InvalidPublicKeyError, InvalidAddressError, InvalidOperationKindError, validateBlock, ValidationResult } from '@taquito/utils';
+import { Prefix, prefixLength, b58cencode, prefix, buf2hex, b58cdecode, InvalidKeyHashError, InvalidPublicKeyError, InvalidAddressError, InvalidContractAddressError, InvalidOperationKindError, validateBlock, ValidationResult } from '@taquito/utils';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 
 const toHexString = (bytes) => bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
@@ -30,6 +30,7 @@ var CODEC;
     CODEC["INT16"] = "int16";
     CODEC["PARAMETERS"] = "parameters";
     CODEC["ADDRESS"] = "address";
+    CODEC["SMART_CONTRACT_ADDRESS"] = "smart_contract_address";
     CODEC["VALUE"] = "value";
     CODEC["MANAGER"] = "manager";
     CODEC["BLOCK_PAYLOAD_HASH"] = "blockPayloadHash";
@@ -52,6 +53,7 @@ var CODEC;
     CODEC["TX_ROLLUP_ORIGINATION_PARAM"] = "tx_rollup_origination_param";
     CODEC["TX_ROLLUP_ID"] = "tx_rollup_id";
     CODEC["TX_ROLLUP_BATCH_CONTENT"] = "tx_rollup_batch_content";
+    CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
 })(CODEC || (CODEC = {}));
 // See https://tezos.gitlab.io/whitedoc/michelson.html#full-grammar
 const opMapping = {
@@ -187,7 +189,7 @@ const opMapping = {
     '81': 'bls12_381_g2',
     '82': 'bls12_381_fr',
     '83': 'sapling_state',
-    '84': 'sapling_transaction',
+    '84': 'sapling_transaction_deprecated',
     '85': 'SAPLING_EMPTY_STATE',
     '86': 'SAPLING_VERIFY_UPDATE',
     '87': 'ticket',
@@ -203,6 +205,10 @@ const opMapping = {
     '91': 'view',
     '92': 'constant',
     '93': 'SUB_MUTEZ',
+    '94': 'tx_rollup_l2_address',
+    '95': 'MIN_BLOCK_TIME',
+    '96': 'sapling_transaction',
+    '97': 'EMIT',
 };
 const opMappingReverse = (() => {
     const result = {};
@@ -226,6 +232,7 @@ const kindMapping = {
     0x96: 'tx_rollup_origination',
     0x97: 'tx_rollup_submit_batch',
     0x9e: 'transfer_ticket',
+    0x71: 'increase_paid_storage',
 };
 const kindMappingReverse = (() => {
     const result = {};
@@ -572,7 +579,7 @@ const primDecoder = (value, preamble) => {
     let combPairArgs;
     let combPairAnnots;
     if ((opMapping[op] === 'pair' || opMapping[op] === 'Pair') && argsCount > 2) {
-        combPairArgs = decodeCombPair$1(value);
+        combPairArgs = decodeCombPair(value);
         argsCount = 0;
         combPairAnnots = decodeAnnots(value);
     }
@@ -600,7 +607,7 @@ const primViewDecoder = (value, result) => {
     value.consume(4);
     return result;
 };
-const decodeCombPair$1 = (val) => {
+const decodeCombPair = (val) => {
     const array = new Uint8ArrayConsumer(extractRequiredLen(val));
     const args = [];
     while (array.length() > 0) {
@@ -782,6 +789,13 @@ const addressEncoder = (val) => {
             throw new InvalidAddressError(val);
     }
 };
+const smartContractAddressEncoder = (val) => {
+    const prefix = val.substring(0, 3);
+    if (prefix === Prefix.KT1) {
+        return '01' + prefixEncoder(Prefix.KT1)(val) + '00';
+    }
+    throw new InvalidContractAddressError(val);
+};
 const publicKeyDecoder = (val) => {
     const preamble = val.consume(1);
     switch (preamble[0]) {
@@ -809,6 +823,15 @@ const addressDecoder = (val) => {
             throw new InvalidAddressError(val.toString());
     }
 };
+const smartContractAddressDecoder = (val) => {
+    const preamble = val.consume(1);
+    if (preamble[0] === 0x01) {
+        const scAddress = prefixDecoder(Prefix.KT1)(val);
+        val.consume(1);
+        return scAddress;
+    }
+    throw new InvalidContractAddressError(val.toString());
+};
 const zarithEncoder = (n) => {
     const fn = [];
     let nn = new BigNumber$1(n, 10);
@@ -906,7 +929,39 @@ const valueParameterDecoder = (val) => {
     return valueDecoder(new Uint8ArrayConsumer(value));
 };
 const blockPayloadHashEncoder = prefixEncoder(Prefix.VH);
-const blockPayloadHashDecoder = prefixDecoder(Prefix.VH);
+const blockPayloadHashDecoder = prefixDecoder(Prefix.VH);
+const entrypointNameEncoder = (entrypoint) => {
+    const value = { string: entrypoint };
+    return `${valueEncoder(value).slice(2)}`;
+};
+const entrypointNameDecoder = (val) => {
+    const entry = extractRequiredLen(val);
+    return Buffer.from(entry).toString('utf8');
+};
+const txRollupOriginationParamEncoder = (_value) => {
+    return '';
+};
+const txRollupOriginationParamDecoder = (_val) => {
+    return {};
+};
+const txRollupIdEncoder = prefixEncoder(Prefix.TXR1);
+const txRollupIdDecoder = prefixDecoder(Prefix.TXR1);
+const txRollupBatchContentEncoder = (value) => {
+    return `${pad(value.length / 2)}${value}`;
+};
+const txRollupBatchContentDecoder = (val) => {
+    const value = extractRequiredLen(val);
+    return Buffer.from(value).toString('hex');
+};
+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 ManagerOperationSchema = {
     branch: CODEC.BRANCH,
@@ -981,6 +1036,46 @@ const RegisterGlobalConstantSchema = {
     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 TxRollupOriginationSchema = {
+    source: CODEC.PKH,
+    fee: CODEC.ZARITH,
+    counter: CODEC.ZARITH,
+    gas_limit: CODEC.ZARITH,
+    storage_limit: CODEC.ZARITH,
+    tx_rollup_origination: CODEC.TX_ROLLUP_ORIGINATION_PARAM,
+};
+const TxRollupSubmitBatchSchema = {
+    source: CODEC.PKH,
+    fee: CODEC.ZARITH,
+    counter: CODEC.ZARITH,
+    gas_limit: CODEC.ZARITH,
+    storage_limit: CODEC.ZARITH,
+    rollup: CODEC.TX_ROLLUP_ID,
+    content: CODEC.TX_ROLLUP_BATCH_CONTENT,
+    burn_limit: CODEC.BURN_LIMIT,
+};
+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 operationEncoder = (encoders) => (operation) => {
     if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse)) {
         throw new InvalidOperationKindError(operation.kind);
@@ -1062,9 +1157,15 @@ const decoders = {
     [CODEC.PROPOSAL_ARR]: proposalsDecoder,
     [CODEC.PARAMETERS]: parametersDecoder,
     [CODEC.ADDRESS]: addressDecoder,
+    [CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressDecoder,
     [CODEC.VALUE]: valueParameterDecoder,
     [CODEC.INT16]: int16Decoder,
     [CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashDecoder,
+    [CODEC.ENTRYPOINT]: entrypointNameDecoder,
+    [CODEC.TX_ROLLUP_ORIGINATION_PARAM]: txRollupOriginationParamDecoder,
+    [CODEC.TX_ROLLUP_ID]: txRollupIdDecoder,
+    [CODEC.TX_ROLLUP_BATCH_CONTENT]: txRollupBatchContentDecoder,
+    [CODEC.BURN_LIMIT]: burnLimitDecoder,
 };
 decoders[CODEC.OPERATION] = operationDecoder(decoders);
 decoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decoders)(ActivationSchema)(val);
@@ -1077,6 +1178,10 @@ decoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decoders)(Seed
 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_TX_ROLLUP_ORIGINATION] = (val) => schemaDecoder(decoders)(TxRollupOriginationSchema)(val);
+decoders[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val) => schemaDecoder(decoders)(TxRollupSubmitBatchSchema)(val);
+decoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decoders)(IncreasePaidStorageSchema)(val);
 decoders[CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
 
 const encoders = {
@@ -1095,9 +1200,15 @@ const encoders = {
     [CODEC.INT32]: int32Encoder,
     [CODEC.PARAMETERS]: parametersEncoder,
     [CODEC.ADDRESS]: addressEncoder,
+    [CODEC.SMART_CONTRACT_ADDRESS]: smartContractAddressEncoder,
     [CODEC.VALUE]: valueParameterEncoder,
     [CODEC.INT16]: int16Encoder,
     [CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashEncoder,
+    [CODEC.ENTRYPOINT]: entrypointNameEncoder,
+    [CODEC.TX_ROLLUP_ORIGINATION_PARAM]: txRollupOriginationParamEncoder,
+    [CODEC.TX_ROLLUP_ID]: txRollupIdEncoder,
+    [CODEC.TX_ROLLUP_BATCH_CONTENT]: txRollupBatchContentEncoder,
+    [CODEC.BURN_LIMIT]: burnLimitEncoder,
 };
 encoders[CODEC.OPERATION] = operationEncoder(encoders);
 encoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encoders)(ActivationSchema)(val);
@@ -1110,40 +1221,12 @@ encoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encoders)(Seed
 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_TX_ROLLUP_ORIGINATION] = (val) => schemaEncoder(encoders)(TxRollupOriginationSchema)(val);
+encoders[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val) => schemaEncoder(encoders)(TxRollupSubmitBatchSchema)(val);
+encoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encoders)(IncreasePaidStorageSchema)(val);
 encoders[CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
 
-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 TxRollupOriginationSchema = {
-    source: CODEC.PKH,
-    fee: CODEC.ZARITH,
-    counter: CODEC.ZARITH,
-    gas_limit: CODEC.ZARITH,
-    storage_limit: CODEC.ZARITH,
-    tx_rollup_origination: CODEC.TX_ROLLUP_ORIGINATION_PARAM,
-};
-const TxRollupSubmitBatchSchema = {
-    source: CODEC.PKH,
-    fee: CODEC.ZARITH,
-    counter: CODEC.ZARITH,
-    gas_limit: CODEC.ZARITH,
-    storage_limit: CODEC.ZARITH,
-    rollup: CODEC.TX_ROLLUP_ID,
-    content: CODEC.TX_ROLLUP_BATCH_CONTENT,
-    burn_limit: CODEC.BURN_LIMIT,
-};
-
 const OperationKindMapping = {
     activate_account: ActivationSchema,
     reveal: RevealSchema,
@@ -1158,6 +1241,7 @@ const OperationKindMapping = {
     transfer_ticket: TransferTicketSchema,
     tx_rollup_origination: TxRollupOriginationSchema,
     tx_rollup_submit_batch: TxRollupSubmitBatchSchema,
+    increase_paid_storage: IncreasePaidStorageSchema,
 };
 // Asymmetric difference: only account for things in arr2 that are not present in arr1, not vice versa
 const getArrayDifference = (arr1, arr2) => {
@@ -1200,284 +1284,14 @@ var ProtocolsHash;
     ProtocolsHash["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
     ProtocolsHash["Psithaca2"] = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A";
     ProtocolsHash["PtJakart2"] = "PtJakart2xVj7pYXJBXrqHgd82rdkLey5ZeeGwDgPp9rhQUbSqY";
+    ProtocolsHash["PtKathman"] = "PtKathmankSpLLDALzWw7CGD2j2MtyveTwboEYokqUCP4a1LxMg";
     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,
-    ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 14,
-};
-function ProtoInferiorTo(a, b) {
-    return protoLevel[a] < protoLevel[b];
-}
-
-const opMappingProto13 = Object.assign(Object.assign({}, opMapping), { '84': 'sapling_transaction_deprecated', '94': 'tx_rollup_l2_address', '95': 'MIN_BLOCK_TIME', '96': 'sapling_transaction' });
-const opMappingReverseProto13 = (() => {
-    const result = {};
-    Object.keys(opMappingProto13).forEach((key) => {
-        result[opMappingProto13[key]] = key;
-    });
-    return result;
-})();
-
-const scriptEncoderProto13 = (script) => {
-    const code = valueEncoderProto13(script.code);
-    const storage = valueEncoderProto13(script.storage);
-    return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
-};
-const scriptDecoderProto13 = (value) => {
-    const code = extractRequiredLen(value);
-    const storage = extractRequiredLen(value);
-    return {
-        code: valueDecoderProto13(new Uint8ArrayConsumer(code)),
-        storage: valueDecoderProto13(new Uint8ArrayConsumer(storage)),
-    };
-};
-const valueEncoderProto13 = (value) => {
-    if (Array.isArray(value)) {
-        const encoded = value.map((x) => valueEncoderProto13(x)).join('');
-        const len = encoded.length / 2;
-        return `02${pad(len)}${encoded}`;
-    }
-    else if (isPrim(value)) {
-        return primEncoderProto13(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('Unexpected value');
-};
-const valueDecoderProto13 = (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(valueDecoderProto13(val));
-            }
-            return results;
-        }
-        default:
-            return primDecoderProto13(value, preamble);
-    }
-};
-const primEncoderProto13 = (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 = opMappingReverseProto13[value.prim];
-    let encodedArgs = (value.args || []).map((arg) => valueEncoderProto13(arg)).join('');
-    const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
-    if (value.prim === 'LAMBDA' && 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 primDecoderProto13 = (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: opMappingProto13[op],
-    };
-    if (opMappingProto13[op] === 'LAMBDA') {
-        value.consume(4);
-    }
-    if (opMappingProto13[op] === 'view') {
-        if (argsCount != 0) {
-            return primViewDecoderProto13(value, result);
-        }
-        else {
-            return result;
-        }
-    }
-    let combPairArgs;
-    let combPairAnnots;
-    if ((opMappingProto13[op] === 'pair' || opMappingProto13[op] === 'Pair') && argsCount > 2) {
-        combPairArgs = decodeCombPair(value);
-        argsCount = 0;
-        combPairAnnots = decodeAnnots(value);
-    }
-    const args = new Array(argsCount).fill(0).map(() => valueDecoderProto13(value));
-    if (opMappingProto13[op] === 'LAMBDA') {
-        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 primViewDecoderProto13 = (value, result) => {
-    value.consume(4);
-    result['args'] = new Array(4).fill(0).map(() => valueDecoderProto13(value));
-    value.consume(4);
-    return result;
-};
-const decodeCombPair = (val) => {
-    const array = new Uint8ArrayConsumer(extractRequiredLen(val));
-    const args = [];
-    while (array.length() > 0) {
-        args.push(valueDecoderProto13(array));
-    }
-    return args;
-};
-
-const parametersDecoderProto13 = (val) => {
-    const preamble = val.consume(1);
-    if (preamble[0] === 0x00) {
-        return;
-    }
-    else {
-        const encodedEntrypoint = entrypointDecoder(val);
-        const params = extractRequiredLen(val);
-        const parameters = valueDecoderProto13(new Uint8ArrayConsumer(params));
-        return {
-            entrypoint: encodedEntrypoint,
-            value: parameters,
-        };
-    }
-};
-const valueParameterDecoderProto13 = (val) => {
-    const value = extractRequiredLen(val);
-    return valueDecoderProto13(new Uint8ArrayConsumer(value));
-};
-const entrypointEncoderProto13 = (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${valueEncoderProto13(value).slice(8)}`;
-    }
-};
-const entrypointNameEncoderProto13 = (entrypoint) => {
-    const value = { string: entrypoint };
-    return `${valueEncoderProto13(value).slice(2)}`;
-};
-const entrypointNameDecoderProto13 = (val) => {
-    const entry = extractRequiredLen(val);
-    return Buffer.from(entry).toString('utf8');
-};
-const parametersEncoderProto13 = (val) => {
-    if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
-        return '00';
-    }
-    const encodedEntrypoint = entrypointEncoderProto13(val.entrypoint);
-    const parameters = valueEncoderProto13(val.value);
-    const length = (parameters.length / 2).toString(16).padStart(8, '0');
-    return `ff${encodedEntrypoint}${length}${parameters}`;
-};
-const valueParameterEncoderProto13 = (value) => {
-    const valueEncoded = valueEncoderProto13(value);
-    return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
-};
-const txRollupOriginationParamEncoderProto13 = (_value) => {
-    return '';
-};
-const txRollupOriginationParamDecoderProto13 = (_val) => {
-    return {};
-};
-const txRollupIdEncoderProto13 = prefixEncoder(Prefix.TXR1);
-const txRollupIdDecoderProto13 = prefixDecoder(Prefix.TXR1);
-const txRollupBatchContentEncoderProto13 = (value) => {
-    return `${pad(value.length / 2)}${value}`;
-};
-const txRollupBatchContentDecoderProto13 = (val) => {
-    const value = extractRequiredLen(val);
-    return Buffer.from(value).toString('hex');
-};
-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 encodersProto13 = Object.assign(Object.assign({}, encoders), { [CODEC.SCRIPT]: scriptEncoderProto13, [CODEC.PARAMETERS]: parametersEncoderProto13, [CODEC.VALUE]: valueParameterEncoderProto13, [CODEC.ENTRYPOINT]: entrypointNameEncoderProto13, [CODEC.TX_ROLLUP_ORIGINATION_PARAM]: txRollupOriginationParamEncoderProto13, [CODEC.TX_ROLLUP_ID]: txRollupIdEncoderProto13, [CODEC.TX_ROLLUP_BATCH_CONTENT]: txRollupBatchContentEncoderProto13, [CODEC.BURN_LIMIT]: burnLimitEncoder });
-encodersProto13[CODEC.OPERATION] = operationEncoder(encodersProto13);
-encodersProto13[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encodersProto13)(ActivationSchema)(val);
-encodersProto13[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encodersProto13)(DelegationSchema)(val);
-encodersProto13[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encodersProto13)(TransactionSchema)(val);
-encodersProto13[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encodersProto13)(OriginationSchema)(val);
-encodersProto13[CODEC.OP_BALLOT] = (val) => schemaEncoder(encodersProto13)(BallotSchema)(val);
-encodersProto13[CODEC.OP_ENDORSEMENT] = (val) => schemaEncoder(encodersProto13)(EndorsementSchema)(val);
-encodersProto13[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encodersProto13)(SeedNonceRevelationSchema)(val);
-encodersProto13[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encodersProto13)(ProposalsSchema)(val);
-encodersProto13[CODEC.OP_REVEAL] = (val) => schemaEncoder(encodersProto13)(RevealSchema)(val);
-encodersProto13[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encodersProto13)(RegisterGlobalConstantSchema)(val);
-encodersProto13[CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encodersProto13)(TransferTicketSchema)(val);
-encodersProto13[CODEC.OP_TX_ROLLUP_ORIGINATION] = (val) => schemaEncoder(encodersProto13)(TxRollupOriginationSchema)(val);
-encodersProto13[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val) => schemaEncoder(encodersProto13)(TxRollupSubmitBatchSchema)(val);
-encodersProto13[CODEC.MANAGER] = schemaEncoder(encodersProto13)(ManagerOperationSchema);
-
-const decodersProto13 = Object.assign(Object.assign({}, decoders), { [CODEC.SCRIPT]: scriptDecoderProto13, [CODEC.PARAMETERS]: parametersDecoderProto13, [CODEC.VALUE]: valueParameterDecoderProto13, [CODEC.ENTRYPOINT]: entrypointNameDecoderProto13, [CODEC.TX_ROLLUP_ORIGINATION_PARAM]: txRollupOriginationParamDecoderProto13, [CODEC.TX_ROLLUP_ID]: txRollupIdDecoderProto13, [CODEC.TX_ROLLUP_BATCH_CONTENT]: txRollupBatchContentDecoderProto13, [CODEC.BURN_LIMIT]: burnLimitDecoder });
-decodersProto13[CODEC.OPERATION] = operationDecoder(decodersProto13);
-decodersProto13[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decodersProto13)(ActivationSchema)(val);
-decodersProto13[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decodersProto13)(DelegationSchema)(val);
-decodersProto13[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decodersProto13)(TransactionSchema)(val);
-decodersProto13[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decodersProto13)(OriginationSchema)(val);
-decodersProto13[CODEC.OP_BALLOT] = (val) => schemaDecoder(decodersProto13)(BallotSchema)(val);
-decodersProto13[CODEC.OP_ENDORSEMENT] = (val) => schemaDecoder(decodersProto13)(EndorsementSchema)(val);
-decodersProto13[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decodersProto13)(SeedNonceRevelationSchema)(val);
-decodersProto13[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decodersProto13)(ProposalsSchema)(val);
-decodersProto13[CODEC.OP_REVEAL] = (val) => schemaDecoder(decodersProto13)(RevealSchema)(val);
-decodersProto13[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decodersProto13)(RegisterGlobalConstantSchema)(val);
-decodersProto13[CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decodersProto13)(TransferTicketSchema)(val);
-decodersProto13[CODEC.OP_TX_ROLLUP_ORIGINATION] = (val) => schemaDecoder(decodersProto13)(TxRollupOriginationSchema)(val);
-decodersProto13[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val) => schemaDecoder(decodersProto13)(TxRollupSubmitBatchSchema)(val);
-decodersProto13[CODEC.MANAGER] = schemaDecoder(decodersProto13)(ManagerOperationSchema);
+})(ProtocolsHash || (ProtocolsHash = {}));
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "01d3579d51bb8d70038a304cd4dbb7c6366a244b",
-    "version": "13.0.0"
+    "commitHash": "b1a433145402043facaec3519daceb21a305deef",
+    "version": "14.0.0"
 };
 
 /**
@@ -1485,25 +1299,14 @@ const VERSION = {
  * @module @taquito/local-forging
  */
 const PROTOCOL_CURRENT = ProtocolsHash.Psithaca2;
-function getCodec(codec, proto) {
-    if (proto === ProtocolsHash.Psithaca2 || ProtoInferiorTo(proto, ProtocolsHash.Psithaca2)) {
-        return {
-            encoder: encoders[codec],
-            decoder: (hex) => {
-                const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                return decoders[codec](consumer);
-            },
-        };
-    }
-    else {
-        return {
-            encoder: encodersProto13[codec],
-            decoder: (hex) => {
-                const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                return decodersProto13[codec](consumer);
-            },
-        };
-    }
+function getCodec(codec, _proto) {
+    return {
+        encoder: encoders[codec],
+        decoder: (hex) => {
+            const consumer = Uint8ArrayConsumer.fromHexString(hex);
+            return decoders[codec](consumer);
+        },
+    };
 }
 class LocalForger {
     constructor(protocolHash = PROTOCOL_CURRENT) {