@taquito/michel-codec 18.0.0-RC.0 → 19.0.0-beta-RC.0

package/dist/types/micheline-parser.d.ts

@@ -1,130 +1,130 @@
-import { Token } from './scan';
-import { Expr } from './micheline';
-import { ProtocolOptions } from './michelson-types';
-import { TaquitoError } from '@taquito/core';
-/**
- *  @category Error
- *  @description Error that indicates a failure when parsing Micheline expressions
- */
-export declare class MichelineParseError extends TaquitoError {
-    readonly token: Token | null;
-    readonly message: string;
-    /**
-     * @param token A token caused the error
-     * @param message An error message
-     */
-    constructor(token: Token | null, message: string);
-}
-/**
- *  @category Error
- *  @description Error inidicates a failure when parsing Micheline JSON
- */
-export declare class JSONParseError extends TaquitoError {
-    readonly node: unknown;
-    readonly message: string;
-    /**
-     * @param node A node caused the error
-     * @param message An error message
-     */
-    constructor(node: unknown, message: string);
-}
-export interface GlobalConstantHashAndValue {
-    [globalConstantHash: string]: Expr;
-}
-export interface ParserOptions extends ProtocolOptions {
-    /**
-     * Expand [Michelson macros](https://tezos.gitlab.io/whitedoc/michelson.html#macros) during parsing.
-     */
-    expandMacros?: boolean;
-    /**
-     * Expand global constants during parsing.
-     * `expandGlobalConstant` expects an object where the keys are global constant hashes and the values are the corresponding JSON Micheline expressions.
-     * @example
-     * ```
-     * const parserOptions: ParserOptions = {
-     *  expandGlobalConstant: {
-     *      'expr...': { prim: 'DROP', args: [{ int: '2' }] }
-     *  }
-     * }
-     *
-     * const p = new Parser(parserOptions);
-     * ```
-     */
-    expandGlobalConstant?: GlobalConstantHashAndValue;
-}
-/**
- * Converts and validates Michelson expressions between JSON-based Michelson and Micheline
- *
- * Pretty Print a Michelson Smart Contract:
- * ```
- * const contract = await Tezos.contract.at("KT1Vsw3kh9638gqWoHTjvHCoHLPKvCbMVbCg");
- * const p = new Parser();
- *
- * const michelsonCode = p.parseJSON(contract.script.code);
- * const storage = p.parseJSON(contract.script.storage);
- *
- * console.log("Pretty print Michelson smart contract:");
- * console.log(emitMicheline(michelsonCode, {indent:"    ", newline: "\n",}));
- *
- * console.log("Pretty print Storage:");
- * console.log(emitMicheline(storage, {indent:"    ", newline: "\n",}));
- * ```
- *
- * Encode a Michelson expression for inital storage of a smart contract
- * ```
- * const src = `(Pair (Pair { Elt 1
- *                (Pair (Pair "tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx")
- *                      0x0501000000026869) }
- *          10000000)
- *    (Pair 2 333))`;
- *
- * const p = new Parser();
- *
- * const exp = p.parseMichelineExpression(src);
- * console.log(JSON.stringify(exp));
- * ```
- */
-export declare class Parser {
-    private opt?;
-    constructor(opt?: ParserOptions | undefined);
-    private expand;
-    private parseListExpr;
-    private parseArgs;
-    private parseSequenceExpr;
-    private parseExpr;
-    /**
-     * Parses a Micheline sequence expression, such as smart contract source. Enclosing curly brackets may be omitted.
-     * @param src A Micheline sequence `{parameter ...; storage int; code { DUP ; ...};}` or `parameter ...; storage int; code { DUP ; ...};`
-     */
-    parseSequence(src: string): Expr[] | null;
-    /**
-     * Parse a Micheline sequence expression. Enclosing curly brackets may be omitted.
-     * @param src A Michelson list expression such as `(Pair {Elt "0" 0} 0)` or `Pair {Elt "0" 0} 0`
-     * @returns An AST node or null for empty document.
-     */
-    parseList(src: string): Expr | null;
-    /**
-     * Parse any Michelson expression
-     * @param src A Michelson expression such as `(Pair {Elt "0" 0} 0)` or `{parameter ...; storage int; code { DUP ; ...};}`
-     * @returns An AST node or null for empty document.
-     */
-    parseMichelineExpression(src: string): Expr | null;
-    /**
-     * Parse a Micheline sequence expression, such as smart contract source. Enclosing curly brackets may be omitted.
-     * An alias for `parseSequence`
-     * @param src A Micheline sequence `{parameter ...; storage int; code { DUP ; ...};}` or `parameter ...; storage int; code { DUP ; ...};`
-     */
-    parseScript(src: string): Expr[] | null;
-    /**
-     * Parse a Micheline sequence expression. Enclosing curly brackets may be omitted.
-     * An alias for `parseList`
-     * @param src A Michelson list expression such as `(Pair {Elt "0" 0} 0)` or `Pair {Elt "0" 0} 0`
-     * @returns An AST node or null for empty document.
-     */
-    parseData(src: string): Expr | null;
-    /**
-     * Takes a JSON-encoded Michelson, validates it, strips away unneeded properties and optionally expands macros (See {@link ParserOptions}).
-     * @param src An object containing JSON-encoded Michelson, usually returned by `JSON.parse()`
-     */
-    parseJSON(src: object): Expr;
-}
+import { Token } from './scan';
+import { Expr } from './micheline';
+import { ProtocolOptions } from './michelson-types';
+import { TaquitoError } from '@taquito/core';
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when parsing Micheline expressions
+ */
+export declare class MichelineParseError extends TaquitoError {
+    readonly token: Token | null;
+    readonly message: string;
+    /**
+     * @param token A token caused the error
+     * @param message An error message
+     */
+    constructor(token: Token | null, message: string);
+}
+/**
+ *  @category Error
+ *  @description Error indicates a failure when parsing Micheline JSON
+ */
+export declare class JSONParseError extends TaquitoError {
+    readonly node: unknown;
+    readonly message: string;
+    /**
+     * @param node A node caused the error
+     * @param message An error message
+     */
+    constructor(node: unknown, message: string);
+}
+export interface GlobalConstantHashAndValue {
+    [globalConstantHash: string]: Expr;
+}
+export interface ParserOptions extends ProtocolOptions {
+    /**
+     * Expand [Michelson macros](https://tezos.gitlab.io/whitedoc/michelson.html#macros) during parsing.
+     */
+    expandMacros?: boolean;
+    /**
+     * Expand global constants during parsing.
+     * `expandGlobalConstant` expects an object where the keys are global constant hashes and the values are the corresponding JSON Micheline expressions.
+     * @example
+     * ```
+     * const parserOptions: ParserOptions = {
+     *  expandGlobalConstant: {
+     *      'expr...': { prim: 'DROP', args: [{ int: '2' }] }
+     *  }
+     * }
+     *
+     * const p = new Parser(parserOptions);
+     * ```
+     */
+    expandGlobalConstant?: GlobalConstantHashAndValue;
+}
+/**
+ * Converts and validates Michelson expressions between JSON-based Michelson and Micheline
+ *
+ * Pretty Print a Michelson Smart Contract:
+ * ```
+ * const contract = await Tezos.contract.at("KT1Vsw3kh9638gqWoHTjvHCoHLPKvCbMVbCg");
+ * const p = new Parser();
+ *
+ * const michelsonCode = p.parseJSON(contract.script.code);
+ * const storage = p.parseJSON(contract.script.storage);
+ *
+ * console.log("Pretty print Michelson smart contract:");
+ * console.log(emitMicheline(michelsonCode, {indent:"    ", newline: "\n",}));
+ *
+ * console.log("Pretty print Storage:");
+ * console.log(emitMicheline(storage, {indent:"    ", newline: "\n",}));
+ * ```
+ *
+ * Encode a Michelson expression for initial storage of a smart contract
+ * ```
+ * const src = `(Pair (Pair { Elt 1
+ *                (Pair (Pair "tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx")
+ *                      0x0501000000026869) }
+ *          10000000)
+ *    (Pair 2 333))`;
+ *
+ * const p = new Parser();
+ *
+ * const exp = p.parseMichelineExpression(src);
+ * console.log(JSON.stringify(exp));
+ * ```
+ */
+export declare class Parser {
+    private opt?;
+    constructor(opt?: ParserOptions | undefined);
+    private expand;
+    private parseListExpr;
+    private parseArgs;
+    private parseSequenceExpr;
+    private parseExpr;
+    /**
+     * Parses a Micheline sequence expression, such as smart contract source. Enclosing curly brackets may be omitted.
+     * @param src A Micheline sequence `{parameter ...; storage int; code { DUP ; ...};}` or `parameter ...; storage int; code { DUP ; ...};`
+     */
+    parseSequence(src: string): Expr[] | null;
+    /**
+     * Parse a Micheline sequence expression. Enclosing curly brackets may be omitted.
+     * @param src A Michelson list expression such as `(Pair {Elt "0" 0} 0)` or `Pair {Elt "0" 0} 0`
+     * @returns An AST node or null for empty document.
+     */
+    parseList(src: string): Expr | null;
+    /**
+     * Parse any Michelson expression
+     * @param src A Michelson expression such as `(Pair {Elt "0" 0} 0)` or `{parameter ...; storage int; code { DUP ; ...};}`
+     * @returns An AST node or null for empty document.
+     */
+    parseMichelineExpression(src: string): Expr | null;
+    /**
+     * Parse a Micheline sequence expression, such as smart contract source. Enclosing curly brackets may be omitted.
+     * An alias for `parseSequence`
+     * @param src A Micheline sequence `{parameter ...; storage int; code { DUP ; ...};}` or `parameter ...; storage int; code { DUP ; ...};`
+     */
+    parseScript(src: string): Expr[] | null;
+    /**
+     * Parse a Micheline sequence expression. Enclosing curly brackets may be omitted.
+     * An alias for `parseList`
+     * @param src A Michelson list expression such as `(Pair {Elt "0" 0} 0)` or `Pair {Elt "0" 0} 0`
+     * @returns An AST node or null for empty document.
+     */
+    parseData(src: string): Expr | null;
+    /**
+     * Takes a JSON-encoded Michelson, validates it, strips away unneeded properties and optionally expands macros (See {@link ParserOptions}).
+     * @param src An object containing JSON-encoded Michelson, usually returned by `JSON.parse()`
+     */
+    parseJSON(src: object): Expr;
+}

