@taquito/wallet-connect 24.3.0-beta.2 → 24.3.0-beta.3

package/dist/types/taquito-local-forging/src/decoder.d.ts

@@ -1,5 +0,0 @@
-import { Uint8ArrayConsumer } from './uint8array-consumer';
-export type Decoder = (val: Uint8ArrayConsumer) => string | number | object | undefined;
-export declare const decoders: {
-    [key: string]: Decoder;
-};

package/dist/types/taquito-local-forging/src/encoder.d.ts

@@ -1,4 +0,0 @@
-export type Encoder<T> = (val: T) => string;
-export declare const encoders: {
-    [key: string]: Encoder<any>;
-};

package/dist/types/taquito-local-forging/src/errors.d.ts

@@ -1,109 +0,0 @@
-import { ParameterValidationError } from '@taquito/core';
-import { OperationContents } from '@taquito/rpc';
-/**
- *  @category Error
- *  Error that indicates an invalid operation content being passed or used
- */ export declare class InvalidOperationSchemaError extends ParameterValidationError {
-    readonly operation: OperationContents;
-    readonly errorDetail?: string | undefined;
-    constructor(operation: OperationContents, errorDetail?: string | undefined);
-}
-/**
- *  @category Error
- *  Error that indicates an entrypoint name exceeding maximum length
- */
-export declare class OversizedEntryPointError extends ParameterValidationError {
-    readonly entrypoint: string;
-    constructor(entrypoint: string);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid ballot value being used
- */
-export declare class InvalidBallotValueError extends ParameterValidationError {
-    readonly ballotValue: string;
-    constructor(ballotValue: string);
-}
-/**
- *  @category Error
- *  Error that indicates a failure when trying to decode ballot value
- */
-export declare class DecodeBallotValueError extends ParameterValidationError {
-    readonly ballotValue: string;
-    constructor(ballotValue: string);
-}
-/**
- *  @category Error
- *  Error that indicates unexpected Michelson Value being passed or used
- */
-export declare class UnexpectedMichelsonValueError extends ParameterValidationError {
-    readonly value: string;
-    constructor(value: string);
-}
-/**
- *  @category Error
- *  Error that indicates a failure when trying to decode an operation
- */
-export declare class OperationDecodingError extends ParameterValidationError {
-    readonly message: string;
-    constructor(message: string);
-}
-/**
- *  @category Error
- *  Error that indicates a failure when trying to encode an operation
- */
-export declare class OperationEncodingError extends ParameterValidationError {
-    readonly message: string;
-    constructor(message: string);
-}
-/**
- *  @category Error
- *  Error that indicates an unsupported operation being passed or used
- */
-export declare class UnsupportedOperationError extends ParameterValidationError {
-    readonly op: string;
-    constructor(op: string);
-}
-/**
- * @cateogry Error
- * Error that indicates an unsupported pvm being passed or used
- */
-export declare class UnsupportedPvmKindError extends ParameterValidationError {
-    readonly pvm: string;
-    constructor(pvm: string);
-}
-/**
- * @category Error
- * Error that indicates an unsupported pvm to decode
- */
-export declare class DecodePvmKindError extends ParameterValidationError {
-    readonly pvm: string;
-    constructor(pvm: string);
-}
-/**
- * @category Error
- * Error that indicates an invalid Smart Rollup Address (sr1)
- */
-export declare class InvalidSmartRollupAddressError extends ParameterValidationError {
-    readonly address: string;
-    readonly errorDetail?: string | undefined;
-    constructor(address: string, errorDetail?: string | undefined);
-}
-/**
- * @category Error
- * Error that indicates an invalid Smart Rollup commitment hash (src1)
- */
-export declare class InvalidSmartRollupCommitmentHashError extends ParameterValidationError {
-    readonly hash: string;
-    readonly errorDetail?: string | undefined;
-    constructor(hash: string, errorDetail?: string | undefined);
-}
-/**
- * @category Error
- * Error that indicates an invalid dal commitment (sh)
- */
-export declare class InvalidDalCommitmentError extends ParameterValidationError {
-    readonly commitment: string;
-    readonly errorDetail?: string | undefined;
-    constructor(commitment: string, errorDetail?: string | undefined);
-}

package/dist/types/taquito-local-forging/src/interface.d.ts

@@ -1,9 +0,0 @@
-import { OperationContents } from '@taquito/rpc';
-export interface ForgeParams {
-    branch: string;
-    contents: OperationContents[];
-}
-export type ForgeResponse = string;
-export interface Forger {
-    forge(params: ForgeParams): Promise<ForgeResponse>;
-}

package/dist/types/taquito-local-forging/src/michelson/codec.d.ts

@@ -1,49 +0,0 @@
-import { Decoder } from '../decoder';
-import { Uint8ArrayConsumer } from '../uint8array-consumer';
-import { Encoder } from '../encoder';
-export type PrimValue = {
-    prim: string;
-    args?: MichelsonValue[];
-    annots?: string[];
-};
-export type BytesValue = {
-    bytes: string;
-};
-export type StringValue = {
-    string: string;
-};
-export type IntValue = {
-    int: string;
-};
-export type MichelsonValue = PrimValue | BytesValue | StringValue | IntValue | (PrimValue | BytesValue | StringValue | IntValue)[];
-export declare const isPrim: (value: MichelsonValue) => value is PrimValue;
-export declare const isBytes: (value: MichelsonValue) => value is BytesValue;
-export declare const isString: (value: MichelsonValue) => value is StringValue;
-export declare const isInt: (value: MichelsonValue) => value is IntValue;
-export declare const scriptEncoder: Encoder<{
-    code: MichelsonValue;
-    storage: MichelsonValue;
-}>;
-export declare const scriptDecoder: Decoder;
-export declare const valueEncoder: Encoder<MichelsonValue>;
-export declare const valueDecoder: Decoder;
-export declare const extractRequiredLen: (value: Uint8ArrayConsumer, bytesLength?: number) => Uint8Array<ArrayBufferLike>;
-/**
- * parse bytes into multiple items of an array
- * @param value Uint8ArrayConsumer class of forged segment to parse
- * @param bytesLength default 4 bytes for length of variable bytes
- * @returns array of Uint8Array values for each array item
- */
-export declare const stripLengthPrefixFromBytes: (value: Uint8ArrayConsumer, bytesLength?: number) => Uint8Array[];
-export declare const bytesEncoder: Encoder<BytesValue>;
-export declare const bytesDecoder: Decoder;
-export declare const stringEncoder: Encoder<StringValue>;
-export declare const stringDecoder: Decoder;
-export declare const intEncoder: Encoder<IntValue>;
-export declare const intDecoder: (value: Uint8ArrayConsumer) => IntValue;
-export declare const primEncoder: Encoder<PrimValue>;
-export declare const primDecoder: (value: Uint8ArrayConsumer, preamble: Uint8Array) => Partial<PrimValue>;
-export declare const primViewDecoder: (value: Uint8ArrayConsumer, result: Partial<PrimValue>) => Partial<PrimValue>;
-export declare const decodeCombPair: Decoder;
-export declare const encodeAnnots: Encoder<string[]>;
-export declare const decodeAnnots: Decoder;

package/dist/types/taquito-local-forging/src/protocols.d.ts

@@ -1,27 +0,0 @@
-export declare enum ProtocolsHash {
-    Pt24m4xi = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd",
-    PsBABY5H = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU",
-    PsBabyM1 = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS",
-    PsCARTHA = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb",
-    PsDELPH1 = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo",
-    PtEdo2Zk = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA",
-    PsFLorena = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i",
-    PtGRANADs = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV",
-    PtHangz2 = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx",
-    Psithaca2 = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A",
-    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 function ProtoInferiorTo(a: ProtocolsHash, b: ProtocolsHash): boolean;

package/dist/types/taquito-local-forging/src/schema/operation.d.ts

@@ -1,198 +0,0 @@
-import { Decoder } from '../decoder';
-import { Uint8ArrayConsumer } from '../uint8array-consumer';
-import { CODEC } from '../constants';
-export declare const ManagerOperationSchema: {
-    branch: CODEC;
-    contents: CODEC[];
-};
-export declare const ActivationSchema: {
-    pkh: CODEC;
-    secret: CODEC;
-};
-export declare const RevealSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    public_key: CODEC;
-    proof: CODEC;
-};
-export declare const DelegationSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    delegate: CODEC;
-};
-export declare const TransactionSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    amount: CODEC;
-    destination: CODEC;
-    parameters: CODEC;
-};
-export declare const OriginationSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    balance: CODEC;
-    delegate: CODEC;
-    script: CODEC;
-};
-export declare const BallotSchema: {
-    source: CODEC;
-    period: CODEC;
-    proposal: CODEC;
-    ballot: CODEC;
-};
-export declare const AttestationSchema: {
-    slot: CODEC;
-    level: CODEC;
-    round: CODEC;
-    block_payload_hash: CODEC;
-};
-export declare const AttestationWithDalSchema: {
-    slot: CODEC;
-    level: CODEC;
-    round: CODEC;
-    block_payload_hash: CODEC;
-    dal_attestation: CODEC;
-};
-export declare const SeedNonceRevelationSchema: {
-    level: CODEC;
-    nonce: CODEC;
-};
-export declare const ProposalsSchema: {
-    source: CODEC;
-    period: CODEC;
-    proposals: CODEC;
-};
-export declare const RegisterGlobalConstantSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    value: CODEC;
-};
-export declare const TransferTicketSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    ticket_contents: CODEC;
-    ticket_ty: CODEC;
-    ticket_ticketer: CODEC;
-    ticket_amount: CODEC;
-    destination: CODEC;
-    entrypoint: CODEC;
-};
-export declare const IncreasePaidStorageSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    amount: CODEC;
-    destination: CODEC;
-};
-export declare const UpdateConsensusKeySchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    pk: CODEC;
-    proof: CODEC;
-};
-export declare const UpdateCompanionKeySchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    pk: CODEC;
-    proof: CODEC;
-};
-export declare const DrainDelegateSchema: {
-    consensus_key: CODEC;
-    delegate: CODEC;
-    destination: CODEC;
-};
-export declare const SetDepositsLimitSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    limit: CODEC;
-};
-export declare const SmartRollupOriginateSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    pvm_kind: CODEC;
-    kernel: CODEC;
-    parameters_ty: CODEC;
-    whitelist: CODEC;
-};
-export declare const SmartRollupAddMessagesSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    message: CODEC;
-};
-export declare const SmartRollupExecuteOutboxMessageSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    rollup: CODEC;
-    cemented_commitment: CODEC;
-    output_proof: CODEC;
-};
-export declare const DalPublishCommitmentSchema: {
-    source: CODEC;
-    fee: CODEC;
-    counter: CODEC;
-    gas_limit: CODEC;
-    storage_limit: CODEC;
-    slot_header: CODEC;
-};
-export declare const FailingNoopSchema: {
-    arbitrary: CODEC;
-};
-export declare const operationEncoder: (encoders: {
-    [key: string]: (val: object) => string;
-}) => (operation: {
-    kind: string;
-}) => string;
-export declare const operationDecoder: (decoders: {
-    [key: string]: Decoder;
-}) => (value: Uint8ArrayConsumer) => {
-    kind: string;
-};
-type Schema = Record<string, CODEC | CODEC[]>;
-export type Value = Record<keyof Schema, unknown[]>;
-export declare const schemaEncoder: (encoders: {
-    [key: string]: (val: object) => string;
-}) => (schema: Schema) => (value: Value) => string;
-export declare const schemaDecoder: (decoders: {
-    [key: string]: Decoder;
-}) => (schema: {
-    [key: string]: string | string[];
-}) => (value: Uint8ArrayConsumer) => {};
-export {};

