@tezos-x/octez.js-michel-codec 0.9.0

package/dist/octez.js-michel-codec.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"octez.js-michel-codec.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/base58.d.ts

@@ -0,0 +1,13 @@
+import { TaquitoError } from '@tezos-x/octez.js-core';
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when decoding a base58 encoding
+ */
+export declare class Base58DecodingError extends TaquitoError {
+    readonly message: string;
+    constructor(message: string);
+}
+export declare function decodeBase58(src: string): number[];
+export declare function encodeBase58(src: number[] | Uint8Array): string;
+export declare function decodeBase58Check(src: string): number[];
+export declare function encodeBase58Check(src: number[] | Uint8Array): string;

package/dist/types/binary.d.ts

@@ -0,0 +1,127 @@
+import { BytesLiteral } from './micheline';
+import { MichelsonData, MichelsonType } from './michelson-types';
+type AddressType = 'ED25519PublicKeyHash' | 'SECP256K1PublicKeyHash' | 'P256PublicKeyHash' | 'ContractHash';
+export interface Address {
+    type: AddressType;
+    hash: number[] | Uint8Array;
+    entryPoint?: string;
+}
+export type PublicKeyType = 'ED25519PublicKey' | 'SECP256K1PublicKey' | 'P256PublicKey';
+export interface PublicKey {
+    type: PublicKeyType;
+    publicKey: number[] | Uint8Array;
+}
+/**
+ * Serializes any value of packable type to its optimized binary representation
+ * identical to the one used by PACK and UNPACK Michelson instructions.
+ * Without a type definition (not recommended) the data will be encoded as a binary form of a generic Michelson expression.
+ * Type definition allows some types like `timestamp` and `address` and other base58 representable types to be encoded to
+ * corresponding optimized binary forms borrowed from the Tezos protocol
+ *
+ * ```typescript
+ * const data: MichelsonData = {
+ *     string: "KT1RvkwF4F7pz1gCoxkyZrG1RkrxQy3gmFTv%foo"
+ * };
+ *
+ * const typ: MichelsonType = {
+ *     prim: "address"
+ * };
+ *
+ * const packed = packData(data, typ);
+ *
+ * // 050a0000001901be41ee922ddd2cf33201e49d32da0afec571dce300666f6f
+ * ```
+ *
+ * Without a type definition the base58 encoded address will be treated as a string
+ * ```typescript
+ * const data: MichelsonData = {
+ *     string: "KT1RvkwF4F7pz1gCoxkyZrG1RkrxQy3gmFTv%foo"
+ * };
+ *
+ * const packed = packData(data);
+ *
+ * // 0501000000284b543152766b7746344637707a3167436f786b795a724731526b7278517933676d46547625666f6f
+ * ```
+ * @param d Data object
+ * @param t Optional type definition
+ * @returns Binary representation as numeric array
+ */
+export declare function packData(d: MichelsonData, t?: MichelsonType): number[];
+/**
+ * Serializes any value of packable type to its optimized binary representation
+ * identical to the one used by PACK and UNPACK Michelson instructions.
+ * Same as {@link packData} but returns a `bytes` Michelson data literal instead of an array
+ *
+ * ```typescript
+ * const data: MichelsonData = {
+ *     string: "2019-09-26T10:59:51Z"
+ * };
+ *
+ * const typ: MichelsonType = {
+ *     prim: "timestamp"
+ * };
+ *
+ * const packed = packDataBytes(data, typ);
+ *
+ * // { bytes: "0500a7e8e4d80b" }
+ * ```
+ * @param d Data object
+ * @param t Optional type definition
+ * @returns Binary representation as a bytes literal
+ */
+export declare function packDataBytes(d: MichelsonData, t?: MichelsonType): BytesLiteral;
+/**
+ * Deserialize a byte array into the corresponding Michelson value.
+ * Without a type definition (not recommended) the binary data will be treated as a binary form of a generic Michelson expression and returned as is.
+ * Type definition allows some types like `timestamp` and `address` and other types usually encoded in optimized binary forms to be transformed
+ * back to their string representations like base58 and ISO timestamps.
+ *
+ * ```typescript
+ * const src = [0x05, 0x00, 0xa7, 0xe8, 0xe4, 0xd8, 0x0b];
+ *
+ * const typ: MichelsonType = {
+ *     prim: "timestamp"
+ * };
+ *
+ * const data = unpackData(src, typ);
+ *
+ * // { string: "2019-09-26T10:59:51Z" }
+ * ```
+ *
+ * Same binary data without a type definition
+ * ```typescript
+ * const src = [0x05, 0x00, 0xa7, 0xe8, 0xe4, 0xd8, 0x0b];
+ *
+ * const data = unpackData(src);
+ *
+ * // { int: "1569495591" }
+ * ```
+ * @param src Byte array
+ * @param t Optional type definition
+ * @returns Deserialized data
+ */
+export declare function unpackData(src: number[] | Uint8Array, t?: MichelsonType): MichelsonData;
+/**
+ * Deserialize a byte array into the corresponding Michelson value.
+ * Same as {@link unpackData} but takes a `bytes` Michelson data literal instead of an array
+ *
+ * ```typescript
+ * const src = { bytes: "0500a7e8e4d80b" };
+ *
+ * const typ: MichelsonType = {
+ *     prim: "timestamp"
+ * };
+ *
+ * const data = unpackDataBytes(src, typ);
+ *
+ * // { string: "2019-09-26T10:59:51Z" }
+ * ```
+ * @param src Bytes object
+ * @param t Optional type definition
+ * @returns Deserialized data
+ */
+export declare function unpackDataBytes(src: BytesLiteral, t?: MichelsonType): MichelsonData;
+export declare function decodeAddressBytes(b: BytesLiteral): Address;
+export declare function decodePublicKeyHashBytes(b: BytesLiteral): Address;
+export declare function decodePublicKeyBytes(b: BytesLiteral): PublicKey;
+export {};

