Repository: ecadlabs/taquito
Pull request #1838 (2022-08-20 00:03:08)

New 1762 map typcheck error

have not recreated a failing test yet though 

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.__


github-actions[bot]: New packages have been deployed to the preview repository at https://npm.preview.tezostaquito.io/.

### Published packages:
```
npm i @taquito/local-forging@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/rpc@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/signer@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/taquito@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/remote-signer@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/tezbridge-wallet@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/michelson-encoder@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/contracts-library@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/ledger-signer@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/beacon-wallet@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/http-utils@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/tezbridge-signer@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/michel-codec@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/utils@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/tzip12@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
npm i @taquito/tzip16@13.0.1-ddc6a986--1838 --registry https://npm.preview.tezostaquito.io/
```
<!-- Sticky Pull Request Commentdeploy-packages -->
codecov-commenter: # [Codecov](https://codecov.io/gh/ecadlabs/taquito/pull/1838?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs) Report
> Merging [#1838](https://codecov.io/gh/ecadlabs/taquito/pull/1838?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs) (cecdbd7) into [master](https://codecov.io/gh/ecadlabs/taquito/commit/659ed9bef21e7956a8968592bca073d369551cf2?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs) (659ed9b) will **increase** coverage by `0.03%`.
> The diff coverage is `100.00%`.

```diff
@@            Coverage Diff             @@
##           master    #1838      +/-   ##
==========================================
+ Coverage   80.48%   80.51%   +0.03%     
==========================================
  Files         211      211              
  Lines       11632    11635       +3     
  Branches     2856     2857       +1     
==========================================
+ Hits         9362     9368       +6     
+ Misses       2164     2161       -3     
  Partials      106      106              
```


| [Impacted Files](https://codecov.io/gh/ecadlabs/taquito/pull/1838?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs) | Coverage Δ | |
|---|---|---|
| [...es/taquito-michelson-encoder/src/schema/storage.ts](https://codecov.io/gh/ecadlabs/taquito/pull/1838/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs#diff-cGFja2FnZXMvdGFxdWl0by1taWNoZWxzb24tZW5jb2Rlci9zcmMvc2NoZW1hL3N0b3JhZ2UudHM=) | `80.62% <100.00%> (+0.46%)` | :arrow_up: |
| [...ages/taquito/src/contract/rpc-contract-provider.ts](https://codecov.io/gh/ecadlabs/taquito/pull/1838/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs#diff-cGFja2FnZXMvdGFxdWl0by9zcmMvY29udHJhY3QvcnBjLWNvbnRyYWN0LXByb3ZpZGVyLnRz) | `94.33% <0.00%> (+0.47%)` | :arrow_up: |
| [packages/taquito/src/contract/contract.ts](https://codecov.io/gh/ecadlabs/taquito/pull/1838/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs#diff-cGFja2FnZXMvdGFxdWl0by9zcmMvY29udHJhY3QvY29udHJhY3QudHM=) | `93.75% <0.00%> (+2.08%)` | :arrow_up: |

Help us with your feedback. Take ten seconds to tell us [how you rate us](https://about.codecov.io/nps?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs). Have a feature suggestion? [Share it here.](https://app.codecov.io/gh/feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=ecadlabs)

github-actions[bot]: A new deploy preview is available on Netlify at https://ddc6a986--tezostaquito.netlify.app
<!-- Sticky Pull Request Commentnetlify-preview -->

Patch:
diff --git a/.github/workflows/algolia.yml b/.github/workflows/algolia.yml
index 76224b866..26b59f5a8 100644
--- a/.github/workflows/algolia.yml
+++ b/.github/workflows/algolia.yml
@@ -20,7 +20,7 @@ jobs:
       uses: actions/checkout@v2
     - uses: actions/setup-node@v2
       with:
-        node-version: 14.x
+        node-version: 16.13.1
     - run: cd website && npm ci
     - name: Run delete script
       run: cd website && npm run delete-index
diff --git a/packages/taquito-http-utils/src/taquito-http-utils.ts b/packages/taquito-http-utils/src/taquito-http-utils.ts
index e700113f1..9b2dc1299 100644
--- a/packages/taquito-http-utils/src/taquito-http-utils.ts
+++ b/packages/taquito-http-utils/src/taquito-http-utils.ts
@@ -14,7 +14,7 @@ enum ResponseType {
   JSON = 'json',
 }
 // Z TODO change any type >.>
-type ObjectType = Record<string, any>
+type ObjectType = Record<string, any>;
 
 export interface HttpRequestOptions {
   url: string;
@@ -51,8 +51,10 @@ export class HttpResponseError extends Error {
 export class HttpRequestFailed extends Error {
   public name = 'HttpRequestFailed';
 
-  constructor(public errorDetail: string) {
-    super(errorDetail);
+  constructor(
+    public message: string
+  ) {
+    super(message);
   }
 }
 
@@ -146,7 +148,7 @@ export class HttpBackend {
           url + this.serialize(query)
         );
       } else {
-        throw new HttpRequestFailed(err as string);
+        throw new HttpRequestFailed(`${method} ${url + this.serialize(query)} ${String(err)}`);
       }
     }
   }
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 =
diff --git a/packages/taquito-michelson-encoder/src/schema/storage.ts b/packages/taquito-michelson-encoder/src/schema/storage.ts
index 841fd1b2f..09d07279b 100644
--- a/packages/taquito-michelson-encoder/src/schema/storage.ts
+++ b/packages/taquito-michelson-encoder/src/schema/storage.ts
@@ -3,6 +3,7 @@ import { BigMapToken } from '../tokens/bigmap';
 import { createToken } from '../tokens/createToken';
 import { OrToken } from '../tokens/or';
 import { PairToken } from '../tokens/pair';
+import { TicketToken } from '../tokens/ticket';
 import {
   BigMapKeyType,
   Semantic,
@@ -149,6 +150,9 @@ export class Schema {
     if (this.root instanceof BigMapToken && Number.isInteger(Number(val))) {
       return true;
     }
+    if (this.root instanceof TicketToken && val.ticketer && val.value && val.amount) {
+      return true
+    }
     try {
       this.root.EncodeObject(val);
       return true;


Test patch:
diff --git a/integration-tests/config.ts b/integration-tests/config.ts
index e15258b6f..092abd07e 100644
--- a/integration-tests/config.ts
+++ b/integration-tests/config.ts
@@ -26,6 +26,7 @@ interface Config {
   knownBigMapContract: string;
   knownTzip1216Contract: string; 
   knownSaplingContract: string; 
+  txRollupAddress: string;
   protocol: Protocols;
   signerConfig: EphemeralConfig | FaucetConfig;
 }
@@ -67,6 +68,7 @@ const kathmandunetEphemeral = {
   knownBigMapContract: 'KT1AwUJp6ozYtzhpf5wVXZPQSFxb64JFcVvi',
   knownTzip1216Contract: 'KT1VjJDRHPWngmzvjdg9HNq4cbLq1R8A6nfe',
   knownSaplingContract: 'KT1W8U1Svr9ZK68SJT871DRuwDk8VjTuXkgd',
+  txRollupAddress: 'txr1ebHhewaVykePYWRH5g8vZchXdX9ebwYZQ',
   protocol: Protocols.PtKathman,
   signerConfig: {
     type: SignerType.EPHEMERAL_KEY as SignerType.EPHEMERAL_KEY,
@@ -76,12 +78,13 @@ const kathmandunetEphemeral = {
 };
 
 const jakartanetEphemeral = {
-  rpc: process.env['TEZOS_RPC_JAKARTANET'] || 'http://ecad-jakartanet-archive.i.tez.ie:8732',
+  rpc: process.env['TEZOS_RPC_JAKARTANET'] || 'https://jakartanet-archive.ecadinfra.com',
   knownBaker: 'tz1cjyja1TU6fiyiFav3mFAdnDsCReJ12hPD',
   knownContract: 'KT1SHtH6qWcWWnQ5gZThCD5EnrErKHxyqxca',
   knownBigMapContract: 'KT1AbzoXYgGXjCD3Msi3spuqa5r5MP3rkvM9',
   knownTzip1216Contract: 'KT1GmRf51jFNMQBFDo2mYKnC8Pjm1d7yDwVj',
   knownSaplingContract: 'KT1G2kvdfPoavgR6Fjdd68M2vaPk14qJ8bhC',
+  txRollupAddress: 'txr1YTdi9BktRmybwhgkhRK7WPrutEWVGJT7w',
   protocol: Protocols.PtJakart2,
   signerConfig: {
     type: SignerType.EPHEMERAL_KEY as SignerType.EPHEMERAL_KEY,
@@ -97,6 +100,7 @@ const mondaynetEphemeral = {
   knownBigMapContract: process.env['TEZOS_MONDAYNET_BIGMAPCONTRACT_ADDRESS'] || '',
   knownTzip1216Contract: process.env['TEZOS_MONDAYNET_TZIP1216CONTRACT_ADDRESS'] || '',
   knownSaplingContract: process.env['TEZOS_MONDAYNET_SAPLINGCONTRACT_ADDRESS'] || '',
+  txRollupAddress: process.env['TEZOS_MONDAYNET_TXROLLUP_ADDRESS'] || '',
   protocol: Protocols.ProtoALpha,
   signerConfig: {
     type: SignerType.EPHEMERAL_KEY as SignerType.EPHEMERAL_KEY,
@@ -112,6 +116,7 @@ const kathmandunetFaucet = {
   knownBigMapContract: 'KT1AwUJp6ozYtzhpf5wVXZPQSFxb64JFcVvi',
   knownTzip1216Contract: 'KT1VjJDRHPWngmzvjdg9HNq4cbLq1R8A6nfe',
   knownSaplingContract: 'KT1W8U1Svr9ZK68SJT871DRuwDk8VjTuXkgd',
+  txRollupAddress: 'txr1ebHhewaVykePYWRH5g8vZchXdX9ebwYZQ',
   protocol: Protocols.PtKathman,
   signerConfig: {
     type: SignerType.FAUCET as SignerType.FAUCET,
@@ -149,6 +154,7 @@ const jakartanetFaucet = {
   knownBigMapContract: 'KT1AbzoXYgGXjCD3Msi3spuqa5r5MP3rkvM9',
   knownTzip1216Contract: 'KT1GmRf51jFNMQBFDo2mYKnC8Pjm1d7yDwVj',
   knownSaplingContract: 'KT1G2kvdfPoavgR6Fjdd68M2vaPk14qJ8bhC',
+  txRollupAddress: 'txr1YTdi9BktRmybwhgkhRK7WPrutEWVGJT7w',
   protocol: Protocols.PtJakart2,
   signerConfig: {
     type: SignerType.FAUCET as SignerType.FAUCET,
@@ -273,6 +279,7 @@ export const CONFIGS = () => {
         knownBigMapContract,
         knownTzip1216Contract,
         knownSaplingContract,
+        txRollupAddress,
         signerConfig,
       }) => {
         const Tezos = new TezosToolkit(new RpcClientCache(new RpcClient(rpc)));
@@ -289,6 +296,7 @@ export const CONFIGS = () => {
           knownBigMapContract,
           knownTzip1216Contract,
           knownSaplingContract,
+          txRollupAddress,
           signerConfig,
           setup: async (preferFreshKey: boolean = false) => {
             if (signerConfig.type === SignerType.FAUCET) {
diff --git a/integration-tests/http-backend-request-error-handling.spec.ts b/integration-tests/http-backend-request-error-handling.spec.ts
new file mode 100644
index 000000000..6b5f2eaa5
--- /dev/null
+++ b/integration-tests/http-backend-request-error-handling.spec.ts
@@ -0,0 +1,37 @@
+import { HttpBackend } from '@taquito/http-utils';
+
+describe('HttpBackend request', () => {
+    it('will fail with method and url in error message', async (done) => {
+        try {
+            const http: HttpBackend = new HttpBackend(1);
+            await http.createRequest<string>({
+              method: 'GET',
+              url: 'https://mainnet.api.tez.ie/chains/main/blocks/head/hash'
+            });
+        } catch (err: any) {
+            expect(err.name).toEqual('HttpRequestFailed')
+            expect(err.message).toContain('GET')
+            expect(err.message).toContain('https://mainnet.api.tez.ie/chains/main/blocks/head/hash')
+            expect(err.message).toContain('Error: timeout of 1ms exceeded')
+        }
+        done()
+      });
+      it('will fail with method, url and query in error message', async (done) => {
+        try {
+            const http: HttpBackend = new HttpBackend(1);
+            await http.createRequest<string>({
+              method: 'GET',
+              url: 'https://mainnet.api.tez.ie/chains/main/blocks/head/helpers/baking_rights',
+              query: {
+                level: 0
+              }
+            });
+        } catch (err: any) {
+            expect(err.name).toEqual('HttpRequestFailed')
+            expect(err.message).toContain('GET')
+            expect(err.message).toContain('https://mainnet.api.tez.ie/chains/main/blocks/head/helpers/baking_rights')
+            expect(err.message).toContain('Error: timeout of 1ms exceeded')
+        }
+        done()
+      });
+})
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/integration-tests/rpc-nodes.spec.ts b/integration-tests/rpc-nodes.spec.ts
index 585bc3b36..76a2f3d49 100644
--- a/integration-tests/rpc-nodes.spec.ts
+++ b/integration-tests/rpc-nodes.spec.ts
@@ -15,6 +15,7 @@ CONFIGS().forEach(
     knownContract,
     knownBigMapContract,
     knownSaplingContract,
+    txRollupAddress, 
   }) => {
     const Tezos = lib;
     const jakartanet = protocol === Protocols.PtJakart2 ? test: test.skip;
@@ -391,25 +392,25 @@ CONFIGS().forEach(
         });
 
         jakartanet('getTxRollupInbox', async (done) => {
-          const inbox = await rpcClient.getTxRollupInbox('txr1YTdi9BktRmybwhgkhRK7WPrutEWVGJT7w', '0');
+          const inbox = await rpcClient.getTxRollupInbox(txRollupAddress, '0');
           expect(inbox).toBeDefined();
           done();
         });
 
         jakartanet('getTxRollupState', async (done) => {
-           const state = await rpcClient.getTxRollupState('txr1YTdi9BktRmybwhgkhRK7WPrutEWVGJT7w');
+           const state = await rpcClient.getTxRollupState(txRollupAddress);
            expect(state).toBeDefined();
            done();
          });
          
         kathmandunet('getTxRollupInbox', async (done) => {
-          const inbox = await rpcClient.getTxRollupInbox('txr1ebHhewaVykePYWRH5g8vZchXdX9ebwYZQ', '0');
+          const inbox = await rpcClient.getTxRollupInbox(txRollupAddress, '0');
           expect(inbox).toBeDefined();
           done();
         });
 
         kathmandunet('getTxRollupState', async (done) => {
-           const state = await rpcClient.getTxRollupState('txr1ebHhewaVykePYWRH5g8vZchXdX9ebwYZQ');
+           const state = await rpcClient.getTxRollupState(txRollupAddress);
            expect(state).toBeDefined();
            done();
          });
diff --git a/integration-tests/wallet-batch.spec.ts b/integration-tests/wallet-batch.spec.ts
index ed7e64bfa..884ed5370 100644
--- a/integration-tests/wallet-batch.spec.ts
+++ b/integration-tests/wallet-batch.spec.ts
@@ -12,7 +12,7 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
             done();
         });
 
-        test('Simple transfers with origination (with code in JSON Michelson format)', async (done) => {
+        test('Verify wallet.batch simple transfers with origination code in JSON Michelson format', async (done) => {
             const batch = Tezos.wallet
                 .batch()
                 .withTransfer({ to: 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu', amount: 0.02 })
@@ -41,7 +41,7 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
             done();
         });
 
-        test('Simple transfers with origination (with code in Michelson format)', async (done) => {
+        test('Verify wallet.batch simple transfers with origination code in Michelson format', async (done) => {
             const batch = Tezos.wallet
                 .batch()
                 .withTransfer({ to: 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu', amount: 0.02 })
@@ -70,7 +70,7 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
             done();
         });
 
-        test('Simple transfers with origination using with', async (done) => {
+        test('Verify wallet.batch simple transfers with origination', async (done) => {
             const op = await Tezos.wallet
                 .batch([
                     {
@@ -105,7 +105,7 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
             done();
         });
 
-        test('Test batch from account with low balance', async (done) => {
+        test('Verify wallet.batch simple transfers from an account with low balance', async (done) => {
             const LocalTez = await createAddress();
             const op = await Tezos.wallet.transfer({ to: await LocalTez.wallet.pkh(), amount: 2 }).send();
             await op.confirmation();
@@ -133,7 +133,7 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
             done();
         });
 
-        test('Chain contract calls', async (done) => {
+        test('Verify wallet.batch simple transfers with chained contract calls', async (done) => {
             const op = await Tezos.wallet
                 .originate({
                     balance: '1',
@@ -172,7 +172,7 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
             done();
         });
 
-        test('Batch transfers and method call', async (done) => {
+        test('Verify wallet.batch with contract.method call', async (done) => {
             const contract = await Tezos.wallet.at(knownContract);
             const batch = await Tezos.wallet
                 .batch([
@@ -197,9 +197,10 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
             expect(await batch.status()).toEqual('applied');
             done();
         });
+    });
 
         test('Batch multiple originations and get contract addresses info from getOriginatedContractAddresses member function', async (done) => {
-          const batch = Tezos.wallet
+            const batch = Tezos.wallet
               .batch()
               .withOrigination({
                 balance: '1',
@@ -211,11 +212,11 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
                 code: ligoSampleMichelson,
                 storage: 0
               });
-          
+
           const op = await batch.send();
           const confirmation = await op.confirmation()
           const currentConfirmation = await op.getCurrentConfirmation()
-          
+
           expect(currentConfirmation).toEqual(1);
           expect(confirmation).toEqual(
               expect.objectContaining({
@@ -229,5 +230,4 @@ CONFIGS().forEach(({ lib, rpc, setup, knownContract, knownBaker, createAddress }
           expect((await op.getOriginatedContractAddresses()).length).toEqual(2);
           done();
         });
-    });
-});
+    });
\ No newline at end of file
diff --git a/integration-tests/wallet-big-map.spec.ts b/integration-tests/wallet-big-map.spec.ts
index f63a4b7e3..c70321fc2 100644
--- a/integration-tests/wallet-big-map.spec.ts
+++ b/integration-tests/wallet-big-map.spec.ts
@@ -1,21 +1,19 @@
 import { CONFIGS } from "./config";
-import { tokenCode, tokenInit } from "./data/tokens";
 import { storageContract } from "./data/storage-contract";
 import { MichelsonMap } from "@taquito/taquito";
-import { storage } from '../packages/taquito-michelson-encoder/data/proto005/unit_contract';
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
 
-  describe(`Test wallet with multiple bigmap variations using: ${rpc}`, () => {
+  describe(`Test contract origination with initialized Map with variants of data through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
 
-    it('originates a contract and initializes bigmaps with variants of data using the wallet API', async (done) => {
-     
+    it('Verify wallet.originate with initialized Map with variants of data', async (done) => {
+
         const op = await Tezos.wallet.originate({
         balance: "1",
         code: storageContract,
diff --git a/integration-tests/wallet-collections.spec.ts b/integration-tests/wallet-collections.spec.ts
index a39b9d66b..0c27b4912 100644
--- a/integration-tests/wallet-collections.spec.ts
+++ b/integration-tests/wallet-collections.spec.ts
@@ -4,13 +4,13 @@ import { collection_code } from "./data/collection_contract";
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  describe(`Collection wallet tests using: ${rpc}`, () => {
+  describe(`Test contract origination with collection through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    it('Originate a contract using wallet api with set,list,map and exercise all collections', async (done) => {
+    it('Verify wallet.originate for a contract with set, list, map and then exercise all collections', async (done) => {
       const addr = await Tezos.signer.publicKeyHash();
 
       const initialStorage = {
diff --git a/integration-tests/wallet-edo-deploy-having-ticket.spec.ts b/integration-tests/wallet-edo-deploy-having-ticket.spec.ts
index 26a728a11..bfe8b1305 100644
--- a/integration-tests/wallet-edo-deploy-having-ticket.spec.ts
+++ b/integration-tests/wallet-edo-deploy-having-ticket.spec.ts
@@ -4,14 +4,14 @@ import { ticketCode, ticketStorage } from '../packages/taquito-local-forging/tes
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
 
-  describe(`Test origination of a token contract made with wallet api using: ${rpc}`, () => {
+  describe(`Test contract origination having ticket with init through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup();
       done()
     })
 
-    it('Originates a contract having ticket with init and the wallet api', async (done) => {
+    it('Verify wallet.originate for a contract having ticket with init', async (done) => {
       const op = await Tezos.wallet.originate({
         code: ticketCode,
         init: ticketStorage
@@ -23,7 +23,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
       done();
     });
 
-    it('Originates a contract having ticket with init in JSON and the wallet api', async (done) => {
+    it('Verify wallet.originate having ticket with init in JSON', async (done) => {
       const op = await Tezos.wallet.originate({
         code: ticketCode,
         init: { prim: 'Pair', args: [ { prim: 'None' }, { prim: 'None' } ] }
@@ -34,7 +34,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
       done();
     });
 
-    it('Originates a contract having ticket with storage and the wallet api', async (done) => {
+    it('Verify wallet.originate for a contract having ticket with storage', async (done) => {
       const op = await Tezos.wallet.originate({
         code: ticketCode,
         storage: {
@@ -45,8 +45,8 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
 
       await op.confirmation();
       expect(op.opHash).toBeDefined();
-      
+
       done();
-    }); 
+    });
   });
 })
diff --git a/integration-tests/wallet-empty-delegated-implicit-account.spec.ts b/integration-tests/wallet-empty-delegated-implicit-account.spec.ts
index 01f294e6e..c535e72f1 100644
--- a/integration-tests/wallet-empty-delegated-implicit-account.spec.ts
+++ b/integration-tests/wallet-empty-delegated-implicit-account.spec.ts
@@ -4,13 +4,13 @@ CONFIGS().forEach(({ lib, rpc, setup, createAddress, knownBaker }) => {
   const Tezos = lib;
 
 
-  describe(`Test emptying a delegated implicit wallet account using: ${rpc}`, () => {
+  describe(`Test emptying a delegated implicit account through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    test('creates a new wallet account, delegates it, and attempts to empty it despite the delegation being expected to fail', async (done) => {
+    test('Verify that new Account can be created, delegated and attempt to empty, it should fail despite delegation', async (done) => {
       const LocalTez = await createAddress();
       const op = await Tezos.wallet.transfer({ to: await LocalTez.signer.publicKeyHash(), amount: 2 }).send();
       await op.confirmation();
diff --git a/integration-tests/wallet-empty-revealed-implicit-account.spec.ts b/integration-tests/wallet-empty-revealed-implicit-account.spec.ts
index 6b3fecb72..db8cc760f 100644
--- a/integration-tests/wallet-empty-revealed-implicit-account.spec.ts
+++ b/integration-tests/wallet-empty-revealed-implicit-account.spec.ts
@@ -2,13 +2,13 @@ import { CONFIGS } from "./config";
 
 CONFIGS().forEach(({ lib, rpc, setup, createAddress }) => {
   const Tezos = lib;
-  describe(`Test emptying a revealed implicit wallet account using: ${rpc}`, () => {
+  describe(`Test emptying a revealed implicit account through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    it('creates a revealed implicit wallet account, funds it, empties it', async (done) => {
+    it('Verify that a new revealed implicit account can be created, funded and emptied', async (done) => {
       const LocalTez = await createAddress();
       const op = await Tezos.wallet.transfer({ to: await LocalTez.signer.publicKeyHash(), amount: 2 }).send();
       await op.confirmation();
@@ -24,7 +24,7 @@ CONFIGS().forEach(({ lib, rpc, setup, createAddress }) => {
       // Emptying the account
       // The max amount that can be sent now is the total balance minus the fees (no need for reveal fees)
       const maxAmount = balance.minus(estimate.suggestedFeeMutez).toNumber();
-      
+
       const op3 = await LocalTez.wallet.transfer({ to: await Tezos.signer.publicKeyHash(), mutez: true, amount: maxAmount }).send();
       await op3.confirmation();
 
diff --git a/integration-tests/wallet-extensions.spec.ts b/integration-tests/wallet-extensions.spec.ts
index 0dbb5b215..2ac78d2b1 100644
--- a/integration-tests/wallet-extensions.spec.ts
+++ b/integration-tests/wallet-extensions.spec.ts
@@ -35,15 +35,15 @@ CONFIGS().forEach(({ lib, rpc, setup, knownBigMapContract, knownTzip1216Contract
         ],
         storage: { prim: 'Pair', args: [{ int: '7' }, { int: '60101' }] }
     }
-    describe(`Test extensions TezosToolkit: ${rpc}`, () => {
+    describe(`Test extensions TezosToolkit through wallet api: ${rpc}`, () => {
         beforeEach(async (done) => {
             await setup();
             done();
         });
 
-        it('configures a ContractsLibrary and a Tzip16Module on the TezosToolkit instance', async (done) => {
+        it('Verify configuration of a ContractsLibrary and a Tzip16Module on the TezosToolkit instance', async (done) => {
             const contractsLibrary = new ContractsLibrary();
-            
+
             // We intentionally load a script that does not match the knownBigMapContract script
             contractsLibrary.addContract({
                 [knownBigMapContract]: {
diff --git a/integration-tests/wallet-failwith.spec.ts b/integration-tests/wallet-failwith.spec.ts
index 4d1dff028..2cdf79aed 100644
--- a/integration-tests/wallet-failwith.spec.ts
+++ b/integration-tests/wallet-failwith.spec.ts
@@ -3,13 +3,13 @@ import { failwithContractCode } from "./data/failwith";
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  describe(`Test contract made with wallet API that throws FAILWITH api using: ${rpc}`, () => {
+  describe(`Test contract origination that throws FAILWITH api through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    it('captures a FAILWITH and throws an error', async (done) => {
+    it('Verify calling the default method of a contract with FAILWITH code will fail and throw an error', async (done) => {
       const op = await Tezos.wallet.originate({
         balance: "1",
         code: failwithContractCode,
diff --git a/integration-tests/wallet-init-with-empty-bigmap.spec.ts b/integration-tests/wallet-init-with-empty-bigmap.spec.ts
index 8ebfd138c..62d0d0f17 100644
--- a/integration-tests/wallet-init-with-empty-bigmap.spec.ts
+++ b/integration-tests/wallet-init-with-empty-bigmap.spec.ts
@@ -5,14 +5,14 @@ import { MichelsonMap } from "@taquito/taquito";
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
   const test = require('jest-retries');
-  
-  describe(`Token contract with empty big map origination scenario using: ${rpc}`, () => {
+
+  describe(`Test contract origination with empty BigMap origination scenario through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    test('Originate wallet contract and init bigmap to empty map', 2, async (done: () => void) => {
+    test('Verify wallet.originate for a contract and init the BigMap to empty map', 2, async (done: () => void) => {
       const op = await Tezos.wallet.originate({
         balance: "1",
         code: tokenBigmapCode,
diff --git a/integration-tests/wallet-ligo-increment-contract.spec.ts b/integration-tests/wallet-ligo-increment-contract.spec.ts
index b894806ad..236d38002 100644
--- a/integration-tests/wallet-ligo-increment-contract.spec.ts
+++ b/integration-tests/wallet-ligo-increment-contract.spec.ts
@@ -3,13 +3,13 @@ import { ligoSample } from "./data/ligo-simple-contract";
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  describe(`Simple ligo origination scenario using: ${rpc}`, () => {
+  describe(`Test contract origination with simple ligo origination scenario through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    it('for wallet api, originates michelson produced by ligo, and increments a counter in storage', async (done) => {
+    it('Verify wallet.originate for a contract in Michelson format produced by LIGO (also increments a counter in a storage).', async (done) => {
       const op = await Tezos.wallet.originate({
         balance: "1",
         code: ligoSample,
diff --git a/integration-tests/wallet-manager-scenario.spec.ts b/integration-tests/wallet-manager-scenario.spec.ts
index 0fad941fb..3b03593db 100644
--- a/integration-tests/wallet-manager-scenario.spec.ts
+++ b/integration-tests/wallet-manager-scenario.spec.ts
@@ -5,12 +5,12 @@ import { MANAGER_LAMBDA, Protocols } from "@taquito/taquito";
 CONFIGS().forEach(({ lib, rpc, setup, knownBaker, knownContract, protocol }) => {
   const Tezos = lib;
 
-  describe(`Manager TZ: ${rpc}`, () => {
+  describe(`Test TZ Manager through wallet api: ${rpc}`, () => {
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    test('tests manager transfer scenarios with wallet APi contract', async (done) => {
+    test('Verify wallet.transfer scenarios: implicit transfer to and from contracts, set and remove delegate, and transfer from a contract to a contract.', async (done) => {
       const op = await Tezos.wallet.originate({
         balance: "1",
         code: managerCode,
diff --git a/integration-tests/wallet-manager-that-calls-failwith-contract.spec.ts b/integration-tests/wallet-manager-that-calls-failwith-contract.spec.ts
index b2deaea51..a308d74b7 100644
--- a/integration-tests/wallet-manager-that-calls-failwith-contract.spec.ts
+++ b/integration-tests/wallet-manager-that-calls-failwith-contract.spec.ts
@@ -6,13 +6,13 @@ import { MANAGER_LAMBDA } from "@taquito/taquito";
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
 
-  describe(`Test contract that calls 2nd contract that FAILs: ${rpc}`, () => {
+  describe(`Test contract origination of a contract that calls 2nd contract that FAILs through wallet api: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    test('Catches a Failwith from a contract made with wallet api called via a manager contract',  async (done) => {
+    test('Verify that transferring token from the manager contract to a contract having a FAILWITH instruction will fail.', async (done: () => void) => {
       const op = await Tezos.wallet.originate({
         balance: "1",
         code: failwithContractCode,
diff --git a/integration-tests/wallet-michelson-origination.spec.ts b/integration-tests/wallet-michelson-origination.spec.ts
index 23868c91c..145c27802 100644
--- a/integration-tests/wallet-michelson-origination.spec.ts
+++ b/integration-tests/wallet-michelson-origination.spec.ts
@@ -3,13 +3,13 @@ import { idMichelsonCode, idInitData } from "./data/id-contract"
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  describe(`Originating a plain Michelson contract using: ${rpc}`, () => {
+  describe(`Test contract origination in a plain Michelson contract through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    it('Origination of an ID contract using wallet API written in plain Michelson', async (done) => {
+    it('Verify wallet.originate for an ID contract written in plain Michelson', async (done) => {
       const op = await Tezos.wallet.originate({
         balance: "0",
         code: idMichelsonCode,
diff --git a/integration-tests/wallet-multisig-scenario.spec.ts b/integration-tests/wallet-multisig-scenario.spec.ts
index b878f91b8..6e41beddc 100644
--- a/integration-tests/wallet-multisig-scenario.spec.ts
+++ b/integration-tests/wallet-multisig-scenario.spec.ts
@@ -5,12 +5,12 @@ import { genericMultisig } from "./data/multisig";
 CONFIGS().forEach(({ lib, rpc, setup, createAddress }) => {
   const Tezos = lib;
 
-  describe(`Generic Multisig: ${rpc}`, () => {
+  describe(`Test multisig contract through wallet api for origination, contract interaction, and tranfer to an implicit account with: ${rpc}`, () => {
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    test('test manager transfers scenarios for wallet api contract', async (done) => {
+    test('Verify contract.originate, contract interaction, and transfer to an implicit account for a contract with multiple signatures', async (done) => {
       const account1 = await createAddress();
       const account2 = await createAddress();
       const account3 = await createAddress();
diff --git a/integration-tests/wallet-no-annotations-call-by-index.spec.ts b/integration-tests/wallet-no-annotations-call-by-index.spec.ts
index 0951efc26..35e6c639e 100644
--- a/integration-tests/wallet-no-annotations-call-by-index.spec.ts
+++ b/integration-tests/wallet-no-annotations-call-by-index.spec.ts
@@ -3,13 +3,13 @@ import { noAnnotCode, noAnnotInit } from "./data/token_without_annotation";
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  describe(`Test contract made with wallet API with no annotations calling methods by index using: ${rpc}`, () => {
+  describe(`Test calling methods by index through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    test('Test contract made with wallet API with no annotations for methods', async (done) => {
+    test('Verify calls to the methods of the contract that have no annotations and must be referred to using indexes.', async (done) => {
       // Constants to replace annotations
       const ACCOUNTS = '0';
       const BALANCE = '0';
@@ -55,4 +55,4 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
       done();
     })
   });
-})
+})
\ No newline at end of file
diff --git a/integration-tests/wallet-originate-contract-unpair.spec.ts b/integration-tests/wallet-originate-contract-unpair.spec.ts
index 8afbeb712..a7a933a42 100644
--- a/integration-tests/wallet-originate-contract-unpair.spec.ts
+++ b/integration-tests/wallet-originate-contract-unpair.spec.ts
@@ -5,13 +5,13 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
     const Tezos = lib;
     const test = require('jest-retries');
 
-    describe(`Test origination of a token contract using: ${rpc}`, () => {
+    describe(`Test contract origination with UNPAIR through wallet api using: ${rpc}`, () => {
         beforeEach(async (done) => {
             await setup();
             done();
         });
 
-        test('Originates a contract having UNPAIR with code and init in Michelson', 2, async (done: () => void) => {
+        test('Verify wallet.originate for a contract having UNPAIR with code and init in Michelson', 2, async (done: () => void) => {
             const op = await Tezos.wallet.originate({
                 code: miStr,
                 init: '(Pair 0 "tz1QZ6KY7d3BuZDT1d19dUxoQrtFPN2QJ3hn")'
@@ -29,7 +29,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
             done();
         });
 
-        test('Originates a contract having UNPAIR with code in Michelson and init in JSON Michelson', 2, async (done: () => void) => {
+        test('Verify wallet.originate for a contract having UNPAIR with code in Michelson and init in JSON Michelson', 2, async (done: () => void) => {
             const op = await Tezos.wallet.originate({
                 code: miStr,
                 init: { prim: 'Pair', args: [{ int: '0' }, { string: 'tz1QZ6KY7d3BuZDT1d19dUxoQrtFPN2QJ3hn' }] }
@@ -47,7 +47,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
             done();
         });
 
-        test('Originates a contract having UNPAIR with code in Michelson and storage', 2, async (done: () => void) => {
+        test('Verify wallet.originate for a contract having UNPAIR with code in Michelson and storage', 2, async (done: () => void) => {
             const op = await Tezos.wallet.originate({
                 code: miStr,
                 storage: {
@@ -68,7 +68,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
             done();
         });
 
-        test('Originates a contract having UNPAIR with code in JSON Michelson and init in Michelson', 2, async (done: () => void) => {
+        test('Verify wallet.originate for a contract having UNPAIR with code in JSON Michelson and init in Michelson', 2, async (done: () => void) => {
             const op = await Tezos.wallet.originate({
                 code: miObject,
                 init: '(Pair 0 "tz1QZ6KY7d3BuZDT1d19dUxoQrtFPN2QJ3hn")'
@@ -86,7 +86,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
             done();
         });
 
-        test('Originates a contract having UNPAIR with code and init in JSON Michelson', 2, async (done: () => void) => {
+        test('Verify wallet.originate for a contract having UNPAIR with code and init in JSON Michelson', 2, async (done: () => void) => {
             const op = await Tezos.wallet.originate({
                 code: miObject,
                 init: { prim: 'Pair', args: [{ int: '0' }, { string: 'tz1QZ6KY7d3BuZDT1d19dUxoQrtFPN2QJ3hn' }] }
@@ -104,7 +104,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
             done();
         });
 
-        test('Originates a contract having UNPAIR with code in JSON Michelson and storage', 2, async (done: () => void) => {
+        test('Verify wallet.originate for a contract having UNPAIR with code in JSON Michelson and storage', 2, async (done: () => void) => {
             const op = await Tezos.wallet.originate({
                 code: miObject,
                 storage: {
diff --git a/integration-tests/wallet-originate-contract-with-bool.spec.ts b/integration-tests/wallet-originate-contract-with-bool.spec.ts
index 9b2e1d4e3..d5996da48 100644
--- a/integration-tests/wallet-originate-contract-with-bool.spec.ts
+++ b/integration-tests/wallet-originate-contract-with-bool.spec.ts
@@ -3,13 +3,13 @@ import { booleanCode } from "./data/boolean_parameter";
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  describe(`Originate contract and set bool prop on init and via call using: ${rpc}`, () => {
+  describe(`Test contract origination with set bool prop on init and via call through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    it('originates a wallet contract with bool storage init to true then sets to false', async (done) => {
+    it('Verify wallet.originate for a contract with bool storage init to true and then sets to false', async (done) => {
       const op = await Tezos.wallet.originate({
         balance: "1",
         code: booleanCode,
diff --git a/integration-tests/wallet-originate-contract-with-sapling.spec.ts b/integration-tests/wallet-originate-contract-with-sapling.spec.ts
index 0303a2edb..49c2fefbb 100644
--- a/integration-tests/wallet-originate-contract-with-sapling.spec.ts
+++ b/integration-tests/wallet-originate-contract-with-sapling.spec.ts
@@ -2,27 +2,27 @@ import { CONFIGS } from "./config";
 import { SaplingStateValue } from '../packages/taquito-michelson-encoder/src/taquito-michelson-encoder';
 import { saplingContractDoubleJProto } from "./data/sapling_test_contracts";
 
-CONFIGS().forEach(({ lib, rpc, setup }) => {
+CONFIGS().forEach(({ lib, rpc, setup, }) => {
   const Tezos = lib;
 
-  describe(`Test origination of contracts made with wallet api with sapling using: ${rpc}`, () => {
+  describe(`Test contract origination with sapling through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup();
       done()
     })
 
-    test('Originates a contract made with wallet api with sapling states in its storage', async (done) => {
-      const op = await Tezos.wallet.originate({
-        code: saplingContractDoubleJProto,
-        storage: {
-          left: SaplingStateValue,
-          right: SaplingStateValue
-        }
-      }).send();
-      await op.confirmation();
-      expect(op.opHash).toBeDefined();
-      done();
-    });
+     it('Originates a contract made with wallet api with sapling states in its storage', async (done) => {
+       const op = await Tezos.wallet.originate({
+         code: saplingContractDoubleJProto,
+         storage: {
+           left: SaplingStateValue,
+           right: SaplingStateValue
+         }
+       }).send();
+       await op.confirmation();
+       expect(op.opHash).toBeDefined();
+       done();
+     });
   });
-})
\ No newline at end of file
+})
diff --git a/integration-tests/wallet-originate-invalid-string.spec.ts b/integration-tests/wallet-originate-invalid-string.spec.ts
index 4092cdfc6..51cb939a7 100644
--- a/integration-tests/wallet-originate-invalid-string.spec.ts
+++ b/integration-tests/wallet-originate-invalid-string.spec.ts
@@ -3,13 +3,13 @@ import { CONFIGS } from "./config";
 
 CONFIGS().forEach(({ lib, rpc, setup, protocol }) => {
   const Tezos = lib;
-  describe(`Test invalid data for origination using: ${rpc}`, () => {
+  describe(`Test contract origination with invalid data through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    it('wallet contract fails because non-ascii in init data', async (done) => {
+    it('Verify that wallet.originate for a contract with non-ascii (invalid string) in the init data will fail', async (done) => {
       expect.assertions(1);
       try {
         await Tezos.wallet.originate({
diff --git a/integration-tests/wallet-originate-token-contract.spec.ts b/integration-tests/wallet-originate-token-contract.spec.ts
index ad10116a9..7c6026f00 100644
--- a/integration-tests/wallet-originate-token-contract.spec.ts
+++ b/integration-tests/wallet-originate-token-contract.spec.ts
@@ -3,15 +3,14 @@ import { tokenCode, tokenInit } from "./data/tokens";
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  const test = require('jest-retries');
 
-  describe(`Test origination of a token contract using: ${rpc}`, () => {
+  describe(`Test contract origination of a token contract through wallet api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {
       await setup()
       done()
     })
-    test('originates a token contract made from wallet api and mints some tokens',2, async (done: () => void) => {
+    test('Verify wallet.originate for a token contract and mints some tokens', async (done) => {
       // TODO: Fails when using ephemeral keys
       const op = await Tezos.wallet.originate({
         balance: "1",
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 () => {
diff --git a/packages/taquito/test/contract/rpc-contract-provider.spec.ts b/packages/taquito/test/contract/rpc-contract-provider.spec.ts
index ace5a59f0..eb669352d 100644
--- a/packages/taquito/test/contract/rpc-contract-provider.spec.ts
+++ b/packages/taquito/test/contract/rpc-contract-provider.spec.ts
@@ -35,6 +35,7 @@ import { OpKind, ParamsWithKind, TransferTicketParams } from '../../src/operatio
 import { NoopParser } from '../../src/taquito';
 import { OperationBatch } from '../../src/batch/rpc-batch-provider';
 import { ContractMethodObject } from '../../src/contract/contract-methods/contract-method-object-param';
+import { ticketTokenTestMock } from '../helpers';
 
 /**
  * RPCContractProvider test
@@ -1856,4 +1857,20 @@ describe('RpcContractProvider test', () => {
       done();
     });
   });
+
+  describe('Storage', () => {
+    it('should have defined storage with TicketTokens without errors (#1762)', async (done) => {
+      mockRpcClient.getEntrypoints.mockResolvedValue({
+        entrypoints: {},
+      })
+      mockRpcClient.getContract.mockResolvedValue(ticketTokenTestMock)
+      const rpcContract = await rpcContractProvider.at('KT19mzgsjrR2Er4rm4vuDqAcMfBF5DBMs2uq');
+      const storage = await rpcContract.storage() as any;
+      expect(rpcContract).toBeDefined();
+
+      const keyList = storage.keyMap;
+      expect(keyList.size).toEqual(3);
+      done();
+    })
+  })
 });
diff --git a/packages/taquito/test/helpers.ts b/packages/taquito/test/helpers.ts
index 46992f23c..72849afd2 100644
--- a/packages/taquito/test/helpers.ts
+++ b/packages/taquito/test/helpers.ts
@@ -332,3 +332,176 @@ export class TransferTicketOperationBuilder {
     }
   }
 }
+
+export const ticketTokenTestMock = {
+  "balance": "0",
+  "script": {
+    "code": [
+      {
+        "prim": "parameter",
+        "args": [
+          {
+            "prim": "pair",
+            "args": [
+              {
+                "prim": "ticket",
+                "args": [
+                  {
+                    "prim": "bytes"
+                  }
+                ]
+              },
+              {
+                "prim": "address"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "prim": "storage",
+        "args": [
+          {
+            "prim": "map",
+            "args": [
+              {
+                "prim": "address"
+              },
+              {
+                "prim": "ticket",
+                "args": [
+                  {
+                    "prim": "bytes"
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "prim": "code",
+        "args": [
+          [
+            {
+              "prim": "UNPAIR"
+            },
+            {
+              "prim": "UNPAIR"
+            },
+            {
+              "prim": "READ_TICKET"
+            },
+            {
+              "prim": "DROP"
+            },
+            {
+              "prim": "DIG",
+              "args": [
+                {
+                  "int": "2"
+                }
+              ]
+            },
+            {
+              "prim": "SWAP"
+            },
+            {
+              "prim": "SOME"
+            },
+            {
+              "prim": "DIG",
+              "args": [
+                {
+                  "int": "2"
+                }
+              ]
+            },
+            {
+              "prim": "UPDATE"
+            },
+            {
+              "prim": "NIL",
+              "args": [
+                {
+                  "prim": "operation"
+                }
+              ]
+            },
+            {
+              "prim": "PAIR"
+            }
+          ]
+        ]
+      }
+    ],
+    "storage": [
+      {
+        "prim": "Elt",
+        "args": [
+          {
+            "string": "tz1QYD1zbK2gTUu1YWX8m7hPcKNkuXoxPo73"
+          },
+          {
+            "prim": "Pair",
+            "args": [
+              {
+                "string": "KT19mzgsjrR2Er4rm4vuDqAcMfBF5DBMs2uq"
+              },
+              {
+                "bytes": "0505080a0000001601f37d4eddfff4e08fb1f19895ac9c83bc12d2b36800"
+              },
+              {
+                "int": "2"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "prim": "Elt",
+        "args": [
+          {
+            "string": "tz1cor8JEddCMvLFpWBK1EcNFDU3QgaSwvc1"
+          },
+          {
+            "prim": "Pair",
+            "args": [
+              {
+                "string": "KT19mzgsjrR2Er4rm4vuDqAcMfBF5DBMs2uq"
+              },
+              {
+                "bytes": "0505080a0000001601f37d4eddfff4e08fb1f19895ac9c83bc12d2b36800"
+              },
+              {
+                "int": "10000"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "prim": "Elt",
+        "args": [
+          {
+            "string": "tz1h5GajcQWq4ybaWuwSiYrR5PvmUxndm8T8"
+          },
+          {
+            "prim": "Pair",
+            "args": [
+              {
+                "string": "KT19mzgsjrR2Er4rm4vuDqAcMfBF5DBMs2uq"
+              },
+              {
+                "bytes": "050505030b"
+              },
+              {
+                "int": "1000000"
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+}