package/dist/types/taquito-local-forging/src/taquito-local-forging.d.ts

@@ -1,27 +0,0 @@
-/**
- * @packageDocumentation
- * @module @taquito/local-forging
- */
-import 'fast-text-encoding';
-import { ForgeParams, Forger } from './interface';
-import { CODEC } from './constants';
-import { ProtocolsHash } from './protocols';
-export { CODEC, opMapping, opMappingReverse } from './constants';
-export * from './decoder';
-export * from './encoder';
-export * from './uint8array-consumer';
-export * from './interface';
-export { VERSION } from './version';
-export { ProtocolsHash } from './protocols';
-export declare function getCodec(codec: CODEC, _proto: ProtocolsHash): {
-    encoder: import("./encoder").Encoder<any>;
-    decoder: (hex: string) => any;
-};
-export declare class LocalForger implements Forger {
-    readonly protocolHash: ProtocolsHash;
-    constructor(protocolHash?: ProtocolsHash);
-    private codec;
-    forge(params: ForgeParams): Promise<string>;
-    parse(hex: string): Promise<ForgeParams>;
-}
-export declare const localForger: LocalForger;

package/dist/types/taquito-local-forging/src/uint8array-consumer.d.ts

@@ -1,10 +0,0 @@
-export declare class Uint8ArrayConsumer {
-    private readonly arr;
-    private offset;
-    static fromHexString(hex: string): Uint8ArrayConsumer;
-    constructor(arr: Uint8Array, offset?: number);
-    consume(count: number): Uint8Array;
-    get(idx: number): number;
-    length(): number;
-    slice(start: number, end?: number): Uint8ArrayConsumer;
-}

