2073 support type ticket deprecated in michelson encoder

apps/taquito-test-dapp/README.md

@@ -10,4 +10,7 @@ A minimal end-to-end testing setup for developing Tezos DApps with Taquito and B
     `npm install`
 4. Start development server:
     `npm run dev`
-5. Open http://localhost:3030 in your browser to see a sample application.
+5. Open http://localhost:3030 in your browser to see a sample application.
+6. Start production server:
+    `npm run build && npm run preview`
+7. Open http://localhost:4173 in your browser to see a preview application.

apps/taquito-test-dapp/package.json

@@ -21,7 +21,7 @@
     "svelte-preprocess": "^4.9.8",
     "tslib": "^2.3.1",
     "typescript": "^4.5.4",
-    "vite": "^2.9.7",
+    "vite": "^3.2.0",
     "vite-compatible-readable-stream": "^3.6.1"
   },
   "dependencies": {

integration-tests/contract-michelson-origination.spec.ts

@@ -1,9 +1,61 @@
-import { IntegerError } from "@taquito/taquito";
+import { IntegerError, MichelCodecParser, NoopParser, Context, InvalidCodeParameter } from '@taquito/taquito';
 import { CONFIGS } from "./config";
 import { idMichelsonCode, idInitData } from "./data/id-contract"
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
+
+  describe(`Test contract origination to configure parserProvider to parse plain Michelson`, () => {
+
+    beforeEach(async (done) => {
+      await setup()
+      done()
+    })
+    it('uses noopParser to originate Michelson code and fails', async (done) => {
+      // Configure the Tezostoolkit to use the NoopParser (the Michelson won't be parsed)
+      Tezos.setParserProvider(new NoopParser());
+
+      try {
+        const op = await Tezos.contract.originate({
+          balance: "0",
+          code: idMichelsonCode,
+          init: idInitData
+        });
+        await op.confirmation()
+      } catch (error: any) {
+        expect(error).toBeInstanceOf(InvalidCodeParameter);
+        expect(error.message).toEqual('Wrong code parameter type, expected an array');
+      }
+      done();
+    });
+
+    it('uses MichelCodecParser to originate Michelson code and succeeds', async (done) => {
+      // Configure the Tezostoolkit to use the MichelCodecParser (the Michelson will be parsed to JSONMichelson)
+      Tezos.setParserProvider(new MichelCodecParser(new Context(rpc)));
+
+      const op = await Tezos.contract.originate({
+        balance: "0",
+        code: idMichelsonCode,
+        init: idInitData
+      });
+      await op.confirmation()
+      expect(op.status).toEqual('applied')
+      done();
+    });
+
+    it('no parser configured will use MichelCodecParser by default to originate Michelson code and succeeds', async (done) => {
+      // No parserProvider configured will use MichelCodecParser by default (the Michelson will be parsed to JSONMichelson)
+      const op = await Tezos.contract.originate({
+        balance: "0",
+        code: idMichelsonCode,
+        init: idInitData
+      });
+      await op.confirmation()
+      expect(op.status).toEqual('applied')
+      done();
+    });
+  });
+
   describe(`Test contract origination in a plain Michelson through contract api using: ${rpc}`, () => {
 
     beforeEach(async (done) => {

integration-tests/wallet-michelson-origination.spec.ts

@@ -1,5 +1,7 @@
 import { CONFIGS } from "./config";
-import { idMichelsonCode, idInitData } from "./data/id-contract"
+import { idMichelsonCode, idInitData } from "./data/id-contract";
+import { MichelCodecParser, NoopParser, Context, InvalidCodeParameter } from '@taquito/taquito';
+
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
@@ -21,4 +23,59 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
       done();
     });
   });
+
+  describe(`Test contract origination to configure parserProvider to parse plain Michelson`, () => {
+
+    beforeEach(async (done) => {
+      await setup()
+      done()
+    })
+    it('uses noopParser to originate Michelson code and fails', async (done) => {
+      // Configure the Tezostoolkit to use the NoopParser (the Michelson won't be parsed)
+      Tezos.setParserProvider(new NoopParser());
+
+      try {
+        const op = await Tezos.wallet.originate({
+          balance: "0",
+          code: idMichelsonCode,
+          init: idInitData
+        }).send();
+        await op.confirmation()
+      } catch (error: any) {
+        expect(error).toBeInstanceOf(InvalidCodeParameter);
+        expect(error.message).toEqual('Wrong code parameter type, expected an array');
+      }
+      done();
+    });
+
+    it('uses MichelCodecParser to originate Michelson code and succeeds', async (done) => {
+      // Configure the Tezostoolkit to use the MichelCodecParser (the Michelson will be parsed to JSONMichelson)
+      Tezos.setParserProvider(new MichelCodecParser(new Context(rpc)));
+
+      const op = await Tezos.wallet.originate({
+        balance: "0",
+        code: idMichelsonCode,
+        init: idInitData
+      }).send();
+      await op.confirmation()
+      expect(op.opHash).toBeDefined();
+      expect(op.status).toBeDefined();
+      done();
+    });
+
+    it('no parser configured will use MichelCodecParser by default to originate Michelson code and succeeds', async (done) => {
+      // No parserProvider configured will use MichelCodecParser by default (the Michelson will be parsed to JSONMichelson)
+      const op = await Tezos.wallet.originate({
+        balance: "0",
+        code: idMichelsonCode,
+        init: idInitData
+      }).send();
+      await op.confirmation()
+      expect(op.opHash).toBeDefined();
+      expect(op.status).toBeDefined();
+      done();
+    });
+  });
+
+
 })

