Repository: ecadlabs/taquito
Pull request #1839 (2022-08-22 17:04:08)

refactor(local-forging): remove ithaca
The distinction for jakarta has been removed in the local-forging. It was only required while
testing against jakarta and prior protocols and before the transition.

Thank you for your contribution to Taquito.

Before submitting this PR, please make sure:

- [ ] Your code builds cleanly without any errors or warnings
- [ ] You have added unit tests
- [ ] You have added integration tests (if relevant/appropriate)
- [ ] All public methods or types have TypeDoc coverage with a complete description, and ideally an @example
- [ ] You have added or updated corresponding documentation
- [ ] If relevant, you have written a first draft summary describing the change for inclusion in Release Notes. 

## Release Note Draft Snippet

__If relevant, please write a summary of your change that will be suitable for
inclusion in the Release Notes for the next Taquito release.__



Patch:
diff --git a/packages/taquito-local-forging/src/codec.ts b/packages/taquito-local-forging/src/codec.ts
index 208ebbdc1..2bd535c42 100644
--- a/packages/taquito-local-forging/src/codec.ts
+++ b/packages/taquito-local-forging/src/codec.ts
@@ -330,3 +330,46 @@ export const valueParameterDecoder = (val: Uint8ArrayConsumer) => {
 
 export const blockPayloadHashEncoder = prefixEncoder(Prefix.VH);
 export const blockPayloadHashDecoder = prefixDecoder(Prefix.VH);
+
+export const entrypointNameEncoder = (entrypoint: string) => {
+  const value = { string: entrypoint };
+  return `${valueEncoder(value).slice(2)}`;
+};
+
+export const entrypointNameDecoder = (val: Uint8ArrayConsumer) => {
+  const entry = extractRequiredLen(val);
+
+  return Buffer.from(entry).toString('utf8');
+};
+
+export const txRollupOriginationParamEncoder = (_value: string) => {
+  return '';
+};
+
+export const txRollupOriginationParamDecoder = (_val: Uint8ArrayConsumer) => {
+  return {};
+};
+
+export const txRollupIdEncoder = prefixEncoder(Prefix.TXR1);
+
+export const txRollupIdDecoder = prefixDecoder(Prefix.TXR1);
+
+export const txRollupBatchContentEncoder = (value: string) => {
+  return `${pad(value.length / 2)}${value}`;
+};
+
+export const txRollupBatchContentDecoder = (val: Uint8ArrayConsumer) => {
+  const value = extractRequiredLen(val);
+  return Buffer.from(value).toString('hex');
+};
+
+export const burnLimitEncoder = (val: string) => {
+  return !val ? '00' : `ff${zarithEncoder(val)}`;
+};
+
+export const burnLimitDecoder = (value: Uint8ArrayConsumer) => {
+  const prefix = value.consume(1);
+  if (Buffer.from(prefix).toString('hex') !== '00') {
+    return zarithDecoder(value);
+  }
+};
diff --git a/packages/taquito-local-forging/src/constants.ts b/packages/taquito-local-forging/src/constants.ts
index a028cac90..0eab9bd8c 100644
--- a/packages/taquito-local-forging/src/constants.ts
+++ b/packages/taquito-local-forging/src/constants.ts
@@ -183,7 +183,7 @@ export const opMapping: { [key: string]: string } = {
   '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',
@@ -199,6 +199,9 @@ export const opMapping: { [key: string]: string } = {
   '91': 'view',
   '92': 'constant',
   '93': 'SUB_MUTEZ',
+  '94': 'tx_rollup_l2_address',
+  '95': 'MIN_BLOCK_TIME',
+  '96': 'sapling_transaction',
 };
 
 export const opMappingReverse = (() => {
diff --git a/packages/taquito-local-forging/src/decoder.ts b/packages/taquito-local-forging/src/decoder.ts
index 630f1848e..b357f8b88 100644
--- a/packages/taquito-local-forging/src/decoder.ts
+++ b/packages/taquito-local-forging/src/decoder.ts
@@ -3,7 +3,9 @@ import {
   ballotDecoder,
   blockPayloadHashDecoder,
   branchDecoder,
+  burnLimitDecoder,
   delegateDecoder,
+  entrypointNameDecoder,
   int16Decoder,
   int32Decoder,
   parametersDecoder,
@@ -11,6 +13,9 @@ import {
   proposalDecoder,
   proposalsDecoder,
   publicKeyDecoder,
+  txRollupBatchContentDecoder,
+  txRollupIdDecoder,
+  txRollupOriginationParamDecoder,
   tz1Decoder,
   valueParameterDecoder,
   zarithDecoder,
@@ -31,6 +36,9 @@ import {
   schemaDecoder,
   SeedNonceRevelationSchema,
   TransactionSchema,
+  TransferTicketSchema,
+  TxRollupOriginationSchema,
+  TxRollupSubmitBatchSchema,
 } from './schema/operation';
 import { Uint8ArrayConsumer } from './uint8array-consumer';
 import { toHexString } from './utils';
@@ -56,6 +64,11 @@ export const decoders: { [key: string]: Decoder } = {
   [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);
@@ -77,4 +90,10 @@ decoders[CODEC.OP_PROPOSALS] = (val: Uint8ArrayConsumer) =>
 decoders[CODEC.OP_REVEAL] = (val: Uint8ArrayConsumer) => schemaDecoder(decoders)(RevealSchema)(val);
 decoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val: Uint8ArrayConsumer) =>
   schemaDecoder(decoders)(RegisterGlobalConstantSchema)(val);
+decoders[CODEC.OP_TRANSFER_TICKET] = (val: Uint8ArrayConsumer) =>
+  schemaDecoder(decoders)(TransferTicketSchema)(val);
+decoders[CODEC.OP_TX_ROLLUP_ORIGINATION] = (val: Uint8ArrayConsumer) =>
+  schemaDecoder(decoders)(TxRollupOriginationSchema)(val);
+decoders[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val: Uint8ArrayConsumer) =>
+  schemaDecoder(decoders)(TxRollupSubmitBatchSchema)(val);
 decoders[CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
diff --git a/packages/taquito-local-forging/src/encoder.ts b/packages/taquito-local-forging/src/encoder.ts
index ebd1bd496..77b9c9813 100644
--- a/packages/taquito-local-forging/src/encoder.ts
+++ b/packages/taquito-local-forging/src/encoder.ts
@@ -3,7 +3,9 @@ import {
   ballotEncoder,
   blockPayloadHashEncoder,
   branchEncoder,
+  burnLimitEncoder,
   delegateEncoder,
+  entrypointNameEncoder,
   int16Encoder,
   int32Encoder,
   parametersEncoder,
@@ -11,6 +13,9 @@ import {
   proposalEncoder,
   proposalsEncoder,
   publicKeyEncoder,
+  txRollupBatchContentEncoder,
+  txRollupIdEncoder,
+  txRollupOriginationParamEncoder,
   tz1Encoder,
   valueParameterEncoder,
   zarithEncoder,
@@ -31,6 +36,9 @@ import {
   schemaEncoder,
   SeedNonceRevelationSchema,
   TransactionSchema,
+  TransferTicketSchema,
+  TxRollupOriginationSchema,
+  TxRollupSubmitBatchSchema,
 } from './schema/operation';
 
 export type Encoder<T> = (val: T) => string;
@@ -54,6 +62,11 @@ export const encoders: { [key: string]: Encoder<any> } = {
   [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);
@@ -69,4 +82,10 @@ encoders[CODEC.OP_PROPOSALS] = (val: any) => schemaEncoder(encoders)(ProposalsSc
 encoders[CODEC.OP_REVEAL] = (val: any) => schemaEncoder(encoders)(RevealSchema)(val);
 encoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val: any) =>
   schemaEncoder(encoders)(RegisterGlobalConstantSchema)(val);
+encoders[CODEC.OP_TRANSFER_TICKET] = (val: any) =>
+  schemaEncoder(encoders)(TransferTicketSchema)(val);
+encoders[CODEC.OP_TX_ROLLUP_ORIGINATION] = (val: any) =>
+  schemaEncoder(encoders)(TxRollupOriginationSchema)(val);
+encoders[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val: any) =>
+  schemaEncoder(encoders)(TxRollupSubmitBatchSchema)(val);
 encoders[CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
diff --git a/packages/taquito-local-forging/src/proto13-jakarta/codec-proto13.ts b/packages/taquito-local-forging/src/proto13-jakarta/codec-proto13.ts
deleted file mode 100644
index 291db8852..000000000
--- a/packages/taquito-local-forging/src/proto13-jakarta/codec-proto13.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { Prefix } from '@taquito/utils';
-import {
-  entrypointDecoder,
-  prefixDecoder,
-  prefixEncoder,
-  zarithDecoder,
-  zarithEncoder,
-} from '../codec';
-import { entrypointMappingReverse, ENTRYPOINT_MAX_LENGTH } from '../constants';
-import { OversizedEntryPointError } from '../error';
-import { extractRequiredLen, MichelsonValue } from '../michelson/codec';
-import { Uint8ArrayConsumer } from '../uint8array-consumer';
-import { pad } from '../utils';
-import { valueDecoderProto13, valueEncoderProto13 } from './michelson-proto13/codec-proto13';
-
-export const parametersDecoderProto13 = (val: Uint8ArrayConsumer) => {
-  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,
-    };
-  }
-};
-
-export const valueParameterDecoderProto13 = (val: Uint8ArrayConsumer) => {
-  const value = extractRequiredLen(val);
-  return valueDecoderProto13(new Uint8ArrayConsumer(value));
-};
-
-export const entrypointEncoderProto13 = (entrypoint: string) => {
-  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)}`;
-  }
-};
-
-export const entrypointNameEncoderProto13 = (entrypoint: string) => {
-  const value = { string: entrypoint };
-  return `${valueEncoderProto13(value).slice(2)}`;
-};
-
-export const entrypointNameDecoderProto13 = (val: Uint8ArrayConsumer) => {
-  const entry = extractRequiredLen(val);
-
-  return Buffer.from(entry).toString('utf8');
-};
-
-export const parametersEncoderProto13 = (val: { entrypoint: string; value: MichelsonValue }) => {
-  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}`;
-};
-
-export const valueParameterEncoderProto13 = (value: MichelsonValue) => {
-  const valueEncoded = valueEncoderProto13(value);
-  return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
-};
-
-export const txRollupOriginationParamEncoderProto13 = (_value: string) => {
-  return '';
-};
-
-export const txRollupOriginationParamDecoderProto13 = (_val: Uint8ArrayConsumer) => {
-  return {};
-};
-
-export const txRollupIdEncoderProto13 = prefixEncoder(Prefix.TXR1);
-
-export const txRollupIdDecoderProto13 = prefixDecoder(Prefix.TXR1);
-
-export const txRollupBatchContentEncoderProto13 = (value: string) => {
-  return `${pad(value.length / 2)}${value}`;
-};
-
-export const txRollupBatchContentDecoderProto13 = (val: Uint8ArrayConsumer) => {
-  const value = extractRequiredLen(val);
-  return Buffer.from(value).toString('hex');
-};
-
-export const burnLimitEncoder = (val: string) => {
-  return !val ? '00' : `ff${zarithEncoder(val)}`;
-};
-
-export const burnLimitDecoder = (value: Uint8ArrayConsumer) => {
-  const prefix = value.consume(1);
-  if (Buffer.from(prefix).toString('hex') !== '00') {
-    return zarithDecoder(value);
-  }
-};
diff --git a/packages/taquito-local-forging/src/proto13-jakarta/constants-proto13.ts b/packages/taquito-local-forging/src/proto13-jakarta/constants-proto13.ts
deleted file mode 100644
index 11d6ca0a7..000000000
--- a/packages/taquito-local-forging/src/proto13-jakarta/constants-proto13.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { opMapping as opMappingGeneral } from './../constants';
-
-export const opMappingProto13: { [key: string]: string } = {
-  ...opMappingGeneral,
-  '84': 'sapling_transaction_deprecated',
-  '94': 'tx_rollup_l2_address',
-  '95': 'MIN_BLOCK_TIME',
-  '96': 'sapling_transaction',
-};
-
-export const opMappingReverseProto13 = (() => {
-  const result: { [key: string]: string } = {};
-  Object.keys(opMappingProto13).forEach((key: string) => {
-    result[opMappingProto13[key]] = key;
-  });
-  return result;
-})();
diff --git a/packages/taquito-local-forging/src/proto13-jakarta/decoder-proto13.ts b/packages/taquito-local-forging/src/proto13-jakarta/decoder-proto13.ts
deleted file mode 100644
index 0f615ff28..000000000
--- a/packages/taquito-local-forging/src/proto13-jakarta/decoder-proto13.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import { Decoder, decoders } from '../decoder';
-import { CODEC } from '../constants';
-import { Uint8ArrayConsumer } from '../uint8array-consumer';
-import {
-  entrypointNameDecoderProto13,
-  parametersDecoderProto13,
-  valueParameterDecoderProto13,
-  txRollupBatchContentDecoderProto13,
-  txRollupIdDecoderProto13,
-  txRollupOriginationParamDecoderProto13,
-  burnLimitDecoder,
-} from './codec-proto13';
-import {
-  ActivationSchema,
-  BallotSchema,
-  DelegationSchema,
-  EndorsementSchema,
-  ManagerOperationSchema,
-  operationDecoder,
-  OriginationSchema,
-  ProposalsSchema,
-  RegisterGlobalConstantSchema,
-  RevealSchema,
-  schemaDecoder,
-  SeedNonceRevelationSchema,
-  TransactionSchema,
-} from '../schema/operation';
-import { scriptDecoderProto13 } from './michelson-proto13/codec-proto13';
-import {
-  TransferTicketSchema,
-  TxRollupOriginationSchema,
-  TxRollupSubmitBatchSchema,
-} from './schema/operation-proto13';
-
-export const decodersProto13: { [key: string]: Decoder } = {
-  ...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: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(ActivationSchema)(val);
-decodersProto13[CODEC.OP_DELEGATION] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(DelegationSchema)(val);
-decodersProto13[CODEC.OP_TRANSACTION] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(TransactionSchema)(val);
-decodersProto13[CODEC.OP_ORIGINATION] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(OriginationSchema)(val);
-decodersProto13[CODEC.OP_BALLOT] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(BallotSchema)(val);
-decodersProto13[CODEC.OP_ENDORSEMENT] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(EndorsementSchema)(val);
-decodersProto13[CODEC.OP_SEED_NONCE_REVELATION] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(SeedNonceRevelationSchema)(val);
-decodersProto13[CODEC.OP_PROPOSALS] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(ProposalsSchema)(val);
-decodersProto13[CODEC.OP_REVEAL] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(RevealSchema)(val);
-decodersProto13[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(RegisterGlobalConstantSchema)(val);
-decodersProto13[CODEC.OP_TRANSFER_TICKET] = (val: any) =>
-  schemaDecoder(decodersProto13)(TransferTicketSchema)(val);
-decodersProto13[CODEC.OP_TX_ROLLUP_ORIGINATION] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(TxRollupOriginationSchema)(val);
-decodersProto13[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val: Uint8ArrayConsumer) =>
-  schemaDecoder(decodersProto13)(TxRollupSubmitBatchSchema)(val);
-decodersProto13[CODEC.MANAGER] = schemaDecoder(decodersProto13)(ManagerOperationSchema);
diff --git a/packages/taquito-local-forging/src/proto13-jakarta/encoder-proto13.ts b/packages/taquito-local-forging/src/proto13-jakarta/encoder-proto13.ts
deleted file mode 100644
index fa22fddd6..000000000
--- a/packages/taquito-local-forging/src/proto13-jakarta/encoder-proto13.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { CODEC } from '../constants';
-import { Encoder, encoders } from '../encoder';
-import {
-  ActivationSchema,
-  BallotSchema,
-  DelegationSchema,
-  EndorsementSchema,
-  ManagerOperationSchema,
-  operationEncoder,
-  OriginationSchema,
-  ProposalsSchema,
-  RegisterGlobalConstantSchema,
-  RevealSchema,
-  schemaEncoder,
-  SeedNonceRevelationSchema,
-  TransactionSchema,
-} from '../schema/operation';
-import {
-  entrypointNameEncoderProto13,
-  parametersEncoderProto13,
-  valueParameterEncoderProto13,
-  txRollupOriginationParamEncoderProto13,
-  txRollupIdEncoderProto13,
-  txRollupBatchContentEncoderProto13,
-  burnLimitEncoder,
-} from './codec-proto13';
-import { scriptEncoderProto13 } from './michelson-proto13/codec-proto13';
-import {
-  TransferTicketSchema,
-  TxRollupOriginationSchema,
-  TxRollupSubmitBatchSchema,
-} from './schema/operation-proto13';
-
-export const encodersProto13: { [key: string]: Encoder<any> } = {
-  ...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: any) =>
-  schemaEncoder(encodersProto13)(ActivationSchema)(val);
-encodersProto13[CODEC.OP_DELEGATION] = (val: any) =>
-  schemaEncoder(encodersProto13)(DelegationSchema)(val);
-encodersProto13[CODEC.OP_TRANSACTION] = (val: any) =>
-  schemaEncoder(encodersProto13)(TransactionSchema)(val);
-encodersProto13[CODEC.OP_ORIGINATION] = (val: any) =>
-  schemaEncoder(encodersProto13)(OriginationSchema)(val);
-encodersProto13[CODEC.OP_BALLOT] = (val: any) => schemaEncoder(encodersProto13)(BallotSchema)(val);
-encodersProto13[CODEC.OP_ENDORSEMENT] = (val: any) =>
-  schemaEncoder(encodersProto13)(EndorsementSchema)(val);
-encodersProto13[CODEC.OP_SEED_NONCE_REVELATION] = (val: any) =>
-  schemaEncoder(encodersProto13)(SeedNonceRevelationSchema)(val);
-encodersProto13[CODEC.OP_PROPOSALS] = (val: any) =>
-  schemaEncoder(encodersProto13)(ProposalsSchema)(val);
-encodersProto13[CODEC.OP_REVEAL] = (val: any) => schemaEncoder(encodersProto13)(RevealSchema)(val);
-encodersProto13[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val: any) =>
-  schemaEncoder(encodersProto13)(RegisterGlobalConstantSchema)(val);
-encodersProto13[CODEC.OP_TRANSFER_TICKET] = (val: any) =>
-  schemaEncoder(encodersProto13)(TransferTicketSchema)(val);
-encodersProto13[CODEC.OP_TX_ROLLUP_ORIGINATION] = (val: any) =>
-  schemaEncoder(encodersProto13)(TxRollupOriginationSchema)(val);
-encodersProto13[CODEC.OP_TX_ROLLUP_SUBMIT_BATCH] = (val: any) =>
-  schemaEncoder(encodersProto13)(TxRollupSubmitBatchSchema)(val);
-encodersProto13[CODEC.MANAGER] = schemaEncoder(encodersProto13)(ManagerOperationSchema);
diff --git a/packages/taquito-local-forging/src/proto13-jakarta/michelson-proto13/codec-proto13.ts b/packages/taquito-local-forging/src/proto13-jakarta/michelson-proto13/codec-proto13.ts
deleted file mode 100644
index 523d96d89..000000000
--- a/packages/taquito-local-forging/src/proto13-jakarta/michelson-proto13/codec-proto13.ts
+++ /dev/null
@@ -1,177 +0,0 @@
-import { Decoder } from '../../decoder';
-import { pad } from '../../utils';
-import { Encoder } from '../../encoder';
-import {
-  bytesDecoder,
-  bytesEncoder,
-  decodeAnnots,
-  encodeAnnots,
-  extractRequiredLen,
-  intDecoder,
-  intEncoder,
-  isBytes,
-  isInt,
-  isPrim,
-  isString,
-  MichelsonValue,
-  PrimValue,
-  stringDecoder,
-  stringEncoder,
-} from '../../michelson/codec';
-import { Uint8ArrayConsumer } from '../../uint8array-consumer';
-import { opMappingProto13, opMappingReverseProto13 } from '../constants-proto13';
-import { UnexpectedMichelsonValueError } from '../../error';
-
-export const scriptEncoderProto13: Encoder<{ code: MichelsonValue; storage: MichelsonValue }> = (
-  script
-) => {
-  const code = valueEncoderProto13(script.code);
-  const storage = valueEncoderProto13(script.storage);
-  return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
-};
-
-export const scriptDecoderProto13: Decoder = (value: Uint8ArrayConsumer) => {
-  const code = extractRequiredLen(value);
-  const storage = extractRequiredLen(value);
-
-  return {
-    code: valueDecoderProto13(new Uint8ArrayConsumer(code)),
-    storage: valueDecoderProto13(new Uint8ArrayConsumer(storage)),
-  };
-};
-
-export const valueEncoderProto13: Encoder<MichelsonValue> = (value: MichelsonValue) => {
-  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');
-};
-
-export const valueDecoderProto13: Decoder = (value: Uint8ArrayConsumer) => {
-  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);
-  }
-};
-
-export const primEncoderProto13: Encoder<PrimValue> = (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}`;
-};
-
-export const primDecoderProto13 = (value: Uint8ArrayConsumer, preamble: Uint8Array) => {
-  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: Partial<PrimValue> = {
-    prim: opMappingProto13[op],
-  };
-
-  if (opMappingProto13[op] === 'LAMBDA') {
-    value.consume(4);
-  }
-
-  if (opMappingProto13[op] === 'view') {
-    if (argsCount != 0) {
-      return primViewDecoderProto13(value, result) as any;
-    } 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 as any;
-  } else if (args.length) {
-    result['args'] = args as any;
-  }
-
-  if (combPairAnnots && (combPairAnnots as any)[0] !== '') {
-    result['annots'] = combPairAnnots as any;
-  } else if (hasAnnot) {
-    result['annots'] = decodeAnnots(value) as any;
-  }
-
-  return result;
-};
-
-export const primViewDecoderProto13 = (value: Uint8ArrayConsumer, result: Partial<PrimValue>) => {
-  value.consume(4);
-  result['args'] = new Array(4).fill(0).map(() => valueDecoderProto13(value)) as any;
-  value.consume(4);
-  return result;
-};
-
-export const decodeCombPair: Decoder = (val: Uint8ArrayConsumer) => {
-  const array = new Uint8ArrayConsumer(extractRequiredLen(val));
-  const args = [];
-  while (array.length() > 0) {
-    args.push(valueDecoderProto13(array));
-  }
-  return args;
-};
diff --git a/packages/taquito-local-forging/src/proto13-jakarta/schema/operation-proto13.ts b/packages/taquito-local-forging/src/proto13-jakarta/schema/operation-proto13.ts
deleted file mode 100644
index c8a9989e8..000000000
--- a/packages/taquito-local-forging/src/proto13-jakarta/schema/operation-proto13.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { CODEC } from "../../constants";
-
-export 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,
-};
-
-export 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,
-};
-
-export 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,
-};
diff --git a/packages/taquito-local-forging/src/schema/operation.ts b/packages/taquito-local-forging/src/schema/operation.ts
index 22e0786e5..3473ac91d 100644
--- a/packages/taquito-local-forging/src/schema/operation.ts
+++ b/packages/taquito-local-forging/src/schema/operation.ts
@@ -92,6 +92,40 @@ export const RegisterGlobalConstantSchema = {
   value: CODEC.VALUE,
 };
 
+export 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,
+};
+
+export 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,
+};
+
+export 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,
+};
+
 export const operationEncoder =
   (encoders: { [key: string]: (val: object) => string }) => (operation: { kind: string }) => {
     if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse)) {
@@ -122,73 +156,71 @@ export const operationDecoder =
     };
   };
 
-  type Schema = Record<string, CODEC | CODEC[]>
-  export type Value = Record<keyof Schema, unknown[]>
-  
-  export const schemaEncoder =
-    (encoders: { [key: string]: (val: object) => string }) => 
-      (schema: Schema) => 
-        (value: Value) => {
-          const keys = Object.keys(schema);
-          return keys.reduce((prev, key) => {
-            const valueToEncode = schema[key] as CODEC;
-      
-            if (value && Array.isArray(valueToEncode)) {
-              const encoder = encoders[valueToEncode[0]];
-              const values = value[key];
-      
-              if (!Array.isArray(values)) {
-                throw new OperationEncodingError(`Expected value to be Array ${JSON.stringify(values)}`);
-              }
-      
-              return prev + values.reduce((prevBytes, current) => prevBytes + encoder(current), '');
-            } else {
-              const encoder = encoders[valueToEncode];
-              return prev + encoder(value[key]);
-            }
-          }, '');
-        };
+type Schema = Record<string, CODEC | CODEC[]>;
+export type Value = Record<keyof Schema, unknown[]>;
+
+export const schemaEncoder =
+  (encoders: { [key: string]: (val: object) => string }) => (schema: Schema) => (value: Value) => {
+    const keys = Object.keys(schema);
+    return keys.reduce((prev, key) => {
+      const valueToEncode = schema[key] as CODEC;
+
+      if (value && Array.isArray(valueToEncode)) {
+        const encoder = encoders[valueToEncode[0]];
+        const values = value[key];
+
+        if (!Array.isArray(values)) {
+          throw new OperationEncodingError(`Expected value to be Array ${JSON.stringify(values)}`);
+        }
+
+        return prev + values.reduce((prevBytes, current) => prevBytes + encoder(current), '');
+      } else {
+        const encoder = encoders[valueToEncode];
+        return prev + encoder(value[key]);
+      }
+    }, '');
+  };
 
 export const schemaDecoder =
-(decoders: { [key: string]: Decoder }) =>
+  (decoders: { [key: string]: Decoder }) =>
   (schema: { [key: string]: string | string[] }) =>
-    (value: Uint8ArrayConsumer) => {
-      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');
-            }
+  (value: Uint8ArrayConsumer) => {
+    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 {
+          ...prev,
+          [key]: decoded,
+        };
+      } else {
+        const decoder = decoders[valueToEncode];
 
+        const result = decoder(value);
+
+        if (typeof result !== 'undefined') {
           return {
             ...prev,
-            [key]: decoded,
+            [key]: result,
           };
         } else {
-          const decoder = decoders[valueToEncode];
-
-          const result = decoder(value);
-
-          if (typeof result !== 'undefined') {
-            return {
-              ...prev,
-              [key]: result,
-            };
-          } else {
-            return {
-              ...prev,
-            };
-          }
+          return {
+            ...prev,
+          };
         }
-      }, {});
-    };
+      }
+    }, {});
+  };
diff --git a/packages/taquito-local-forging/src/taquito-local-forging.ts b/packages/taquito-local-forging/src/taquito-local-forging.ts
index baa2f9079..444149faf 100644
--- a/packages/taquito-local-forging/src/taquito-local-forging.ts
+++ b/packages/taquito-local-forging/src/taquito-local-forging.ts
@@ -11,9 +11,7 @@ import { Uint8ArrayConsumer } from './uint8array-consumer';
 import { validateBlock, ValidationResult, InvalidOperationKindError } from '@taquito/utils';
 import { InvalidBlockHashError, InvalidOperationSchemaError } from './error';
 import { validateMissingProperty, validateOperationKind } from './validator';
-import { ProtocolsHash, ProtoInferiorTo } from './protocols';
-import { encodersProto13 } from './proto13-jakarta/encoder-proto13';
-import { decodersProto13 } from './proto13-jakarta/decoder-proto13';
+import { ProtocolsHash } from './protocols';
 
 export { CODEC } from './constants';
 export * from './decoder';
@@ -25,24 +23,14 @@ export { ProtocolsHash } from './protocols';
 
 const PROTOCOL_CURRENT = ProtocolsHash.Psithaca2;
 
-export function getCodec(codec: CODEC, proto: ProtocolsHash) {
-  if (proto === ProtocolsHash.Psithaca2 || ProtoInferiorTo(proto, ProtocolsHash.Psithaca2)) {
-    return {
-      encoder: encoders[codec],
-      decoder: (hex: string) => {
-        const consumer = Uint8ArrayConsumer.fromHexString(hex);
-        return decoders[codec](consumer) as any;
-      },
-    };
-  } else {
-    return {
-      encoder: encodersProto13[codec],
-      decoder: (hex: string) => {
-        const consumer = Uint8ArrayConsumer.fromHexString(hex);
-        return decodersProto13[codec](consumer) as any;
-      },
-    };
-  }
+export function getCodec(codec: CODEC, _proto: ProtocolsHash) {
+  return {
+    encoder: encoders[codec],
+    decoder: (hex: string) => {
+      const consumer = Uint8ArrayConsumer.fromHexString(hex);
+      return decoders[codec](consumer) as any;
+    },
+  };
 }
 
 export class LocalForger implements Forger {
diff --git a/packages/taquito-local-forging/src/validator.ts b/packages/taquito-local-forging/src/validator.ts
index 9543831c3..51c90accd 100644
--- a/packages/taquito-local-forging/src/validator.ts
+++ b/packages/taquito-local-forging/src/validator.ts
@@ -1,10 +1,5 @@
 import { OpKind } from '@taquito/rpc';
 import { OperationContents } from '@taquito/rpc';
-import {
-  TransferTicketSchema,
-  TxRollupOriginationSchema,
-  TxRollupSubmitBatchSchema,
-} from './proto13-jakarta/schema/operation-proto13';
 import {
   ActivationSchema,
   DelegationSchema,
@@ -16,6 +11,9 @@ import {
   RevealSchema,
   RegisterGlobalConstantSchema,
   EndorsementSchema,
+  TransferTicketSchema,
+  TxRollupOriginationSchema,
+  TxRollupSubmitBatchSchema,
 } from './schema/operation';
 
 type OperationKind =


Test patch:
diff --git a/integration-tests/local-forging.spec.ts b/integration-tests/local-forging.spec.ts
index 5f2373cb2..66d733f09 100644
--- a/integration-tests/local-forging.spec.ts
+++ b/integration-tests/local-forging.spec.ts
@@ -1,11 +1,10 @@
 import { CONFIGS } from "./config";
-import { commonCases, jakartaCases } from '../packages/taquito-local-forging/test/allTestsCases';
+import { commonCases } from '../packages/taquito-local-forging/test/allTestsCases';
 import { LocalForger, ProtocolsHash } from '@taquito/local-forging'
-import { Protocols, TezosToolkit } from "@taquito/taquito";
+import { TezosToolkit } from "@taquito/taquito";
 
 CONFIGS().forEach(({ rpc, protocol }) => {
     const Tezos = new TezosToolkit(rpc);
-    const jakartanetAndMondaynet = protocol === Protocols.ProtoALpha || protocol === Protocols.PtJakart2 ? test: test.skip;
 
     describe(`Test local forger: ${rpc}`, () => {
 
@@ -23,16 +22,5 @@ CONFIGS().forEach(({ rpc, protocol }) => {
                 done();
             });
         });
-
-        jakartaCases.forEach(({ name, operation, expected }) => {
-            const localForger = new LocalForger(protocol as unknown as ProtocolsHash);
-            jakartanetAndMondaynet(`Should give the same result as when forging with the rpc: ${name} (${rpc})`, async done => {
-                const result = await localForger.forge(operation);
-                const rpcResult = await Tezos.rpc.forgeOperations(operation);
-                expect(result).toEqual(rpcResult);
-                expect(await localForger.parse(result)).toEqual(expected || operation);
-                done();
-            });
-        });
     });
 })
\ No newline at end of file
diff --git a/packages/taquito-local-forging/test/allTestsCases.ts b/packages/taquito-local-forging/test/allTestsCases.ts
index a9c973377..2d6749b1f 100644
--- a/packages/taquito-local-forging/test/allTestsCases.ts
+++ b/packages/taquito-local-forging/test/allTestsCases.ts
@@ -29,7 +29,6 @@ import {
   codeContractWithConstant,
 } from './data/contract_with_constant';
 import { codeViewsTopLevel, storageViewsTopLevel } from './data/contract_views_top_level';
-import { opMappingProto13 } from './../src/proto13-jakarta/constants-proto13';
 import { ForgeParams } from '../src/interface';
 import { MichelsonV1Expression, OpKind } from '@taquito/rpc';
 
@@ -806,7 +805,7 @@ export const commonCases: TestCase[] = [
       ],
     },
   },
-  ...extractOp(0, 147, opMapping).map((op): TestCase => {
+  ...extractOp(0, 150, opMapping).map((op): TestCase => {
     return {
       name: `Origination operation (${op})`,
       operation: {
@@ -1286,32 +1285,6 @@ export const commonCases: TestCase[] = [
       ],
     },
   },
-];
-
-export const jakartaCases: TestCase[] = [
-  ...extractOp(132, 150, opMappingProto13).map((op): TestCase => {
-    return {
-      name: `Origination operation (${op})`,
-      operation: {
-        branch: 'BLzyjjHKEKMULtvkpSHxuZxx6ei6fpntH2BTkYZiLgs8zLVstvX',
-        contents: [
-          {
-            kind: OpKind.ORIGINATION,
-            counter: '1',
-            source: 'tz1QZ6KY7d3BuZDT1d19dUxoQrtFPN2QJ3hn',
-            fee: '10000',
-            gas_limit: '10',
-            storage_limit: '10',
-            balance: '0',
-            script: {
-              code: genericCode(op) as MichelsonV1Expression[],
-              storage: genericStorage,
-            },
-          },
-        ],
-      },
-    };
-  }),
   {
     name: `Transfer ticket`,
     operation: {
diff --git a/packages/taquito-local-forging/test/taquito-local-forging.spec.ts b/packages/taquito-local-forging/test/taquito-local-forging.spec.ts
index 2bdf63813..e3d4f3de5 100644
--- a/packages/taquito-local-forging/test/taquito-local-forging.spec.ts
+++ b/packages/taquito-local-forging/test/taquito-local-forging.spec.ts
@@ -1,6 +1,6 @@
-import { LocalForger, ProtocolsHash } from '../src/taquito-local-forging';
+import { LocalForger } from '../src/taquito-local-forging';
 import { ticketCode3, ticketStorage3 } from './data/code_with_ticket';
-import { commonCases, jakartaCases } from './allTestsCases';
+import { commonCases } from './allTestsCases';
 import {
   InvalidOperationSchemaError,
   InvalidBlockHashError,
@@ -20,25 +20,6 @@ describe('Forge and parse operations default protocol', () => {
   });
 });
 
-describe('Forge and parse operations jakarta', () => {
-  const localForger = new LocalForger(ProtocolsHash.ProtoALpha);
-  commonCases.forEach(({ name, operation, expected }) => {
-    test(`Common test: ${name}`, async (done) => {
-      const result = await localForger.forge(operation);
-      expect(await localForger.parse(result)).toEqual(expected || operation);
-      done();
-    });
-  });
-
-  jakartaCases.forEach(({ name, operation, expected }) => {
-    test(`Jakarta test: ${name}`, async (done) => {
-      const result = await localForger.forge(operation);
-      expect(await localForger.parse(result)).toEqual(expected || operation);
-      done();
-    });
-  });
-});
-
 describe('Forge should validate parameters against the schema', () => {
   const localForger = new LocalForger();
   test('Should throw error when operation kind is invalid', async () => {