// package: emerald
// file: common.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";

export class Chain extends jspb.Message { 
    getType(): ChainRef;
    setType(value: ChainRef): Chain;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Chain.AsObject;
    static toObject(includeInstance: boolean, msg: Chain): Chain.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Chain, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Chain;
    static deserializeBinaryFromReader(message: Chain, reader: jspb.BinaryReader): Chain;
}

export namespace Chain {
    export type AsObject = {
        type: ChainRef,
    }
}

export class SingleAddress extends jspb.Message { 
    getAddress(): string;
    setAddress(value: string): SingleAddress;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): SingleAddress.AsObject;
    static toObject(includeInstance: boolean, msg: SingleAddress): SingleAddress.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: SingleAddress, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): SingleAddress;
    static deserializeBinaryFromReader(message: SingleAddress, reader: jspb.BinaryReader): SingleAddress;
}

export namespace SingleAddress {
    export type AsObject = {
        address: string,
    }
}

export class XpubAddress extends jspb.Message { 
    getXpub(): string;
    setXpub(value: string): XpubAddress;
    getStart(): number;
    setStart(value: number): XpubAddress;
    getLimit(): number;
    setLimit(value: number): XpubAddress;
    getUnusedLimit(): number;
    setUnusedLimit(value: number): XpubAddress;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): XpubAddress.AsObject;
    static toObject(includeInstance: boolean, msg: XpubAddress): XpubAddress.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: XpubAddress, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): XpubAddress;
    static deserializeBinaryFromReader(message: XpubAddress, reader: jspb.BinaryReader): XpubAddress;
}

export namespace XpubAddress {
    export type AsObject = {
        xpub: string,
        start: number,
        limit: number,
        unusedLimit: number,
    }
}

export class MultiAddress extends jspb.Message { 
    clearAddressesList(): void;
    getAddressesList(): Array<SingleAddress>;
    setAddressesList(value: Array<SingleAddress>): MultiAddress;
    addAddresses(value?: SingleAddress, index?: number): SingleAddress;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MultiAddress.AsObject;
    static toObject(includeInstance: boolean, msg: MultiAddress): MultiAddress.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MultiAddress, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MultiAddress;
    static deserializeBinaryFromReader(message: MultiAddress, reader: jspb.BinaryReader): MultiAddress;
}

export namespace MultiAddress {
    export type AsObject = {
        addressesList: Array<SingleAddress.AsObject>,
    }
}

export class ReferenceAddress extends jspb.Message { 
    getRefid(): number;
    setRefid(value: number): ReferenceAddress;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReferenceAddress.AsObject;
    static toObject(includeInstance: boolean, msg: ReferenceAddress): ReferenceAddress.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReferenceAddress, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReferenceAddress;
    static deserializeBinaryFromReader(message: ReferenceAddress, reader: jspb.BinaryReader): ReferenceAddress;
}

export namespace ReferenceAddress {
    export type AsObject = {
        refid: number,
    }
}

export class AnyAddress extends jspb.Message { 

    hasAddressSingle(): boolean;
    clearAddressSingle(): void;
    getAddressSingle(): SingleAddress | undefined;
    setAddressSingle(value?: SingleAddress): AnyAddress;

    hasAddressMulti(): boolean;
    clearAddressMulti(): void;
    getAddressMulti(): MultiAddress | undefined;
    setAddressMulti(value?: MultiAddress): AnyAddress;

    hasAddressXpub(): boolean;
    clearAddressXpub(): void;
    getAddressXpub(): XpubAddress | undefined;
    setAddressXpub(value?: XpubAddress): AnyAddress;

    hasAddressRef(): boolean;
    clearAddressRef(): void;
    getAddressRef(): ReferenceAddress | undefined;
    setAddressRef(value?: ReferenceAddress): AnyAddress;

    getAddrTypeCase(): AnyAddress.AddrTypeCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AnyAddress.AsObject;
    static toObject(includeInstance: boolean, msg: AnyAddress): AnyAddress.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AnyAddress, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AnyAddress;
    static deserializeBinaryFromReader(message: AnyAddress, reader: jspb.BinaryReader): AnyAddress;
}