packages/taquito-michelson-encoder/src/schema/types.ts

@@ -67,6 +67,14 @@ export type TicketTokenSchema = {
     amount: { __michelsonType: 'int'; schema: 'int' };
   };
 };
+export type TicketDeprecatedTokenSchema = {
+  __michelsonType: 'ticket_deprecated';
+  schema: {
+    value: TokenSchema;
+    ticketer: { __michelsonType: 'contract'; schema: 'contract' };
+    amount: { __michelsonType: 'int'; schema: 'int' };
+  };
+};
 
 export type TokenSchema =
   | BaseTokenSchema
@@ -83,4 +91,5 @@ export type TokenSchema =
   | SaplingStateTokenSchema
   | SaplingTransactionTokenSchema
   | SaplingTransactionDeprecatedTokenSchema
-  | TicketTokenSchema;
+  | TicketTokenSchema
+  | TicketDeprecatedTokenSchema;

packages/taquito-michelson-encoder/src/tokens/ticket-deprecated.ts

@@ -0,0 +1,106 @@
+import { TicketDeprecatedTokenSchema } from '../schema/types';
+import { IntToken } from './comparable/int';
+import { ContractToken } from './contract';
+import { Token, TokenFactory, Semantic, SemanticEncoding } from './token';
+
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when encoding and sending a ticket to the blockchain
+ */
+export class EncodeTicketError extends Error {
+  name = 'TicketEncodeError';
+
+  constructor() {
+    super('Tickets cannot be sent to the blockchain; they are created on-chain');
+  }
+}
+
+const ticketerType = { prim: 'contract' };
+const amountType = { prim: 'int' };
+
+export class TicketDeprecatedToken extends Token {
+  static prim: 'ticket_deprecated' = 'ticket_deprecated' as const;
+
+  constructor(
+    protected val: { prim: string; args: any[]; annots: any[] },
+    protected idx: number,
+    protected fac: TokenFactory
+  ) {
+    super(val, idx, fac);
+  }
+
+  get valueToken() {
+    return this.createToken(this.val.args[0], this.idx);
+  }
+
+  public Encode(_args: any[]): any {
+    throw new EncodeTicketError();
+  }
+
+  public EncodeObject(args: any, semantic?: SemanticEncoding): any {
+    if (semantic && semantic[TicketDeprecatedToken.prim]) {
+      return semantic[TicketDeprecatedToken.prim](args, this.val);
+    }
+    throw new EncodeTicketError();
+  }
+
+  public Execute(val: any, semantics?: Semantic) {
+    if (semantics && semantics[TicketDeprecatedToken.prim]) {
+      return semantics[TicketDeprecatedToken.prim](val, this.val);
+    }
+    const ticketer = this.createToken(ticketerType, this.idx);
+    const value = this.valueToken;
+    const amount = this.createToken(amountType, this.idx);
+
+    if (undefined === val.args[2] && undefined !== val.args[1].args) {
+      return {
+        ticketer: ticketer.Execute(val.args[0], semantics),
+        value: value.Execute(val.args[1].args[0], semantics),
+        amount: amount.Execute(val.args[1].args[1], semantics),
+      };
+    }
+
+    return {
+      ticketer: ticketer.Execute(val.args[0], semantics),
+      value: value.Execute(val.args[1], semantics),
+      amount: amount.Execute(val.args[2], semantics),
+    };
+  }
+
+  /**
+   * @deprecated ExtractSchema has been deprecated in favor of generateSchema
+   *
+   */
+  public ExtractSchema() {
+    return {
+      ticketer: ContractToken.prim,
+      value: this.valueToken.ExtractSchema(),
+      amount: IntToken.prim,
+    };
+  }
+
+  generateSchema(): TicketDeprecatedTokenSchema {
+    return {
+      __michelsonType: TicketDeprecatedToken.prim,
+      schema: {
+        value: this.valueToken.generateSchema(),
+        ticketer: {
+          __michelsonType: ContractToken.prim,
+          schema: ContractToken.prim,
+        },
+        amount: {
+          __michelsonType: IntToken.prim,
+          schema: IntToken.prim,
+        },
+      },
+    };
+  }
+
+  findAndReturnTokens(tokenToFind: string, tokens: Token[]) {
+    if (TicketDeprecatedToken.prim === tokenToFind) {
+      tokens.push(this);
+    }
+    this.valueToken.findAndReturnTokens(tokenToFind, tokens);
+    return tokens;
+  }
+}

