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

package/dist/types/taquito-rpc/src/utils/utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Casts object/array items to BigNumber
+ * @param data input object or array
+ * @param keys keys for processing or all items if not defined
+ *
+ */
+export declare function castToBigNumber(data: any, keys?: any): object;
+/**
+ * Casts object/array BigNumber items to strings for readability
+ * @param data input object or array
+ * @param keys keys for processing or all items if not defined
+ *
+ */
+export declare function castToString(data: any, keys?: any): object;

package/dist/types/taquito-rpc/src/version.d.ts

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

package/dist/types/taquito-signer/src/bls-key.d.ts

@@ -0,0 +1,21 @@
+import { PublicKey, SigningKeyWithProofOfPossession } from './key-interface';
+import { RawSignResult } from '@taquito/core';
+export declare class BLSKey implements SigningKeyWithProofOfPossession {
+    #private;
+    constructor(key: string, decrypt?: (k: Uint8Array) => Uint8Array);
+    private sk;
+    private signDst;
+    sign(message: Uint8Array): RawSignResult;
+    provePossession(): RawSignResult;
+    publicKey(): PublicKey;
+    secretKey(): string;
+}
+export declare class BLSPublicKey implements PublicKey {
+    #private;
+    constructor(src: string | Uint8Array);
+    compare(other: PublicKey): number;
+    hash(): string;
+    bytes(): Uint8Array;
+    toProtocol(): Uint8Array;
+    toString(): string;
+}

package/dist/types/taquito-signer/src/derivation-tools/ecdsa.d.ts

@@ -0,0 +1,49 @@
+import { ExtendedPrivateKey } from './types';
+import BN from 'bn.js';
+export type CurveName = 'p256' | 'secp256k1';
+export declare class PrivateKey implements ExtendedPrivateKey {
+    readonly priv: {
+        curve: CurveName;
+        secretKey: BN;
+    };
+    readonly chainCode: Uint8Array;
+    readonly keyPair: {
+        curve: CurveName;
+        secretKey: BN;
+        publicKey: Uint8Array;
+    };
+    /**
+     *
+     * @param priv { secretKey: BN, curve: 'p256' | 'secp256k1' }
+     * @param chainCode slice 32->n HMAC hash key and seedkey (first instance curve default seedKey. after hmac value slice 32->n)
+     */
+    constructor(priv: {
+        curve: CurveName;
+        secretKey: BN;
+    }, chainCode: Uint8Array);
+    /**
+     * @param seedSrc result of Bip39.mnemonicToSeed
+     * @param curve known supported curve p256 or secp256k1
+     * @returns instance of PrivateKey non-HD keys derived
+     * @throws InvalidBitSize | InvalidCurveError | InvalidSeedLengthError
+     */
+    static fromSeed(seedSrc: Uint8Array | string, curve: CurveName): PrivateKey;
+    /**
+     *
+     * @param index derivation path item pre-hardened if applicable ie: 44' -> 2^31 + 44
+     * @returns child PrivateKey of the current PrivateKey
+     */
+    derive(index: number): PrivateKey;
+    /**
+     *
+     * @param path pre-hardened (if applicable) derivation path items ie 44'/1729'/0/0 -> 2^31 + 44/2^31 + 1729/0/0
+     * @returns final child of the full HD keys derivation
+     */
+    derivePath(path: Iterable<number>): PrivateKey;
+    /**
+     *
+     * @returns Uint8Array (if contains a private key)
+     * @throws InvalidKeyError
+     */
+    bytes(): Uint8Array;
+}

package/dist/types/taquito-signer/src/derivation-tools/ed25519.d.ts