package/dist/types/micheline.d.ts

@@ -1,44 +1,44 @@
-export declare type SourceReference = {
-    first: number;
-    last: number;
-    macro?: Expr;
-    globalConstant?: Expr;
-};
-export declare const sourceReference: unique symbol;
-export interface Node {
-    [sourceReference]?: SourceReference;
-}
-/**
- * An AST node representing Michelson string literal.
- */
-export interface StringLiteral extends Node {
-    string: string;
-}
-/**
- * An AST node representing Michelson int literal.
- */
-export interface IntLiteral<T extends string = string> extends Node {
-    int: T;
-}
-/**
- * An AST node representing Michelson bytes literal.
- */
-export interface BytesLiteral extends Node {
-    bytes: string;
-}
-/**
- * An AST node representing Michelson primitive.
- */
-export interface Prim<PT extends string = string, AT extends Expr[] = Expr[]> extends Node {
-    prim: PT;
-    args?: AT;
-    annots?: string[];
-}
-export declare type List<T extends Expr> = T[] & Node;
-interface ExprList extends List<Expr> {
-}
-/**
- * An AST node representing valid Michelson expression. Directly corresponds to JSON-encoded Michelson node
- */
-export declare type Expr = Prim | StringLiteral | IntLiteral | BytesLiteral | ExprList;
-export {};
+export type SourceReference = {
+    first: number;
+    last: number;
+    macro?: Expr;
+    globalConstant?: Expr;
+};
+export declare const sourceReference: unique symbol;
+export interface Node {
+    [sourceReference]?: SourceReference;
+}
+/**
+ * An AST node representing Michelson string literal.
+ */
+export interface StringLiteral extends Node {
+    string: string;
+}
+/**
+ * An AST node representing Michelson int literal.
+ */
+export interface IntLiteral<T extends string = string> extends Node {
+    int: T;
+}
+/**
+ * An AST node representing Michelson bytes literal.
+ */
+export interface BytesLiteral extends Node {
+    bytes: string;
+}
+/**
+ * An AST node representing Michelson primitive.
+ */
+export interface Prim<PT extends string = string, AT extends Expr[] = Expr[]> extends Node {
+    prim: PT;
+    args?: AT;
+    annots?: string[];
+}
+export type List<T extends Expr> = T[] & Node;
+interface ExprList extends List<Expr> {
+}
+/**
+ * An AST node representing valid Michelson expression. Directly corresponds to JSON-encoded Michelson node
+ */
+export type Expr = Prim | StringLiteral | IntLiteral | BytesLiteral | ExprList;
+export {};