package/dist/types/errors.d.ts

@@ -0,0 +1,57 @@
+import { ParameterValidationError, TaquitoError } from '@tezos-x/octez.js-core';
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid Michelson being passed or used
+ */
+export declare class InvalidMichelsonError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid type expression being passed or used
+ */
+export declare class InvalidTypeExpressionError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid data expression being passed or used
+ */
+export declare class InvalidDataExpressionError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid contract entrypoint being referenced or passed
+ */
+export declare class InvalidEntrypointError extends ParameterValidationError {
+    readonly entrypoint?: string | undefined;
+    constructor(entrypoint?: string | undefined);
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a failure happening when trying to encode Tezos ID
+ */
+export declare class TezosIdEncodeError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a general error happening when trying to create a LongInteger
+ */
+export declare class LongIntegerError extends TaquitoError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a failure occurring when trying to parse a hex byte
+ */
+export declare class HexParseError extends TaquitoError {
+    readonly hexByte: string;
+    constructor(hexByte: string);
+}

package/dist/types/formatters.d.ts

@@ -0,0 +1,6 @@
+import { InstructionTrace } from './michelson-typecheck';
+import { MichelsonError } from './utils';
+import { MichelsonReturnType } from './michelson-types';
+export declare function formatStack(s: MichelsonReturnType): string;
+export declare function traceDumpFunc(blocks: boolean, cb: (s: string) => void): (v: InstructionTrace) => void;
+export declare function formatError(err: MichelsonError): string;

package/dist/types/global-constants.d.ts

@@ -0,0 +1,3 @@
+import { Prim, Expr } from './micheline';
+import { GlobalConstantHashAndValue } from './micheline-parser';
+export declare function expandGlobalConstants(ex: Prim, hashAndValue: GlobalConstantHashAndValue): Expr;

package/dist/types/macros.d.ts

@@ -0,0 +1,13 @@
+import { TaquitoError } from '@tezos-x/octez.js-core';
+import { Prim, Expr } from './micheline';
+import { ProtocolOptions } from './michelson-types';
+/**
+ *  @category Error
+ *  @description Error that indicates macros failed to be expanded
+ */
+export declare class MacroError extends TaquitoError {
+    readonly prim: Prim;
+    readonly message: string;
+    constructor(prim: Prim, message: string);
+}
+export declare function expandMacros(ex: Prim, opt?: ProtocolOptions): Expr;

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

@@ -0,0 +1,17 @@
+import { Expr } from './micheline';
+export interface FormatOptions {
+    /**
+     * A string used for code indentation if desired. Usually a tab character or a number of spaces.
+     */
+    indent?: string;
+    /**
+     * A string used for line separation. Usually a newline character ("\n");
+     */
+    newline?: string;
+}
+/**
+ * Formats Micheline expression
+ * @param expr An AST node
+ * @param opt Options
+ */
+export declare function emitMicheline(expr: Expr, opt?: FormatOptions, foldMacros?: boolean): string;

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

@@ -0,0 +1,130 @@
+import { Token } from './scan';
+import { Expr } from './micheline';
+import { ProtocolOptions } from './michelson-types';
+import { TaquitoError } from '@tezos-x/octez.js-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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +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;

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

@@ -0,0 +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;

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

@@ -0,0 +1,147 @@
+import { Prim, Expr, IntLiteral, StringLiteral, BytesLiteral, List, Node } from './micheline';
+interface Prim0<PT extends string = string> extends Prim<PT> {
+    args?: never;
+}
+interface PrimX<PT extends string = string, AT extends Expr[] = Expr[]> extends Prim<PT, AT> {
+    args: AT;
+}
+type MichelsonNoArgInstructionID = 'ABS' | 'ADD' | 'ADDRESS' | 'AMOUNT' | 'AND' | 'APPLY' | 'BALANCE' | 'BLAKE2B' | 'CAR' | 'CDR' | 'CHAIN_ID' | 'CHECK_SIGNATURE' | 'COMPARE' | 'CONCAT' | 'CONS' | 'EDIV' | 'EQ' | 'EXEC' | 'FAILWITH' | 'GE' | 'GET_AND_UPDATE' | 'GT' | 'HASH_KEY' | 'IMPLICIT_ACCOUNT' | 'INT' | 'ISNAT' | 'JOIN_TICKETS' | 'KECCAK' | 'LE' | 'LEVEL' | 'LSL' | 'LSR' | 'LT' | 'MEM' | 'MUL' | 'NEG' | 'NEQ' | 'NEVER' | 'NOT' | 'NOW' | 'OR' | 'PACK' | 'PAIRING_CHECK' | 'READ_TICKET' | 'SAPLING_VERIFY_UPDATE' | 'SELF' | 'SELF_ADDRESS' | 'SENDER' | 'SET_DELEGATE' | 'SHA256' | 'SHA3' | 'SHA512' | 'SIZE' | 'SLICE' | 'SOME' | 'SOURCE' | 'SPLIT_TICKET' | 'SUB' | 'SUB_MUTEZ' | 'SWAP' | 'TICKET' | 'TICKET_DEPRECATED' | 'TOTAL_VOTING_POWER' | 'TRANSFER_TOKENS' | 'UNIT' | 'VOTING_POWER' | 'XOR' | 'RENAME' | 'OPEN_CHEST' | 'MIN_BLOCK_TIME' | 'BYTES' | 'NAT' | 'IS_IMPLICIT_ACCOUNT' | 'INDEX_ADDRESS' | 'GET_ADDRESS_INDEX';
+type MichelsonRegularInstructionID = 'CONTRACT' | 'CREATE_CONTRACT' | 'DIG' | 'DIP' | 'DROP' | 'DUG' | 'DUP' | 'EMPTY_BIG_MAP' | 'EMPTY_MAP' | 'EMPTY_SET' | 'GET' | 'IF' | 'IF_CONS' | 'IF_LEFT' | 'IF_NONE' | 'ITER' | 'LAMBDA' | 'LAMBDA_REC' | 'LEFT' | 'LOOP' | 'LOOP_LEFT' | 'MAP' | 'NIL' | 'NONE' | 'PAIR' | 'PUSH' | 'RIGHT' | 'SAPLING_EMPTY_STATE' | 'UNPACK' | 'UNPAIR' | 'UPDATE' | 'CAST' | 'VIEW' | 'EMIT' | 'CREATE_ACCOUNT' | 'STEPS_TO_QUOTA';
+export type MichelsonInstructionID = MichelsonNoArgInstructionID | MichelsonRegularInstructionID;
+type InstrPrim<PT extends MichelsonInstructionID, AT extends Expr[]> = Prim<PT, AT>;
+type Instr0<PT extends MichelsonNoArgInstructionID> = Prim0<PT>;
+type InstrX<PT extends MichelsonRegularInstructionID, AT extends Expr[]> = PrimX<PT, AT>;
+export type MichelsonCode = InstructionList | MichelsonInstruction;
+export interface InstructionList extends List<MichelsonCode> {
+}
+export type MichelsonNoArgInstruction = Instr0<MichelsonNoArgInstructionID>;
+export type MichelsonInstruction = MichelsonNoArgInstruction | InstrX<'DIG' | 'DUG' | 'SAPLING_EMPTY_STATE', [IntLiteral]> | InstrX<'NONE' | 'LEFT' | 'RIGHT' | 'NIL' | 'CAST', [MichelsonType]> | InstrX<'IF_NONE' | 'IF_LEFT' | 'IF_CONS' | 'IF', [InstructionList, InstructionList]> | InstrX<'MAP' | 'ITER' | 'LOOP' | 'LOOP_LEFT' | 'DIP', [InstructionList]> | InstrX<'UNPACK', [MichelsonType]> | InstrX<'CONTRACT', [MichelsonType]> | InstrX<'CREATE_CONTRACT', [MichelsonContract]> | InstrX<'PUSH', [MichelsonType, MichelsonData]> | InstrX<'EMPTY_SET', [MichelsonType]> | InstrX<'EMPTY_MAP', [MichelsonType, MichelsonType]> | InstrX<'EMPTY_BIG_MAP', [MichelsonType, MichelsonType]> | InstrX<'LAMBDA' | 'LAMBDA_REC', [MichelsonType, MichelsonType, InstructionList]> | InstrX<'DIP', [IntLiteral, InstructionList] | [InstructionList]> | InstrX<'VIEW', [StringLiteral, MichelsonType]> | InstrX<'EMIT', [MichelsonType]> | InstrPrim<'DROP' | 'PAIR' | 'UNPAIR' | 'DUP' | 'GET' | 'UPDATE', [IntLiteral]>;
+export type MichelsonSimpleComparableTypeID = 'string' | 'nat' | 'int' | 'bytes' | 'bool' | 'mutez' | 'key_hash' | 'address' | 'timestamp' | 'never' | 'key' | 'unit' | 'signature' | 'chain_id' | 'tx_rollup_l2_address';
+export type MichelsonTypeID = MichelsonSimpleComparableTypeID | 'option' | 'list' | 'set' | 'contract' | 'operation' | 'pair' | 'or' | 'lambda' | 'map' | 'big_map' | 'sapling_transaction' | 'sapling_transaction_deprecated' | 'sapling_state' | 'ticket' | 'bls12_381_g1' | 'bls12_381_g2' | 'bls12_381_fr' | 'chest_key' | 'chest';
+type Type0<PT extends MichelsonTypeID> = Prim0<PT>;
+type TypeX<PT extends MichelsonTypeID, AT extends Expr[]> = PrimX<PT, AT>;
+export declare const refContract: unique symbol;
+export interface MichelsonTypeAddress extends Type0<'address'> {
+    [refContract]?: MichelsonTypeContract<MichelsonType>;
+}
+export type MichelsonTypeInt = Type0<'int'>;
+export type MichelsonTypeNat = Type0<'nat'>;
+export type MichelsonTypeString = Type0<'string'>;
+export type MichelsonTypeBytes = Type0<'bytes'>;
+export type MichelsonTypeMutez = Type0<'mutez'>;
+export type MichelsonTypeBool = Type0<'bool'>;
+export type MichelsonTypeKeyHash = Type0<'key_hash'>;
+export type MichelsonTypeTimestamp = Type0<'timestamp'>;
+export type MichelsonTypeKey = Type0<'key'>;
+export type MichelsonTypeUnit = Type0<'unit'>;
+export type MichelsonTypeSignature = Type0<'signature'>;
+export type MichelsonTypeOperation = Type0<'operation'>;
+export type MichelsonTypeChainID = Type0<'chain_id'>;
+export type MichelsonTypeNever = Type0<'never'>;
+export type MichelsonTypeBLS12_381_G1 = Type0<'bls12_381_g1'>;
+export type MichelsonTypeBLS12_381_G2 = Type0<'bls12_381_g2'>;
+export type MichelsonTypeBLS12_381_FR = Type0<'bls12_381_fr'>;
+export type MichelsonTypeChestKey = Type0<'chest_key'>;
+export type MichelsonTypeChest = Type0<'chest'>;
+type TypeList<T extends MichelsonType[]> = T & Node;
+export type MichelsonTypePair<T extends MichelsonType[]> = TypeX<'pair', T> | TypeList<T>;
+export interface MichelsonTypeOption<T extends MichelsonType> extends TypeX<'option', [T]> {
+}
+export interface MichelsonTypeList<T extends MichelsonType> extends TypeX<'list', [T]> {
+}
+export interface MichelsonTypeContract<T extends MichelsonType> extends TypeX<'contract', [T]> {
+}
+export interface MichelsonTypeOr<T extends [MichelsonType, MichelsonType]> extends TypeX<'or', T> {
+}
+export interface MichelsonTypeLambda<Arg extends MichelsonType, Ret extends MichelsonType> extends TypeX<'lambda', [Arg, Ret]> {
+}
+export interface MichelsonTypeSet<T extends MichelsonType> extends TypeX<'set', [T]> {
+}
+export interface MichelsonTypeMap<K extends MichelsonType, V extends MichelsonType> extends TypeX<'map', [K, V]> {
+}
+export interface MichelsonTypeBigMap<K extends MichelsonType, V extends MichelsonType> extends TypeX<'big_map', [K, V]> {
+}
+export interface MichelsonTypeSaplingState<S extends string = string> extends TypeX<'sapling_state', [IntLiteral<S>]> {
+}
+export interface MichelsonTypeSaplingTransaction<S extends string = string> extends TypeX<'sapling_transaction', [IntLiteral<S>]> {
+}
+export interface MichelsonTypeTicket<T extends MichelsonType> extends TypeX<'ticket', [T]> {
+}
+export type MichelsonType<T extends MichelsonTypeID = MichelsonTypeID> = T extends 'int' ? MichelsonTypeInt : T extends 'nat' ? MichelsonTypeNat : T extends 'string' ? MichelsonTypeString : T extends 'bytes' ? MichelsonTypeBytes : T extends 'mutez' ? MichelsonTypeMutez : T extends 'bool' ? MichelsonTypeBool : T extends 'key_hash' ? MichelsonTypeKeyHash : T extends 'timestamp' ? MichelsonTypeTimestamp : T extends 'address' ? MichelsonTypeAddress : T extends 'key' ? MichelsonTypeKey : T extends 'unit' ? MichelsonTypeUnit : T extends 'signature' ? MichelsonTypeSignature : T extends 'operation' ? MichelsonTypeOperation : T extends 'chain_id' ? MichelsonTypeChainID : T extends 'option' ? MichelsonTypeOption<MichelsonType> : T extends 'list' ? MichelsonTypeList<MichelsonType> : T extends 'contract' ? MichelsonTypeContract<MichelsonType> : T extends 'ticket' ? MichelsonTypeTicket<MichelsonType> : T extends 'pair' ? MichelsonTypePair<MichelsonType[]> : T extends 'or' ? MichelsonTypeOr<[MichelsonType, MichelsonType]> : T extends 'lambda' ? MichelsonTypeLambda<MichelsonType, MichelsonType> : T extends 'set' ? MichelsonTypeSet<MichelsonType> : T extends 'map' ? MichelsonTypeMap<MichelsonType, MichelsonType> : T extends 'big_map' ? MichelsonTypeBigMap<MichelsonType, MichelsonType> : T extends 'never' ? MichelsonTypeNever : T extends 'bls12_381_g1' ? MichelsonTypeBLS12_381_G1 : T extends 'bls12_381_g2' ? MichelsonTypeBLS12_381_G2 : T extends 'bls12_381_fr' ? MichelsonTypeBLS12_381_FR : T extends 'sapling_transaction' ? MichelsonTypeSaplingTransaction : T extends 'sapling_state' ? MichelsonTypeSaplingState : T extends 'chest_key' ? MichelsonTypeChestKey : MichelsonTypeChest;
+export type MichelsonDataID = 'Unit' | 'True' | 'False' | 'None' | 'Pair' | 'Left' | 'Right' | 'Some' | 'Lambda_rec' | 'Ticket';
+type Data0<PT extends MichelsonDataID> = Prim0<PT>;
+type DataX<PT extends MichelsonDataID, AT extends MichelsonData[]> = PrimX<PT, AT>;
+export type MichelsonDataOption = DataX<'Some', [MichelsonData]> | Data0<'None'>;
+export type MichelsonDataOr = DataX<'Left' | 'Right', [MichelsonData]>;
+type DataList<T extends MichelsonData[]> = T & Node;
+export type MichelsonDataPair<T extends MichelsonData[]> = DataX<'Pair', T> | DataList<T>;
+export type MichelsonMapElt = PrimX<'Elt', [MichelsonData, MichelsonData]>;
+export type MichelsonMapEltList = List<MichelsonMapElt>;
+export type MichelsonLambdaRec = DataX<'Lambda_rec', [InstructionList]>;
+export type MichelsonTicket = PrimX<'Ticket', [
+    StringLiteral | BytesLiteral,
+    MichelsonType,
+    MichelsonData,
+    IntLiteral
+]>;
+export type MichelsonData = IntLiteral | StringLiteral | BytesLiteral | Data0<'Unit' | 'True' | 'False'> | MichelsonDataOption | MichelsonDataOr | DataList<MichelsonData[]> | MichelsonDataPair<MichelsonData[]> | InstructionList | MichelsonMapEltList | MichelsonLambdaRec | MichelsonTicket;
+export type MichelsonSectionID = 'parameter' | 'storage' | 'code' | 'view';
+type SectionPrim<PT extends MichelsonSectionID, AT extends Expr[]> = PrimX<PT, AT>;
+export type MichelsonContractParameter = SectionPrim<'parameter', [MichelsonType]>;
+export type MichelsonContractStorage = SectionPrim<'storage', [MichelsonType]>;
+export type MichelsonContractCode = SectionPrim<'code', [InstructionList]>;
+export type MichelsonContractView = SectionPrim<'view', [
+    StringLiteral,
+    MichelsonType,
+    MichelsonType,
+    InstructionList
+]>;
+export type MichelsonContract = MichelsonContractSection[];
+export type MichelsonContractSection<T extends MichelsonSectionID = MichelsonSectionID> = T extends 'parameter' ? MichelsonContractParameter : T extends 'storage' ? MichelsonContractStorage : T extends 'view' ? MichelsonContractView : MichelsonContractCode;
+export interface MichelsonTypeFailed {
+    failed: MichelsonType;
+    level: number;
+}
+export type MichelsonReturnType = MichelsonType[] | MichelsonTypeFailed;
+export declare enum Protocol {
+    Ps9mPmXa = "Ps9mPmXaRzmzk35gbAYNCAw6UXdE2qoABTHbN2oEEc1qM7CwT9P",
+    PtCJ7pwo = "PtCJ7pwoxe8JasnHY8YonnLYjcVHmhiARPJvqcC6VfHT5s8k8sY",
+    PsYLVpVv = "PsYLVpVvgbLhAhoqAkMFUo6gudkJ9weNXhUYCiLDzcUpFpkk8Wt",
+    PsddFKi3 = "PsddFKi32cMJ2qPjf43Qv5GDWLDPZb3T3bF6fLKiF5HtvHNU7aP",
+    Pt24m4xi = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd",
+    PsBABY5H = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU",
+    PsBabyM1 = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS",
+    PsCARTHA = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb",
+    PsDELPH1 = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo",
+    PtEdoTez = "PtEdoTezd3RHSC31mpxxo1npxFjoWWcFgQtxapi51Z8TLu6v6Uq",
+    PtEdo2Zk = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA",
+    PsFLorena = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i",
+    PtGRANADs = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV",
+    PtHangzH = "PtHangzHogokSuiMHemCuowEavgYTP8J5qQ9fQS793MHYFpCY3r",
+    PtHangz2 = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx",
+    PsiThaCa = "PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP",
+    Psithaca2 = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A",
+    PtJakarta = "PtJakartaiDz69SfDDLXJSiuZqTSeSKRDbKVZC8MNzJnvRjvnGw",
+    PtJakart2 = "PtJakart2xVj7pYXJBXrqHgd82rdkLey5ZeeGwDgPp9rhQUbSqY",
+    PtKathman = "PtKathmankSpLLDALzWw7CGD2j2MtyveTwboEYokqUCP4a1LxMg",
+    PtLimaPtL = "PtLimaPtLMwfNinJi9rCfDPWea8dFgTZ1MeJ9f1m2SRic6ayiwW",
+    PtMumbaii = "PtMumbaiiFFEGbew1rRjzSPyzRbA51Tm3RVZL5suHPxSZYDhCEc",
+    PtMumbai2 = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1",
+    PtNairobi = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf",
+    ProxfordY = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH",
+    PtParisBx = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ",
+    PsParisCZ = "PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi",
+    PsQuebecn = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg",
+    PsRiotuma = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7",
+    PtSeouLou = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh",
+    PtTALLiNt = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu",
+    ProtoALpha = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"
+}
+export declare const DefaultProtocol = Protocol.PtTALLiNt;
+export type ProtocolID = `${Protocol}`;
+export declare function ProtoGreaterOrEqual(a: ProtocolID, b: ProtocolID): boolean;
+export declare function ProtoInferiorTo(a: ProtocolID, b: ProtocolID): boolean;
+export interface ProtocolOptions {
+    protocol?: ProtocolID;
+}
+export {};