@@ -0,0 +1,33 @@
+import { ExtendedPrivateKey } from './types';
+export declare class PrivateKey implements ExtendedPrivateKey {
+    readonly priv: Uint8Array;
+    readonly chainCode: Uint8Array;
+    /**
+     *
+     * @param priv generated keypair 0->32 private key 32->n public key
+     * @param chainCode new HMAC hash with new key
+     */
+    constructor(priv: Uint8Array, chainCode: Uint8Array);
+    /**
+     *
+     * @param seedSrc result of Bip39.mnemonicToSeed
+     * @returns instance of PrivateKey
+     * @throws InvalidSeedLengthError
+     */
+    static fromSeed(seedSrc: Uint8Array | string): PrivateKey;
+    /**
+     *
+     * @returns slice(0, 32) of current priv for new seed for next derived priv
+     */
+    seed(): Uint8Array;
+    /**
+     \* @remarks index: current derivation path item ie: 1729'
+     * @returns derivation path child of original private key pair
+     */
+    derive(index: number): PrivateKey;
+    /**
+     * @param path array of numbers pre adjusted for hardened paths ie: 44' -> 2^31 + 44
+     * @returns final child of full derivation path private key pair
+     */
+    derivePath(path: Iterable<number>): PrivateKey;
+}

package/dist/types/taquito-signer/src/derivation-tools/index.d.ts

@@ -0,0 +1,12 @@
+export * as ECDSA from './ecdsa';
+export * as Ed25519 from './ed25519';
+export * from './types';
+export declare class Path extends Array<number> {
+    static from(iterable: Iterable<number> | ArrayLike<number>): Path;
+    /**
+     *
+     * @param s derivation path eg: 44'/1729'/0'/0'
+     * @returns applied hardened values
+     */
+    static fromString(s: string): Path;
+}

package/dist/types/taquito-signer/src/derivation-tools/types.d.ts

@@ -0,0 +1,10 @@
+export declare const Hard = 2147483648;
+export interface ExtendedKey {
+    readonly chainCode: Uint8Array;
+    derive(index: number): ExtendedKey;
+    derivePath(path: Iterable<number>): ExtendedKey;
+}
+export interface ExtendedPrivateKey extends ExtendedKey {
+    derive(index: number): ExtendedPrivateKey;
+    derivePath(path: number[]): ExtendedPrivateKey;
+}

package/dist/types/taquito-signer/src/derivation-tools/utils.d.ts

@@ -0,0 +1 @@
+export declare function parseHex(s: string): Uint8Array;

package/dist/types/taquito-signer/src/ec-key.d.ts

@@ -0,0 +1,42 @@
+import { SigningKey, PublicKey } from './key-interface';
+import { RawSignResult } from '@taquito/core';
+type Curve = 'p256' | 'secp256k1';
+/**
+ * Provide signing logic for elliptic curve based key (tz2, tz3)
+ */
+export declare class ECKey implements SigningKey {
+    #private;
+    /**
+     *
+     * @param key Encoded private key
+     * @param decrypt Decrypt function
+     * @throws InvalidKeyError
+     */
+    constructor(key: string, decrypt?: (k: Uint8Array) => Uint8Array);
+    /**
+     *
+     * @param bytes Bytes to sign
+     * @param bytesHash Blake2b hash of the bytes to sign
+     */
+    sign(bytes: Uint8Array): RawSignResult;
+    /**
+     * @returns Encoded public key
+     */
+    publicKey(): PublicKey;
+    /**
+     * @returns Encoded private key
+     */
+    secretKey(): string;
+}
+export declare class ECPublicKey implements PublicKey {
+    #private;
+    readonly curve: Curve;
+    constructor(src: string);
+    constructor(src: Uint8Array, curve: Curve);
+    compare(other: PublicKey): number;
+    hash(): string;
+    bytes(compress?: boolean): Uint8Array;
+    toProtocol(): Uint8Array;
+    toString(): string;
+}
+export {};

package/dist/types/taquito-signer/src/ed-key.d.ts