package/dist/types/michelson-contract.d.ts

@@ -1,24 +1,24 @@
-import { MichelsonContract, MichelsonContractSection, MichelsonType, MichelsonData, MichelsonCode, MichelsonReturnType } from './michelson-types';
-import { InstructionTrace } from './michelson-typecheck';
-import { ParserOptions } from './micheline-parser';
-export interface ContractOptions extends ParserOptions {
-    traceCallback?: (t: InstructionTrace) => void;
-}
-export declare class Contract {
-    readonly contract: MichelsonContract;
-    private ctx;
-    readonly output: MichelsonReturnType;
-    constructor(contract: MichelsonContract, opt?: ContractOptions);
-    static parse(src: string | object, opt?: ContractOptions): Contract;
-    static parseTypeExpression(src: string | object, opt?: ParserOptions): MichelsonType;
-    static parseDataExpression(src: string | object, opt?: ParserOptions): MichelsonData;
-    section<T extends 'parameter' | 'storage' | 'code'>(section: T): MichelsonContractSection<T>;
-    entryPoints(): [string, MichelsonType][];
-    entryPoint(ep?: string): MichelsonType | null;
-    assertDataValid(d: MichelsonData, t: MichelsonType): void;
-    isDataValid(d: MichelsonData, t: MichelsonType): boolean;
-    assertParameterValid(ep: string | null, d: MichelsonData): void;
-    isParameterValid(ep: string | null, d: MichelsonData): boolean;
-    functionType(inst: MichelsonCode, stack: MichelsonType[]): MichelsonReturnType;
-}
-export declare const dummyContract: Contract;
+import { MichelsonContract, MichelsonContractSection, MichelsonType, MichelsonData, MichelsonCode, MichelsonReturnType } from './michelson-types';
+import { InstructionTrace } from './michelson-typecheck';
+import { ParserOptions } from './micheline-parser';
+export interface ContractOptions extends ParserOptions {
+    traceCallback?: (t: InstructionTrace) => void;
+}
+export declare class Contract {
+    readonly contract: MichelsonContract;
+    private ctx;
+    readonly output: MichelsonReturnType;
+    constructor(contract: MichelsonContract, opt?: ContractOptions);
+    static parse(src: string | object, opt?: ContractOptions): Contract;
+    static parseTypeExpression(src: string | object, opt?: ParserOptions): MichelsonType;
+    static parseDataExpression(src: string | object, opt?: ParserOptions): MichelsonData;
+    section<T extends 'parameter' | 'storage' | 'code'>(section: T): MichelsonContractSection<T>;
+    entryPoints(): [string, MichelsonType][];
+    entryPoint(ep?: string): MichelsonType | null;
+    assertDataValid(d: MichelsonData, t: MichelsonType): void;
+    isDataValid(d: MichelsonData, t: MichelsonType): boolean;
+    assertParameterValid(ep: string | null, d: MichelsonData): void;
+    isParameterValid(ep: string | null, d: MichelsonData): boolean;
+    functionType(inst: MichelsonCode, stack: MichelsonType[]): MichelsonReturnType;
+}
+export declare const dummyContract: Contract;