export namespace AnyAddress {
    export type AsObject = {
        addressSingle?: SingleAddress.AsObject,
        addressMulti?: MultiAddress.AsObject,
        addressXpub?: XpubAddress.AsObject,
        addressRef?: ReferenceAddress.AsObject,
    }

    export enum AddrTypeCase {
        ADDR_TYPE_NOT_SET = 0,
        ADDRESS_SINGLE = 1,
        ADDRESS_MULTI = 2,
        ADDRESS_XPUB = 3,
        ADDRESS_REF = 4,
    }

}

export class Asset extends jspb.Message { 
    getChain(): ChainRef;
    setChain(value: ChainRef): Asset;
    getCode(): string;
    setCode(value: string): Asset;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Asset.AsObject;
    static toObject(includeInstance: boolean, msg: Asset): Asset.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Asset, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Asset;
    static deserializeBinaryFromReader(message: Asset, reader: jspb.BinaryReader): Asset;
}

export namespace Asset {
    export type AsObject = {
        chain: ChainRef,
        code: string,
    }
}

export class Erc20Asset extends jspb.Message { 
    getChain(): ChainRef;
    setChain(value: ChainRef): Erc20Asset;
    getContractAddress(): string;
    setContractAddress(value: string): Erc20Asset;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Erc20Asset.AsObject;
    static toObject(includeInstance: boolean, msg: Erc20Asset): Erc20Asset.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Erc20Asset, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Erc20Asset;
    static deserializeBinaryFromReader(message: Erc20Asset, reader: jspb.BinaryReader): Erc20Asset;
}

export namespace Erc20Asset {
    export type AsObject = {
        chain: ChainRef,
        contractAddress: string,
    }
}

export class BlockInfo extends jspb.Message { 
    getHeight(): number;
    setHeight(value: number): BlockInfo;
    getBlockId(): string;
    setBlockId(value: string): BlockInfo;
    getTimestamp(): number;
    setTimestamp(value: number): BlockInfo;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): BlockInfo.AsObject;
    static toObject(includeInstance: boolean, msg: BlockInfo): BlockInfo.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: BlockInfo, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): BlockInfo;
    static deserializeBinaryFromReader(message: BlockInfo, reader: jspb.BinaryReader): BlockInfo;
}

export namespace BlockInfo {
    export type AsObject = {
        height: number,
        blockId: string,
        timestamp: number,
    }
}

export class BlockRef extends jspb.Message { 
    getBlockchain(): ChainRef;
    setBlockchain(value: ChainRef): BlockRef;

    hasHeight(): boolean;
    clearHeight(): void;
    getHeight(): number;
    setHeight(value: number): BlockRef;

    hasBlockId(): boolean;
    clearBlockId(): void;
    getBlockId(): string;
    setBlockId(value: string): BlockRef;

    getRefTypeCase(): BlockRef.RefTypeCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): BlockRef.AsObject;
    static toObject(includeInstance: boolean, msg: BlockRef): BlockRef.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: BlockRef, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): BlockRef;
    static deserializeBinaryFromReader(message: BlockRef, reader: jspb.BinaryReader): BlockRef;
}

export namespace BlockRef {
    export type AsObject = {
        blockchain: ChainRef,
        height: number,
        blockId: string,
    }

    export enum RefTypeCase {
        REF_TYPE_NOT_SET = 0,
        HEIGHT = 2,
        BLOCK_ID = 3,
    }

}

export enum ChainRef {
    CHAIN_UNSPECIFIED = 0,
    CHAIN_BITCOIN = 1,
    CHAIN_ETHEREUM = 100,
    CHAIN_ETHEREUM_CLASSIC = 101,
    CHAIN_FANTOM = 102,
    CHAIN_MATIC = 1002,
    CHAIN_RSK = 1003,
    CHAIN_MORDEN = 10001,
    CHAIN_KOVAN = 10002,
    CHAIN_TESTNET_BITCOIN = 10003,
    CHAIN_TESTNET_BITCOIN_4 = 10004,
    CHAIN_GOERLI = 10005,
    CHAIN_ROPSTEN = 10006,
    CHAIN_RINKEBY = 10007,
    CHAIN_HOLESKY = 10008,
    CHAIN_SEPOLIA = 10009,
    CHAIN_HOODI = 10010,
}