@@ -0,0 +1,39 @@
+import { SigningKey, PublicKey } from './key-interface';
+import { RawSignResult } from '@taquito/core';
+/**
+ * Provide signing logic for ed25519 curve based key (tz1)
+ */
+export declare class EdKey implements SigningKey {
+    #private;
+    /**
+     *
+     * @param key Encoded private key
+     * @param encrypted Is the private key encrypted
+     * @param decrypt Decrypt function
+     * @throws InvalidKeyError
+     */
+    constructor(key: string, decrypt?: (k: Uint8Array) => Uint8Array);
+    /**
+     *
+     * @param bytes Bytes to sign
+     * @param bytesHash Blake2b hash of the bytes to sign
+     */
+    sign(bytes: Uint8Array): RawSignResult;
+    /**
+     * @returns Encoded public key
+     */
+    publicKey(): PublicKey;
+    /**
+     * @returns Encoded private key
+     */
+    secretKey(): string;
+}
+export declare class EdPublicKey implements PublicKey {
+    #private;
+    constructor(src: string | Uint8Array);
+    compare(other: PublicKey): number;
+    hash(): string;
+    bytes(): Uint8Array;
+    toProtocol(): Uint8Array;
+    toString(): string;
+}

package/dist/types/taquito-signer/src/errors.d.ts

@@ -0,0 +1,51 @@
+import { ParameterValidationError, UnsupportedActionError } from '@taquito/core';
+/**
+ *  @category Error
+ *  Error that indicates an invalid Mnemonic being passed or used
+ */
+export declare class InvalidMnemonicError extends ParameterValidationError {
+    /**
+     * @deprecated Use `new InvalidMnemonicError()` instead. The mnemonic argument is ignored for security reasons.
+     */
+    constructor(_mnemonic: string);
+    constructor();
+}
+/**
+ *  @category Error
+ *  Error that indicates a curve with incorrect bit size being passed or used
+ */
+export declare class InvalidBitSize extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates an unsupported cureve being passed or used
+ */
+export declare class InvalidCurveError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates a seed with invalid length being passed or used
+ */
+export declare class InvalidSeedLengthError extends ParameterValidationError {
+    readonly seedLength: number;
+    constructor(seedLength: number);
+}
+/**
+ *  @category Error
+ *  Error that indicates a feature still under developement
+ */
+export declare class ToBeImplemented extends UnsupportedActionError {
+    constructor();
+}
+/**
+ *  @category Error
+ *  Error that indicates an invalid passphrase being passed or used
+ */
+export declare class InvalidPassphraseError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}

package/dist/types/taquito-signer/src/helpers.d.ts

@@ -0,0 +1,10 @@
+export type Curves = 'ed25519' | 'secp256k1' | 'p256' | 'bip25519';
+/**
+ *
+ * @param seed bip39.mnemonicToSeed
+ * @param derivationPath Tezos Requirement 44'/1729' for HD key address default 44'/1729'/0'/0'
+ * @param curve 'ed25519' | 'secp256k1' | 'p256''
+ * @returns final Derivation of HD keys tezos Secret key
+ * @throws InvalidCurveError | ToBeImplemented
+ */
+export declare const generateSecretKey: (seed: Uint8Array, derivationPath: string, curve: Curves) => string;

package/dist/types/taquito-signer/src/in-memory-signer.d.ts

@@ -0,0 +1,56 @@
+import { Curves } from './helpers';
+import { SignResult, RawSignResult, Signer } from '@taquito/core';
+import { PublicKey } from './key-interface';
+export interface FromMnemonicParams {
+    mnemonic: string;
+    password?: string;
+    derivationPath?: string;
+    curve?: Curves;
+}
+/**
+ * A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
+ *
+ * @remarks If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
+ * @throws InvalidMnemonicError
+ */
+export declare class InMemorySigner implements Signer {
+    #private;
+    static fromFundraiser(email: string, password: string, mnemonic: string): InMemorySigner;
+    static fromSecretKey(key: string, passphrase?: string): Promise<InMemorySigner>;
+    /**
+     *
+     * Instantiation of an InMemorySigner instance from a mnemonic
+     * @returns InMemorySigner
+     * @throws InvalidMnemonicError
+     */
+    static fromMnemonic({ mnemonic, password, derivationPath, curve, }: FromMnemonicParams): InMemorySigner;
+    /**
+     *
+     * @param key Encoded private key
+     * @param passphrase Passphrase to decrypt the private key if it is encrypted
+     * @throws InvalidKeyError
+     *
+     */
+    constructor(key: string, passphrase?: string);
+    /**
+     *
+     * @param message Bytes to sign
+     * @param watermark Watermark to append to the bytes
+     */
+    sign(message: string | Uint8Array, watermark?: Uint8Array): Promise<SignResult>;
+    provePossession(): Promise<RawSignResult>;
+    get canProvePossession(): boolean;
+    /**
+     * @returns Encoded public key
+     */
+    publicKey(): Promise<string>;
+    /**
+     * @returns Encoded public key hash
+     */
+    publicKeyHash(): Promise<string>;
+    /**
+     * @returns Encoded private key
+     */
+    secretKey(): Promise<string>;
+}
+export declare function publicKeyFromString(src: string): PublicKey;