package/dist/types/taquito-local-forging/src/utils.d.ts

@@ -1,3 +0,0 @@
-export declare const concat: (...arr: Uint8Array[]) => Uint8Array<ArrayBufferLike>;
-export declare const toHexString: (bytes: Uint8Array) => string;
-export declare const pad: (num: number, paddingLen?: number) => string;

package/dist/types/taquito-local-forging/src/validator.d.ts

@@ -1,13 +0,0 @@
-import { OpKind } from '@taquito/rpc';
-import { OperationContents } from '@taquito/rpc';
-/**
- * @returns A boolean value to indicate whether the operation kind is valid or not
- */
-export declare const validateOperationKind: (opKind: OpKind) => boolean;
-/**
- *  returns 0 when the two array of properties are identical or the passed property
- *  does not have any missing parameters from the corresponding schema
- *
- *  @returns array element differences if there are missing required property keys
- */
-export declare const validateMissingProperty: (operationContent: OperationContents) => string[];

package/dist/types/taquito-local-forging/src/version.d.ts

@@ -1,4 +0,0 @@
-export declare const VERSION: {
-    commitHash: string;
-    version: string;
-};

package/dist/types/taquito-michel-codec/src/base58.d.ts

@@ -1,13 +0,0 @@
-import { TaquitoError } from '@taquito/core';
-/**
- *  @category Error
- *  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/taquito-michel-codec/src/binary.d.ts

@@ -1,127 +0,0 @@
-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: "KT1J4E79F1qL6kGBSQ3yXBdXmuq5j4FNThK2%main"
- * };
- *
- * const typ: MichelsonType = {
- *     prim: "address"
- * };
- *
- * const packed = packData(data, typ);
- *
- * // 050a0000001a0167ea84b1082efb9619d6ce04e033633906636e1d006d61696e
- * ```
- *
- * Without a type definition the base58 encoded address will be treated as a string
- * ```typescript
- * const data: MichelsonData = {
- *     string: "KT1J4E79F1qL6kGBSQ3yXBdXmuq5j4FNThK2%main"
- * };
- *
- * const packed = packData(data);
- *
- * // 0501000000294b54314a344537394631714c366b474253513379584264586d7571356a34464e54684b32256d61696e
- * ```
- * @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/taquito-michel-codec/src/errors.d.ts

@@ -1,57 +0,0 @@
-import { ParameterValidationError, TaquitoError } from '@taquito/core';
-/**
- *  @category Error
- *  Error that indicates an invalid Michelson being passed or used
- */
-export declare class InvalidMichelsonError extends ParameterValidationError {
-    readonly message: string;
-    constructor(message: string);
-}
-/**
- *  @category Error
- *  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
- *  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
- *  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
- *  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
- *  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
- *  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/taquito-michel-codec/src/formatters.d.ts

@@ -1,6 +0,0 @@
-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/taquito-michel-codec/src/global-constants.d.ts

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