From 1152b03f2a9aaeeeb2dfdb5c9a976d36e1a56860 Mon Sep 17 00:00:00 2001
From: Craig Buckler <craig@optimalworks.net>
Date: Mon, 29 Apr 2024 23:48:02 +0100
Subject: [PATCH 1/5] add Tezos Foundation RPCs (#2934)

---
 docs/rpc_nodes.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/rpc_nodes.md b/docs/rpc_nodes.md
index 6ce4048300..7cd09f7543 100644
--- a/docs/rpc_nodes.md
+++ b/docs/rpc_nodes.md
@@ -29,6 +29,9 @@ values={[
 | SmartPy          | Mainnet      | https://mainnet.smartpy.io               | [Check](https://mainnet.smartpy.io/chains/main/blocks/head/header)              |
 | SmartPy          | Ghostnet     | https://ghostnet.smartpy.io              | [Check](https://ghostnet.smartpy.io/chains/main/blocks/head/header)             |
 | Tezos Foundation | Mainnet      | https://rpc.tzbeta.net/                  | [Check](https://rpc.tzbeta.net/chains/main/blocks/head/header)                  |
+| Tezos Foundation | Ghostnet     | https://rpc.ghostnet.teztnets.com/       | [Check](https://rpc.ghostnet.teztnets.com/chains/main/blocks/head/header)       |
+| Tezos Foundation | Oxfordnet    | https://rpc.oxfordnet.teztnets.com/      | [Check](https://rpc.oxfordnet.teztnets.com/chains/main/blocks/head/header)      |
+| Tezos Foundation | Parisnet     | https://rpc.parisnet.teztnets.com/       | [Check](https://rpc.parisnet.teztnets.com/chains/main/blocks/head/header)       |
 | Marigold         | Mainnet      | https://mainnet.tezos.marigold.dev/      | [Check](https://mainnet.tezos.marigold.dev/chains/main/blocks/head/header)      |
 | Marigold         | Ghostnet     | https://ghostnet.tezos.marigold.dev/     | [Check](https://ghostnet.tezos.marigold.dev/chains/main/blocks/head/header)     |
 | Marigold         | Oxfordnet    | https://oxfordnet.tezos.marigold.dev/    | [Check](https://oxfordnet.tezos.marigold.dev/chains/main/blocks/head/header)    |

From 8f30cf3b0de75d045932e5bc228974e408f3a19a Mon Sep 17 00:00:00 2001
From: hui-an-yang <106410553+hui-an-yang@users.noreply.github.com>
Date: Wed, 1 May 2024 13:31:26 -0700
Subject: [PATCH 2/5] 2942 tez to etherlink (#2944)

* feat: add a case to transfer ghostnet tez to etherlink in test-dapp

* style: move the case to top

* feat: updaing desc and naming to Send tez from Ghostnet to Etherlink
---
 .../src/lib/TestContainer.svelte              | 24 +++++++++--
 apps/taquito-test-dapp/src/tests.ts           | 42 ++++++++++++++++++-
 apps/taquito-test-dapp/src/types.ts           |  2 +-
 cspell.json                                   |  1 +
 example/package.json                          |  2 +-
 5 files changed, 64 insertions(+), 7 deletions(-)

diff --git a/apps/taquito-test-dapp/src/lib/TestContainer.svelte b/apps/taquito-test-dapp/src/lib/TestContainer.svelte
index 3191c3aade..d748260eef 100644
--- a/apps/taquito-test-dapp/src/lib/TestContainer.svelte
+++ b/apps/taquito-test-dapp/src/lib/TestContainer.svelte
@@ -11,7 +11,7 @@
   let loading = false;
   let success: boolean | undefined;
   let opHash = "";
-  let input = { text: "", fee: 400, storageLimit: 400, gasLimit: 1320 };
+  let input = { text: "", fee: 400, storageLimit: 400, gasLimit: 1320, amount: 0, address: "" };
   let testResult: { id: string; title: string; body: any };
 
   const run = async () => {
@@ -28,6 +28,7 @@
         test.id === "sign-payload-and-send" ||
         test.id === "sign-failingNoop" ||
         test.id === "verify-signature" ||
+        test.id === "send-tez-to-etherlink" ||
         test.id === "set-transaction-limits"
       ) {
         result = await test.run(input);
@@ -188,7 +189,7 @@
   /* ----------------------------------------------
  * Generated by Animista on 2022-4-21 9:31:8
  * Licensed under FreeBSD License.
- * See http://animista.net/license for more info. 
+ * See http://animista.net/license for more info.
  * w: http://animista.net, t: @cssanimista
  * ---------------------------------------------- */
 
@@ -302,6 +303,19 @@
             bind:value={input.text}
           />
         </div>
+      {:else if test.inputRequired && test.inputType === "etherlink"}
+        <div class="test-input test-send-tez-to-etherlink">
+          <label for="etherlink-address">
+            <span>Etherlink address</span>
+            <input type="string" id="etherlink-address" bind:value={input.address} />
+          </label>
+          <br />
+          <br />
+          <label for="send-amount">
+            <span>amount</span>
+            <input type="number" id="send-amount" bind:value={input.amount} />
+          </label>
+        </div>
       {:else if test.inputRequired && test.inputType === "set-limits"}
         <div class="test-input test-limits">
           <label for="set-limit-fee">
@@ -338,7 +352,11 @@
               {#if $store.networkType === NetworkType.CUSTOM}
                 {shortenHash(opHash)}
               {:else}
-                <a href={`${getTzKtUrl($store.networkType)}/${opHash}`} target="_blank" rel="noopener noreferrer">
+                <a
+                  href={`${getTzKtUrl($store.networkType)}/${opHash}`}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                >
                   {shortenHash(opHash)}
                 </a>
               {/if}
diff --git a/apps/taquito-test-dapp/src/tests.ts b/apps/taquito-test-dapp/src/tests.ts
index d1c277bc8d..823c59ac13 100644
--- a/apps/taquito-test-dapp/src/tests.ts
+++ b/apps/taquito-test-dapp/src/tests.ts
@@ -36,6 +36,25 @@ const preparePayloadToSign = (
   };
 };
 
+const sendTezToEtherlink = async (
+  amount: number,
+  address: string,
+  tezos: TezosToolkit,
+): Promise<TestResult> => {
+  let opHash = "";
+  try {
+    const contract = await tezos.wallet.at('KT1VEjeQfDBSfpDH5WeBM5LukHPGM2htYEh3')
+    let op = await contract.methodsObject.deposit({ evm_address: 'sr18wx6ezkeRjt1SZSeZ2UQzQN3Uc3YLMLqg', l2_address: address }).send({ amount });
+    await op.confirmation()
+    opHash = op.hasOwnProperty("opHash") ? op["opHash"] : op["hash"];
+    console.log("Operation successful with op hash:", opHash);
+    return { success: true, opHash };
+  } catch (error) {
+    console.log(error);
+    return { success: false, opHash: "" };
+  }
+};
+
 const sendTez = async (Tezos: TezosToolkit): Promise<TestResult> => {
   let opHash = "";
   try {
@@ -302,7 +321,7 @@ const signPayloadAndSend = async (
     const publicKey = activeAccount.publicKey;
     // sends transaction to contract
     const op = await contract.methodsObject
-      .check_signature({0: publicKey, 1: signedPayload.signature, 2: payload.payload})
+      .check_signature({ 0: publicKey, 1: signedPayload.signature, 2: payload.payload })
       .send();
     await op.confirmation();
     return {
@@ -455,7 +474,7 @@ const permit = async (Tezos: TezosToolkit, wallet: BeaconWallet) => {
     const contract = await Tezos.wallet.at(contractAddress);
     // hashes the parameter for the contract call
     const mintParam: any = contract.methodsObject
-      .mint({0: store.userAddress, 1: 100})
+      .mint({ 0: store.userAddress, 1: 100 })
       .toTransferParams().parameter?.value;
     const mintParamType = contract.entrypoints.entrypoints["mint"];
     // packs the entrypoint call
@@ -548,6 +567,7 @@ const saplingShielded = async (
 
 export const list = [
   "Send tez",
+  "Send tez from Ghostnet to Etherlink",
   "Contract call with int",
   "Contract call with (pair nat string)",
   "Contract call that fails",
@@ -582,6 +602,24 @@ export const init = (
       inputRequired: false,
       lastResult: { option: "none", val: false }
     },
+    {
+      id: "send-tez-to-etherlink",
+      name: "Send tez from Ghostnet to Etherlink",
+      description:
+        "This test allows you send your ghostnet tez to etherlink address",
+      documentation: '',
+      keyword: 'etherlink',
+      run: input =>
+        sendTezToEtherlink(
+          input.amount,
+          input.address,
+          Tezos
+        ),
+      showExecutionTime: false,
+      inputRequired: true,
+      inputType: "etherlink",
+      lastResult: { option: "none", val: false }
+    },
     {
       id: "contract-call-simple-type",
       name: "Contract call with int",
diff --git a/apps/taquito-test-dapp/src/types.ts b/apps/taquito-test-dapp/src/types.ts
index 0d30f426c4..eaf412dd8e 100644
--- a/apps/taquito-test-dapp/src/types.ts
+++ b/apps/taquito-test-dapp/src/types.ts
@@ -15,7 +15,7 @@ export interface TestSettings {
   run: (input?: any) => Promise<TestResult>;
   showExecutionTime: boolean;
   inputRequired: boolean;
-  inputType?: "string" | "set-limits" | "sapling";
+  inputType?: "string" | "set-limits" | "sapling" | "etherlink";
   lastResult: { option: "none" | "some"; val: boolean };
 }
 
diff --git a/cspell.json b/cspell.json
index f1ed6f1a4c..c035e310f0 100644
--- a/cspell.json
+++ b/cspell.json
@@ -30,6 +30,7 @@
     "edsk",
     "Ejara",
     "entrypoints",
+    "etherlink",
     "eztz",
     "FAILWITH",
     "flextesa",
diff --git a/example/package.json b/example/package.json
index 20c005bf7c..ebfa3a03ec 100644
--- a/example/package.json
+++ b/example/package.json
@@ -41,7 +41,7 @@
     "example:scan-path-ledger": "node -r ts-node/register --preserve-symlinks scan-path-ledger.ts"
   },
   "dependencies": {
-    "@ledgerhq/hw-transport-node-hid": "^6.27.21",
+    "@ledgerhq/hw-transport-node-hid": "^6.28.5",
     "@taquito/ledger-signer": "^19.2.0",
     "@taquito/local-forging": "^19.2.0",
     "@taquito/michel-codec": "^19.2.0",

From 55f6772e63a3d8b6f68197ee99b6c11718ff44dd Mon Sep 17 00:00:00 2001
From: ac10n <alirezahaghshenas@gmail.com>
Date: Thu, 2 May 2024 16:09:45 -0700
Subject: [PATCH 3/5] fix: the idx of a `pair` inside `or` inside `pair` is not
 calculated correctly (#2929)

* fix: the idx of a pair inside or inside pair is not calculated correctly

* chore: update tests

* test: fix failing unit tests

* test: fix failing integration test

* Using static variable to configure field numbering strategy (#2939)

* feat: option for the user to choose between legacy and updated field numbering

* chore: fix typo

* chore: add typedoc comments for Token.fieldNumberingStrategy

* test: fix failing integration test

* test: comment in the integration test to make it clear that we are testing all three strategies
---
 ...ations-call-by-index-methodsObject.spec.ts | 100 ++-
 .../src/taquito-michelson-encoder.ts          |   2 +-
 .../src/tokens/createToken.ts                 |  15 +-
 .../src/tokens/or.ts                          |  66 +-
 .../src/tokens/pair.ts                        |  37 +-
 .../src/tokens/token.ts                       |  39 +-
 .../test/sample1.spec.ts                      | 415 ++++++---
 .../test/sample11_dexter.spec.ts              | 594 ++++++++++---
 .../test/sample9_lambda.spec.ts               | 117 ++-
 .../test/tokens/map.spec.ts                   |  66 +-
 .../test/tokens/or.spec.ts                    | 798 ++++++++++++++++--
 packages/taquito/src/taquito.ts               |  11 +-
 .../test/contract/contractAbstraction.spec.ts |   4 +-
 13 files changed, 1850 insertions(+), 414 deletions(-)

diff --git a/integration-tests/__tests__/contract/no-annotations-call-by-index-methodsObject.spec.ts b/integration-tests/__tests__/contract/no-annotations-call-by-index-methodsObject.spec.ts
index 096976adb9..daee5318df 100644
--- a/integration-tests/__tests__/contract/no-annotations-call-by-index-methodsObject.spec.ts
+++ b/integration-tests/__tests__/contract/no-annotations-call-by-index-methodsObject.spec.ts
@@ -1,3 +1,4 @@
+import { FieldNumberingStrategy } from "@taquito/michelson-encoder";
 import { CONFIGS } from "../../config";
 import { noAnnotCode, noAnnotInit } from "../../data/token_without_annotation";
 
@@ -10,59 +11,70 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
     beforeEach(async () => {
       await setup()
     })
-    it('Verify contract.originate for a contract with no annotations for methods using methodObjects', async () => {
-      // Constants to replace annotations
-      const ACCOUNTS = '0';
-      const BALANCE = '0';
-      const ALLOWANCES = '1';
-      const TRANSFER = '0';
-      const APPROVE = '2';
 
-      // Actual tests
+    // Constants to replace annotations
+    const ACCOUNTS = '0';
+    const BALANCE = '0';
+    const ALLOWANCES = '1';
+    const TRANSFER = '0';
+    const APPROVE = '2';
 
-      const ACCOUNT1_ADDRESS = await Tezos.signer.publicKeyHash()
-      const ACCOUNT2_ADDRESS = 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu'
+    // Actual tests
 
-      // Originate a contract with a known state
-      const op = await Tezos.contract.originate({
-        balance: "1",
-        code: noAnnotCode,
-        init: noAnnotInit(await Tezos.signer.publicKeyHash())
-      })
-      await op.confirmation()
-      const contract = await op.contract()
+    const ACCOUNT2_ADDRESS = 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu'
+    
+    // Runs the entire tests for a given fieldNumberingStrategy
+    const testContract = (strategy: FieldNumberingStrategy, innerObjectStartingIndex: number) => {
+      it(`Verify contract.originate for a contract with no annotations for methods using methodObjects with fieldNumberingStrategy: ${strategy}`, async () => {
+        Tezos.setFieldNumberingStrategy(strategy);
+        const ACCOUNT1_ADDRESS = await Tezos.signer.publicKeyHash()
+        // Originate a contract with a known state
+        const op = await Tezos.contract.originate({
+          balance: "1",
+          code: noAnnotCode,
+          init: noAnnotInit(await Tezos.signer.publicKeyHash())
+        })
+        await op.confirmation()
+        const contract = await op.contract()
 
-      // Make a transfer
+        // Make a transfer
 
-      const operation = await contract.methodsObject[TRANSFER]({
-        0: ACCOUNT1_ADDRESS,
-        1: ACCOUNT2_ADDRESS,
-        2: "1"
-      }).send();
+        const operation = await contract.methodsObject[TRANSFER]({
+          0: ACCOUNT1_ADDRESS,
+          1: ACCOUNT2_ADDRESS,
+          2: "1"
+        }).send();
 
-      await operation.confirmation();
-      expect(operation.status).toEqual('applied')
+        await operation.confirmation();
+        expect(operation.status).toEqual('applied')
 
-      // Verify that the transfer was done as expected
-      const storage = await contract.storage<any>()
-      let account1 = await storage[ACCOUNTS].get(ACCOUNT1_ADDRESS)
-      expect(account1[BALANCE].toString()).toEqual('16')
+        // Verify that the transfer was done as expected
+        const storage = await contract.storage<any>()
+        let account1 = await storage[ACCOUNTS].get(ACCOUNT1_ADDRESS)
+        expect(account1[BALANCE].toString()).toEqual('16')
 
-      const account2 = await storage[ACCOUNTS].get(ACCOUNT2_ADDRESS)
-      expect(account2[BALANCE].toString()).toEqual('1')
+        const account2 = await storage[ACCOUNTS].get(ACCOUNT2_ADDRESS)
+        expect(account2[BALANCE].toString()).toEqual('1')
 
-      // Approve
-      const operation2 = await contract.methodsObject[APPROVE]({
-        2: ACCOUNT2_ADDRESS,
-        3: "1"
-      }).send();
+        // Approve
+        const operation2 = await contract.methodsObject[APPROVE]({
+          [innerObjectStartingIndex]: ACCOUNT2_ADDRESS,
+          [innerObjectStartingIndex + 1]: "1"
+        }).send();
 
-      await operation2.confirmation();
-      expect(operation2.status).toEqual('applied')
+        await operation2.confirmation();
+        expect(operation2.status).toEqual('applied')
+
+        // Verify that the allowance was done as expected
+        account1 = await storage[ACCOUNTS].get(ACCOUNT1_ADDRESS)
+        expect(account1[ALLOWANCES].get(ACCOUNT2_ADDRESS).toString()).toEqual('1')
+      });
+    };
+    
+    // Run the tests for all fieldNumberingStrategies
+    testContract('Legacy', 2);
+    testContract('ResetFieldNumbersInNestedObjects', 0);
+    testContract('Latest', 0);
 
-      // Verify that the allowance was done as expected
-      account1 = await storage[ACCOUNTS].get(ACCOUNT1_ADDRESS)
-      expect(account1[ALLOWANCES].get(ACCOUNT2_ADDRESS).toString()).toEqual('1')
-    })
   });
-})
+});
diff --git a/packages/taquito-michelson-encoder/src/taquito-michelson-encoder.ts b/packages/taquito-michelson-encoder/src/taquito-michelson-encoder.ts
index eca1e3d16f..92fead1cfb 100644
--- a/packages/taquito-michelson-encoder/src/taquito-michelson-encoder.ts
+++ b/packages/taquito-michelson-encoder/src/taquito-michelson-encoder.ts
@@ -16,4 +16,4 @@ export const UnitValue = Symbol();
 export const SaplingStateValue = {};
 export * from './michelson-map';
 export { VERSION } from './version';
-export { Token } from './tokens/token';
+export { FieldNumberingStrategy, Token } from './tokens/token';
diff --git a/packages/taquito-michelson-encoder/src/tokens/createToken.ts b/packages/taquito-michelson-encoder/src/tokens/createToken.ts
index 1f269d2e6a..c0a30bd303 100644
--- a/packages/taquito-michelson-encoder/src/tokens/createToken.ts
+++ b/packages/taquito-michelson-encoder/src/tokens/createToken.ts
@@ -9,7 +9,10 @@ import { TaquitoError } from '@taquito/core';
  */
 export class InvalidTokenError extends TaquitoError {
   name = 'Invalid token error';
-  constructor(public message: string, public data: any) {
+  constructor(
+    public message: string,
+    public data: any
+  ) {
     super(message);
   }
 }
@@ -19,9 +22,13 @@ export class InvalidTokenError extends TaquitoError {
  * @description Create a token from a value
  * @throws {@link InvalidTokenError} If the value passed is not supported by the Michelson Encoder
  */
-export function createToken(val: any, idx: number): Token {
+export function createToken(
+  val: any,
+  idx: number,
+  parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined
+): Token {
   if (Array.isArray(val)) {
-    return new PairToken(val, idx, createToken);
+    return new PairToken(val, idx, createToken, parentTokenType);
   }
 
   const t = tokens.find((x) => x.prim === val.prim);
@@ -31,5 +38,5 @@ export function createToken(val: any, idx: number): Token {
       val
     );
   }
-  return new t(val, idx, createToken);
+  return new t(val, idx, createToken, parentTokenType);
 }
diff --git a/packages/taquito-michelson-encoder/src/tokens/or.ts b/packages/taquito-michelson-encoder/src/tokens/or.ts
index 1d3b25ac86..8b748e5b8c 100644
--- a/packages/taquito-michelson-encoder/src/tokens/or.ts
+++ b/packages/taquito-michelson-encoder/src/tokens/or.ts
@@ -14,7 +14,11 @@ import {
  */
 export class OrValidationError extends TokenValidationError {
   name = 'OrValidationError';
-  constructor(public value: any, public token: OrToken, message: string) {
+  constructor(
+    public value: any,
+    public token: OrToken,
+    message: string
+  ) {
     super(value, token, message);
   }
 }
@@ -25,21 +29,26 @@ export class OrToken extends ComparableToken {
   constructor(
     protected val: { prim: string; args: any[]; annots: any[] },
     protected idx: number,
-    protected fac: TokenFactory
+    protected fac: TokenFactory,
+    protected parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined
   ) {
-    super(val, idx, fac);
+    super(val, idx, fac, parentTokenType);
   }
 
   public Encode(args: any[]): any {
     const label = args[args.length - 1];
 
-    const leftToken = this.createToken(this.val.args[0], this.idx);
+    const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
     let keyCount = 1;
     if (leftToken instanceof OrToken) {
       keyCount = Object.keys(leftToken.ExtractSchema()).length;
     }
 
-    const rightToken = this.createToken(this.val.args[1], this.idx + keyCount);
+    const rightToken = this.createToken(
+      this.val.args[1],
+      this.getIdxForChildren() + keyCount,
+      'Or'
+    );
 
     if (String(leftToken.annot()) === String(label) && !(leftToken instanceof OrToken)) {
       args.pop();
@@ -66,13 +75,17 @@ export class OrToken extends ComparableToken {
   }
 
   public ExtractSignature(): any {
-    const leftToken = this.createToken(this.val.args[0], this.idx);
+    const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
     let keyCount = 1;
     if (leftToken instanceof OrToken) {
       keyCount = Object.keys(leftToken.ExtractSchema()).length;
     }
 
-    const rightToken = this.createToken(this.val.args[1], this.idx + keyCount);
+    const rightToken = this.createToken(
+      this.val.args[1],
+      this.getIdxForChildren() + keyCount,
+      'Or'
+    );
 
     const newSig = [];
 
@@ -102,13 +115,17 @@ export class OrToken extends ComparableToken {
     this.validateJavascriptObject(args);
     const label = Object.keys(args)[0];
 
-    const leftToken = this.createToken(this.val.args[0], this.idx);
+    const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
     let keyCount = 1;
     if (leftToken instanceof OrToken) {
       keyCount = Object.keys(leftToken.ExtractSchema()).length;
     }
 
-    const rightToken = this.createToken(this.val.args[1], this.idx + keyCount);
+    const rightToken = this.createToken(
+      this.val.args[1],
+      this.getIdxForChildren() + keyCount,
+      'Or'
+    );
 
     if (String(leftToken.annot()) === String(label) && !(leftToken instanceof OrToken)) {
       return { prim: 'Left', args: [leftToken.EncodeObject(args[label], semantic)] };
@@ -154,12 +171,16 @@ export class OrToken extends ComparableToken {
    * @throws {@link OrValidationError}
    */
   public Execute(val: any, semantics?: Semantic): any {
-    const leftToken = this.createToken(this.val.args[0], this.idx);
+    const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
     let keyCount = 1;
     if (leftToken instanceof OrToken) {
       keyCount = Object.keys(leftToken.ExtractSchema()).length;
     }
-    const rightToken = this.createToken(this.val.args[1], this.idx + keyCount);
+    const rightToken = this.createToken(
+      this.val.args[1],
+      this.getIdxForChildren() + keyCount,
+      'Or'
+    );
 
     if (val.prim === 'Right') {
       if (rightToken instanceof OrToken) {
@@ -190,7 +211,7 @@ export class OrToken extends ComparableToken {
     getRightValue: (token: Token) => any,
     concat: (left: any, right: any) => any
   ) {
-    const leftToken = this.createToken(this.val.args[0], this.idx);
+    const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
     let keyCount = 1;
     let leftValue;
     if (leftToken instanceof OrToken) {
@@ -200,7 +221,11 @@ export class OrToken extends ComparableToken {
       leftValue = { [leftToken.annot()]: getLeftValue(leftToken) };
     }
 
-    const rightToken = this.createToken(this.val.args[1], this.idx + keyCount);
+    const rightToken = this.createToken(
+      this.val.args[1],
+      this.getIdxForChildren() + keyCount,
+      'Or'
+    );
     let rightValue;
     if (rightToken instanceof OrToken) {
       rightValue = getRightValue(rightToken);
@@ -255,13 +280,17 @@ export class OrToken extends ComparableToken {
   }
 
   private findToken(label: any): Token | null {
-    const leftToken = this.createToken(this.val.args[0], this.idx);
+    const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
     let keyCount = 1;
     if (leftToken instanceof OrToken) {
       keyCount = Object.keys(leftToken.ExtractSchema()).length;
     }
 
-    const rightToken = this.createToken(this.val.args[1], this.idx + keyCount);
+    const rightToken = this.createToken(
+      this.val.args[1],
+      this.getIdxForChildren() + keyCount,
+      'Or'
+    );
 
     if (
       String(leftToken.annot()) === String(label) &&
@@ -334,4 +363,11 @@ export class OrToken extends ComparableToken {
     );
     return tokens;
   }
+
+  protected getIdxForChildren(): number {
+    if (Token.fieldNumberingStrategy === 'Legacy') {
+      return this.idx;
+    }
+    return this.parentTokenType === 'Or' ? this.idx : 0;
+  }
 }
diff --git a/packages/taquito-michelson-encoder/src/tokens/pair.ts b/packages/taquito-michelson-encoder/src/tokens/pair.ts
index 47f76093cb..7d73aaa166 100644
--- a/packages/taquito-michelson-encoder/src/tokens/pair.ts
+++ b/packages/taquito-michelson-encoder/src/tokens/pair.ts
@@ -65,7 +65,12 @@ function collapse(val: Token['val'] | any[], prim: string = PairToken.prim): [an
 export class PairToken extends ComparableToken {
   static prim: 'pair' = 'pair' as const;
 
-  constructor(val: MichelsonV1Expression, idx: number, fac: TokenFactory) {
+  constructor(
+    val: MichelsonV1Expression,
+    idx: number,
+    fac: TokenFactory,
+    parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined
+  ) {
     super(
       Array.isArray(val)
         ? {
@@ -73,13 +78,14 @@ export class PairToken extends ComparableToken {
             args: val,
           }
         : (val as MichelsonV1ExpressionExtended).prim
-        ? (val as MichelsonV1ExpressionExtended)
-        : ({
-            prim: PairToken.prim,
-            args: val,
-          } as MichelsonV1ExpressionExtended),
+          ? (val as MichelsonV1ExpressionExtended)
+          : ({
+              prim: PairToken.prim,
+              args: val,
+            } as MichelsonV1ExpressionExtended),
       idx,
-      fac
+      fac,
+      parentTokenType
     );
   }
 
@@ -91,7 +97,7 @@ export class PairToken extends ComparableToken {
   private tokens(): [Token, Token] {
     let cnt = 0;
     return this.args().map((a) => {
-      const tok = this.createToken(a, this.idx + cnt);
+      const tok = this.createToken(a, this.getIdxForChildren() + cnt, 'Pair');
       if (tok instanceof PairToken) {
         cnt += Object.keys(tok.ExtractSchema()).length;
       } else {
@@ -110,13 +116,13 @@ export class PairToken extends ComparableToken {
 
   public ExtractSignature(): any {
     const args = this.args();
-    const leftToken = this.createToken(args[0], this.idx);
+    const leftToken = this.createToken(args[0], this.getIdxForChildren(), 'Pair');
     let keyCount = 1;
     if (leftToken instanceof OrToken) {
       keyCount = Object.keys(leftToken.ExtractSchema()).length;
     }
 
-    const rightToken = this.createToken(args[1], this.idx + keyCount);
+    const rightToken = this.createToken(args[1], this.getIdxForChildren() + keyCount, 'Pair');
 
     const newSig = [];
 
@@ -169,7 +175,7 @@ export class PairToken extends ComparableToken {
   private traversal(getLeftValue: (token: Token) => any, getRightValue: (token: Token) => any) {
     const args = this.args();
 
-    const leftToken = this.createToken(args[0], this.idx);
+    const leftToken = this.createToken(args[0], this.getIdxForChildren(), 'Pair');
     let keyCount = 1;
     let leftValue;
     if (leftToken instanceof PairToken && !leftToken.hasAnnotations()) {
@@ -181,7 +187,7 @@ export class PairToken extends ComparableToken {
       leftValue = { [leftToken.annot()]: getLeftValue(leftToken) };
     }
 
-    const rightToken = this.createToken(args[1], this.idx + keyCount);
+    const rightToken = this.createToken(args[1], this.getIdxForChildren() + keyCount, 'Pair');
     let rightValue;
     if (rightToken instanceof PairToken && !rightToken.hasAnnotations()) {
       rightValue = getRightValue(rightToken);
@@ -275,4 +281,11 @@ export class PairToken extends ComparableToken {
     this.tokens().map((t) => t.findAndReturnTokens(tokenToFind, tokens));
     return tokens;
   }
+
+  protected getIdxForChildren(): number {
+    if (Token.fieldNumberingStrategy === 'Legacy') {
+      return this.idx;
+    }
+    return this.parentTokenType === 'Pair' ? this.idx : 0;
+  }
 }
diff --git a/packages/taquito-michelson-encoder/src/tokens/token.ts b/packages/taquito-michelson-encoder/src/tokens/token.ts
index c39dd35a38..de71d7ba58 100644
--- a/packages/taquito-michelson-encoder/src/tokens/token.ts
+++ b/packages/taquito-michelson-encoder/src/tokens/token.ts
@@ -9,7 +9,11 @@ import { TaquitoError } from '@taquito/core';
 export abstract class TokenValidationError extends TaquitoError {
   name = 'TokenValidationError';
 
-  constructor(public readonly value: any, public readonly token: Token, baseMessage: string) {
+  constructor(
+    public readonly value: any,
+    public readonly token: Token,
+    baseMessage: string
+  ) {
     super();
     const annot = this.token.annot();
     const annotText = annot ? `[${annot}] ` : '';
@@ -17,7 +21,11 @@ export abstract class TokenValidationError extends TaquitoError {
   }
 }
 
-export type TokenFactory = (val: any, idx: number) => Token;
+export type TokenFactory = (
+  val: any,
+  idx: number,
+  parentTokenType?: 'Or' | 'Pair' | 'Other'
+) => Token;
 
 export interface Semantic {
   [key: string]: (value: MichelsonV1Expression, schema: MichelsonV1Expression) => any;
@@ -27,11 +35,36 @@ export interface SemanticEncoding {
   [key: string]: (value: any, type?: MichelsonV1Expression) => MichelsonV1Expression;
 }
 
+/**
+ * @description Possible strategies for mapping between javascript classes and Michelson values
+ * Legacy: The old behaviour: { annot1: 'some value', annot2: 'other Value', annot3: { 2: 'yet another value', 3: 'also some value' }}
+ * ResetFieldNumbersInNestedObjects: { annot1: 'some value', annot2: 'other Value', annot3: { 0: 'yet another value', 1: 'also some value' }}
+ * Latest: This will include new changes as we might implement in the future. This is the suggested value if it does not break your code
+ */
+export type FieldNumberingStrategy = 'Legacy' | 'ResetFieldNumbersInNestedObjects' | 'Latest';
+
 export abstract class Token {
+  private static _fieldNumberingStrategy: FieldNumberingStrategy = 'Latest';
+
+  /**
+   * @description Gets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects, returns a value of type {@link FieldNumberingStrategy} that controls how field numbers are calculated
+   */
+  static get fieldNumberingStrategy() {
+    return Token._fieldNumberingStrategy;
+  }
+
+  /**
+   * @description Sets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects, accepts a value of type {@link FieldNumberingStrategy} that controls how field numbers are calculated
+   */
+  static set fieldNumberingStrategy(value: FieldNumberingStrategy) {
+    Token._fieldNumberingStrategy = value;
+  }
+
   constructor(
     protected val: MichelsonV1ExpressionExtended,
     protected idx: number,
-    protected fac: TokenFactory
+    protected fac: TokenFactory,
+    protected parentTokenType?: 'Or' | 'Pair' | 'Other'
   ) {}
 
   protected typeWithoutAnnotations() {
diff --git a/packages/taquito-michelson-encoder/test/sample1.spec.ts b/packages/taquito-michelson-encoder/test/sample1.spec.ts
index 2ab346d56c..415fa11f03 100644
--- a/packages/taquito-michelson-encoder/test/sample1.spec.ts
+++ b/packages/taquito-michelson-encoder/test/sample1.spec.ts
@@ -4,6 +4,7 @@ import { ParameterSchema } from '../src/schema/parameter';
 import { Schema } from '../src/schema/storage';
 import { MichelsonMap } from '../src/michelson-map';
 import { expectMichelsonMap } from './utils';
+import { Token } from '../src/taquito-michelson-encoder';
 
 describe('Schema test', () => {
   it('Should extract schema properly', () => {
@@ -12,7 +13,7 @@ describe('Schema test', () => {
     expect(s).toEqual({
       accounts: {
         big_map: {
-          key: "address",
+          key: 'address',
           value: {
             allowances: {
               map: {
@@ -32,60 +33,60 @@ describe('Schema test', () => {
     });
 
     expect(schema.generateSchema()).toEqual({
-      __michelsonType: "pair",
+      __michelsonType: 'pair',
       schema: {
         accounts: {
-          __michelsonType: "big_map",
+          __michelsonType: 'big_map',
           schema: {
             key: {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             value: {
-              __michelsonType: "pair",
+              __michelsonType: 'pair',
               schema: {
                 allowances: {
-                  __michelsonType: "map",
+                  __michelsonType: 'map',
                   schema: {
                     key: {
-                      __michelsonType: "address",
-                      schema: "address"
+                      __michelsonType: 'address',
+                      schema: 'address',
                     },
                     value: {
-                      __michelsonType: "nat",
-                      schema: "nat"
+                      __michelsonType: 'nat',
+                      schema: 'nat',
                     },
                   },
                 },
                 balance: {
-                  __michelsonType: "nat",
-                  schema: "nat"
-                }
-              }
+                  __michelsonType: 'nat',
+                  schema: 'nat',
+                },
+              },
             },
           },
         },
         name: {
-          __michelsonType: "string",
-          schema: "string"
+          __michelsonType: 'string',
+          schema: 'string',
         },
         owner: {
-          __michelsonType: "address",
-          schema: "address"
+          __michelsonType: 'address',
+          schema: 'address',
         },
         symbol: {
-          __michelsonType: "string",
-          schema: "string"
+          __michelsonType: 'string',
+          schema: 'string',
         },
         totalSupply: {
-          __michelsonType: "nat",
-          schema: "nat"
+          __michelsonType: 'nat',
+          schema: 'nat',
         },
         version: {
-          __michelsonType: "nat",
-          schema: "nat"
+          __michelsonType: 'nat',
+          schema: 'nat',
         },
-      }
+      },
     });
   });
 
@@ -202,8 +203,7 @@ describe('Schema test', () => {
 
   it('Should build parameter schema properly', () => {
     const schema = new ParameterSchema(params);
-    const s = schema.ExtractSchema();
-    expect(s).toEqual({
+    const extractSchema_Legacy = {
       allowance: {
         '4': 'address',
         '5': 'address',
@@ -223,8 +223,8 @@ describe('Schema test', () => {
       },
       createAccounts: {
         list: {
-          "6": "address",
-          "7": "nat",
+          '6': 'address',
+          '7': 'nat',
         },
       },
       transfer: {
@@ -236,134 +236,305 @@ describe('Schema test', () => {
         '3': 'address',
         '4': 'nat',
       },
-    });
+    };
+    const extractSchema_ResetFields = {
+      allowance: {
+        '0': 'address',
+        '1': 'address',
+        NatNatContract: 'contract',
+      },
+      approve: {
+        '0': 'address',
+        '1': 'nat',
+      },
+      balanceOf: {
+        '0': 'address',
+        NatContract: 'contract',
+      },
+      createAccount: {
+        '0': 'address',
+        '1': 'nat',
+      },
+      createAccounts: {
+        list: {
+          '0': 'address',
+          '1': 'nat',
+        },
+      },
+      transfer: {
+        '0': 'address',
+        '1': 'nat',
+      },
+      transferFrom: {
+        '0': 'address',
+        '1': 'address',
+        '2': 'nat',
+      },
+    };
 
-    expect(schema.generateSchema()).toEqual({
-      __michelsonType: "or",
+    const generateSchema_Legacy = {
+      __michelsonType: 'or',
       schema: {
         allowance: {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '4': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             '5': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             NatNatContract: {
-              __michelsonType: "contract",
+              __michelsonType: 'contract',
               schema: {
                 parameter: {
-                  __michelsonType: "pair",
+                  __michelsonType: 'pair',
                   schema: {
                     '0': {
-                      __michelsonType: "nat",
-                      schema: "nat"
+                      __michelsonType: 'nat',
+                      schema: 'nat',
                     },
                     '1': {
-                      __michelsonType: "nat",
-                      schema: "nat"
-                    }
-                  }
-                }
-              }
-            }
-          }
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                  },
+                },
+              },
+            },
+          },
         },
         approve: {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '1': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             '2': {
-              __michelsonType: "nat",
-              schema: "nat"
-            }
-          }
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+          },
         },
         balanceOf: {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '3': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             NatContract: {
-              __michelsonType: "contract",
+              __michelsonType: 'contract',
               schema: {
                 parameter: {
-                  __michelsonType: "nat",
-                  schema: "nat"
-                }
-              }
+                  __michelsonType: 'nat',
+                  schema: 'nat',
+                },
+              },
             },
-          }
+          },
         },
         createAccount: {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '5': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             '6': {
-              __michelsonType: "nat",
-              schema: "nat"
+              __michelsonType: 'nat',
+              schema: 'nat',
             },
-          }
+          },
         },
         createAccounts: {
-          __michelsonType: "list",
+          __michelsonType: 'list',
           schema: {
-            __michelsonType: "pair",
+            __michelsonType: 'pair',
             schema: {
-              "6": {
-                __michelsonType: "address",
-                schema: "address"
+              '6': {
+                __michelsonType: 'address',
+                schema: 'address',
               },
-              "7": {
-                __michelsonType: "nat",
-                schema: "nat"
+              '7': {
+                __michelsonType: 'nat',
+                schema: 'nat',
               },
-            }
+            },
           },
         },
         transfer: {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '0': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             '1': {
-              __michelsonType: "nat",
-              schema: "nat"
+              __michelsonType: 'nat',
+              schema: 'nat',
             },
-          }
+          },
         },
         transferFrom: {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '2': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             '3': {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             '4': {
-              __michelsonType: "nat",
-              schema: "nat"
+              __michelsonType: 'nat',
+              schema: 'nat',
             },
-          }
+          },
         },
-      }
-    });
+      },
+    };
+
+    const generateSchema_ResetFields = {
+      __michelsonType: 'or',
+      schema: {
+        allowance: {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '1': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            NatNatContract: {
+              __michelsonType: 'contract',
+              schema: {
+                parameter: {
+                  __michelsonType: 'pair',
+                  schema: {
+                    '0': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                    '1': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        approve: {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '1': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+          },
+        },
+        balanceOf: {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            NatContract: {
+              __michelsonType: 'contract',
+              schema: {
+                parameter: {
+                  __michelsonType: 'nat',
+                  schema: 'nat',
+                },
+              },
+            },
+          },
+        },
+        createAccount: {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '1': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+          },
+        },
+        createAccounts: {
+          __michelsonType: 'list',
+          schema: {
+            __michelsonType: 'pair',
+            schema: {
+              '0': {
+                __michelsonType: 'address',
+                schema: 'address',
+              },
+              '1': {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+            },
+          },
+        },
+        transfer: {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '1': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+          },
+        },
+        transferFrom: {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '1': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '2': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+          },
+        },
+      },
+    };
+
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_Legacy);
+    expect(schema.generateSchema()).toEqual(generateSchema_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
   });
 
   it('Should extract signature properly', () => {
@@ -373,12 +544,29 @@ describe('Schema test', () => {
     expect(sig).toContainEqual(['approve', 'address', 'nat']);
     expect(sig).toContainEqual(['balanceOf', 'address', 'contract']);
     expect(sig).toContainEqual(['createAccount', 'address', 'nat']);
-    expect(sig).toContainEqual(["createAccounts", {
+    const createAccount_Legacy = {
+      list: {
+        '6': 'address',
+        '7': 'nat',
+      },
+    };
+    const createAccount_ResetFields = {
       list: {
-        "6": "address",
-        "7": "nat"
-      }
-    }
+        '0': 'address',
+        '1': 'nat',
+      },
+    };
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.ExtractSignatures()).toContainEqual(['createAccounts', createAccount_Legacy]);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.ExtractSignatures()).toContainEqual([
+      'createAccounts',
+      createAccount_ResetFields,
+    ]);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.ExtractSignatures()).toContainEqual([
+      'createAccounts',
+      createAccount_ResetFields,
     ]);
     expect(sig).toContainEqual(['transfer', 'address', 'nat']);
     expect(sig).toContainEqual(['transferFrom', 'address', 'address', 'nat']);
@@ -386,20 +574,33 @@ describe('Schema test', () => {
 
   it('Should parse parameter properly', () => {
     const schema = new ParameterSchema(params);
-    const s = schema.Execute(txParams);
-    expect(s).toEqual({
+    const execute_Legacy = {
       approve: {
         '1': 'tz1fPjyo55HwUAkd1xcL5vo6DGzJrkxAMpiD',
         '2': new BigNumber('60'),
       },
-    });
+    };
+    const execute_ResetFields = {
+      approve: {
+        '0': 'tz1fPjyo55HwUAkd1xcL5vo6DGzJrkxAMpiD',
+        '1': new BigNumber('60'),
+      },
+    };
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.Execute(txParams)).toEqual(execute_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.Execute(txParams)).toEqual(execute_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.Execute(txParams)).toEqual(execute_ResetFields);
   });
 
   it(`Should find the value that corresponds to the type ({ prim: 'string', annots: ['%name'] }) in top-level pairs of the storage`, () => {
     const typeOfValueToFind = { prim: 'string', annots: ['%name'] };
     const storageSchema = new Schema(storage);
-    const valueFound = storageSchema.FindFirstInTopLevelPair(rpcContractResponse.script.storage, typeOfValueToFind);
+    const valueFound = storageSchema.FindFirstInTopLevelPair(
+      rpcContractResponse.script.storage,
+      typeOfValueToFind
+    );
     expect(valueFound).toEqual({ string: 'Token B' });
   });
-
 });
diff --git a/packages/taquito-michelson-encoder/test/sample11_dexter.spec.ts b/packages/taquito-michelson-encoder/test/sample11_dexter.spec.ts
index 11ef24ee48..f0f90c0c49 100644
--- a/packages/taquito-michelson-encoder/test/sample11_dexter.spec.ts
+++ b/packages/taquito-michelson-encoder/test/sample11_dexter.spec.ts
@@ -9,15 +9,16 @@ import BigNumber from 'bignumber.js';
 import { ParameterSchema } from '../src/schema/parameter';
 import { MichelsonMap } from '../src/michelson-map';
 import { expectMichelsonMap } from './utils';
+import { Token } from '../src/taquito-michelson-encoder';
 describe('Exchange contract test', () => {
   it('Test storage schema', () => {
     const schema = new Schema(storageDexter);
-    expect(schema.ExtractSchema()).toEqual({
+    const extractSchema_Legacy = {
       '0': {
         big_map: {
-          key: "address",
-          value: "nat"
-        }
+          key: 'address',
+          value: 'nat',
+        },
       },
       '1': 'contract',
       '2': 'contract',
@@ -49,23 +50,68 @@ describe('Exchange contract test', () => {
           },
         },
       },
-    });
+    };
+    const extractSchema_ResetFields = {
+      '0': {
+        big_map: {
+          key: 'address',
+          value: 'nat',
+        },
+      },
+      '1': 'contract',
+      '2': 'contract',
+      '3': 'nat',
+      '4': {
+        map: {
+          key: 'address',
+          value: {
+            '0': {
+              '0': 'nat',
+              '1': 'nat',
+              '2': 'timestamp',
+            },
+            '1': {
+              '0': 'nat',
+              '1': 'mutez',
+              '2': 'nat',
+              '3': 'timestamp',
+            },
+            '2': {
+              '0': 'nat',
+              '1': 'timestamp',
+            },
+            '3': {
+              '0': 'nat',
+              '1': 'mutez',
+              '2': 'timestamp',
+            },
+          },
+        },
+      },
+    };
 
-    expect(schema.generateSchema()).toEqual({
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+
+    const generateSchema_Legacy = {
       __michelsonType: 'pair',
       schema: {
         '0': {
-          __michelsonType: "big_map",
+          __michelsonType: 'big_map',
           schema: {
             key: {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             value: {
-              __michelsonType: "nat",
-              schema: "nat"
-            }
-          }
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+          },
         },
         '1': {
           __michelsonType: 'contract',
@@ -78,7 +124,7 @@ describe('Exchange contract test', () => {
                   schema: {
                     0: {
                       __michelsonType: 'address',
-                      schema: 'address'
+                      schema: 'address',
                     },
                     1: {
                       __michelsonType: 'contract',
@@ -91,155 +137,351 @@ describe('Exchange contract test', () => {
                               schema: {
                                 0: {
                                   __michelsonType: 'address',
-                                  schema: 'address'
+                                  schema: 'address',
                                 },
                                 1: {
                                   __michelsonType: 'address',
-                                  schema: 'address'
+                                  schema: 'address',
                                 },
                                 2: {
                                   __michelsonType: 'nat',
-                                  schema: 'nat'
+                                  schema: 'nat',
                                 },
-                              }
+                              },
                             },
                             1: {
                               __michelsonType: 'address',
-                              schema: 'address'
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
+                              schema: 'address',
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
                 },
                 1: {
                   __michelsonType: 'nat',
-                  schema: 'nat'
-                }
-              }
-            }
-          }
+                  schema: 'nat',
+                },
+              },
+            },
+          },
         },
         '2': {
           __michelsonType: 'contract',
           schema: {
             parameter: {
-              __michelsonType: "or",
+              __michelsonType: 'or',
               schema: {
                 0: {
-                  __michelsonType: "pair",
+                  __michelsonType: 'pair',
                   schema: {
                     0: {
                       __michelsonType: 'address',
-                      schema: 'address'
+                      schema: 'address',
                     },
                     1: {
                       __michelsonType: 'address',
-                      schema: 'address'
+                      schema: 'address',
                     },
                     2: {
                       __michelsonType: 'nat',
-                      schema: 'nat'
+                      schema: 'nat',
                     },
-                  }
+                  },
                 },
                 1: {
                   __michelsonType: 'address',
-                  schema: 'address'
-                }
-              }
-            }
-          }
+                  schema: 'address',
+                },
+              },
+            },
+          },
         },
         '3': {
           __michelsonType: 'nat',
-          schema: 'nat'
+          schema: 'nat',
         },
         '4': {
-          __michelsonType: "map",
+          __michelsonType: 'map',
           schema: {
             key: {
               __michelsonType: 'address',
-              schema: 'address'
+              schema: 'address',
             },
             value: {
-              __michelsonType: "or",
+              __michelsonType: 'or',
               schema: {
                 '0': {
-                  __michelsonType: "pair",
+                  __michelsonType: 'pair',
                   schema: {
                     '0': {
                       __michelsonType: 'nat',
-                      schema: 'nat'
+                      schema: 'nat',
                     },
                     '1': {
                       __michelsonType: 'nat',
-                      schema: 'nat'
+                      schema: 'nat',
                     },
                     '2': {
                       __michelsonType: 'timestamp',
-                      schema: 'timestamp'
+                      schema: 'timestamp',
                     },
-                  }
+                  },
                 },
                 '1': {
                   __michelsonType: 'pair',
                   schema: {
                     '1': {
                       __michelsonType: 'nat',
-                      schema: 'nat'
+                      schema: 'nat',
                     },
                     '2': {
                       __michelsonType: 'mutez',
-                      schema: 'mutez'
+                      schema: 'mutez',
                     },
                     '3': {
                       __michelsonType: 'nat',
-                      schema: 'nat'
+                      schema: 'nat',
                     },
                     '4': {
                       __michelsonType: 'timestamp',
-                      schema: 'timestamp'
+                      schema: 'timestamp',
                     },
-                  }
+                  },
                 },
                 '2': {
                   __michelsonType: 'pair',
                   schema: {
                     '2': {
                       __michelsonType: 'nat',
-                      schema: 'nat'
+                      schema: 'nat',
                     },
                     '3': {
                       __michelsonType: 'timestamp',
-                      schema: 'timestamp'
+                      schema: 'timestamp',
                     },
-                  }
+                  },
                 },
                 '3': {
                   __michelsonType: 'pair',
                   schema: {
                     '3': {
                       __michelsonType: 'nat',
-                      schema: 'nat'
+                      schema: 'nat',
                     },
                     '4': {
                       __michelsonType: 'mutez',
-                      schema: 'mutez'
+                      schema: 'mutez',
                     },
                     '5': {
                       __michelsonType: 'timestamp',
-                      schema: 'timestamp'
+                      schema: 'timestamp',
                     },
-                  }
+                  },
                 },
-              }
+              },
             },
           },
         },
-      }
-    });
+      },
+    };
+    const generateSchema_ResetFields = {
+      __michelsonType: 'pair',
+      schema: {
+        '0': {
+          __michelsonType: 'big_map',
+          schema: {
+            key: {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            value: {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+          },
+        },
+        '1': {
+          __michelsonType: 'contract',
+          schema: {
+            parameter: {
+              __michelsonType: 'or',
+              schema: {
+                0: {
+                  __michelsonType: 'pair',
+                  schema: {
+                    0: {
+                      __michelsonType: 'address',
+                      schema: 'address',
+                    },
+                    1: {
+                      __michelsonType: 'contract',
+                      schema: {
+                        parameter: {
+                          __michelsonType: 'or',
+                          schema: {
+                            0: {
+                              __michelsonType: 'pair',
+                              schema: {
+                                0: {
+                                  __michelsonType: 'address',
+                                  schema: 'address',
+                                },
+                                1: {
+                                  __michelsonType: 'address',
+                                  schema: 'address',
+                                },
+                                2: {
+                                  __michelsonType: 'nat',
+                                  schema: 'nat',
+                                },
+                              },
+                            },
+                            1: {
+                              __michelsonType: 'address',
+                              schema: 'address',
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+                1: {
+                  __michelsonType: 'nat',
+                  schema: 'nat',
+                },
+              },
+            },
+          },
+        },
+        '2': {
+          __michelsonType: 'contract',
+          schema: {
+            parameter: {
+              __michelsonType: 'or',
+              schema: {
+                0: {
+                  __michelsonType: 'pair',
+                  schema: {
+                    0: {
+                      __michelsonType: 'address',
+                      schema: 'address',
+                    },
+                    1: {
+                      __michelsonType: 'address',
+                      schema: 'address',
+                    },
+                    2: {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                  },
+                },
+                1: {
+                  __michelsonType: 'address',
+                  schema: 'address',
+                },
+              },
+            },
+          },
+        },
+        '3': {
+          __michelsonType: 'nat',
+          schema: 'nat',
+        },
+        '4': {
+          __michelsonType: 'map',
+          schema: {
+            key: {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            value: {
+              __michelsonType: 'or',
+              schema: {
+                '0': {
+                  __michelsonType: 'pair',
+                  schema: {
+                    '0': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                    '1': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                    '2': {
+                      __michelsonType: 'timestamp',
+                      schema: 'timestamp',
+                    },
+                  },
+                },
+                '1': {
+                  __michelsonType: 'pair',
+                  schema: {
+                    '0': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                    '1': {
+                      __michelsonType: 'mutez',
+                      schema: 'mutez',
+                    },
+                    '2': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                    '3': {
+                      __michelsonType: 'timestamp',
+                      schema: 'timestamp',
+                    },
+                  },
+                },
+                '2': {
+                  __michelsonType: 'pair',
+                  schema: {
+                    '0': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                    '1': {
+                      __michelsonType: 'timestamp',
+                      schema: 'timestamp',
+                    },
+                  },
+                },
+                '3': {
+                  __michelsonType: 'pair',
+                  schema: {
+                    '0': {
+                      __michelsonType: 'nat',
+                      schema: 'nat',
+                    },
+                    '1': {
+                      __michelsonType: 'mutez',
+                      schema: 'mutez',
+                    },
+                    '2': {
+                      __michelsonType: 'timestamp',
+                      schema: 'timestamp',
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.generateSchema()).toEqual(generateSchema_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
   });
 
   it('Test storage parsing', () => {
@@ -271,7 +513,7 @@ describe('Exchange contract test', () => {
 
   it('Test parameter schema', () => {
     const schema = new ParameterSchema(params);
-    expect(schema.ExtractSchema()).toEqual({
+    const extractSchema_Legacy = {
       '0': {
         '0': 'nat',
         '1': 'nat',
@@ -293,85 +535,199 @@ describe('Exchange contract test', () => {
         '5': 'timestamp',
       },
       '4': 'nat',
-    });
+    };
+    const extractSchema_ResetFields = {
+      '0': {
+        '0': 'nat',
+        '1': 'nat',
+        '2': 'timestamp',
+      },
+      '1': {
+        '0': 'nat',
+        '1': 'mutez',
+        '2': 'nat',
+        '3': 'timestamp',
+      },
+      '2': {
+        '0': 'nat',
+        '1': 'timestamp',
+      },
+      '3': {
+        '0': 'nat',
+        '1': 'mutez',
+        '2': 'timestamp',
+      },
+      '4': 'nat',
+    };
 
-    expect(schema.generateSchema()).toEqual({
-      __michelsonType: "or",
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+
+    const generateSchema_Legacy = {
+      __michelsonType: 'or',
       schema: {
         '0': {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '0': {
               __michelsonType: 'nat',
-              schema: 'nat'
+              schema: 'nat',
             },
             '1': {
               __michelsonType: 'nat',
-              schema: 'nat'
+              schema: 'nat',
             },
             '2': {
               __michelsonType: 'timestamp',
-              schema: 'timestamp'
+              schema: 'timestamp',
             },
-          }
+          },
         },
         '1': {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '1': {
               __michelsonType: 'nat',
-              schema: 'nat'
+              schema: 'nat',
             },
             '2': {
               __michelsonType: 'mutez',
-              schema: 'mutez'
+              schema: 'mutez',
             },
             '3': {
               __michelsonType: 'nat',
-              schema: 'nat'
+              schema: 'nat',
             },
             '4': {
               __michelsonType: 'timestamp',
-              schema: 'timestamp'
+              schema: 'timestamp',
             },
-          }
+          },
         },
         '2': {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '2': {
               __michelsonType: 'nat',
-              schema: 'nat'
+              schema: 'nat',
             },
             '3': {
               __michelsonType: 'timestamp',
-              schema: 'timestamp'
+              schema: 'timestamp',
             },
-          }
+          },
         },
         '3': {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '3': {
               __michelsonType: 'nat',
-              schema: 'nat'
+              schema: 'nat',
             },
             '4': {
               __michelsonType: 'mutez',
-              schema: 'mutez'
+              schema: 'mutez',
             },
             '5': {
               __michelsonType: 'timestamp',
-              schema: 'timestamp'
+              schema: 'timestamp',
             },
-          }
+          },
         },
         '4': {
           __michelsonType: 'nat',
-          schema: 'nat'
+          schema: 'nat',
         },
-      }
-    });
+      },
+    };
+    const generateSchema_ResetFields = {
+      __michelsonType: 'or',
+      schema: {
+        '0': {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+            '1': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+            '2': {
+              __michelsonType: 'timestamp',
+              schema: 'timestamp',
+            },
+          },
+        },
+        '1': {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+            '1': {
+              __michelsonType: 'mutez',
+              schema: 'mutez',
+            },
+            '2': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+            '3': {
+              __michelsonType: 'timestamp',
+              schema: 'timestamp',
+            },
+          },
+        },
+        '2': {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+            '1': {
+              __michelsonType: 'timestamp',
+              schema: 'timestamp',
+            },
+          },
+        },
+        '3': {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'nat',
+              schema: 'nat',
+            },
+            '1': {
+              __michelsonType: 'mutez',
+              schema: 'mutez',
+            },
+            '2': {
+              __michelsonType: 'timestamp',
+              schema: 'timestamp',
+            },
+          },
+        },
+        '4': {
+          __michelsonType: 'nat',
+          schema: 'nat',
+        },
+      },
+    };
+
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.generateSchema()).toEqual(generateSchema_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
   });
 
   it('Encode parameter properly func 0', () => {
@@ -525,7 +881,7 @@ describe('Exchange contract test', () => {
     expect(schema.ExtractSchema()).toEqual({
       '0': {
         big_map: {
-          key: "address",
+          key: 'address',
           value: {
             '0': 'nat',
             '1': {
@@ -543,52 +899,52 @@ describe('Exchange contract test', () => {
     });
 
     expect(schema.generateSchema()).toEqual({
-      __michelsonType: "pair",
+      __michelsonType: 'pair',
       schema: {
         '0': {
-          __michelsonType: "big_map",
+          __michelsonType: 'big_map',
           schema: {
             key: {
-              __michelsonType: "address",
-              schema: "address"
+              __michelsonType: 'address',
+              schema: 'address',
             },
             value: {
               __michelsonType: 'pair',
               schema: {
                 '0': {
-                  __michelsonType: "nat",
-                  schema: "nat"
+                  __michelsonType: 'nat',
+                  schema: 'nat',
                 },
                 '1': {
                   __michelsonType: 'map',
                   schema: {
                     key: {
-                      __michelsonType: "address",
-                      schema: "address"
+                      __michelsonType: 'address',
+                      schema: 'address',
                     },
                     value: {
-                      __michelsonType: "nat",
-                      schema: "nat"
+                      __michelsonType: 'nat',
+                      schema: 'nat',
                     },
                   },
                 },
-              }
+              },
             },
           },
         },
         '1': {
-          __michelsonType: "nat",
-          schema: "nat"
+          __michelsonType: 'nat',
+          schema: 'nat',
         },
         '2': {
-          __michelsonType: "string",
-          schema: "string"
+          __michelsonType: 'string',
+          schema: 'string',
         },
         '3': {
-          __michelsonType: "string",
-          schema: "string"
+          __michelsonType: 'string',
+          schema: 'string',
         },
-      }
+      },
     });
   });
 
@@ -614,30 +970,30 @@ describe('Exchange contract test', () => {
     });
 
     expect(schema.generateSchema()).toEqual({
-      __michelsonType: "or",
+      __michelsonType: 'or',
       schema: {
         '0': {
-          __michelsonType: "pair",
+          __michelsonType: 'pair',
           schema: {
             '0': {
               __michelsonType: 'address',
-              schema: "address"
+              schema: 'address',
             },
             '1': {
               __michelsonType: 'address',
-              schema: "address"
+              schema: 'address',
             },
             '2': {
               __michelsonType: 'nat',
-              schema: "nat"
+              schema: 'nat',
             },
-          }
+          },
         },
         '1': {
           __michelsonType: 'address',
-          schema: "address"
+          schema: 'address',
         },
-      }
+      },
     });
 
     expect(schema.ExtractSignatures()).toContainEqual(['1', 'address']);
diff --git a/packages/taquito-michelson-encoder/test/sample9_lambda.spec.ts b/packages/taquito-michelson-encoder/test/sample9_lambda.spec.ts
index b7fc84630a..8b025b4d7c 100644
--- a/packages/taquito-michelson-encoder/test/sample9_lambda.spec.ts
+++ b/packages/taquito-michelson-encoder/test/sample9_lambda.spec.ts
@@ -2,17 +2,17 @@
 
 import { params as params9 } from '../data/sample9';
 import { ParameterSchema } from '../src/schema/parameter';
+import { Token } from '../src/taquito-michelson-encoder';
 
 describe('Schema test', () => {
   it('Should parse storage properly', () => {
     const schema = new ParameterSchema(params9);
-    const storage = schema.ExtractSchema();
 
     expect(schema.ExtractSignatures()).toContainEqual(['0', 'address', 'string', 'bytes']);
     expect(schema.ExtractSignatures()).toContainEqual(['1', 'mutez']);
     expect(schema.ExtractSignatures()).toContainEqual(['2', 'address', 'bool']);
 
-    expect(storage).toEqual({
+    const extractSchema_Legacy = {
       '0': {
         '0': 'address',
         '1': 'string',
@@ -33,9 +33,38 @@ describe('Schema test', () => {
           returns: 'operation',
         },
       },
-    });
+    };
+    const extractSchema_ResetFields = {
+      '0': {
+        '0': 'address',
+        '1': 'string',
+        '2': { Some: 'bytes' },
+      },
+      '1': 'mutez',
+      '2': {
+        '0': 'address',
+        '1': 'bool',
+      },
+      '3': {
+        lambda: {
+          parameters: {
+            0: 'address',
+            1: 'string',
+            2: { Some: 'bytes' },
+          },
+          returns: 'operation',
+        },
+      },
+    };
 
-    expect(schema.generateSchema()).toEqual({
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.ExtractSchema()).toEqual(extractSchema_ResetFields);
+
+    const generateSchema_Legacy = {
       __michelsonType: 'or',
       schema: {
         '0': {
@@ -105,7 +134,85 @@ describe('Schema test', () => {
           },
         },
       },
-    });
+    };
+    const generateSchema_ResetFields = {
+      __michelsonType: 'or',
+      schema: {
+        '0': {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '1': {
+              __michelsonType: 'string',
+              schema: 'string',
+            },
+            '2': {
+              __michelsonType: 'option',
+              schema: {
+                __michelsonType: 'bytes',
+                schema: 'bytes',
+              },
+            },
+          },
+        },
+        '1': {
+          __michelsonType: 'mutez',
+          schema: 'mutez',
+        },
+        '2': {
+          __michelsonType: 'pair',
+          schema: {
+            '0': {
+              __michelsonType: 'address',
+              schema: 'address',
+            },
+            '1': {
+              __michelsonType: 'bool',
+              schema: 'bool',
+            },
+          },
+        },
+        '3': {
+          __michelsonType: 'lambda',
+          schema: {
+            parameters: {
+              __michelsonType: 'pair',
+              schema: {
+                0: {
+                  __michelsonType: 'address',
+                  schema: 'address',
+                },
+                1: {
+                  __michelsonType: 'string',
+                  schema: 'string',
+                },
+                2: {
+                  __michelsonType: 'option',
+                  schema: {
+                    __michelsonType: 'bytes',
+                    schema: 'bytes',
+                  },
+                },
+              },
+            },
+            returns: {
+              __michelsonType: 'operation',
+              schema: 'operation',
+            },
+          },
+        },
+      },
+    };
+
+    Token.fieldNumberingStrategy = 'Legacy';
+    expect(schema.generateSchema()).toEqual(generateSchema_Legacy);
+    Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
+    Token.fieldNumberingStrategy = 'Latest';
+    expect(schema.generateSchema()).toEqual(generateSchema_ResetFields);
 
     expect({
       args: [
diff --git a/packages/taquito-michelson-encoder/test/tokens/map.spec.ts b/packages/taquito-michelson-encoder/test/tokens/map.spec.ts
index 8e85cc432d..eaeecf6169 100644
--- a/packages/taquito-michelson-encoder/test/tokens/map.spec.ts
+++ b/packages/taquito-michelson-encoder/test/tokens/map.spec.ts
@@ -192,7 +192,7 @@ describe('Map token', () => {
       map.set({ myBytes: 'cccc' }, 15); //LLR
       map.set({ myAddress: 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu' }, 5); //LLL
       map.set({ myNat: 48 }, 16); //LRR
-      map.set({ myPair: { 4: 12, 5: 6 } }, 3); //RLL
+      map.set({ myPair: { 0: 12, 1: 6 } }, 3); //RLL
       map.set({ myInt: 4 }, 6); //LRL
       map.set({ myString: 'test' }, 3); //RLR
       map.set({ myBytes: 'aaaa' }, 5); //LLR
@@ -351,7 +351,7 @@ describe('Map token', () => {
       map.set({ 1: 'cccc' }, 15); //LLR
       map.set({ 0: 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu' }, 5); //LLL
       map.set({ 3: 48 }, 16); //LRR
-      map.set({ 4: { 4: 12, 5: 6 } }, 3); //RLL
+      map.set({ 4: { 0: 12, 1: 6 } }, 3); //RLL
       map.set({ 2: 4 }, 6); //LRL
       map.set({ 5: 'test' }, 3); //RLR
       map.set({ 1: 'aaaa' }, 5); //LLR
@@ -642,13 +642,13 @@ describe('Map token', () => {
         schema: {
           key: {
             __michelsonType: 'string',
-            schema: 'string'
+            schema: 'string',
           },
           value: {
             __michelsonType: 'int',
-            schema: 'int'
-          }
-        }
+            schema: 'int',
+          },
+        },
       });
     });
   });
@@ -760,19 +760,19 @@ describe('Map token with pair', () => {
             schema: {
               0: {
                 __michelsonType: 'string',
-                schema: 'string'
+                schema: 'string',
               },
               1: {
                 __michelsonType: 'string',
-                schema: 'string'
-              }
-            }
+                schema: 'string',
+              },
+            },
           },
           value: {
             __michelsonType: 'int',
-            schema: 'int'
-          }
-        }
+            schema: 'int',
+          },
+        },
       });
     });
   });
@@ -890,19 +890,19 @@ describe('Map token with annotated pair', () => {
           schema: {
             test: {
               __michelsonType: 'string',
-              schema: 'string'
+              schema: 'string',
             },
             test2: {
               __michelsonType: 'string',
-              schema: 'string'
-            }
-          }
+              schema: 'string',
+            },
+          },
         },
         value: {
           __michelsonType: 'int',
-          schema: 'int'
-        }
-      }
+          schema: 'int',
+        },
+      },
     });
   });
 });
@@ -1176,47 +1176,47 @@ describe('Map token with complex pair', () => {
           schema: {
             0: {
               __michelsonType: 'int',
-              schema: 'int'
+              schema: 'int',
             },
             1: {
               __michelsonType: 'nat',
-              schema: 'nat'
+              schema: 'nat',
             },
             2: {
               __michelsonType: 'string',
-              schema: 'string'
+              schema: 'string',
             },
             3: {
               __michelsonType: 'bytes',
-              schema: 'bytes'
+              schema: 'bytes',
             },
             4: {
               __michelsonType: 'mutez',
-              schema: 'mutez'
+              schema: 'mutez',
             },
             5: {
               __michelsonType: 'bool',
-              schema: 'bool'
+              schema: 'bool',
             },
             6: {
               __michelsonType: 'key_hash',
-              schema: 'key_hash'
+              schema: 'key_hash',
             },
             7: {
               __michelsonType: 'timestamp',
-              schema: 'timestamp'
+              schema: 'timestamp',
             },
             8: {
               __michelsonType: 'address',
-              schema: 'address'
+              schema: 'address',
             },
-          }
+          },
         },
         value: {
           __michelsonType: 'int',
-          schema: 'int'
-        }
-      }
+          schema: 'int',
+        },
+      },
     });
   });
 });
diff --git a/packages/taquito-michelson-encoder/test/tokens/or.spec.ts b/packages/taquito-michelson-encoder/test/tokens/or.spec.ts
index df501340e5..ba784290d4 100644
--- a/packages/taquito-michelson-encoder/test/tokens/or.spec.ts
+++ b/packages/taquito-michelson-encoder/test/tokens/or.spec.ts
@@ -10,6 +10,7 @@ import {
   tokenNoAnnots,
   tokenOrWithOption,
 } from '../data/or-tokens';
+import { Schema, Token } from '../../src/taquito-michelson-encoder';
 
 describe('Or token', () => {
   describe('generateSchema, EncodeObject, Execute', () => {
@@ -151,11 +152,8 @@ describe('Or token', () => {
           },
         ],
       });
-      expect(
-        tokenComplexNoAnnots.EncodeObject({
-          1: { 1: 3, 2: 4, 3: 31, 4: '2019-09-06T15:08:29.000Z' },
-        })
-      ).toEqual({
+
+      let encode_Expected: object = {
         prim: 'Left',
         args: [
           {
@@ -174,8 +172,17 @@ describe('Or token', () => {
             ],
           },
         ],
-      });
-      expect(tokenComplexNoAnnots.EncodeObject({ 2: { 2: 3, 3: 'test' } })).toEqual({
+      };
+      let object_Legacy: object = { 1: { 1: 3, 2: 4, 3: 31, 4: '2019-09-06T15:08:29.000Z' } };
+      let object_ResetFields: object = { 1: { 0: 3, 1: 4, 2: 31, 3: '2019-09-06T15:08:29.000Z' } };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplexNoAnnots.EncodeObject(object_Legacy)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplexNoAnnots.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplexNoAnnots.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+
+      encode_Expected = {
         prim: 'Right',
         args: [
           {
@@ -183,12 +190,17 @@ describe('Or token', () => {
             args: [{ prim: 'Pair', args: [{ int: '3' }, { string: 'test' }] }],
           },
         ],
-      });
-      expect(
-        tokenComplexNoAnnots.EncodeObject({
-          3: { 3: 4, 4: 3, 5: '2019-09-06T15:08:29.000Z' },
-        })
-      ).toEqual({
+      };
+      object_Legacy = { 2: { 2: 3, 3: 'test' } };
+      object_ResetFields = { 2: { 0: 3, 1: 'test' } };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplexNoAnnots.EncodeObject(object_Legacy)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplexNoAnnots.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplexNoAnnots.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+
+      encode_Expected = {
         prim: 'Right',
         args: [
           {
@@ -212,7 +224,15 @@ describe('Or token', () => {
             ],
           },
         ],
-      });
+      };
+      object_Legacy = { 3: { 3: 4, 4: 3, 5: '2019-09-06T15:08:29.000Z' } };
+      object_ResetFields = { 3: { 0: 4, 1: 3, 2: '2019-09-06T15:08:29.000Z' } };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplexNoAnnots.EncodeObject(object_Legacy)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplexNoAnnots.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplexNoAnnots.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
       expect(tokenComplexNoAnnots.EncodeObject({ 4: 4 })).toEqual({
         prim: 'Right',
         args: [{ prim: 'Right', args: [{ prim: 'Right', args: [{ int: '4' }] }] }],
@@ -242,11 +262,8 @@ describe('Or token', () => {
           },
         ],
       });
-      expect(
-        tokenComplex.EncodeObject({
-          option1: { 1: 3, 2: 4, 3: 31, 4: '2019-09-06T15:08:29.000Z' },
-        })
-      ).toEqual({
+
+      encode_Expected = {
         prim: 'Left',
         args: [
           {
@@ -265,8 +282,17 @@ describe('Or token', () => {
             ],
           },
         ],
-      });
-      expect(tokenComplex.EncodeObject({ option2: { 2: 3, 3: 'test' } })).toEqual({
+      };
+      object_Legacy = { option1: { 1: 3, 2: 4, 3: 31, 4: '2019-09-06T15:08:29.000Z' } };
+      object_ResetFields = { option1: { 0: 3, 1: 4, 2: 31, 3: '2019-09-06T15:08:29.000Z' } };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplex.EncodeObject(object_Legacy)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplex.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplex.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+
+      encode_Expected = {
         prim: 'Right',
         args: [
           {
@@ -274,12 +300,17 @@ describe('Or token', () => {
             args: [{ prim: 'Pair', args: [{ int: '3' }, { string: 'test' }] }],
           },
         ],
-      });
-      expect(
-        tokenComplex.EncodeObject({
-          option3: { 3: 4, 4: 3, 5: '2019-09-06T15:08:29.000Z' },
-        })
-      ).toEqual({
+      };
+      object_Legacy = { option2: { 2: 3, 3: 'test' } };
+      object_ResetFields = { option2: { 0: 3, 1: 'test' } };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplex.EncodeObject(object_Legacy)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplex.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplex.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+
+      encode_Expected = {
         prim: 'Right',
         args: [
           {
@@ -303,7 +334,16 @@ describe('Or token', () => {
             ],
           },
         ],
-      });
+      };
+      object_Legacy = { option3: { 3: 4, 4: 3, 5: '2019-09-06T15:08:29.000Z' } };
+      object_ResetFields = { option3: { 0: 4, 1: 3, 2: '2019-09-06T15:08:29.000Z' } };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplex.EncodeObject(object_Legacy)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplex.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplex.EncodeObject(object_ResetFields)).toEqual(encode_Expected);
+
       expect(tokenComplex.EncodeObject({ option4: 4 })).toEqual({
         prim: 'Right',
         args: [{ prim: 'Right', args: [{ prim: 'Right', args: [{ int: '4' }] }] }],
@@ -574,15 +614,28 @@ describe('Or token', () => {
         },
       });
 
-      expect(tokenComplexNoAnnots.ExtractSchema()).toEqual({
+      let extractSchema_Legacy: object = {
         0: { 0: 'nat', 1: 'nat', 2: 'timestamp' },
         1: { 1: 'nat', 2: 'mutez', 3: 'nat', 4: 'timestamp' },
         2: { 2: 'nat', 3: 'timestamp' },
         3: { 3: 'nat', 4: 'mutez', 5: 'timestamp' },
         4: 'nat',
-      });
+      };
+      let extractSchema_ResetFields: object = {
+        0: { 0: 'nat', 1: 'nat', 2: 'timestamp' },
+        1: { 0: 'nat', 1: 'mutez', 2: 'nat', 3: 'timestamp' },
+        2: { 0: 'nat', 1: 'timestamp' },
+        3: { 0: 'nat', 1: 'mutez', 2: 'timestamp' },
+        4: 'nat',
+      };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplexNoAnnots.ExtractSchema()).toEqual(extractSchema_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplexNoAnnots.ExtractSchema()).toEqual(extractSchema_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplexNoAnnots.ExtractSchema()).toEqual(extractSchema_ResetFields);
 
-      expect(tokenComplexNoAnnots.generateSchema()).toEqual({
+      let generateSchema_Legacy: object = {
         __michelsonType: 'or',
         schema: {
           0: {
@@ -658,17 +711,113 @@ describe('Or token', () => {
             schema: 'nat',
           },
         },
-      });
+      };
+      let generateSchema_ResetFields: object = {
+        __michelsonType: 'or',
+        schema: {
+          0: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              2: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          1: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'mutez',
+                schema: 'mutez',
+              },
+              2: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              3: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          2: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          3: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'mutez',
+                schema: 'mutez',
+              },
+              2: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          4: {
+            __michelsonType: 'nat',
+            schema: 'nat',
+          },
+        },
+      };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplexNoAnnots.generateSchema()).toEqual(generateSchema_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplexNoAnnots.generateSchema()).toEqual(generateSchema_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplexNoAnnots.generateSchema()).toEqual(generateSchema_ResetFields);
 
-      expect(tokenComplex.ExtractSchema()).toEqual({
+      extractSchema_Legacy = {
         option0: { 0: 'nat', 1: 'nat', 2: 'timestamp' },
         option1: { 1: 'nat', 2: 'mutez', 3: 'nat', 4: 'timestamp' },
         option2: { 2: 'nat', 3: 'timestamp' },
         option3: { 3: 'nat', 4: 'mutez', 5: 'timestamp' },
         option4: 'nat',
-      });
+      };
+      extractSchema_ResetFields = {
+        option0: { 0: 'nat', 1: 'nat', 2: 'timestamp' },
+        option1: { 0: 'nat', 1: 'mutez', 2: 'nat', 3: 'timestamp' },
+        option2: { 0: 'nat', 1: 'timestamp' },
+        option3: { 0: 'nat', 1: 'mutez', 2: 'timestamp' },
+        option4: 'nat',
+      };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplex.ExtractSchema()).toEqual(extractSchema_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplex.ExtractSchema()).toEqual(extractSchema_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplex.ExtractSchema()).toEqual(extractSchema_ResetFields);
 
-      expect(tokenComplex.generateSchema()).toEqual({
+      generateSchema_Legacy = {
         __michelsonType: 'or',
         schema: {
           option0: {
@@ -744,7 +893,90 @@ describe('Or token', () => {
             schema: 'nat',
           },
         },
-      });
+      };
+      generateSchema_ResetFields = {
+        __michelsonType: 'or',
+        schema: {
+          option0: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              2: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          option1: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'mutez',
+                schema: 'mutez',
+              },
+              2: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              3: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          option2: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          option3: {
+            __michelsonType: 'pair',
+            schema: {
+              0: {
+                __michelsonType: 'nat',
+                schema: 'nat',
+              },
+              1: {
+                __michelsonType: 'mutez',
+                schema: 'mutez',
+              },
+              2: {
+                __michelsonType: 'timestamp',
+                schema: 'timestamp',
+              },
+            },
+          },
+          option4: {
+            __michelsonType: 'nat',
+            schema: 'nat',
+          },
+        },
+      };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenComplex.generateSchema()).toEqual(generateSchema_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenComplex.generateSchema()).toEqual(generateSchema_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenComplex.generateSchema()).toEqual(generateSchema_ResetFields);
 
       expect(tokenOrWithOption.generateSchema()).toEqual({
         __michelsonType: 'or',
@@ -840,22 +1072,29 @@ describe('Or token', () => {
           ],
         })
       ).toEqual({ myNat: new BigNumber(6) }); // { 0: '6'  }
-      expect(
-        tokenNestedOr.Execute({
-          prim: 'Right',
-          args: [
-            {
-              prim: 'Left',
-              args: [
-                {
-                  prim: 'Left',
-                  args: [{ prim: 'Pair', args: [{ int: '3' }, { int: '4' }] }],
-                },
-              ],
-            },
-          ],
-        })
-      ).toEqual({ myPair: { 4: new BigNumber(3), 5: new BigNumber(4) } }); // { 4: { myPair: { 4: '3', 5: '4'} } }
+      let michelson: object = {
+        prim: 'Right',
+        args: [
+          {
+            prim: 'Left',
+            args: [
+              {
+                prim: 'Left',
+                args: [{ prim: 'Pair', args: [{ int: '3' }, { int: '4' }] }],
+              },
+            ],
+          },
+        ],
+      };
+      let execute_Legacy: object = { myPair: { 4: new BigNumber(3), 5: new BigNumber(4) } };
+      let execute_ResetFields: object = { myPair: { 0: new BigNumber(3), 1: new BigNumber(4) } };
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenNestedOr.Execute(michelson)).toEqual(execute_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenNestedOr.Execute(michelson)).toEqual(execute_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenNestedOr.Execute(michelson)).toEqual(execute_ResetFields);
+
       expect(
         tokenNestedOr.Execute({
           prim: 'Right',
@@ -923,22 +1162,31 @@ describe('Or token', () => {
           ],
         })
       ).toEqual({ 3: new BigNumber(6) }); // { 0: '6'  }
-      expect(
-        tokenNestedOrWithoutAnnot.Execute({
-          prim: 'Right',
-          args: [
-            {
-              prim: 'Left',
-              args: [
-                {
-                  prim: 'Left',
-                  args: [{ prim: 'Pair', args: [{ int: '3' }, { int: '4' }] }],
-                },
-              ],
-            },
-          ],
-        })
-      ).toEqual({ 4: { 4: new BigNumber(3), 5: new BigNumber(4) } }); // { 4: { myPair: { 4: '3', 5: '4'} } }
+
+      michelson = {
+        prim: 'Right',
+        args: [
+          {
+            prim: 'Left',
+            args: [
+              {
+                prim: 'Left',
+                args: [{ prim: 'Pair', args: [{ int: '3' }, { int: '4' }] }],
+              },
+            ],
+          },
+        ],
+      };
+      execute_Legacy = { 4: { 4: new BigNumber(3), 5: new BigNumber(4) } };
+      execute_ResetFields = { 4: { 0: new BigNumber(3), 1: new BigNumber(4) } };
+
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(tokenNestedOrWithoutAnnot.Execute(michelson)).toEqual(execute_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(tokenNestedOrWithoutAnnot.Execute(michelson)).toEqual(execute_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(tokenNestedOrWithoutAnnot.Execute(michelson)).toEqual(execute_ResetFields);
+
       expect(
         tokenNestedOrWithoutAnnot.Execute({
           prim: 'Right',
@@ -982,4 +1230,418 @@ describe('Or token', () => {
       });
     });
   });
+
+  describe('Nesting of Pair and Or', () => {
+    it('reproducing the reported bug in #2927', () => {
+      const schemaObj = {
+        prim: 'pair',
+        args: [
+          {
+            prim: 'set',
+            args: [
+              {
+                prim: 'address',
+              },
+            ],
+            annots: ['%owners'],
+          },
+          {
+            prim: 'set',
+            args: [
+              {
+                prim: 'address',
+              },
+            ],
+            annots: ['%inheritors'],
+          },
+          {
+            prim: 'or',
+            args: [
+              {
+                prim: 'unit',
+                annots: ['%aCTIVE'],
+              },
+              {
+                prim: 'or',
+                args: [
+                  {
+                    prim: 'pair',
+                    args: [
+                      {
+                        prim: 'address',
+                      },
+                      {
+                        prim: 'timestamp',
+                      },
+                    ],
+                    annots: ['%rECOVERING'],
+                  },
+                  {
+                    prim: 'unit',
+                    annots: ['%dEAD'],
+                  },
+                ],
+              },
+            ],
+            annots: ['%status'],
+          },
+          {
+            prim: 'mutez',
+            annots: ['%quick_recovery_stake'],
+          },
+          {
+            prim: 'nat',
+            annots: ['%quick_recovery_period'],
+          },
+          {
+            prim: 'big_map',
+            args: [
+              {
+                prim: 'pair',
+                args: [
+                  {
+                    prim: 'address',
+                  },
+                  {
+                    prim: 'or',
+                    args: [
+                      {
+                        prim: 'nat',
+                        annots: ['%sECOND'],
+                      },
+                      {
+                        prim: 'or',
+                        args: [
+                          {
+                            prim: 'nat',
+                            annots: ['%mINUTE'],
+                          },
+                          {
+                            prim: 'or',
+                            args: [
+                              {
+                                prim: 'nat',
+                                annots: ['%hOUR'],
+                              },
+                              {
+                                prim: 'or',
+                                args: [
+                                  {
+                                    prim: 'nat',
+                                    annots: ['%dAY'],
+                                  },
+                                  {
+                                    prim: 'or',
+                                    args: [
+                                      {
+                                        prim: 'nat',
+                                        annots: ['%wEEK'],
+                                      },
+                                      {
+                                        prim: 'or',
+                                        args: [
+                                          {
+                                            prim: 'nat',
+                                            annots: ['%mONTH'],
+                                          },
+                                          {
+                                            prim: 'nat',
+                                            annots: ['%yEAR'],
+                                          },
+                                        ],
+                                      },
+                                    ],
+                                  },
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+              {
+                prim: 'mutez',
+              },
+            ],
+            annots: ['%direct_debit_mandates'],
+          },
+          {
+            prim: 'big_map',
+            args: [
+              {
+                prim: 'pair',
+                args: [
+                  {
+                    prim: 'address',
+                  },
+                  {
+                    prim: 'or',
+                    args: [
+                      {
+                        prim: 'nat',
+                        annots: ['%sECOND'],
+                      },
+                      {
+                        prim: 'or',
+                        args: [
+                          {
+                            prim: 'nat',
+                            annots: ['%mINUTE'],
+                          },
+                          {
+                            prim: 'or',
+                            args: [
+                              {
+                                prim: 'nat',
+                                annots: ['%hOUR'],
+                              },
+                              {
+                                prim: 'or',
+                                args: [
+                                  {
+                                    prim: 'nat',
+                                    annots: ['%dAY'],
+                                  },
+                                  {
+                                    prim: 'or',
+                                    args: [
+                                      {
+                                        prim: 'nat',
+                                        annots: ['%wEEK'],
+                                      },
+                                      {
+                                        prim: 'or',
+                                        args: [
+                                          {
+                                            prim: 'nat',
+                                            annots: ['%mONTH'],
+                                          },
+                                          {
+                                            prim: 'nat',
+                                            annots: ['%yEAR'],
+                                          },
+                                        ],
+                                      },
+                                    ],
+                                  },
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+              {
+                prim: 'timestamp',
+              },
+            ],
+            annots: ['%direct_debit_mandates_history'],
+          },
+        ],
+      };
+      const dataObj = {
+        prim: 'Pair',
+        args: [
+          [
+            {
+              string: 'tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6',
+            },
+          ],
+          [],
+          {
+            prim: 'Right',
+            args: [
+              {
+                prim: 'Left',
+                args: [
+                  {
+                    prim: 'Pair',
+                    args: [
+                      {
+                        string: 'tz1dcjLdDM6uYKYdQhK177cUbtvL8QwX4ebH',
+                      },
+                      {
+                        string: '2024-04-19T13:53:22Z',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            int: '1000000',
+          },
+          {
+            int: '0',
+          },
+          {
+            int: '414522',
+          },
+          {
+            int: '414523',
+          },
+        ],
+      };
+      const execute_Legacy = {
+        owners: ['tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6'],
+        inheritors: [],
+        status: {
+          rECOVERING: {
+            3: 'tz1dcjLdDM6uYKYdQhK177cUbtvL8QwX4ebH',
+            4: '2024-04-19T13:53:22.000Z',
+          },
+        },
+        quick_recovery_stake: BigNumber(1000000),
+        quick_recovery_period: BigNumber(0),
+        direct_debit_mandates: '414522',
+        direct_debit_mandates_history: '414523',
+      };
+      const execte_ResetFields = {
+        owners: ['tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6'],
+        inheritors: [],
+        status: {
+          rECOVERING: {
+            0: 'tz1dcjLdDM6uYKYdQhK177cUbtvL8QwX4ebH',
+            1: '2024-04-19T13:53:22.000Z',
+          },
+        },
+        quick_recovery_stake: BigNumber(1000000),
+        quick_recovery_period: BigNumber(0),
+        direct_debit_mandates: '414522',
+        direct_debit_mandates_history: '414523',
+      };
+
+      const schema = new Schema(schemaObj);
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(schema.Execute(dataObj)).toEqual(execute_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(schema.Execute(dataObj)).toEqual(execte_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(schema.Execute(dataObj)).toEqual(execte_ResetFields);
+    });
+
+    it('a smaller reproduction', () => {
+      const schemaObj = {
+        prim: 'pair',
+        args: [
+          {
+            prim: 'set',
+            args: [
+              {
+                prim: 'address',
+              },
+            ],
+            annots: ['%owners'],
+          },
+          {
+            prim: 'set',
+            args: [
+              {
+                prim: 'address',
+              },
+            ],
+            annots: ['%inheritors'],
+          },
+          {
+            prim: 'or',
+            args: [
+              {
+                prim: 'unit',
+                annots: ['%aCTIVE'],
+              },
+              {
+                prim: 'or',
+                args: [
+                  {
+                    prim: 'pair',
+                    args: [
+                      {
+                        prim: 'address',
+                      },
+                      {
+                        prim: 'timestamp',
+                      },
+                    ],
+                    annots: ['%rECOVERING'],
+                  },
+                  {
+                    prim: 'unit',
+                    annots: ['%dEAD'],
+                  },
+                ],
+              },
+            ],
+            annots: ['%status'],
+          },
+        ],
+      };
+      const dataObj = {
+        prim: 'Pair',
+        args: [
+          [
+            {
+              string: 'tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6',
+            },
+          ],
+          [],
+          {
+            prim: 'Right',
+            args: [
+              {
+                prim: 'Left',
+                args: [
+                  {
+                    prim: 'Pair',
+                    args: [
+                      {
+                        string: 'tz1dcjLdDM6uYKYdQhK177cUbtvL8QwX4ebH',
+                      },
+                      {
+                        string: '2024-04-19T13:53:22Z',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      };
+      const execute_Legacy = {
+        owners: ['tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6'],
+        inheritors: [],
+        status: {
+          rECOVERING: {
+            3: 'tz1dcjLdDM6uYKYdQhK177cUbtvL8QwX4ebH',
+            4: '2024-04-19T13:53:22.000Z',
+          },
+        },
+      };
+      const execute_ResetFields = {
+        owners: ['tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6'],
+        inheritors: [],
+        status: {
+          rECOVERING: {
+            0: 'tz1dcjLdDM6uYKYdQhK177cUbtvL8QwX4ebH',
+            1: '2024-04-19T13:53:22.000Z',
+          },
+        },
+      };
+
+      const schema = new Schema(schemaObj);
+      Token.fieldNumberingStrategy = 'Legacy';
+      expect(schema.Execute(dataObj)).toEqual(execute_Legacy);
+      Token.fieldNumberingStrategy = 'ResetFieldNumbersInNestedObjects';
+      expect(schema.Execute(dataObj)).toEqual(execute_ResetFields);
+      Token.fieldNumberingStrategy = 'Latest';
+      expect(schema.Execute(dataObj)).toEqual(execute_ResetFields);
+    });
+  });
 });
diff --git a/packages/taquito/src/taquito.ts b/packages/taquito/src/taquito.ts
index 4710b76e26..a15025e70e 100644
--- a/packages/taquito/src/taquito.ts
+++ b/packages/taquito/src/taquito.ts
@@ -32,8 +32,9 @@ import { ParserProvider } from './parser/interface';
 import { MichelCodecParser } from './parser/michel-codec-parser';
 import { Injector } from './injector/interface';
 import { RpcInjector } from './injector/rpc-injector';
+import { FieldNumberingStrategy, Token } from '@taquito/michelson-encoder';
 
-export { MichelsonMap, UnitValue } from '@taquito/michelson-encoder';
+export { FieldNumberingStrategy, Token, MichelsonMap, UnitValue } from '@taquito/michelson-encoder';
 export { Forger, ForgeParams, ForgeResponse } from '@taquito/local-forging';
 export * from './constants';
 export * from './context';
@@ -360,6 +361,14 @@ export class TezosToolkit {
     }
   }
 
+  /**
+   * @description Sets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects
+   * @param strategy a value of type FieldNumberingStrategy that controls how field numbers are calculated
+   */
+  setFieldNumberingStrategy(strategy: FieldNumberingStrategy) {
+    Token.fieldNumberingStrategy = strategy;
+  }
+
   /**
    * @description Provide access to tezos account management
    */
diff --git a/packages/taquito/test/contract/contractAbstraction.spec.ts b/packages/taquito/test/contract/contractAbstraction.spec.ts
index 8abc67ff6c..15f470371f 100644
--- a/packages/taquito/test/contract/contractAbstraction.spec.ts
+++ b/packages/taquito/test/contract/contractAbstraction.spec.ts
@@ -382,8 +382,8 @@ describe('ContractAbstraction test', () => {
       expect(method2).toBeInstanceOf(ContractMethod);
 
       const methodObject2 = contractAbs.methodsObject[2]({
-        2: 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu',
-        3: '1',
+        0: 'tz1ZfrERcALBwmAqwonRXYVQBDT9BjNjBHJu',
+        1: '1',
       });
       expect(methodObject2).toBeInstanceOf(ContractMethodObject);
 

From b114bc2c653ca268c6daa76d3d9c39f4cc28d43a Mon Sep 17 00:00:00 2001
From: Snoppy <michaleli@foxmail.com>
Date: Thu, 9 May 2024 07:35:03 +0800
Subject: [PATCH 4/5] chore:fix typos (#2952)

---
 docs/dapp_prelaunch.md | 2 +-
 docs/signing.md        | 2 +-
 waku-helpers.sh        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/dapp_prelaunch.md b/docs/dapp_prelaunch.md
index f4c0a892f5..10c0067e5c 100644
--- a/docs/dapp_prelaunch.md
+++ b/docs/dapp_prelaunch.md
@@ -11,7 +11,7 @@ author: Claude Barde
 - Did you enable `Local Pack` in your dapp? Local Pack reduces the search time in bigmaps by 50%, and you can easily add it to your dapp by providing a new instance of the `MichelCodecPacker` class to the `setPackerProvider` method of the `TezosToolkit`.
 - Are you creating a single instance of the `BeaconWallet` that you can reuse throughout the different components of your dapp? The JavaScript frameworks generally offer a solution to easily share data between components (the Context API in React, Provide/Inject in Vue, or a Svelte store). The instance of the `BeaconWallet` must be saved there in order to use the same one in every component. Creating multiple instances of the `BeaconWallet` may create errors when forging new transactions.
 - Is your dapp making HTTP requests on update only when necessary? The JavaScript frameworks provide different solutions to rerender the DOM when internal data is updated (React `useEffect`, Vue `beforeUpdate` and Svelte `afterUpdate`). These data may be based on call responses to Tezos nodes or indexers, which is why it is crucial to optimize them. Unnecessary HTTP requests increase the traffic to Tezos nodes and indexer servers and slow down your dapp.
-- Does your application wait for a confirmation of an operation, and does it check if the operation was successfull or failed when receiving the transaction receipt? This piece of information is crucial to your users in order to know if the transaction went through or not.
+- Does your application wait for a confirmation of an operation, and does it check if the operation was successful or failed when receiving the transaction receipt? This piece of information is crucial to your users in order to know if the transaction went through or not.
 - Do you display user-friendly error messages, for example, when a transaction fails? A lack of visual feedback when transactions don't go through as expected can be confusing for users. Users must be informed about skipped, backtracked, and failed transactions.
 - Are you handling big numbers? Because numbers in Michelson are arbitrary-precision, they can become quite long, and JavaScript switches to the scientific notation to represent them, which can be confusing for users. You can use the `bignumber.js` library to handle potentially long numbers coming from the blockchain.
 - Do you have error reporting enabled on your dapp? An error reporting tool like [BugSnag](https://www.bugsnag.com/platforms/javascript) allows you to understand the issues your users face when using your dapp.
diff --git a/docs/signing.md b/docs/signing.md
index 54903020f2..022ee1021a 100644
--- a/docs/signing.md
+++ b/docs/signing.md
@@ -143,7 +143,7 @@ const isVerified = verifySignature(
 
 ## Signing Michelson data
 
-Taquito also offers the possibility to sign Michelson code. This feature can be useful, for example, if you need to send a lambda to a contract to be executed but want to restrict the number of users who can submit a lambda by verifiying the signer's address. The signing of Michelson code requires the use of the `michel-codec` package:
+Taquito also offers the possibility to sign Michelson code. This feature can be useful, for example, if you need to send a lambda to a contract to be executed but want to restrict the number of users who can submit a lambda by verifying the signer's address. The signing of Michelson code requires the use of the `michel-codec` package:
 
 ```js live noInline
 // import { TezosToolkit } from '@taquito/taquito';
diff --git a/waku-helpers.sh b/waku-helpers.sh
index 7b6cbe6f30..62661ed51c 100644
--- a/waku-helpers.sh
+++ b/waku-helpers.sh
@@ -9,7 +9,7 @@
 # * Clone and build nwaku: https://is.gd/NXeAnv
 # * Add a .env file with a variable NWAKU_DIR set to your nwaku directory
 
-_err() { # write a (loud) message to stderr, if running interacively
+_err() { # write a (loud) message to stderr, if running interactively
     [[ -o interactive ]] && tput setaf 1
     echo "$@" 1>&2
 }

From adcb48397cddbf4ef84ae4b2fb9e224c48874941 Mon Sep 17 00:00:00 2001
From: hui-an-yang <106410553+hui-an-yang@users.noreply.github.com>
Date: Fri, 10 May 2024 11:29:56 -0700
Subject: [PATCH 5/5] 2945 readme 0509 (#2955)

* docs: updated readme

* docs: addressed review comments

* docs: addressed review comments
---
 README.md | 43 ++++++++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 21 deletions(-)

diff --git a/README.md b/README.md
index 70a8bc9ada..ac60686ad9 100644
--- a/README.md
+++ b/README.md
@@ -11,10 +11,6 @@ Welcome, Web3 developer!
 
 Taquito is a fast and lightweight [TypeScript](https://www.typescriptlang.org/) library to accelerate DApp development on the [Tezos](https://tezos.com/developers) blockchain. With it, you can easily interact with Smart Contracts deployed to Tezos. It is distributed as a suite of individual `npm` packages, to reduce bloat and improve application startup times.
 
-## What about Smart Contract Development?
-
-If you are a current or aspiring "full-stack" blockchain developer, be sure to check out Taquito's sister project [Taqueria](https://taqueria.io). Taqueria is a Developer Tool Suite with *rich support* for Smart Contract development and orchestration on Tezos, and fully compliments Taquito.
-
 ## What is Included in Taquito?
 
 Taquito is primarily targeted at Front-End Web3 developers, so it comes with batteries included, such as a [React Template Project](https://github.com/ecadlabs/taquito-react-template), an extensible framework, and many helpful utilities. It can be used in *many* execution contexts, including Serverless, Node.js, Deno, and Electron (to name a few) and has minimal dependencies.
@@ -45,11 +41,9 @@ Taquito currently supports the following versions of Node.js®:
 | ---------------- | ---------- |
 | v12 LTS          |    ❌      |
 | v14 LTS          |    ❌      |
-| v16.13.1         |    ❌      |
 | v16 LTS/Gallium  |    ❌      |
-| 17.3.x           |    ❌      |
 | v18 LTS/Hydrogen |    ✅      |
-| v20              |    ✅      |
+| v20 LTS/Iron     |    ✅      |
 
 While other versions often work, the above are what we officially support. YMMV!
 
@@ -64,27 +58,34 @@ We are active and enthusiastic participants of the following community support c
 
 Taquito is organized as a [monorepo](https://en.wikipedia.org/wiki/Monorepo), and is composed of several npm packages that are [published to npmjs.org](https://www.npmjs.com/package/@taquito/taquito) under the `@taquito` handle. Each package has its own README which can be found in the corresponding directory within `packages/`.
 
-| High-Level Packages                                            | Responsibility                                               |
-| -------------------------------------------------------------- | ------------------------------------------------------------ |
+| High-Level Packages                                            | Responsibility                                                                                         |
+| -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
 | [@taquito/taquito](packages/taquito)                           | [Facade](https://en.wikipedia.org/wiki/Facade_pattern) to lower-level, package-specific functionality  |
 
-| Low-Level Packages                                               | Responsibility                                                |
-| ---------------------------------------------------------------- | ------------------------------------------------------------- |
-| [@taquito/local-forging](packages/taquito-local-forging)         | Local "forging": serialization of Tezos operations as bytes   |
-| [@taquito/michelson-encoder](packages/taquito-michelson-encoder) | Creates JS abstractions of Smart Contracts                    |
-| [@taquito/michel-codec](packages/taquito-michel-codec)           | Converts Michelson between forms, expands Macros, etc         |
-| [@taquito/remote-signer](packages/taquito-remote-signer)         | Provides the facility to use a remote signer, such as https://signatory.io    |
-| [@taquito/rpc](packages/taquito-rpc)                             | RPC client library: every rpc endpoint has its own method     |
-| [@taquito/signer](packages/taquito-signer)                       | Provides functionality to sign data using tezos keys          |
-| [@taquito/utils](packages/taquito-utils)                         | Provides different encoding and decoding utilities            |
-| [@taquito/tzip12](packages/taquito-tzip12)                       | TZIP-12 allows retrieving NFT/token metadata                  |
-| [@taquito/tzip16](packages/taquito-tzip16)                       | TZIP-16 allows retrieving contract metadata and executing off-chain views |
-| [@taquito/beacon-wallet](packages/taquito-beacon-wallet)         | TZIP-10 implementation of a Wallet API                        |
+| Low-Level Packages                                               | Responsibility                                                                                       |
+| ---------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| [@taquito/local-forging](packages/taquito-local-forging)         | Local "forging": serialization of Tezos operations as bytes                                          |
+| [@taquito/michelson-encoder](packages/taquito-michelson-encoder) | Creates JS abstractions of Smart Contracts                                                           |
+| [@taquito/michel-codec](packages/taquito-michel-codec)           | Converts Michelson between forms, expands Macros, etc                                                |
+| [@taquito/remote-signer](packages/taquito-remote-signer)         | Provides the facility to use a remote signer, such as https://signatory.io                           |
+| [@taquito/rpc](packages/taquito-rpc)                             | RPC client library: every rpc endpoint has its own method                                            |
+| [@taquito/signer](packages/taquito-signer)                       | Provides functionality to sign data using tezos keys                                                 |
+| [@taquito/utils](packages/taquito-utils)                         | Provides different encoding and decoding utilities                                                   |
+| [@taquito/tzip12](packages/taquito-tzip12)                       | TZIP-12 allows retrieving NFT/token metadata                                                         |
+| [@taquito/tzip16](packages/taquito-tzip16)                       | TZIP-16 allows retrieving contract metadata and executing off-chain views                            |
+| [@taquito/beacon-wallet](packages/taquito-beacon-wallet)         | TZIP-10 implementation of a Wallet API                                                               |
+| [@taquito/http-utils](packages/taquito-http-utils)               | Provides functionality to configure and customize http requests                                      |
+| [@taquito/core](packages/taquito-core)                           | Provides parent and core types, classes, and interfaces for other Taquito packages or external uses  |
+| [@taquito/sapling](packages/taquito-sapling)                     | Provides functionality to prepare and read sapling transactions                                      |
+| [@taquito/contracts-library](packages/taquito-contracts-library) | Provides functionality specify static data related to contracts                                      |
+| [@taquito/ledger-signer](packages/taquito-ledger-signer)         | Provides functionality for ledger signer provider                                                    |
+| [@taquito/timelock](packages/taquito-timelock)                   | Provides functionality to create and open timelocks                                                  |
 
 ## API Documentation
 
 TypeDoc API documentation for Taquito [is available here](https://taquito.io/typedoc).
 
+
 ## Versioning Strategy
 
 Supported versions of Taquito packages are maintained for the *current* and *next* (beta) protocol versions.