package/dist/types/taquito-signer/src/key-interface.d.ts

@@ -0,0 +1,37 @@
+import { RawSignResult } from '@taquito/core';
+export interface SigningKey {
+    sign(message: Uint8Array): RawSignResult;
+    publicKey(): PublicKey;
+    secretKey(): string;
+    provePossession?: () => RawSignResult;
+}
+export interface SigningKeyWithProofOfPossession extends SigningKey {
+    provePossession(): RawSignResult;
+}
+export declare function isPOP(k: SigningKey): k is SigningKeyWithProofOfPossession;
+export interface PublicKey {
+    /**
+     * Compare two public keys of the same elliptic curve
+     * @param other the other PublicKey class to compare to
+     * @returns -1 if this public key is less than the other, 0 if they are equal, 1 if this public key is greater than the other
+     * @throws InvalidPublicKeyError
+     */
+    compare(other: PublicKey): number;
+    /**
+     * Hash of the public key (tz1, tz2, tz3, tz4 addresses)
+     * @returns the hash of the public key
+     */
+    hash(): string;
+    /**
+     * Get the bytes of the public key without prefix
+     * @param compress Whether to get the compressed format of the public key
+     * @default true
+     * @returns the bytes of the public key
+     */
+    bytes(compress?: boolean): Uint8Array;
+    /**
+     * Get the bytes of the public key with prefix
+     * @returns the bytes of the public key
+     */
+    toProtocol(): Uint8Array;
+}

package/dist/types/taquito-signer/src/taquito-signer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @packageDocumentation
+ * @module @taquito/signer
+ */
+export * from './in-memory-signer';
+export { VERSION } from './version';
+export * from './derivation-tools';
+export * from './helpers';
+export { InvalidPassphraseError } from './errors';
+export { PublicKey } from './key-interface';

package/dist/types/taquito-signer/src/version.d.ts

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

package/dist/types/taquito-utils/src/constants.d.ts