package/dist/types/michelson-typecheck.d.ts

@@ -1,38 +1,38 @@
-import { MichelsonType, MichelsonData, MichelsonCode, MichelsonContract, MichelsonContractSection, MichelsonReturnType, MichelsonContractView } from './michelson-types';
-import { MichelsonError } from './utils';
-import { ParserOptions } from './micheline-parser';
-export interface Context extends ParserOptions {
-    contract?: MichelsonContract;
-    traceCallback?: (t: InstructionTrace) => void;
-}
-export declare class MichelsonInstructionError extends MichelsonError<MichelsonCode> {
-    readonly val: MichelsonCode;
-    readonly stackState: MichelsonReturnType;
-    readonly message: string;
-    /**
-     * @param val Value of a type node caused the error
-     * @param stackState Current stack state
-     * @param message An error message
-     */
-    constructor(val: MichelsonCode, stackState: MichelsonReturnType, message: string);
-}
-export declare function assertTypeAnnotationsValid(t: MichelsonType, field?: boolean): void;
-export interface InstructionTrace {
-    op: MichelsonCode;
-    in: MichelsonType[];
-    out: MichelsonReturnType;
-}
-export declare function contractSection<T extends 'parameter' | 'storage' | 'code'>(contract: MichelsonContract, section: T): MichelsonContractSection<T>;
-export declare function contractViews(contract: MichelsonContract): {
-    [name: string]: MichelsonContractView;
-};
-export declare function contractEntryPoint(src: MichelsonContract | MichelsonType, ep?: string): MichelsonType | null;
-export declare function contractEntryPoints(src: MichelsonContract | MichelsonType): [string, MichelsonType][];
-export declare function assertContractValid(contract: MichelsonContract, ctx?: Context): MichelsonReturnType;
-export declare function assertDataValid(d: MichelsonData, t: MichelsonType, ctx?: Context): void;
-export declare function functionType(inst: MichelsonCode, stack: MichelsonType[], ctx?: Context): MichelsonReturnType;
-export declare function assertTypesEqual<T1 extends MichelsonType | MichelsonType[], T2 extends T1>(a: T1, b: T2, field?: boolean): void;
-export declare function isTypeAnnotationsValid(t: MichelsonType, field?: boolean): boolean;
-export declare function isContractValid(contract: MichelsonContract, ctx?: Context): MichelsonReturnType | null;
-export declare function isDataValid(d: MichelsonData, t: MichelsonType, ctx?: Context): boolean;
-export declare function isTypeEqual<T1 extends MichelsonType | MichelsonType[], T2 extends T1>(a: T1, b: T2, field?: boolean): boolean;
+import { MichelsonType, MichelsonData, MichelsonCode, MichelsonContract, MichelsonContractSection, MichelsonReturnType, MichelsonContractView } from './michelson-types';
+import { MichelsonError } from './utils';
+import { ParserOptions } from './micheline-parser';
+export interface Context extends ParserOptions {
+    contract?: MichelsonContract;
+    traceCallback?: (t: InstructionTrace) => void;
+}
+export declare class MichelsonInstructionError extends MichelsonError<MichelsonCode> {
+    readonly val: MichelsonCode;
+    readonly stackState: MichelsonReturnType;
+    readonly message: string;
+    /**
+     * @param val Value of a type node caused the error
+     * @param stackState Current stack state
+     * @param message An error message
+     */
+    constructor(val: MichelsonCode, stackState: MichelsonReturnType, message: string);
+}
+export declare function assertTypeAnnotationsValid(t: MichelsonType, field?: boolean): void;
+export interface InstructionTrace {
+    op: MichelsonCode;
+    in: MichelsonType[];
+    out: MichelsonReturnType;
+}
+export declare function contractSection<T extends 'parameter' | 'storage' | 'code'>(contract: MichelsonContract, section: T): MichelsonContractSection<T>;
+export declare function contractViews(contract: MichelsonContract): {
+    [name: string]: MichelsonContractView;
+};
+export declare function contractEntryPoint(src: MichelsonContract | MichelsonType, ep?: string): MichelsonType | null;
+export declare function contractEntryPoints(src: MichelsonContract | MichelsonType): [string, MichelsonType][];
+export declare function assertContractValid(contract: MichelsonContract, ctx?: Context): MichelsonReturnType;
+export declare function assertDataValid(d: MichelsonData, t: MichelsonType, ctx?: Context): void;
+export declare function functionType(inst: MichelsonCode, stack: MichelsonType[], ctx?: Context): MichelsonReturnType;
+export declare function assertTypesEqual<T1 extends MichelsonType | MichelsonType[], T2 extends T1>(a: T1, b: T2, field?: boolean): void;
+export declare function isTypeAnnotationsValid(t: MichelsonType, field?: boolean): boolean;
+export declare function isContractValid(contract: MichelsonContract, ctx?: Context): MichelsonReturnType | null;
+export declare function isDataValid(d: MichelsonData, t: MichelsonType, ctx?: Context): boolean;
+export declare function isTypeEqual<T1 extends MichelsonType | MichelsonType[], T2 extends T1>(a: T1, b: T2, field?: boolean): boolean;