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

package/dist/types/base58.d.ts

@@ -1,13 +1,13 @@
-import { TaquitoError } from '@taquito/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;
+import { TaquitoError } from '@taquito/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

@@ -1,127 +1,127 @@
-import { BytesLiteral } from './micheline';
-import { MichelsonData, MichelsonType } from './michelson-types';
-declare type AddressType = 'ED25519PublicKeyHash' | 'SECP256K1PublicKeyHash' | 'P256PublicKeyHash' | 'ContractHash';
-export interface Address {
-    type: AddressType;
-    hash: number[] | Uint8Array;
-    entryPoint?: string;
-}
-export declare 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 {};
+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

@@ -1,57 +1,57 @@
-import { ParameterValidationError, TaquitoError } from '@taquito/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);
-}
+import { ParameterValidationError, TaquitoError } from '@taquito/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

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

@@ -1,3 +1,3 @@
-import { Prim, Expr } from './micheline';
-import { GlobalConstantHashAndValue } from './micheline-parser';
-export declare function expandGlobalConstants(ex: Prim, hashAndValue: GlobalConstantHashAndValue): Expr;
+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

@@ -1,13 +1,13 @@
-import { TaquitoError } from '@taquito/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;
+import { TaquitoError } from '@taquito/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

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