@@ -0,0 +1,78 @@
+/**
+ * base58 name to prefix mapping
+ */
+export declare enum PrefixV2 {
+    BlockHash = "B",
+    OperationHash = "o",
+    OperationListHash = "Lo",
+    OperationListListHash = "LLo",
+    ProtocolHash = "P",
+    ContextHash = "Co",
+    BlockMetadataHash = "bm",
+    OperationMetadataHash = "r",
+    OperationMetadataListHash = "Lr",
+    OperationMetadataListListHash = "LLr",
+    Ed25519PublicKeyHash = "tz1",
+    Secp256k1PublicKeyHash = "tz2",
+    P256PublicKeyHash = "tz3",
+    ContractHash = "KT1",
+    BlindedPublicKeyHash = "btz1",
+    BLS12_381PublicKeyHash = "tz4",
+    TXRollupAddress = "txr1",
+    ZkRollupHash = "epx1",
+    ScRollupHash = "scr1",
+    SmartRollupHash = "sr1",
+    CryptoboxPublicKeyHash = "id",
+    Ed25519Seed = "edsk",
+    Ed25519PublicKey = "edpk",
+    Secp256k1SecretKey = "spsk",
+    P256SecretKey = "p2sk",
+    BLS12_381SecretKey = "BLsk",
+    ValueHash = "vh",
+    CycleNonce = "nce",
+    ScriptExpr = "expr",
+    InboxHash = "txi",
+    MessageHash = "txm",
+    CommitmentHash = "txc",
+    MessageResultHash = "txmr",
+    MessageResultListHash = "txM",
+    WithdrawListHash = "txw",
+    ScRollupStateHash = "scs1",
+    ScRollupCommitmentHash = "scc1",
+    SmartRollupStateHash = "srs1",
+    SmartRollupCommitmentHash = "src1",
+    Ed25519EncryptedSeed = "edesk",
+    Secp256k1EncryptedSecretKey = "spesk",
+    P256EncryptedSecretKey = "p2esk",
+    BLS12_381EncryptedSecretKey = "BLesk",
+    Secp256k1EncryptedScalar = "seesk",
+    Secp256k1PublicKey = "sppk",
+    P256PublicKey = "p2pk",
+    Secp256k1Scalar = "SSp",
+    Secp256k1Element = "GSp",
+    Ed25519SecretKey = "_edsk",
+    Ed25519Signature = "edsig",
+    Secp256k1Signature = "spsig1",
+    P256Signature = "p2sig",
+    GenericSignature = "sig",
+    ChainID = "Net",
+    SaplingSpendingKey = "sask",
+    EncryptedSaplingSpendingKey = "_sask",
+    SaplingAddress = "zet1",
+    GenericAggregateSignature = "asig",
+    BLS12_381Signature = "BLsig",
+    BLS12_381PublicKey = "BLpk",
+    SlotHeader = "sh"
+}
+/**
+ * base58 prefix to bytes mapping
+ */
+export declare const prefixV2: {
+    [key in PrefixV2]: Uint8Array;
+};
+/**
+ * base58 prefix to payload length mapping
+ */
+export declare const payloadLength: {
+    [key in PrefixV2]: number;
+};

package/dist/types/taquito-utils/src/encoding.d.ts