packages/taquito-michelson-encoder/src/tokens/tokens.ts

@@ -33,6 +33,7 @@ import { OperationToken } from './operation';
 import { SetToken } from './set';
 import { ChainIDToken } from './chain-id';
 import { TicketToken } from './ticket';
+import { TicketDeprecatedToken } from './ticket-deprecated';
 import { NeverToken } from './never';
 import { SaplingStateToken } from './sapling-state';
 import { SaplingTransactionToken } from './sapling-transaction';
@@ -70,6 +71,7 @@ export const tokens = [
   SetToken,
   ChainIDToken,
   TicketToken,
+  TicketDeprecatedToken,
   NeverToken,
   SaplingStateToken,
   SaplingTransactionToken,

packages/taquito/src/taquito.ts

@@ -27,6 +27,8 @@ import { LegacyWalletProvider, Wallet, WalletProvider } from './wallet';
 import { OperationFactory } from './wallet/operation-factory';
 import { TaquitoLocalForger } from './forger/taquito-local-forger';
 import { EstimationProvider } from './estimate/estimate-provider-interface';
+import { ParserProvider } from './parser/interface';
+import { MichelCodecParser } from './parser/michel-codec-parser';
 
 export { MichelsonMap, UnitValue } from '@taquito/michelson-encoder';
 export { Forger, ForgeParams, ForgeResponse } from '@taquito/local-forging';
@@ -77,6 +79,7 @@ export interface SetProviderOptions {
   config?: Partial<ConfigConfirmation>;
   packer?: Packer;
   globalConstantsProvider?: GlobalConstantsProvider;
+  parserProvider?: ParserProvider;
 }
 
 export interface VersionInfo {
@@ -135,6 +138,7 @@ export class TezosToolkit {
     packer,
     globalConstantsProvider,
     readProvider,
+    parserProvider,
   }: SetProviderOptions) {
     this.setRpcProvider(rpc);
     this.setStreamProvider(stream);
@@ -144,6 +148,7 @@ export class TezosToolkit {
     this.setPackerProvider(packer);
     this.setGlobalConstantsProvider(globalConstantsProvider);
     this.setReadProvider(readProvider);
+    this.setParserProvider(parserProvider);
 
     this._context.proto = protocol;
     if (config) {
@@ -312,6 +317,27 @@ export class TezosToolkit {
     this._context.readProvider = readP;
   }
 
+  /**
+   * @description Sets parser provider on the Tezos Taquito instance
+   *
+   * @param options parserProvider to use to interact with the Tezos network
+   *
+   * @example
+   * ```
+   * Tezos.setParserProvider(new MichelCodecParser(...))
+   * ```
+   */
+  setParserProvider(parserProvider?: SetProviderOptions['parserProvider']) {
+    if (!this._options.parserProvider && typeof parserProvider === 'undefined') {
+      const p = new MichelCodecParser(this._context);
+      this._context.parser = p;
+      this._options.parserProvider = p;
+    } else if (typeof parserProvider !== 'undefined') {
+      this._context.parser = parserProvider;
+      this._options.parserProvider = parserProvider;
+    }
+  }
+
   /**
    * @description Provide access to tezos account management
    */