@taquito/local-forging 22.0.0-beta.0 → 23.0.0-beta.0

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

@@ -1,5 +1,5 @@
 import { Prefix, buf2hex, b58cdecode, prefix, prefixLength, b58cencode, InvalidKeyHashError, invalidDetail, ValidationResult, InvalidPublicKeyError, validateBlock } from '@taquito/utils';
-import { ParameterValidationError, InvalidHexStringError, InvalidAddressError, InvalidContractAddressError, InvalidSignatureError, ProhibitedActionError, InvalidOperationKindError, InvalidBlockHashError } from '@taquito/core';
+import { ParameterValidationError, InvalidHexStringError, InvalidAddressError, InvalidContractAddressError, ProhibitedActionError, InvalidOperationKindError, InvalidSignatureError, 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'), '');
@@ -58,6 +58,7 @@ var CODEC$1;
     CODEC["BURN_LIMIT"] = "burn_limit";
     CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
     CODEC["OP_UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
+    CODEC["OP_UPDATE_COMPANION_KEY"] = "update_companion_key";
     CODEC["SIGNATURE_PROOF"] = "signature_proof";
     CODEC["OP_DRAIN_DELEGATE"] = "drain_delegate";
     CODEC["DEPOSITS_LIMIT"] = "deposits_limit";
@@ -229,8 +230,9 @@ const opMapping$1 = {
     '9b': 'BYTES',
     '9c': 'NAT',
     '9d': 'Ticket',
+    '9e': 'IS_IMPLICIT_ACCOUNT',
 };
-const opMappingReverse = (() => {
+const opMappingReverse$1 = (() => {
     const result = {};
     Object.keys(opMapping$1).forEach((key) => {
         result[opMapping$1[key]] = key;
@@ -254,6 +256,7 @@ const kindMapping$1 = {
     0x70: 'set_deposits_limit',
     0x71: 'increase_paid_storage',
     0x72: 'update_consensus_key',
+    0x73: 'update_companion_key',
     0x09: 'drain_delegate',
     0xc8: 'smart_rollup_originate',
     0xc9: 'smart_rollup_add_messages',
@@ -483,73 +486,73 @@ class Uint8ArrayConsumer {
     }
 }
 
-const isPrim = (value) => {
+const isPrim$1 = (value) => {
     return 'prim' in value;
 };
-const isBytes = (value) => {
+const isBytes$1 = (value) => {
     return 'bytes' in value && typeof value.bytes === 'string';
 };
-const isString = (value) => {
+const isString$1 = (value) => {
     return 'string' in value && typeof value.string === 'string';
 };
-const isInt = (value) => {
+const isInt$1 = (value) => {
     return 'int' in value && typeof value.int === 'string';
 };
-const scriptEncoder = (script) => {
-    const code = valueEncoder(script.code);
-    const storage = valueEncoder(script.storage);
+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 = (value) => {
-    const code = extractRequiredLen(value);
-    const storage = extractRequiredLen(value);
+const scriptDecoder$1 = (value) => {
+    const code = extractRequiredLen$1(value);
+    const storage = extractRequiredLen$1(value);
     return {
-        code: valueDecoder(new Uint8ArrayConsumer(code)),
-        storage: valueDecoder(new Uint8ArrayConsumer(storage)),
+        code: valueDecoder$1(new Uint8ArrayConsumer(code)),
+        storage: valueDecoder$1(new Uint8ArrayConsumer(storage)),
     };
 };
-const valueEncoder = (value) => {
+const valueEncoder$1 = (value) => {
     if (Array.isArray(value)) {
-        const encoded = value.map((x) => valueEncoder(x)).join('');
+        const encoded = value.map((x) => valueEncoder$1(x)).join('');
         const len = encoded.length / 2;
         return `02${pad(len)}${encoded}`;
     }
-    else if (isPrim(value)) {
-        return primEncoder(value);
+    else if (isPrim$1(value)) {
+        return primEncoder$1(value);
     }
-    else if (isBytes(value)) {
-        return bytesEncoder(value);
+    else if (isBytes$1(value)) {
+        return bytesEncoder$1(value);
     }
-    else if (isString(value)) {
-        return stringEncoder(value);
+    else if (isString$1(value)) {
+        return stringEncoder$1(value);
     }
-    else if (isInt(value)) {
-        return intEncoder(value);
+    else if (isInt$1(value)) {
+        return intEncoder$1(value);
     }
     throw new UnexpectedMichelsonValueError(JSON.stringify(value));
 };
-const valueDecoder = (value) => {
+const valueDecoder$1 = (value) => {
     const preamble = value.consume(1);
     switch (preamble[0]) {
         case 0x0a:
-            return bytesDecoder(value);
+            return bytesDecoder$1(value);
         case 0x01:
-            return stringDecoder(value);
+            return stringDecoder$1(value);
         case 0x00:
-            return intDecoder(value);
+            return intDecoder$1(value);
         case 0x02: {
-            const val = new Uint8ArrayConsumer(extractRequiredLen(value));
+            const val = new Uint8ArrayConsumer(extractRequiredLen$1(value));
             const results = [];
             while (val.length() > 0) {
-                results.push(valueDecoder(val));
+                results.push(valueDecoder$1(val));
             }
             return results;
         }
         default:
-            return primDecoder(value, preamble);
+            return primDecoder$1(value, preamble);
     }
 };
-const extractRequiredLen = (value, bytesLength = 4) => {
+const extractRequiredLen$1 = (value, bytesLength = 4) => {
     const len = value.consume(bytesLength);
     const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
     return value.consume(valueLen);
@@ -560,7 +563,7 @@ const extractRequiredLen = (value, bytesLength = 4) => {
  * @param bytesLength default 4 bytes for length of variable bytes
  * @returns array of Uint8Array values for each array item
  */
-const stripLengthPrefixFromBytes = (value, bytesLength = 4) => {
+const stripLengthPrefixFromBytes$1 = (value, bytesLength = 4) => {
     const ret = [];
     let values = value;
     while (values.length()) {
@@ -571,31 +574,31 @@ const stripLengthPrefixFromBytes = (value, bytesLength = 4) => {
     }
     return ret;
 };
-const bytesEncoder = (value) => {
+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 = (value) => {
-    const bytes = extractRequiredLen(value);
+const bytesDecoder$1 = (value) => {
+    const bytes = extractRequiredLen$1(value);
     return {
         bytes: Buffer.from(bytes).toString('hex'),
     };
 };
-const stringEncoder = (value) => {
+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 = (value) => {
-    const str = extractRequiredLen(value);
+const stringDecoder$1 = (value) => {
+    const str = extractRequiredLen$1(value);
     return {
         string: Buffer.from(str).toString('utf8'),
     };
 };
-const intEncoder = ({ int }) => {
+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, '');
@@ -615,7 +618,7 @@ const intEncoder = ({ int }) => {
         .padStart(2, '0'));
     return `00${numHex.join('')}`;
 };
-const intDecoder = (value) => {
+const intDecoder$1 = (value) => {
     let c = value.consume(1)[0];
     const hexNumber = [];
     const isNotLastChunkMask = 1 << 7;
@@ -640,14 +643,14 @@ const intDecoder = (value) => {
         int: num.toFixed(),
     };
 };
-const primEncoder = (value) => {
+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[value.prim];
-    let encodedArgs = (value.args || []).map((arg) => valueEncoder(arg)).join('');
-    const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
+    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);
     }
@@ -662,7 +665,7 @@ const primEncoder = (value) => {
     }
     return `${preamble}${op}${encodedArgs}${encodedAnnots}`;
 };
-const primDecoder = (value, preamble) => {
+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');
@@ -674,7 +677,7 @@ const primDecoder = (value, preamble) => {
     }
     if (opMapping$1[op] === 'view') {
         if (argsCount != 0) {
-            return primViewDecoder(value, result);
+            return primViewDecoder$1(value, result);
         }
         else {
             return result;
@@ -683,11 +686,11 @@ const primDecoder = (value, preamble) => {
     let combPairArgs;
     let combPairAnnots;
     if ((opMapping$1[op] === 'pair' || opMapping$1[op] === 'Pair') && argsCount > 2) {
-        combPairArgs = decodeCombPair(value);
+        combPairArgs = decodeCombPair$1(value);
         argsCount = 0;
-        combPairAnnots = decodeAnnots(value);
+        combPairAnnots = decodeAnnots$1(value);
     }
-    const args = new Array(argsCount).fill(0).map(() => valueDecoder(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);
     }
@@ -701,25 +704,25 @@ const primDecoder = (value, preamble) => {
         result['annots'] = combPairAnnots;
     }
     else if (hasAnnot) {
-        result['annots'] = decodeAnnots(value);
+        result['annots'] = decodeAnnots$1(value);
     }
     return result;
 };
-const primViewDecoder = (value, result) => {
+const primViewDecoder$1 = (value, result) => {
     value.consume(4);
-    result['args'] = new Array(4).fill(0).map(() => valueDecoder(value));
+    result['args'] = new Array(4).fill(0).map(() => valueDecoder$1(value));
     value.consume(4);
     return result;
 };
-const decodeCombPair = (val) => {
-    const array = new Uint8ArrayConsumer(extractRequiredLen(val));
+const decodeCombPair$1 = (val) => {
+    const array = new Uint8ArrayConsumer(extractRequiredLen$1(val));
     const args = [];
     while (array.length() > 0) {
-        args.push(valueDecoder(array));
+        args.push(valueDecoder$1(array));
     }
     return args;
 };
-const encodeAnnots = (value) => {
+const encodeAnnots$1 = (value) => {
     const mergedAnnot = value
         .map((x) => {
         return Buffer.from(x, 'utf8').toString('hex');
@@ -728,7 +731,7 @@ const encodeAnnots = (value) => {
     const len = mergedAnnot.length / 2;
     return `${pad(len)}${mergedAnnot}`;
 };
-const decodeAnnots = (val) => {
+const decodeAnnots$1 = (val) => {
     const len = val.consume(4);
     const annotLen = parseInt(Buffer.from(len).toString('hex'), 16);
     const restOfAnnot = val.consume(annotLen);
@@ -1069,7 +1072,7 @@ const entrypointDecoder$1 = (value) => {
         return entrypointMapping$1[preamble];
     }
     else {
-        const entry = extractRequiredLen(value, 1);
+        const entry = extractRequiredLen$1(value, 1);
         const entrypoint = Buffer.from(entry).toString('utf8');
         if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
             throw new OversizedEntryPointError(entrypoint);
@@ -1084,8 +1087,8 @@ const parametersDecoder$1 = (val) => {
     }
     else {
         const encodedEntrypoint = entrypointDecoder$1(val);
-        const params = extractRequiredLen(val);
-        const parameters = valueDecoder(new Uint8ArrayConsumer(params));
+        const params = extractRequiredLen$1(val);
+        const parameters = valueDecoder$1(new Uint8ArrayConsumer(params));
         return {
             entrypoint: encodedEntrypoint,
             value: parameters,
@@ -1101,7 +1104,7 @@ const entrypointEncoder$1 = (entrypoint) => {
             throw new OversizedEntryPointError(entrypoint);
         }
         const value = { string: entrypoint };
-        return `ff${valueEncoder(value).slice(8)}`;
+        return `ff${valueEncoder$1(value).slice(8)}`;
     }
 };
 const parametersEncoder$1 = (val) => {
@@ -1109,26 +1112,26 @@ const parametersEncoder$1 = (val) => {
         return '00';
     }
     const encodedEntrypoint = entrypointEncoder$1(val.entrypoint);
-    const parameters = valueEncoder(val.value);
+    const parameters = valueEncoder$1(val.value);
     const length = pad(parameters.length / 2);
     return `ff${encodedEntrypoint}${length}${parameters}`;
 };
 const valueParameterEncoder$1 = (value) => {
-    const valueEncoded = valueEncoder(value);
+    const valueEncoded = valueEncoder$1(value);
     return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
 };
 const valueParameterDecoder$1 = (val) => {
-    const value = extractRequiredLen(val);
-    return valueDecoder(new Uint8ArrayConsumer(value));
+    const value = extractRequiredLen$1(val);
+    return valueDecoder$1(new Uint8ArrayConsumer(value));
 };
 const blockPayloadHashEncoder$1 = prefixEncoder$1(Prefix.VH);
 const blockPayloadHashDecoder$1 = prefixDecoder$1(Prefix.VH);
 const entrypointNameEncoder$1 = (entrypoint) => {
     const value = { string: entrypoint };
-    return `${valueEncoder(value).slice(2)}`;
+    return `${valueEncoder$1(value).slice(2)}`;
 };
 const entrypointNameDecoder$1 = (val) => {
-    const entry = extractRequiredLen(val);
+    const entry = extractRequiredLen$1(val);
     return Buffer.from(entry).toString('utf8');
 };
 const burnLimitEncoder$1 = (val) => {
@@ -1149,23 +1152,16 @@ const depositsLimitDecoder$1 = (value) => {
         return zarithDecoder$1(value);
     }
 };
-const signatureV1Encoder = (val) => {
+const signatureV1Encoder$1 = (val) => {
     const signaturePrefix = val.substring(0, 5);
-    switch (signaturePrefix) {
-        case Prefix.EDSIG:
-            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.EDSIG)(val));
-        case Prefix.SPSIG:
-            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.SPSIG)(val));
-        case Prefix.P2SIG:
-            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.P2SIG)(val));
-        case Prefix.BLSIG:
-            return paddedBytesEncoder$1(prefixEncoder$1(Prefix.BLSIG)(val));
-        default:
-            throw new InvalidSignatureError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following '${Prefix.EDSIG}', '${Prefix.SPSIG}', '${Prefix.P2SIG}' or '${Prefix.BLSIG}'.`);
+    if (signaturePrefix === Prefix.BLSIG) {
+        return paddedBytesEncoder$1(prefixEncoder$1(Prefix.BLSIG)(val));
+    }
+    else {
+        throw new ProhibitedActionError('currently we only support encoding of BLSIG signatures');
     }
 };
-const signatureV1Decoder = (val) => {
+const signatureV1Decoder$1 = (val) => {
     val.consume(4);
     if (val.length().toString() === '96') {
         return prefixDecoder$1(Prefix.BLSIG)(val);
@@ -1174,25 +1170,25 @@ const signatureV1Decoder = (val) => {
         throw new ProhibitedActionError('currently we only support decoding of BLSIG signatures');
     }
 };
-const signatureProofEncoder = (val) => {
+const signatureProofEncoder$1 = (val) => {
     if (val) {
-        return boolEncoder$1(true) + signatureV1Encoder(val);
+        return boolEncoder$1(true) + signatureV1Encoder$1(val);
     }
     else {
         return boolEncoder$1(false);
     }
 };
-const signatureProofDecoder = (value) => {
+const signatureProofDecoder$1 = (value) => {
     const hasProof = boolDecoder$1(value);
     if (hasProof) {
-        return signatureV1Decoder(value);
+        return signatureV1Decoder$1(value);
     }
 };
 const paddedBytesEncoder$1 = (val, paddingLength = 8) => {
     return `${pad(val.length / 2, paddingLength)}${val}`;
 };
 const paddedBytesDecoder$1 = (val) => {
-    const value = extractRequiredLen(val);
+    const value = extractRequiredLen$1(val);
     return Buffer.from(value).toString('hex');
 };
 const smartRollupMessageEncoder$1 = (val) => {
@@ -1202,8 +1198,8 @@ const smartRollupMessageEncoder$1 = (val) => {
     return `${pad(message.length / 2)}${message}`;
 };
 const smartRollupMessageDecoder$1 = (val) => {
-    const valueArray = extractRequiredLen(val);
-    const ret = stripLengthPrefixFromBytes(new Uint8ArrayConsumer(valueArray));
+    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) => {
@@ -1247,6 +1243,7 @@ const RevealSchema$1 = {
     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,
@@ -1343,6 +1340,15 @@ const UpdateConsensusKeySchema$1 = {
     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,
@@ -1461,7 +1467,7 @@ const schemaDecoder$1 = (decoders) => (schema) => (value) => {
     }, {});
 };
 
-const decoders = {
+const decoders$1 = {
     [CODEC$1.SECRET]: (val) => toHexString(val.consume(20)),
     [CODEC$1.RAW]: (val) => toHexString(val.consume(32)),
     [CODEC$1.TZ1]: tz1Decoder$1,
@@ -1472,7 +1478,7 @@ const decoders = {
     [CODEC$1.PKH_ARR]: publicKeyHashesDecoder$1,
     [CODEC$1.DELEGATE]: delegateDecoder$1,
     [CODEC$1.INT32]: int32Decoder$1,
-    [CODEC$1.SCRIPT]: scriptDecoder,
+    [CODEC$1.SCRIPT]: scriptDecoder$1,
     [CODEC$1.BALLOT_STATEMENT]: ballotDecoder$1,
     [CODEC$1.PROPOSAL]: proposalDecoder$1,
     [CODEC$1.PROPOSAL_ARR]: proposalsDecoder$1,
@@ -1487,35 +1493,36 @@ const decoders = {
     [CODEC$1.ENTRYPOINT]: entrypointNameDecoder$1,
     [CODEC$1.BURN_LIMIT]: burnLimitDecoder$1,
     [CODEC$1.DEPOSITS_LIMIT]: depositsLimitDecoder$1,
-    [CODEC$1.SIGNATURE_PROOF]: signatureProofDecoder,
+    [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[CODEC$1.OPERATION] = operationDecoder$1(decoders);
-decoders[CODEC$1.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder$1(decoders)(ActivationSchema$1)(val);
-decoders[CODEC$1.OP_FAILING_NOOP] = (val) => schemaDecoder$1(decoders)(FailingNoopSchema$1)(val);
-decoders[CODEC$1.OP_DELEGATION] = (val) => schemaDecoder$1(decoders)(DelegationSchema$1)(val);
-decoders[CODEC$1.OP_TRANSACTION] = (val) => schemaDecoder$1(decoders)(TransactionSchema$1)(val);
-decoders[CODEC$1.OP_ORIGINATION] = (val) => schemaDecoder$1(decoders)(OriginationSchema$1)(val);
-decoders[CODEC$1.OP_BALLOT] = (val) => schemaDecoder$1(decoders)(BallotSchema$1)(val);
-decoders[CODEC$1.OP_ATTESTATION] = (val) => schemaDecoder$1(decoders)(AttestationSchema$1)(val);
-decoders[CODEC$1.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder$1(decoders)(AttestationWithDalSchema$1)(val);
-decoders[CODEC$1.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder$1(decoders)(SeedNonceRevelationSchema$1)(val);
-decoders[CODEC$1.OP_PROPOSALS] = (val) => schemaDecoder$1(decoders)(ProposalsSchema$1)(val);
-decoders[CODEC$1.OP_REVEAL] = (val) => schemaDecoder$1(decoders)(RevealSchema$1)(val);
-decoders[CODEC$1.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder$1(decoders)(RegisterGlobalConstantSchema$1)(val);
-decoders[CODEC$1.OP_TRANSFER_TICKET] = (val) => schemaDecoder$1(decoders)(TransferTicketSchema$1)(val);
-decoders[CODEC$1.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder$1(decoders)(IncreasePaidStorageSchema$1)(val);
-decoders[CODEC$1.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder$1(decoders)(UpdateConsensusKeySchema$1)(val);
-decoders[CODEC$1.OP_DRAIN_DELEGATE] = (val) => schemaDecoder$1(decoders)(DrainDelegateSchema$1)(val);
-decoders[CODEC$1.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder$1(decoders)(SmartRollupOriginateSchema$1)(val);
-decoders[CODEC$1.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder$1(decoders)(SmartRollupAddMessagesSchema$1)(val);
-decoders[CODEC$1.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder$1(decoders)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-decoders[CODEC$1.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder$1(decoders)(DalPublishCommitmentSchema$1)(val);
-decoders[CODEC$1.MANAGER] = schemaDecoder$1(decoders)(ManagerOperationSchema$1);
-decoders[CODEC$1.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder$1(decoders)(SetDepositsLimitSchema$1)(val);
+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
@@ -1568,6 +1575,7 @@ var CODEC;
     CODEC["BURN_LIMIT"] = "burn_limit";
     CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
     CODEC["OP_UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
+    CODEC["SIGNATURE_PROOF"] = "signature_proof";
     CODEC["OP_DRAIN_DELEGATE"] = "drain_delegate";
     CODEC["DEPOSITS_LIMIT"] = "deposits_limit";
     CODEC["OP_SET_DEPOSITS_LIMIT"] = "set_deposits_limit";
@@ -1739,7 +1747,7 @@ const opMapping = {
     '9c': 'NAT',
     '9d': 'Ticket',
 };
-(() => {
+const opMappingReverse = (() => {
     const result = {};
     Object.keys(opMapping).forEach((key) => {
         result[opMapping[key]] = key;
@@ -1799,6 +1807,259 @@ const entrypointMappingReverse = (() => {
     return result;
 })();
 
+const isPrim = (value) => {
+    return 'prim' in value;
+};
+const isBytes = (value) => {
+    return 'bytes' in value && typeof value.bytes === 'string';
+};
+const isString = (value) => {
+    return 'string' in value && typeof value.string === 'string';
+};
+const isInt = (value) => {
+    return 'int' in value && typeof value.int === 'string';
+};
+const scriptEncoder = (script) => {
+    const code = valueEncoder(script.code);
+    const storage = valueEncoder(script.storage);
+    return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
+};
+const scriptDecoder = (value) => {
+    const code = extractRequiredLen(value);
+    const storage = extractRequiredLen(value);
+    return {
+        code: valueDecoder(new Uint8ArrayConsumer(code)),
+        storage: valueDecoder(new Uint8ArrayConsumer(storage)),
+    };
+};
+const valueEncoder = (value) => {
+    if (Array.isArray(value)) {
+        const encoded = value.map((x) => valueEncoder(x)).join('');
+        const len = encoded.length / 2;
+        return `02${pad(len)}${encoded}`;
+    }
+    else if (isPrim(value)) {
+        return primEncoder(value);
+    }
+    else if (isBytes(value)) {
+        return bytesEncoder(value);
+    }
+    else if (isString(value)) {
+        return stringEncoder(value);
+    }
+    else if (isInt(value)) {
+        return intEncoder(value);
+    }
+    throw new UnexpectedMichelsonValueError(JSON.stringify(value));
+};
+const valueDecoder = (value) => {
+    const preamble = value.consume(1);
+    switch (preamble[0]) {
+        case 0x0a:
+            return bytesDecoder(value);
+        case 0x01:
+            return stringDecoder(value);
+        case 0x00:
+            return intDecoder(value);
+        case 0x02: {
+            const val = new Uint8ArrayConsumer(extractRequiredLen(value));
+            const results = [];
+            while (val.length() > 0) {
+                results.push(valueDecoder(val));
+            }
+            return results;
+        }
+        default:
+            return primDecoder(value, preamble);
+    }
+};
+const extractRequiredLen = (value, bytesLength = 4) => {
+    const len = value.consume(bytesLength);
+    const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
+    return value.consume(valueLen);
+};
+/**
+ * @description parse bytes into multiple items of an array
+ * @param value Uint8ArrayConsumer class of forged segment to parse
+ * @param bytesLength default 4 bytes for length of variable bytes
+ * @returns array of Uint8Array values for each array item
+ */
+const stripLengthPrefixFromBytes = (value, bytesLength = 4) => {
+    const ret = [];
+    let values = value;
+    while (values.length()) {
+        const len = values.consume(bytesLength);
+        const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
+        ret.push(values.consume(valueLen));
+        values = values.slice(valueLen + bytesLength);
+    }
+    return ret;
+};
+const bytesEncoder = (value) => {
+    if (!/^([A-Fa-f0-9]{2})*$/.test(value.bytes)) {
+        throw new InvalidHexStringError(value.bytes);
+    }
+    const len = value.bytes.length / 2;
+    return `0a${pad(len)}${value.bytes}`;
+};
+const bytesDecoder = (value) => {
+    const bytes = extractRequiredLen(value);
+    return {
+        bytes: Buffer.from(bytes).toString('hex'),
+    };
+};
+const stringEncoder = (value) => {
+    const str = Buffer.from(value.string, 'utf8').toString('hex');
+    const hexLength = str.length / 2;
+    return `01${pad(hexLength)}${str}`;
+};
+const stringDecoder = (value) => {
+    const str = extractRequiredLen(value);
+    return {
+        string: Buffer.from(str).toString('utf8'),
+    };
+};
+const intEncoder = ({ int }) => {
+    const num = new BigNumber(int, 10);
+    const positiveMark = num.toString(2)[0] === '-' ? '1' : '0';
+    const binary = num.toString(2).replace(/-/g, '');
+    const pad = binary.length <= 6
+        ? 6
+        : (binary.length - 6) % 7
+            ? binary.length + 7 - ((binary.length - 6) % 7)
+            : binary.length;
+    const splitted = binary.padStart(pad, '0').match(/\d{6,7}/g);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const reversed = splitted.reverse();
+    reversed[0] = positiveMark + reversed[0];
+    const numHex = reversed.map((x, i) => 
+    // Add one to the last chunk
+    parseInt((i === reversed.length - 1 ? '0' : '1') + x, 2)
+        .toString(16)
+        .padStart(2, '0'));
+    return `00${numHex.join('')}`;
+};
+const intDecoder = (value) => {
+    let c = value.consume(1)[0];
+    const hexNumber = [];
+    const isNotLastChunkMask = 1 << 7;
+    while (c & isNotLastChunkMask) {
+        hexNumber.push(c);
+        c = value.consume(1)[0];
+    }
+    hexNumber.push(c);
+    const isNegative = !!((1 << 6) & hexNumber[0]);
+    hexNumber[0] = hexNumber[0] & 0b1111111;
+    const numBin = hexNumber
+        .map((x, i) => x
+        .toString(2)
+        .slice(i === 0 ? -6 : -7)
+        .padStart(i === 0 ? 6 : 7, '0'))
+        .reverse();
+    let num = new BigNumber(numBin.join(''), 2);
+    if (isNegative) {
+        num = num.times(-1);
+    }
+    return {
+        int: num.toFixed(),
+    };
+};
+const primEncoder = (value) => {
+    const hasAnnot = +Array.isArray(value.annots);
+    const argsCount = Array.isArray(value.args) ? value.args.length : 0;
+    // Specify the number of args max is 3 without annotation
+    const preamble = pad(Math.min(2 * argsCount + hasAnnot + 0x03, 9), 2);
+    const op = opMappingReverse[value.prim];
+    let encodedArgs = (value.args || []).map((arg) => valueEncoder(arg)).join('');
+    const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
+    if ((value.prim === 'LAMBDA' || value.prim === 'LAMBDA_REC') && argsCount) {
+        encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
+    }
+    if ((value.prim === 'pair' || value.prim === 'Pair') && argsCount > 2) {
+        encodedArgs =
+            encodedAnnots === ''
+                ? pad(encodedArgs.length / 2) + encodedArgs + pad(0)
+                : pad(encodedArgs.length / 2) + encodedArgs;
+    }
+    if (value.prim === 'view' && value.args) {
+        encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
+    }
+    return `${preamble}${op}${encodedArgs}${encodedAnnots}`;
+};
+const primDecoder = (value, preamble) => {
+    const hasAnnot = (preamble[0] - 0x03) % 2 === 1;
+    let argsCount = Math.floor((preamble[0] - 0x03) / 2);
+    const op = value.consume(1)[0].toString(16).padStart(2, '0');
+    const result = {
+        prim: opMapping[op],
+    };
+    if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
+        value.consume(4);
+    }
+    if (opMapping[op] === 'view') {
+        if (argsCount != 0) {
+            return primViewDecoder(value, result);
+        }
+        else {
+            return result;
+        }
+    }
+    let combPairArgs;
+    let combPairAnnots;
+    if ((opMapping[op] === 'pair' || opMapping[op] === 'Pair') && argsCount > 2) {
+        combPairArgs = decodeCombPair(value);
+        argsCount = 0;
+        combPairAnnots = decodeAnnots(value);
+    }
+    const args = new Array(argsCount).fill(0).map(() => valueDecoder(value));
+    if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
+        value.consume(4);
+    }
+    if (combPairArgs) {
+        result['args'] = combPairArgs;
+    }
+    else if (args.length) {
+        result['args'] = args;
+    }
+    if (combPairAnnots && combPairAnnots[0] !== '') {
+        result['annots'] = combPairAnnots;
+    }
+    else if (hasAnnot) {
+        result['annots'] = decodeAnnots(value);
+    }
+    return result;
+};
+const primViewDecoder = (value, result) => {
+    value.consume(4);
+    result['args'] = new Array(4).fill(0).map(() => valueDecoder(value));
+    value.consume(4);
+    return result;
+};
+const decodeCombPair = (val) => {
+    const array = new Uint8ArrayConsumer(extractRequiredLen(val));
+    const args = [];
+    while (array.length() > 0) {
+        args.push(valueDecoder(array));
+    }
+    return args;
+};
+const encodeAnnots = (value) => {
+    const mergedAnnot = value
+        .map((x) => {
+        return Buffer.from(x, 'utf8').toString('hex');
+    })
+        .join('20');
+    const len = mergedAnnot.length / 2;
+    return `${pad(len)}${mergedAnnot}`;
+};
+const decodeAnnots = (val) => {
+    const len = val.consume(4);
+    const annotLen = parseInt(Buffer.from(len).toString('hex'), 16);
+    const restOfAnnot = val.consume(annotLen);
+    const restOfAnnotHex = Buffer.from(restOfAnnot).toString('hex');
+    return restOfAnnotHex.split('20').map((x) => Buffer.from(x, 'hex').toString('utf8'));
+};
+
 // https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
 const prefixEncoder = (prefix$1) => (str) => {
     return buf2hex(Buffer.from(b58cdecode(str, prefix[prefix$1])));
@@ -1820,10 +2081,13 @@ const publicKeyHashDecoder = (val) => {
     else if (prefix[0] === 0x02) {
         return prefixDecoder(Prefix.TZ3)(val);
     }
+    else if (prefix[0] === 0x03) {
+        return prefixDecoder(Prefix.TZ4)(val);
+    }
 };
 const publicKeyHashesDecoder = (val) => {
     if (!boolDecoder(val)) {
-        return undefined;
+        return;
     }
     const publicKeyHashes = [];
     val.consume(4);
@@ -1991,6 +2255,8 @@ const publicKeyEncoder = (val) => {
             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}'.`);
@@ -2033,6 +2299,8 @@ const publicKeyDecoder = (val) => {
             return prefixDecoder(Prefix.SPPK)(val);
         case 0x02:
             return prefixDecoder(Prefix.P2PK)(val);
+        case 0x03:
+            return prefixDecoder(Prefix.BLPK)(val);
         default:
             throw new InvalidPublicKeyError(val.toString(), invalidDetail(ValidationResult.NO_PREFIX_MATCHED));
     }
@@ -2205,6 +2473,45 @@ const depositsLimitDecoder = (value) => {
         return zarithDecoder(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}'.`);
+    }
+};
+const signatureV1Decoder = (val) => {
+    val.consume(4);
+    if (val.length().toString() === '96') {
+        return prefixDecoder(Prefix.BLSIG)(val);
+    }
+    else {
+        throw new ProhibitedActionError('currently we only support decoding of BLSIG signatures');
+    }
+};
+const signatureProofEncoder = (val) => {
+    if (val) {
+        return boolEncoder(true) + signatureV1Encoder(val);
+    }
+    else {
+        return boolEncoder(false);
+    }
+};
+const signatureProofDecoder = (value) => {
+    const hasProof = boolDecoder(value);
+    if (hasProof) {
+        return signatureV1Decoder(value);
+    }
+};
 const paddedBytesEncoder = (val, paddingLength = 8) => {
     return `${pad(val.length / 2, paddingLength)}${val}`;
 };
@@ -2358,6 +2665,7 @@ const UpdateConsensusKeySchema = {
     gas_limit: CODEC.ZARITH,
     storage_limit: CODEC.ZARITH,
     pk: CODEC.PUBLIC_KEY,
+    proof: CODEC.SIGNATURE_PROOF,
 };
 const DrainDelegateSchema = {
     consensus_key: CODEC.PKH,
@@ -2477,7 +2785,7 @@ const schemaDecoder = (decoders) => (schema) => (value) => {
     }, {});
 };
 
-const decodersProto021 = {
+const decoders = {
     [CODEC.SECRET]: (val) => toHexString(val.consume(20)),
     [CODEC.RAW]: (val) => toHexString(val.consume(32)),
     [CODEC.TZ1]: tz1Decoder,
@@ -2503,36 +2811,37 @@ const decodersProto021 = {
     [CODEC.ENTRYPOINT]: entrypointNameDecoder,
     [CODEC.BURN_LIMIT]: burnLimitDecoder,
     [CODEC.DEPOSITS_LIMIT]: depositsLimitDecoder,
+    [CODEC.SIGNATURE_PROOF]: signatureProofDecoder,
     [CODEC.PVM_KIND]: pvmKindDecoder,
     [CODEC.PADDED_BYTES]: paddedBytesDecoder,
     [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder,
     [CODEC.SLOT_HEADER]: slotHeaderDecoder,
 };
-decodersProto021[CODEC.OPERATION] = operationDecoder(decodersProto021);
-decodersProto021[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decodersProto021)(ActivationSchema)(val);
-decodersProto021[CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder(decodersProto021)(FailingNoopSchema)(val);
-decodersProto021[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decodersProto021)(DelegationSchema)(val);
-decodersProto021[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decodersProto021)(TransactionSchema)(val);
-decodersProto021[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decodersProto021)(OriginationSchema)(val);
-decodersProto021[CODEC.OP_BALLOT] = (val) => schemaDecoder(decodersProto021)(BallotSchema)(val);
-decodersProto021[CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decodersProto021)(AttestationSchema)(val);
-decodersProto021[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decodersProto021)(AttestationWithDalSchema)(val);
-decodersProto021[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decodersProto021)(SeedNonceRevelationSchema)(val);
-decodersProto021[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decodersProto021)(ProposalsSchema)(val);
-decodersProto021[CODEC.OP_REVEAL] = (val) => schemaDecoder(decodersProto021)(RevealSchema)(val);
-decodersProto021[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decodersProto021)(RegisterGlobalConstantSchema)(val);
-decodersProto021[CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decodersProto021)(TransferTicketSchema)(val);
-decodersProto021[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decodersProto021)(IncreasePaidStorageSchema)(val);
-decodersProto021[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder(decodersProto021)(UpdateConsensusKeySchema)(val);
-decodersProto021[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decodersProto021)(DrainDelegateSchema)(val);
-decodersProto021[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decodersProto021)(SmartRollupOriginateSchema)(val);
-decodersProto021[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decodersProto021)(SmartRollupAddMessagesSchema)(val);
-decodersProto021[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decodersProto021)(SmartRollupExecuteOutboxMessageSchema)(val);
-decodersProto021[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decodersProto021)(DalPublishCommitmentSchema)(val);
-decodersProto021[CODEC.MANAGER] = schemaDecoder(decodersProto021)(ManagerOperationSchema);
-decodersProto021[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decodersProto021)(SetDepositsLimitSchema)(val);
+decoders[CODEC.OPERATION] = operationDecoder(decoders);
+decoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decoders)(ActivationSchema)(val);
+decoders[CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder(decoders)(FailingNoopSchema)(val);
+decoders[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decoders)(DelegationSchema)(val);
+decoders[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decoders)(TransactionSchema)(val);
+decoders[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decoders)(OriginationSchema)(val);
+decoders[CODEC.OP_BALLOT] = (val) => schemaDecoder(decoders)(BallotSchema)(val);
+decoders[CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decoders)(AttestationSchema)(val);
+decoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decoders)(AttestationWithDalSchema)(val);
+decoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decoders)(SeedNonceRevelationSchema)(val);
+decoders[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decoders)(ProposalsSchema)(val);
+decoders[CODEC.OP_REVEAL] = (val) => schemaDecoder(decoders)(RevealSchema)(val);
+decoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decoders)(RegisterGlobalConstantSchema)(val);
+decoders[CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decoders)(TransferTicketSchema)(val);
+decoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decoders)(IncreasePaidStorageSchema)(val);
+decoders[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder(decoders)(UpdateConsensusKeySchema)(val);
+decoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decoders)(DrainDelegateSchema)(val);
+decoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decoders)(SmartRollupOriginateSchema)(val);
+decoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decoders)(SmartRollupAddMessagesSchema)(val);
+decoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+decoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decoders)(DalPublishCommitmentSchema)(val);
+decoders[CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
+decoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decoders)(SetDepositsLimitSchema)(val);
 
-const encoders = {
+const encoders$1 = {
     [CODEC$1.SECRET]: (val) => val,
     [CODEC$1.RAW]: (val) => val,
     [CODEC$1.TZ1]: tz1Encoder$1,
@@ -2542,7 +2851,7 @@ const encoders = {
     [CODEC$1.PKH]: publicKeyHashEncoder$1,
     [CODEC$1.PKH_ARR]: publicKeyHashesEncoder$1,
     [CODEC$1.DELEGATE]: delegateEncoder$1,
-    [CODEC$1.SCRIPT]: scriptEncoder,
+    [CODEC$1.SCRIPT]: scriptEncoder$1,
     [CODEC$1.BALLOT_STATEMENT]: ballotEncoder$1,
     [CODEC$1.PROPOSAL]: proposalEncoder$1,
     [CODEC$1.PROPOSAL_ARR]: proposalsEncoder$1,
@@ -2558,37 +2867,38 @@ const encoders = {
     [CODEC$1.ENTRYPOINT]: entrypointNameEncoder$1,
     [CODEC$1.BURN_LIMIT]: burnLimitEncoder$1,
     [CODEC$1.DEPOSITS_LIMIT]: depositsLimitEncoder$1,
-    [CODEC$1.SIGNATURE_PROOF]: signatureProofEncoder,
+    [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[CODEC$1.OPERATION] = operationEncoder$1(encoders);
-encoders[CODEC$1.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder$1(encoders)(ActivationSchema$1)(val);
-encoders[CODEC$1.OP_DELEGATION] = (val) => schemaEncoder$1(encoders)(DelegationSchema$1)(val);
-encoders[CODEC$1.OP_TRANSACTION] = (val) => schemaEncoder$1(encoders)(TransactionSchema$1)(val);
-encoders[CODEC$1.OP_ORIGINATION] = (val) => schemaEncoder$1(encoders)(OriginationSchema$1)(val);
-encoders[CODEC$1.OP_BALLOT] = (val) => schemaEncoder$1(encoders)(BallotSchema$1)(val);
-encoders[CODEC$1.OP_ATTESTATION] = (val) => schemaEncoder$1(encoders)(AttestationSchema$1)(val);
-encoders[CODEC$1.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder$1(encoders)(AttestationWithDalSchema$1)(val);
-encoders[CODEC$1.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder$1(encoders)(SeedNonceRevelationSchema$1)(val);
-encoders[CODEC$1.OP_PROPOSALS] = (val) => schemaEncoder$1(encoders)(ProposalsSchema$1)(val);
-encoders[CODEC$1.OP_REVEAL] = (val) => schemaEncoder$1(encoders)(RevealSchema$1)(val);
-encoders[CODEC$1.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder$1(encoders)(RegisterGlobalConstantSchema$1)(val);
-encoders[CODEC$1.OP_TRANSFER_TICKET] = (val) => schemaEncoder$1(encoders)(TransferTicketSchema$1)(val);
-encoders[CODEC$1.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder$1(encoders)(IncreasePaidStorageSchema$1)(val);
-encoders[CODEC$1.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder$1(encoders)(UpdateConsensusKeySchema$1)(val);
-encoders[CODEC$1.OP_DRAIN_DELEGATE] = (val) => schemaEncoder$1(encoders)(DrainDelegateSchema$1)(val);
-encoders[CODEC$1.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder$1(encoders)(SmartRollupOriginateSchema$1)(val);
-encoders[CODEC$1.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder$1(encoders)(SmartRollupAddMessagesSchema$1)(val);
-encoders[CODEC$1.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder$1(encoders)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-encoders[CODEC$1.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder$1(encoders)(DalPublishCommitmentSchema$1)(val);
-encoders[CODEC$1.MANAGER] = schemaEncoder$1(encoders)(ManagerOperationSchema$1);
-encoders[CODEC$1.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder$1(encoders)(SetDepositsLimitSchema$1)(val);
-encoders[CODEC$1.OP_FAILING_NOOP] = (val) => schemaEncoder$1(encoders)(FailingNoopSchema$1)(val);
+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 encodersProto021 = {
+const encoders = {
     [CODEC.SECRET]: (val) => val,
     [CODEC.RAW]: (val) => val,
     [CODEC.TZ1]: tz1Encoder,
@@ -2614,34 +2924,35 @@ const encodersProto021 = {
     [CODEC.ENTRYPOINT]: entrypointNameEncoder,
     [CODEC.BURN_LIMIT]: burnLimitEncoder,
     [CODEC.DEPOSITS_LIMIT]: depositsLimitEncoder,
+    [CODEC.SIGNATURE_PROOF]: signatureProofEncoder,
     [CODEC.PVM_KIND]: pvmKindEncoder,
     [CODEC.PADDED_BYTES]: paddedBytesEncoder,
     [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder,
     [CODEC.SLOT_HEADER]: slotHeaderEncoder,
 };
-encodersProto021[CODEC.OPERATION] = operationEncoder(encodersProto021);
-encodersProto021[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encodersProto021)(ActivationSchema)(val);
-encodersProto021[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encodersProto021)(DelegationSchema)(val);
-encodersProto021[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encodersProto021)(TransactionSchema)(val);
-encodersProto021[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encodersProto021)(OriginationSchema)(val);
-encodersProto021[CODEC.OP_BALLOT] = (val) => schemaEncoder(encodersProto021)(BallotSchema)(val);
-encodersProto021[CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encodersProto021)(AttestationSchema)(val);
-encodersProto021[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encodersProto021)(AttestationWithDalSchema)(val);
-encodersProto021[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encodersProto021)(SeedNonceRevelationSchema)(val);
-encodersProto021[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encodersProto021)(ProposalsSchema)(val);
-encodersProto021[CODEC.OP_REVEAL] = (val) => schemaEncoder(encodersProto021)(RevealSchema)(val);
-encodersProto021[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encodersProto021)(RegisterGlobalConstantSchema)(val);
-encodersProto021[CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encodersProto021)(TransferTicketSchema)(val);
-encodersProto021[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encodersProto021)(IncreasePaidStorageSchema)(val);
-encodersProto021[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder(encodersProto021)(UpdateConsensusKeySchema)(val);
-encodersProto021[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encodersProto021)(DrainDelegateSchema)(val);
-encodersProto021[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encodersProto021)(SmartRollupOriginateSchema)(val);
-encodersProto021[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encodersProto021)(SmartRollupAddMessagesSchema)(val);
-encodersProto021[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encodersProto021)(SmartRollupExecuteOutboxMessageSchema)(val);
-encodersProto021[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encodersProto021)(DalPublishCommitmentSchema)(val);
-encodersProto021[CODEC.MANAGER] = schemaEncoder(encodersProto021)(ManagerOperationSchema);
-encodersProto021[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encodersProto021)(SetDepositsLimitSchema)(val);
-encodersProto021[CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encodersProto021)(FailingNoopSchema)(val);
+encoders[CODEC.OPERATION] = operationEncoder(encoders);
+encoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encoders)(ActivationSchema)(val);
+encoders[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encoders)(DelegationSchema)(val);
+encoders[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encoders)(TransactionSchema)(val);
+encoders[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encoders)(OriginationSchema)(val);
+encoders[CODEC.OP_BALLOT] = (val) => schemaEncoder(encoders)(BallotSchema)(val);
+encoders[CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encoders)(AttestationSchema)(val);
+encoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encoders)(AttestationWithDalSchema)(val);
+encoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encoders)(SeedNonceRevelationSchema)(val);
+encoders[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encoders)(ProposalsSchema)(val);
+encoders[CODEC.OP_REVEAL] = (val) => schemaEncoder(encoders)(RevealSchema)(val);
+encoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encoders)(RegisterGlobalConstantSchema)(val);
+encoders[CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encoders)(TransferTicketSchema)(val);
+encoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encoders)(IncreasePaidStorageSchema)(val);
+encoders[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder(encoders)(UpdateConsensusKeySchema)(val);
+encoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encoders)(DrainDelegateSchema)(val);
+encoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encoders)(SmartRollupOriginateSchema)(val);
+encoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encoders)(SmartRollupAddMessagesSchema)(val);
+encoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+encoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encoders)(DalPublishCommitmentSchema)(val);
+encoders[CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
+encoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encoders)(SetDepositsLimitSchema)(val);
+encoders[CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encoders)(FailingNoopSchema)(val);
 
 const OperationKindMapping = {
     activate_account: ActivationSchema$1,
@@ -2658,6 +2969,7 @@ const OperationKindMapping = {
     transfer_ticket: TransferTicketSchema$1,
     increase_paid_storage: IncreasePaidStorageSchema$1,
     update_consensus_key: UpdateConsensusKeySchema$1,
+    update_companion_key: UpdateCompanionKeySchema,
     drain_delegate: DrainDelegateSchema$1,
     set_deposits_limit: SetDepositsLimitSchema$1,
     smart_rollup_originate: SmartRollupOriginateSchema$1,
@@ -2717,6 +3029,7 @@ var ProtocolsHash;
     ProtocolsHash["PsParisCZ"] = "PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi";
     ProtocolsHash["PsQuebecn"] = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg";
     ProtocolsHash["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
+    ProtocolsHash["PtSeouLou"] = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh";
     ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(ProtocolsHash || (ProtocolsHash = {}));
 const protoLevel = {
@@ -2741,6 +3054,7 @@ const protoLevel = {
     PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi: 20,
     PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg: 21,
     PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7: 22,
+    PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh: 23,
     ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 23,
 };
 function ProtoInferiorTo(a, b) {
@@ -2749,32 +3063,32 @@ function ProtoInferiorTo(a, b) {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "f0eb755ed1e0de4d1cd86623df4496f76efd0caf",
-    "version": "22.0.0-beta.0"
+    "commitHash": "7af2138a9e5c5b230c4b4c726f35c2f2e67b721c",
+    "version": "23.0.0-beta.0"
 };
 
 /**
  * @packageDocumentation
  * @module @taquito/local-forging
  */
-const PROTOCOL_CURRENT = ProtocolsHash.PsRiotuma;
+const PROTOCOL_CURRENT = ProtocolsHash.PtSeouLou;
 function getCodec(codec, _proto) {
-    // use encodersProto021 & decodersProto021 if it's quebec or prior
-    if (_proto === ProtocolsHash.PsQuebecn || ProtoInferiorTo(_proto, ProtocolsHash.PsQuebecn)) {
+    // use encodersProto022 & decodersProto022 if it's rio or prior
+    if (_proto === ProtocolsHash.PsRiotuma || ProtoInferiorTo(_proto, ProtocolsHash.PsRiotuma)) {
         return {
-            encoder: encodersProto021[codec],
+            encoder: encoders[codec],
             decoder: (hex) => {
                 const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                return decodersProto021[codec](consumer);
+                return decoders[codec](consumer);
             },
         };
     }
     else {
         return {
-            encoder: encoders[codec],
+            encoder: encoders$1[codec],
             decoder: (hex) => {
                 const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                return decoders[codec](consumer);
+                return decoders$1[codec](consumer);
             },
         };
     }
@@ -2821,6 +3135,12 @@ class LocalForger {
                 else if (content.kind === 'update_consensus_key' && diff[0] === 'proof') {
                     continue;
                 }
+                else if (content.kind === 'update_companion_key' && diff[0] === 'proof') {
+                    continue;
+                }
+                else if (content.kind === 'reveal' && diff[0] === 'proof') {
+                    continue;
+                }
                 else {
                     throw new InvalidOperationSchemaError(content, `missing properties "${diff.join(', ')}"`);
                 }
@@ -2838,5 +3158,5 @@ class LocalForger {
 }
 const localForger = new LocalForger();
 
-export { CODEC$1 as CODEC, LocalForger, ProtocolsHash, Uint8ArrayConsumer, VERSION, decoders, encoders, getCodec, localForger, opMapping$1 as opMapping, opMappingReverse };
+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 };
 //# sourceMappingURL=taquito-local-forging.es6.js.map