@@ -0,0 +1,184 @@
+/**
+ * @packageDocumentation
+ * @module @taquito/utils
+ */
+import { Buffer } from 'buffer';
+import { PrefixV2 } from './constants';
+import BigNumber from 'bignumber.js';
+/**
+ * list of prefixes that can be used to decode an address
+ */
+export declare const addressPrefixes: PrefixV2[];
+/**
+ * list of prefixes that can be used to decode a public key
+ */
+export declare const publicKeyPrefixes: PrefixV2[];
+/**
+ * list of prefixes that can be used to decode a public key hash
+ */
+export declare const publicKeyHashPrefixes: PrefixV2[];
+/**
+ * list of prefixes that can be used to decode a signature
+ */
+export declare const signaturePrefixes: PrefixV2[];
+/**
+ * Decodes Base58 string, looks for known prefix and strips it
+ * @param src Base58 string
+ * @returns Payload and prefix
+ * @example b58DecodeAndCheckPrefix('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM') // returns [Uint8Array, PrefixV2.Ed25519PublicKeyHash]
+ * @example b58DecodeAndCheckPrefix('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM', [PrefixV2.Ed25519PublicKeyHash]) // returns [Uint8Array, PrefixV2.Ed25519PublicKeyHash]
+ * @example b58DecodeAndCheckPrefix('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM', [PrefixV2.Ed25519PublicKeyHash], true) // returns Uint8Array
+ */
+export declare function b58DecodeAndCheckPrefix<T extends readonly PrefixV2[]>(src: string, allowed?: T): [Uint8Array, T[number]];
+export declare function b58DecodeAndCheckPrefix<T extends readonly PrefixV2[]>(src: string, allowed: T, payloadOnly: false): [Uint8Array, T[number]];
+export declare function b58DecodeAndCheckPrefix<T extends readonly PrefixV2[]>(src: string, allowed: T, payloadOnly: true): Uint8Array;
+/**
+ * Decode a Base58 public key and return its binary representation
+ * @param value Value to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodePublicKey('edpkuNjKKT48xBoT5asPrWdmuM1Yw8D93MwgFgVvtca8jb5pstzaCh') // return '0060842d4ba23a9940ef5dcf4404fdaa430cfaaccb5029fad06cb5ea894e4562ae'
+ */
+export declare function b58DecodePublicKey(value: string, fmt?: 'hex'): string;
+export declare function b58DecodePublicKey(value: string, fmt: 'array'): Uint8Array;
+/**
+ * Decode a Base58 public key hash and return its binary representation
+ * @param value Value to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodePublicKeyHash('tz2MVED1t9Jery77Bwm1m5YhUx8Wp5KWWRQe') // return '0001907d6a7e9f084df840d6e67ffa8db5464f87d4d1'
+ */
+export declare function b58DecodePublicKeyHash(value: string, fmt?: 'hex'): string;
+export declare function b58DecodePublicKeyHash(value: string, fmt: 'array'): Uint8Array;
+/**
+ * Decode a Base58 string and assert tz4 type
+ * @param value a bls address(tz4) to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodeBlsAddress('tz4QyWfEiv56CVDATV3DT3CDVhPaMKif2Ce8') // return 'af2dc3c40667abc0e89c0ef40171d22aed08d5eb'
+ */
+export declare function b58DecodeBlsAddress(value: string, fmt?: 'hex'): string;
+export declare function b58DecodeBlsAddress(value: string, fmt: 'array'): Uint8Array;
+/**
+ * Decode a Base58 contract ID and return its binary representation
+ * @param value Value to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodeAddress('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM') // return '0000e96b9f8b19af9c7ffa0c0480e1977b295850961f'
+ */
+export declare function b58DecodeAddress(value: string, fmt?: 'hex'): string;
+export declare function b58DecodeAddress(value: string, fmt: 'array'): Uint8Array;
+/**
+ *  Gets Tezos address (PKH) from Public Key
+ *  @param publicKey Base58 Public Key
+ *  @returns A string of the Tezos address (PKH) that was derived from the given Public Key
+ *  @example getPkhfromPk('edpkuNjKKT48xBoT5asPrWdmuM1Yw8D93MwgFgVvtca8jb5pstzaCh') // return 'tz2MVED1t9Jery77Bwm1m5YhUx8Wp5KWWRQe'
+ */
+export declare function getPkhfromPk(publicKey: string): string;
+/**
+ * Add the prefix to a hex string or Uint8Array and Base58 encode it
+ * @param value Value to Base58 encode
+ * @param pre prefix ID to append to the encoded string
+ * @example b58Encode('e96b9f8b19af9c7ffa0c0480e1977b295850961f', PrefixV2.Ed25519PublicKeyHash) // returns 'tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM'
+ */
+export declare function b58Encode(value: string | Uint8Array, pre: PrefixV2): string;
+/**
+ * Parse binary public key and return Base58 representation
+ * @param value Binary key data
+ * @returns return prefixed public key
+ * @example encodeKey('02033aba7da4a2e7b5dd9f074555c118829aff16213ea1b65859686bd5fcfeaf3616') // return 'p2pk66xmhjiN7LpfrDGFwpxPtJxkLtPjQ6HUxJbKmRbxSR7RMpamDwi'
+ */
+export declare function encodeKey(value: string | Uint8Array): string;
+/**
+ * Parse binary public key hash and return Base58 representation
+ * @param value Key hash to parse
+ * @returns return prefixed public key hash
+ * @example encodeKeyHash('0001907d6a7e9f084df840d6e67ffa8db5464f87d4d1') // return 'tz2MVED1t9Jery77Bwm1m5YhUx8Wp5KWWRQe'
+ */
+export declare function encodeKeyHash(value: string | Uint8Array): string;
+/**
+ * Parse binary Contract ID and return Base58 representation
+ * @param value Address to parse (tz1, tz2, tz3, KT1, or sr1).
+ * @example encodeAddress('0000e96b9f8b19af9c7ffa0c0480e1977b295850961f') // return 'tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM'
+ */
+export declare function encodeAddress(value: string | Uint8Array): string;
+/**
+ * Base58 encode an address without predefined prefix
+ * @param value Address to base58 encode (tz4) hex dec
+ * @returns return address
+ * @example encodeBlsAddress('af2dc3c40667abc0e89c0ef40171d22aed08d5eb') // return 'tz4QyWfEiv56CVDATV3DT3CDVhPaMKif2Ce8'
+ */
+export declare function encodeBlsAddress(value: string): string;
+/**
+ * convert a fragment of Michelson code in hex string to an 'expr' prefix + base58 encoded BLAKE2b hash string
+ * @param value a fragment of Michelson code in hex string
+ * @returns return 'expr' prefix + base58 encoded BLAKE2b hash
+ * @example encodeExpr('050a000000160000b2e19a9e74440d86c59f13dab8a18ff873e889ea') // return 'exprv6UsC1sN3Fk2XfgcJCL8NCerP5rCGy1PRESZAqr7L2JdzX55EN'
+ */
+export declare function encodeExpr(value: string): string;
+/**
+ * convert a signed operation in hex string to an 'op' prefix + base58 encoded BLAKE2b hash string
+ * @param value signed operation in hex string
+ * @returns return 'op' prefix + base58 encoded BLAKE2b hash
+ * @example encodeOpHash('0f185d8a30061e8134c162dbb7a6c3ab8f5fdb153363ccd6149b49a33481156a6c00b2e19a9e74440d86c59f13dab8a18ff873e889eaa304ab05da13000001f1585a7384f36e45fb43dc37e8ce172bced3e05700ff0000000002002110c033f3a990c2e46a3d6054ecc2f74072aae7a34b5ac4d9ce9edc11c2410a97695682108951786f05b361da03b97245dc9897e1955e08b5b8d9e153b0bdeb0d') // return 'opapqvVXmebRTCFd2GQFydr4tJj3V5QocQuTmuhbatcHm4Seo2t'
+ */
+export declare function encodeOpHash(value: string): string;
+/**
+ * Convert an hex string to a Uint8Array
+ * @param hex Hex string to convert
+ * @throws {@link ValueConversionError}
+ */
+export declare function hex2buf(hex: string): Uint8Array;
+/**
+ * Merge 2 buffers together
+ * @param b1 First buffer
+ * @param b2 Second buffer
+ */
+export declare function mergebuf(b1: Uint8Array, b2: Uint8Array): Uint8Array;
+/**
+ * Flatten a michelson json representation to an array
+ * @param s michelson json
+ */
+export declare function mic2arr(s: any): any;
+/**
+ * Convert a Uint8Array to an hex string
+ * @param bytes Uint8Array to convert
+ */
+export declare function buf2hex(bytes: ArrayLike<number>): string;
+/**
+ * Convert a string to a byte string representation
+ * @param str String to convert
+ */
+export declare function stringToBytes(str: string): string;
+/**
+ * Convert byte string representation to string
+ * @param hex byte string to convert
+ */
+export declare function bytesToString(hex: string): string;
+/**
+ * Convert hex string/UintArray/Buffer to bytes
+ * @param hex String value to convert to bytes
+ */
+export declare function hex2Bytes(hex: string): Buffer;
+/**
+ * Converts a number or Bignumber to hexadecimal  string
+ * @param val The value  that will be converted to a hexadecimal string value
+ */
+export declare function toHexBuf(val: number | BigNumber, bitLength?: number): Buffer<ArrayBuffer>;
+export declare function numToHexBuffer(val: number | BigNumber, bitLength?: number): Buffer<ArrayBuffer>;
+/**
+ * Converts a number or BigNumber to a padded hexadecimal string
+ * @param val The value that will be converted into a padded hexadecimal string value
+ * @param bitLength The length of bits
+ *
+ */
+export declare function num2PaddedHex(val: number | BigNumber, bitLength?: number): string;
+/**
+ *
+ * Strips the first 2 characters of a hex string (0x)
+ *
+ * @param hex string to strip prefix from
+ */
+export declare function stripHexPrefix(hex: string): string;
+export declare function splitAddress(addr: string): [string, string | null];
+export declare function compareArrays(a: ArrayLike<number>, b: ArrayLike<number>): number;