import * as $protobuf from "protobufjs";
export namespace waves {

    interface IAmount {
        assetId?: (Uint8Array|null);
        amount?: (Long|null);
    }

    class Amount implements IAmount {
        constructor(p?: waves.IAmount);
        public assetId: Uint8Array;
        public amount: Long;
        public static encode(m: waves.IAmount, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.Amount;
    }

    interface IBlock {
        header?: (waves.Block.IHeader|null);
        signature?: (Uint8Array|null);
        transactions?: (waves.ISignedTransaction[]|null);
    }

    class Block implements IBlock {
        constructor(p?: waves.IBlock);
        public header?: (waves.Block.IHeader|null);
        public signature: Uint8Array;
        public transactions: waves.ISignedTransaction[];
        public static encode(m: waves.IBlock, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.Block;
    }

    namespace Block {

        interface IHeader {
            chainId?: (number|null);
            reference?: (Uint8Array|null);
            baseTarget?: (Long|null);
            generationSignature?: (Uint8Array|null);
            featureVotes?: (number[]|null);
            timestamp?: (Long|null);
            version?: (number|null);
            generator?: (Uint8Array|null);
            rewardVote?: (Long|null);
            transactionsRoot?: (Uint8Array|null);
            stateHash?: (Uint8Array|null);
            challengedHeader?: (waves.Block.Header.IChallengedHeader|null);
        }

        class Header implements IHeader {
            constructor(p?: waves.Block.IHeader);
            public chainId: number;
            public reference: Uint8Array;
            public baseTarget: Long;
            public generationSignature: Uint8Array;
            public featureVotes: number[];
            public timestamp: Long;
            public version: number;
            public generator: Uint8Array;
            public rewardVote: Long;
            public transactionsRoot: Uint8Array;
            public stateHash: Uint8Array;
            public challengedHeader?: (waves.Block.Header.IChallengedHeader|null);
            public static encode(m: waves.Block.IHeader, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.Block.Header;
        }

        namespace Header {

            interface IChallengedHeader {
                baseTarget?: (Long|null);
                generationSignature?: (Uint8Array|null);
                featureVotes?: (number[]|null);
                timestamp?: (Long|null);
                generator?: (Uint8Array|null);
                rewardVote?: (Long|null);
                stateHash?: (Uint8Array|null);
                headerSignature?: (Uint8Array|null);
            }

            class ChallengedHeader implements IChallengedHeader {
                constructor(p?: waves.Block.Header.IChallengedHeader);
                public baseTarget: Long;
                public generationSignature: Uint8Array;
                public featureVotes: number[];
                public timestamp: Long;
                public generator: Uint8Array;
                public rewardVote: Long;
                public stateHash: Uint8Array;
                public headerSignature: Uint8Array;
                public static encode(m: waves.Block.Header.IChallengedHeader, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.Block.Header.ChallengedHeader;
            }
        }
    }

    interface IMicroBlock {
        version?: (number|null);
        reference?: (Uint8Array|null);
        updatedBlockSignature?: (Uint8Array|null);
        senderPublicKey?: (Uint8Array|null);
        transactions?: (waves.ISignedTransaction[]|null);
        stateHash?: (Uint8Array|null);
    }

    class MicroBlock implements IMicroBlock {
        constructor(p?: waves.IMicroBlock);
        public version: number;
        public reference: Uint8Array;
        public updatedBlockSignature: Uint8Array;
        public senderPublicKey: Uint8Array;
        public transactions: waves.ISignedTransaction[];
        public stateHash: Uint8Array;
        public static encode(m: waves.IMicroBlock, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.MicroBlock;
    }

    interface ISignedMicroBlock {
        microBlock?: (waves.IMicroBlock|null);
        signature?: (Uint8Array|null);
        totalBlockId?: (Uint8Array|null);
    }

    class SignedMicroBlock implements ISignedMicroBlock {
        constructor(p?: waves.ISignedMicroBlock);
        public microBlock?: (waves.IMicroBlock|null);
        public signature: Uint8Array;
        public totalBlockId: Uint8Array;
        public static encode(m: waves.ISignedMicroBlock, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.SignedMicroBlock;
    }

    namespace events {

        interface IBlockchainUpdated {
            id?: (Uint8Array|null);
            height?: (number|null);
            append?: (waves.events.BlockchainUpdated.IAppend|null);
            rollback?: (waves.events.BlockchainUpdated.IRollback|null);
            referencedAssets?: (waves.events.StateUpdate.IAssetInfo[]|null);
        }

        class BlockchainUpdated implements IBlockchainUpdated {
            constructor(p?: waves.events.IBlockchainUpdated);
            public id: Uint8Array;
            public height: number;
            public append?: (waves.events.BlockchainUpdated.IAppend|null);
            public rollback?: (waves.events.BlockchainUpdated.IRollback|null);
            public referencedAssets: waves.events.StateUpdate.IAssetInfo[];
            public update?: ("append"|"rollback");
            public static encode(m: waves.events.IBlockchainUpdated, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.BlockchainUpdated;
        }

        namespace BlockchainUpdated {

            interface IAppend {
                block?: (waves.events.BlockchainUpdated.Append.IBlockAppend|null);
                microBlock?: (waves.events.BlockchainUpdated.Append.IMicroBlockAppend|null);
                transactionIds?: (Uint8Array[]|null);
                transactionsMetadata?: (waves.events.ITransactionMetadata[]|null);
                stateUpdate?: (waves.events.IStateUpdate|null);
                transactionStateUpdates?: (waves.events.IStateUpdate[]|null);
            }

            class Append implements IAppend {
                constructor(p?: waves.events.BlockchainUpdated.IAppend);
                public block?: (waves.events.BlockchainUpdated.Append.IBlockAppend|null);
                public microBlock?: (waves.events.BlockchainUpdated.Append.IMicroBlockAppend|null);
                public transactionIds: Uint8Array[];
                public transactionsMetadata: waves.events.ITransactionMetadata[];
                public stateUpdate?: (waves.events.IStateUpdate|null);
                public transactionStateUpdates: waves.events.IStateUpdate[];
                public body?: ("block"|"microBlock");
                public static encode(m: waves.events.BlockchainUpdated.IAppend, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.BlockchainUpdated.Append;
            }

            namespace Append {

                interface IBlockAppend {
                    block?: (waves.IBlock|null);
                    updatedWavesAmount?: (Long|null);
                    activatedFeatures?: (number[]|null);
                    vrf?: (Uint8Array|null);
                    rewardShares?: (waves.IRewardShare[]|null);
                }

                class BlockAppend implements IBlockAppend {
                    constructor(p?: waves.events.BlockchainUpdated.Append.IBlockAppend);
                    public block?: (waves.IBlock|null);
                    public updatedWavesAmount: Long;
                    public activatedFeatures: number[];
                    public vrf: Uint8Array;
                    public rewardShares: waves.IRewardShare[];
                    public static encode(m: waves.events.BlockchainUpdated.Append.IBlockAppend, w?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.BlockchainUpdated.Append.BlockAppend;
                }

                interface IMicroBlockAppend {
                    microBlock?: (waves.ISignedMicroBlock|null);
                    updatedTransactionsRoot?: (Uint8Array|null);
                }

                class MicroBlockAppend implements IMicroBlockAppend {
                    constructor(p?: waves.events.BlockchainUpdated.Append.IMicroBlockAppend);
                    public microBlock?: (waves.ISignedMicroBlock|null);
                    public updatedTransactionsRoot: Uint8Array;
                    public static encode(m: waves.events.BlockchainUpdated.Append.IMicroBlockAppend, w?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.BlockchainUpdated.Append.MicroBlockAppend;
                }
            }

            interface IRollback {
                type?: (waves.events.BlockchainUpdated.Rollback.RollbackType|null);
                removedTransactionIds?: (Uint8Array[]|null);
                removedBlocks?: (waves.IBlock[]|null);
                rollbackStateUpdate?: (waves.events.IStateUpdate|null);
                deactivatedFeatures?: (number[]|null);
            }

            class Rollback implements IRollback {
                constructor(p?: waves.events.BlockchainUpdated.IRollback);
                public type: waves.events.BlockchainUpdated.Rollback.RollbackType;
                public removedTransactionIds: Uint8Array[];
                public removedBlocks: waves.IBlock[];
                public rollbackStateUpdate?: (waves.events.IStateUpdate|null);
                public deactivatedFeatures: number[];
                public static encode(m: waves.events.BlockchainUpdated.IRollback, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.BlockchainUpdated.Rollback;
            }

            namespace Rollback {

                enum RollbackType {
                    BLOCK = 0,
                    MICROBLOCK = 1
                }
            }
        }

        interface IStateUpdate {
            balances?: (waves.events.StateUpdate.IBalanceUpdate[]|null);
            leasingForAddress?: (waves.events.StateUpdate.ILeasingUpdate[]|null);
            dataEntries?: (waves.events.StateUpdate.IDataEntryUpdate[]|null);
            assets?: (waves.events.StateUpdate.IAssetStateUpdate[]|null);
            individualLeases?: (waves.events.StateUpdate.ILeaseUpdate[]|null);
            scripts?: (waves.events.StateUpdate.IScriptUpdate[]|null);
            deletedAliases?: (string[]|null);
        }

        class StateUpdate implements IStateUpdate {
            constructor(p?: waves.events.IStateUpdate);
            public balances: waves.events.StateUpdate.IBalanceUpdate[];
            public leasingForAddress: waves.events.StateUpdate.ILeasingUpdate[];
            public dataEntries: waves.events.StateUpdate.IDataEntryUpdate[];
            public assets: waves.events.StateUpdate.IAssetStateUpdate[];
            public individualLeases: waves.events.StateUpdate.ILeaseUpdate[];
            public scripts: waves.events.StateUpdate.IScriptUpdate[];
            public deletedAliases: string[];
            public static encode(m: waves.events.IStateUpdate, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate;
        }

        namespace StateUpdate {

            interface IBalanceUpdate {
                address?: (Uint8Array|null);
                amountAfter?: (waves.IAmount|null);
                amountBefore?: (Long|null);
            }

            class BalanceUpdate implements IBalanceUpdate {
                constructor(p?: waves.events.StateUpdate.IBalanceUpdate);
                public address: Uint8Array;
                public amountAfter?: (waves.IAmount|null);
                public amountBefore: Long;
                public static encode(m: waves.events.StateUpdate.IBalanceUpdate, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.BalanceUpdate;
            }

            interface ILeasingUpdate {
                address?: (Uint8Array|null);
                inAfter?: (Long|null);
                outAfter?: (Long|null);
                inBefore?: (Long|null);
                outBefore?: (Long|null);
            }

            class LeasingUpdate implements ILeasingUpdate {
                constructor(p?: waves.events.StateUpdate.ILeasingUpdate);
                public address: Uint8Array;
                public inAfter: Long;
                public outAfter: Long;
                public inBefore: Long;
                public outBefore: Long;
                public static encode(m: waves.events.StateUpdate.ILeasingUpdate, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.LeasingUpdate;
            }

            interface ILeaseUpdate {
                leaseId?: (Uint8Array|null);
                statusAfter?: (waves.events.StateUpdate.LeaseUpdate.LeaseStatus|null);
                amount?: (Long|null);
                sender?: (Uint8Array|null);
                recipient?: (Uint8Array|null);
                originTransactionId?: (Uint8Array|null);
            }

            class LeaseUpdate implements ILeaseUpdate {
                constructor(p?: waves.events.StateUpdate.ILeaseUpdate);
                public leaseId: Uint8Array;
                public statusAfter: waves.events.StateUpdate.LeaseUpdate.LeaseStatus;
                public amount: Long;
                public sender: Uint8Array;
                public recipient: Uint8Array;
                public originTransactionId: Uint8Array;
                public static encode(m: waves.events.StateUpdate.ILeaseUpdate, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.LeaseUpdate;
            }

            namespace LeaseUpdate {

                enum LeaseStatus {
                    INACTIVE = 0,
                    ACTIVE = 1
                }
            }

            interface IDataEntryUpdate {
                address?: (Uint8Array|null);
                dataEntry?: (waves.IDataEntry|null);
                dataEntryBefore?: (waves.IDataEntry|null);
            }

            class DataEntryUpdate implements IDataEntryUpdate {
                constructor(p?: waves.events.StateUpdate.IDataEntryUpdate);
                public address: Uint8Array;
                public dataEntry?: (waves.IDataEntry|null);
                public dataEntryBefore?: (waves.IDataEntry|null);
                public static encode(m: waves.events.StateUpdate.IDataEntryUpdate, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.DataEntryUpdate;
            }

            interface IAssetStateUpdate {
                before?: (waves.events.StateUpdate.IAssetDetails|null);
                after?: (waves.events.StateUpdate.IAssetDetails|null);
            }

            class AssetStateUpdate implements IAssetStateUpdate {
                constructor(p?: waves.events.StateUpdate.IAssetStateUpdate);
                public before?: (waves.events.StateUpdate.IAssetDetails|null);
                public after?: (waves.events.StateUpdate.IAssetDetails|null);
                public static encode(m: waves.events.StateUpdate.IAssetStateUpdate, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.AssetStateUpdate;
            }

            interface IAssetDetails {
                assetId?: (Uint8Array|null);
                issuer?: (Uint8Array|null);
                decimals?: (number|null);
                name?: (string|null);
                description?: (string|null);
                reissuable?: (boolean|null);
                volume?: (Long|null);
                scriptInfo?: (waves.events.StateUpdate.AssetDetails.IAssetScriptInfo|null);
                sponsorship?: (Long|null);
                nft?: (boolean|null);
                lastUpdated?: (number|null);
                sequenceInBlock?: (number|null);
                issueHeight?: (number|null);
                safeVolume?: (Uint8Array|null);
            }

            class AssetDetails implements IAssetDetails {
                constructor(p?: waves.events.StateUpdate.IAssetDetails);
                public assetId: Uint8Array;
                public issuer: Uint8Array;
                public decimals: number;
                public name: string;
                public description: string;
                public reissuable: boolean;
                public volume: Long;
                public scriptInfo?: (waves.events.StateUpdate.AssetDetails.IAssetScriptInfo|null);
                public sponsorship: Long;
                public nft: boolean;
                public lastUpdated: number;
                public sequenceInBlock: number;
                public issueHeight: number;
                public safeVolume: Uint8Array;
                public static encode(m: waves.events.StateUpdate.IAssetDetails, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.AssetDetails;
            }

            namespace AssetDetails {

                interface IAssetScriptInfo {
                    script?: (Uint8Array|null);
                    complexity?: (Long|null);
                }

                class AssetScriptInfo implements IAssetScriptInfo {
                    constructor(p?: waves.events.StateUpdate.AssetDetails.IAssetScriptInfo);
                    public script: Uint8Array;
                    public complexity: Long;
                    public static encode(m: waves.events.StateUpdate.AssetDetails.IAssetScriptInfo, w?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.AssetDetails.AssetScriptInfo;
                }
            }

            interface IAssetInfo {
                id?: (Uint8Array|null);
                decimals?: (number|null);
                name?: (string|null);
            }

            class AssetInfo implements IAssetInfo {
                constructor(p?: waves.events.StateUpdate.IAssetInfo);
                public id: Uint8Array;
                public decimals: number;
                public name: string;
                public static encode(m: waves.events.StateUpdate.IAssetInfo, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.AssetInfo;
            }

            interface IScriptUpdate {
                address?: (Uint8Array|null);
                before?: (Uint8Array|null);
                after?: (Uint8Array|null);
            }

            class ScriptUpdate implements IScriptUpdate {
                constructor(p?: waves.events.StateUpdate.IScriptUpdate);
                public address: Uint8Array;
                public before: Uint8Array;
                public after: Uint8Array;
                public static encode(m: waves.events.StateUpdate.IScriptUpdate, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.StateUpdate.ScriptUpdate;
            }
        }

        interface ITransactionMetadata {
            senderAddress?: (Uint8Array|null);
            transfer?: (waves.events.TransactionMetadata.ITransferMetadata|null);
            exchange?: (waves.events.TransactionMetadata.IExchangeMetadata|null);
            massTransfer?: (waves.events.TransactionMetadata.IMassTransferMetadata|null);
            invokeScript?: (waves.events.TransactionMetadata.IInvokeScriptMetadata|null);
            lease?: (waves.events.TransactionMetadata.ILeaseMetadata|null);
            ethereum?: (waves.events.TransactionMetadata.IEthereumMetadata|null);
        }

        class TransactionMetadata implements ITransactionMetadata {
            constructor(p?: waves.events.ITransactionMetadata);
            public senderAddress: Uint8Array;
            public transfer?: (waves.events.TransactionMetadata.ITransferMetadata|null);
            public exchange?: (waves.events.TransactionMetadata.IExchangeMetadata|null);
            public massTransfer?: (waves.events.TransactionMetadata.IMassTransferMetadata|null);
            public invokeScript?: (waves.events.TransactionMetadata.IInvokeScriptMetadata|null);
            public lease?: (waves.events.TransactionMetadata.ILeaseMetadata|null);
            public ethereum?: (waves.events.TransactionMetadata.IEthereumMetadata|null);
            public metadata?: ("transfer"|"exchange"|"massTransfer"|"invokeScript"|"lease"|"ethereum");
            public static encode(m: waves.events.ITransactionMetadata, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata;
        }

        namespace TransactionMetadata {

            interface ITransferMetadata {
                recipientAddress?: (Uint8Array|null);
            }

            class TransferMetadata implements ITransferMetadata {
                constructor(p?: waves.events.TransactionMetadata.ITransferMetadata);
                public recipientAddress: Uint8Array;
                public static encode(m: waves.events.TransactionMetadata.ITransferMetadata, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.TransferMetadata;
            }

            interface IMassTransferMetadata {
                recipientsAddresses?: (Uint8Array[]|null);
            }

            class MassTransferMetadata implements IMassTransferMetadata {
                constructor(p?: waves.events.TransactionMetadata.IMassTransferMetadata);
                public recipientsAddresses: Uint8Array[];
                public static encode(m: waves.events.TransactionMetadata.IMassTransferMetadata, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.MassTransferMetadata;
            }

            interface IExchangeMetadata {
                orderIds?: (Uint8Array[]|null);
                orderSenderAddresses?: (Uint8Array[]|null);
                orderSenderPublicKeys?: (Uint8Array[]|null);
            }

            class ExchangeMetadata implements IExchangeMetadata {
                constructor(p?: waves.events.TransactionMetadata.IExchangeMetadata);
                public orderIds: Uint8Array[];
                public orderSenderAddresses: Uint8Array[];
                public orderSenderPublicKeys: Uint8Array[];
                public static encode(m: waves.events.TransactionMetadata.IExchangeMetadata, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.ExchangeMetadata;
            }

            interface IInvokeScriptMetadata {
                dAppAddress?: (Uint8Array|null);
                functionName?: (string|null);
                "arguments"?: (waves.InvokeScriptResult.Call.IArgument[]|null);
                payments?: (waves.IAmount[]|null);
                result?: (waves.IInvokeScriptResult|null);
            }

            class InvokeScriptMetadata implements IInvokeScriptMetadata {
                constructor(p?: waves.events.TransactionMetadata.IInvokeScriptMetadata);
                public dAppAddress: Uint8Array;
                public functionName: string;
                public arguments: waves.InvokeScriptResult.Call.IArgument[];
                public payments: waves.IAmount[];
                public result?: (waves.IInvokeScriptResult|null);
                public static encode(m: waves.events.TransactionMetadata.IInvokeScriptMetadata, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.InvokeScriptMetadata;
            }

            namespace InvokeScriptMetadata {

                interface IArgument {
                    integerValue?: (Long|null);
                    binaryValue?: (Uint8Array|null);
                    stringValue?: (string|null);
                    booleanValue?: (boolean|null);
                    list?: (waves.events.TransactionMetadata.InvokeScriptMetadata.Argument.IList|null);
                }

                class Argument implements IArgument {
                    constructor(p?: waves.events.TransactionMetadata.InvokeScriptMetadata.IArgument);
                    public integerValue: Long;
                    public binaryValue: Uint8Array;
                    public stringValue: string;
                    public booleanValue: boolean;
                    public list?: (waves.events.TransactionMetadata.InvokeScriptMetadata.Argument.IList|null);
                    public value?: ("integerValue"|"binaryValue"|"stringValue"|"booleanValue"|"list");
                    public static encode(m: waves.events.TransactionMetadata.InvokeScriptMetadata.IArgument, w?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.InvokeScriptMetadata.Argument;
                }

                namespace Argument {

                    interface IList {
                        items?: (waves.events.TransactionMetadata.InvokeScriptMetadata.IArgument[]|null);
                    }

                    class List implements IList {
                        constructor(p?: waves.events.TransactionMetadata.InvokeScriptMetadata.Argument.IList);
                        public items: waves.events.TransactionMetadata.InvokeScriptMetadata.IArgument[];
                        public static encode(m: waves.events.TransactionMetadata.InvokeScriptMetadata.Argument.IList, w?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.InvokeScriptMetadata.Argument.List;
                    }
                }
            }

            interface ILeaseMetadata {
                recipientAddress?: (Uint8Array|null);
            }

            class LeaseMetadata implements ILeaseMetadata {
                constructor(p?: waves.events.TransactionMetadata.ILeaseMetadata);
                public recipientAddress: Uint8Array;
                public static encode(m: waves.events.TransactionMetadata.ILeaseMetadata, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.LeaseMetadata;
            }

            interface IEthereumTransferMetadata {
                recipientAddress?: (Uint8Array|null);
                amount?: (waves.IAmount|null);
            }

            class EthereumTransferMetadata implements IEthereumTransferMetadata {
                constructor(p?: waves.events.TransactionMetadata.IEthereumTransferMetadata);
                public recipientAddress: Uint8Array;
                public amount?: (waves.IAmount|null);
                public static encode(m: waves.events.TransactionMetadata.IEthereumTransferMetadata, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.EthereumTransferMetadata;
            }

            interface IEthereumMetadata {
                timestamp?: (Long|null);
                fee?: (Long|null);
                senderPublicKey?: (Uint8Array|null);
                transfer?: (waves.events.TransactionMetadata.IEthereumTransferMetadata|null);
                invoke?: (waves.events.TransactionMetadata.IInvokeScriptMetadata|null);
            }

            class EthereumMetadata implements IEthereumMetadata {
                constructor(p?: waves.events.TransactionMetadata.IEthereumMetadata);
                public timestamp: Long;
                public fee: Long;
                public senderPublicKey: Uint8Array;
                public transfer?: (waves.events.TransactionMetadata.IEthereumTransferMetadata|null);
                public invoke?: (waves.events.TransactionMetadata.IInvokeScriptMetadata|null);
                public Action?: ("transfer"|"invoke");
                public static encode(m: waves.events.TransactionMetadata.IEthereumMetadata, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.TransactionMetadata.EthereumMetadata;
            }
        }

        namespace grpc {

            class BlockchainUpdatesApi extends $protobuf.rpc.Service {
                constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
                public getBlockUpdate(request: waves.events.grpc.IGetBlockUpdateRequest, callback: waves.events.grpc.BlockchainUpdatesApi.GetBlockUpdateCallback): void;
                public getBlockUpdate(request: waves.events.grpc.IGetBlockUpdateRequest): Promise<waves.events.grpc.GetBlockUpdateResponse>;
                public getBlockUpdatesRange(request: waves.events.grpc.IGetBlockUpdatesRangeRequest, callback: waves.events.grpc.BlockchainUpdatesApi.GetBlockUpdatesRangeCallback): void;
                public getBlockUpdatesRange(request: waves.events.grpc.IGetBlockUpdatesRangeRequest): Promise<waves.events.grpc.GetBlockUpdatesRangeResponse>;
                public subscribe(request: waves.events.grpc.ISubscribeRequest, callback: waves.events.grpc.BlockchainUpdatesApi.SubscribeCallback): void;
                public subscribe(request: waves.events.grpc.ISubscribeRequest): Promise<waves.events.grpc.SubscribeEvent>;
            }

            namespace BlockchainUpdatesApi {

                type GetBlockUpdateCallback = (error: (Error|null), response?: waves.events.grpc.GetBlockUpdateResponse) => void;

                type GetBlockUpdatesRangeCallback = (error: (Error|null), response?: waves.events.grpc.GetBlockUpdatesRangeResponse) => void;

                type SubscribeCallback = (error: (Error|null), response?: waves.events.grpc.SubscribeEvent) => void;
            }

            interface IGetBlockUpdateRequest {
                height?: (number|null);
            }

            class GetBlockUpdateRequest implements IGetBlockUpdateRequest {
                constructor(p?: waves.events.grpc.IGetBlockUpdateRequest);
                public height: number;
                public static encode(m: waves.events.grpc.IGetBlockUpdateRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.grpc.GetBlockUpdateRequest;
            }

            interface IGetBlockUpdateResponse {
                update?: (waves.events.IBlockchainUpdated|null);
            }

            class GetBlockUpdateResponse implements IGetBlockUpdateResponse {
                constructor(p?: waves.events.grpc.IGetBlockUpdateResponse);
                public update?: (waves.events.IBlockchainUpdated|null);
                public static encode(m: waves.events.grpc.IGetBlockUpdateResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.grpc.GetBlockUpdateResponse;
            }

            interface IGetBlockUpdatesRangeRequest {
                fromHeight?: (number|null);
                toHeight?: (number|null);
            }

            class GetBlockUpdatesRangeRequest implements IGetBlockUpdatesRangeRequest {
                constructor(p?: waves.events.grpc.IGetBlockUpdatesRangeRequest);
                public fromHeight: number;
                public toHeight: number;
                public static encode(m: waves.events.grpc.IGetBlockUpdatesRangeRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.grpc.GetBlockUpdatesRangeRequest;
            }

            interface IGetBlockUpdatesRangeResponse {
                updates?: (waves.events.IBlockchainUpdated[]|null);
            }

            class GetBlockUpdatesRangeResponse implements IGetBlockUpdatesRangeResponse {
                constructor(p?: waves.events.grpc.IGetBlockUpdatesRangeResponse);
                public updates: waves.events.IBlockchainUpdated[];
                public static encode(m: waves.events.grpc.IGetBlockUpdatesRangeResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.grpc.GetBlockUpdatesRangeResponse;
            }

            interface ISubscribeRequest {
                fromHeight?: (number|null);
                toHeight?: (number|null);
            }

            class SubscribeRequest implements ISubscribeRequest {
                constructor(p?: waves.events.grpc.ISubscribeRequest);
                public fromHeight: number;
                public toHeight: number;
                public static encode(m: waves.events.grpc.ISubscribeRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.grpc.SubscribeRequest;
            }

            interface ISubscribeEvent {
                update?: (waves.events.IBlockchainUpdated|null);
            }

            class SubscribeEvent implements ISubscribeEvent {
                constructor(p?: waves.events.grpc.ISubscribeEvent);
                public update?: (waves.events.IBlockchainUpdated|null);
                public static encode(m: waves.events.grpc.ISubscribeEvent, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.events.grpc.SubscribeEvent;
            }
        }
    }

    interface IInvokeScriptResult {
        data?: (waves.IDataEntry[]|null);
        transfers?: (waves.InvokeScriptResult.IPayment[]|null);
        issues?: (waves.InvokeScriptResult.IIssue[]|null);
        reissues?: (waves.InvokeScriptResult.IReissue[]|null);
        burns?: (waves.InvokeScriptResult.IBurn[]|null);
        errorMessage?: (waves.InvokeScriptResult.IErrorMessage|null);
        sponsorFees?: (waves.InvokeScriptResult.ISponsorFee[]|null);
        leases?: (waves.InvokeScriptResult.ILease[]|null);
        leaseCancels?: (waves.InvokeScriptResult.ILeaseCancel[]|null);
        invokes?: (waves.InvokeScriptResult.IInvocation[]|null);
    }

    class InvokeScriptResult implements IInvokeScriptResult {
        constructor(p?: waves.IInvokeScriptResult);
        public data: waves.IDataEntry[];
        public transfers: waves.InvokeScriptResult.IPayment[];
        public issues: waves.InvokeScriptResult.IIssue[];
        public reissues: waves.InvokeScriptResult.IReissue[];
        public burns: waves.InvokeScriptResult.IBurn[];
        public errorMessage?: (waves.InvokeScriptResult.IErrorMessage|null);
        public sponsorFees: waves.InvokeScriptResult.ISponsorFee[];
        public leases: waves.InvokeScriptResult.ILease[];
        public leaseCancels: waves.InvokeScriptResult.ILeaseCancel[];
        public invokes: waves.InvokeScriptResult.IInvocation[];
        public static encode(m: waves.IInvokeScriptResult, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult;
    }

    namespace InvokeScriptResult {

        interface IPayment {
            address?: (Uint8Array|null);
            amount?: (waves.IAmount|null);
        }

        class Payment implements IPayment {
            constructor(p?: waves.InvokeScriptResult.IPayment);
            public address: Uint8Array;
            public amount?: (waves.IAmount|null);
            public static encode(m: waves.InvokeScriptResult.IPayment, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Payment;
        }

        interface IIssue {
            assetId?: (Uint8Array|null);
            name?: (string|null);
            description?: (string|null);
            amount?: (Long|null);
            decimals?: (number|null);
            reissuable?: (boolean|null);
            script?: (Uint8Array|null);
            nonce?: (Long|null);
        }

        class Issue implements IIssue {
            constructor(p?: waves.InvokeScriptResult.IIssue);
            public assetId: Uint8Array;
            public name: string;
            public description: string;
            public amount: Long;
            public decimals: number;
            public reissuable: boolean;
            public script: Uint8Array;
            public nonce: Long;
            public static encode(m: waves.InvokeScriptResult.IIssue, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Issue;
        }

        interface IReissue {
            assetId?: (Uint8Array|null);
            amount?: (Long|null);
            isReissuable?: (boolean|null);
        }

        class Reissue implements IReissue {
            constructor(p?: waves.InvokeScriptResult.IReissue);
            public assetId: Uint8Array;
            public amount: Long;
            public isReissuable: boolean;
            public static encode(m: waves.InvokeScriptResult.IReissue, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Reissue;
        }

        interface IBurn {
            assetId?: (Uint8Array|null);
            amount?: (Long|null);
        }

        class Burn implements IBurn {
            constructor(p?: waves.InvokeScriptResult.IBurn);
            public assetId: Uint8Array;
            public amount: Long;
            public static encode(m: waves.InvokeScriptResult.IBurn, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Burn;
        }

        interface ISponsorFee {
            minFee?: (waves.IAmount|null);
        }

        class SponsorFee implements ISponsorFee {
            constructor(p?: waves.InvokeScriptResult.ISponsorFee);
            public minFee?: (waves.IAmount|null);
            public static encode(m: waves.InvokeScriptResult.ISponsorFee, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.SponsorFee;
        }

        interface ILease {
            recipient?: (waves.IRecipient|null);
            amount?: (Long|null);
            nonce?: (Long|null);
            leaseId?: (Uint8Array|null);
        }

        class Lease implements ILease {
            constructor(p?: waves.InvokeScriptResult.ILease);
            public recipient?: (waves.IRecipient|null);
            public amount: Long;
            public nonce: Long;
            public leaseId: Uint8Array;
            public static encode(m: waves.InvokeScriptResult.ILease, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Lease;
        }

        interface ILeaseCancel {
            leaseId?: (Uint8Array|null);
        }

        class LeaseCancel implements ILeaseCancel {
            constructor(p?: waves.InvokeScriptResult.ILeaseCancel);
            public leaseId: Uint8Array;
            public static encode(m: waves.InvokeScriptResult.ILeaseCancel, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.LeaseCancel;
        }

        interface IErrorMessage {
            code?: (number|null);
            text?: (string|null);
        }

        class ErrorMessage implements IErrorMessage {
            constructor(p?: waves.InvokeScriptResult.IErrorMessage);
            public code: number;
            public text: string;
            public static encode(m: waves.InvokeScriptResult.IErrorMessage, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.ErrorMessage;
        }

        interface ICall {
            "function"?: (string|null);
            argsBytes?: (Uint8Array[]|null);
            args?: (waves.InvokeScriptResult.Call.IArgument[]|null);
        }

        class Call implements ICall {
            constructor(p?: waves.InvokeScriptResult.ICall);
            public function: string;
            public argsBytes: Uint8Array[];
            public args: waves.InvokeScriptResult.Call.IArgument[];
            public static encode(m: waves.InvokeScriptResult.ICall, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Call;
        }

        namespace Call {

            interface IArgument {
                integerValue?: (Long|null);
                binaryValue?: (Uint8Array|null);
                stringValue?: (string|null);
                booleanValue?: (boolean|null);
                caseObj?: (Uint8Array|null);
                list?: (waves.InvokeScriptResult.Call.Argument.IList|null);
            }

            class Argument implements IArgument {
                constructor(p?: waves.InvokeScriptResult.Call.IArgument);
                public integerValue: Long;
                public binaryValue: Uint8Array;
                public stringValue: string;
                public booleanValue: boolean;
                public caseObj: Uint8Array;
                public list?: (waves.InvokeScriptResult.Call.Argument.IList|null);
                public value?: ("integerValue"|"binaryValue"|"stringValue"|"booleanValue"|"caseObj"|"list");
                public static encode(m: waves.InvokeScriptResult.Call.IArgument, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Call.Argument;
            }

            namespace Argument {

                interface IList {
                    items?: (waves.InvokeScriptResult.Call.IArgument[]|null);
                }

                class List implements IList {
                    constructor(p?: waves.InvokeScriptResult.Call.Argument.IList);
                    public items: waves.InvokeScriptResult.Call.IArgument[];
                    public static encode(m: waves.InvokeScriptResult.Call.Argument.IList, w?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Call.Argument.List;
                }
            }
        }

        interface IInvocation {
            dApp?: (Uint8Array|null);
            call?: (waves.InvokeScriptResult.ICall|null);
            payments?: (waves.IAmount[]|null);
            stateChanges?: (waves.IInvokeScriptResult|null);
        }

        class Invocation implements IInvocation {
            constructor(p?: waves.InvokeScriptResult.IInvocation);
            public dApp: Uint8Array;
            public call?: (waves.InvokeScriptResult.ICall|null);
            public payments: waves.IAmount[];
            public stateChanges?: (waves.IInvokeScriptResult|null);
            public static encode(m: waves.InvokeScriptResult.IInvocation, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptResult.Invocation;
        }
    }

    interface IDAppMeta {
        version?: (number|null);
        funcs?: (waves.DAppMeta.ICallableFuncSignature[]|null);
        compactNameAndOriginalNamePairList?: (waves.DAppMeta.ICompactNameAndOriginalNamePair[]|null);
        originalNames?: (string[]|null);
    }

    class DAppMeta implements IDAppMeta {
        constructor(p?: waves.IDAppMeta);
        public version: number;
        public funcs: waves.DAppMeta.ICallableFuncSignature[];
        public compactNameAndOriginalNamePairList: waves.DAppMeta.ICompactNameAndOriginalNamePair[];
        public originalNames: string[];
        public static encode(m: waves.IDAppMeta, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.DAppMeta;
    }

    namespace DAppMeta {

        interface ICallableFuncSignature {
            types?: (Uint8Array|null);
        }

        class CallableFuncSignature implements ICallableFuncSignature {
            constructor(p?: waves.DAppMeta.ICallableFuncSignature);
            public types: Uint8Array;
            public static encode(m: waves.DAppMeta.ICallableFuncSignature, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.DAppMeta.CallableFuncSignature;
        }

        interface ICompactNameAndOriginalNamePair {
            compactName?: (string|null);
            originalName?: (string|null);
        }

        class CompactNameAndOriginalNamePair implements ICompactNameAndOriginalNamePair {
            constructor(p?: waves.DAppMeta.ICompactNameAndOriginalNamePair);
            public compactName: string;
            public originalName: string;
            public static encode(m: waves.DAppMeta.ICompactNameAndOriginalNamePair, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.DAppMeta.CompactNameAndOriginalNamePair;
        }
    }

    namespace node {

        namespace grpc {

            class AccountsApi extends $protobuf.rpc.Service {
                constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
                public getBalances(request: waves.node.grpc.IBalancesRequest, callback: waves.node.grpc.AccountsApi.GetBalancesCallback): void;
                public getBalances(request: waves.node.grpc.IBalancesRequest): Promise<waves.node.grpc.BalanceResponse>;
                public getScript(request: waves.node.grpc.IAccountRequest, callback: waves.node.grpc.AccountsApi.GetScriptCallback): void;
                public getScript(request: waves.node.grpc.IAccountRequest): Promise<waves.node.grpc.ScriptResponse>;
                public getActiveLeases(request: waves.node.grpc.IAccountRequest, callback: waves.node.grpc.AccountsApi.GetActiveLeasesCallback): void;
                public getActiveLeases(request: waves.node.grpc.IAccountRequest): Promise<waves.node.grpc.LeaseResponse>;
                public getDataEntries(request: waves.node.grpc.IDataRequest, callback: waves.node.grpc.AccountsApi.GetDataEntriesCallback): void;
                public getDataEntries(request: waves.node.grpc.IDataRequest): Promise<waves.node.grpc.DataEntryResponse>;
                public resolveAlias(request: google.protobuf.IStringValue, callback: waves.node.grpc.AccountsApi.ResolveAliasCallback): void;
                public resolveAlias(request: google.protobuf.IStringValue): Promise<google.protobuf.BytesValue>;
            }

            namespace AccountsApi {

                type GetBalancesCallback = (error: (Error|null), response?: waves.node.grpc.BalanceResponse) => void;

                type GetScriptCallback = (error: (Error|null), response?: waves.node.grpc.ScriptResponse) => void;

                type GetActiveLeasesCallback = (error: (Error|null), response?: waves.node.grpc.LeaseResponse) => void;

                type GetDataEntriesCallback = (error: (Error|null), response?: waves.node.grpc.DataEntryResponse) => void;

                type ResolveAliasCallback = (error: (Error|null), response?: google.protobuf.BytesValue) => void;
            }

            interface IAccountRequest {
                address?: (Uint8Array|null);
            }

            class AccountRequest implements IAccountRequest {
                constructor(p?: waves.node.grpc.IAccountRequest);
                public address: Uint8Array;
                public static encode(m: waves.node.grpc.IAccountRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.AccountRequest;
            }

            interface IDataRequest {
                address?: (Uint8Array|null);
                key?: (string|null);
            }

            class DataRequest implements IDataRequest {
                constructor(p?: waves.node.grpc.IDataRequest);
                public address: Uint8Array;
                public key: string;
                public static encode(m: waves.node.grpc.IDataRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.DataRequest;
            }

            interface IBalancesRequest {
                address?: (Uint8Array|null);
                assets?: (Uint8Array[]|null);
            }

            class BalancesRequest implements IBalancesRequest {
                constructor(p?: waves.node.grpc.IBalancesRequest);
                public address: Uint8Array;
                public assets: Uint8Array[];
                public static encode(m: waves.node.grpc.IBalancesRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.BalancesRequest;
            }

            interface IBalanceResponse {
                waves?: (waves.node.grpc.BalanceResponse.IWavesBalances|null);
                asset?: (waves.IAmount|null);
            }

            class BalanceResponse implements IBalanceResponse {
                constructor(p?: waves.node.grpc.IBalanceResponse);
                public waves?: (waves.node.grpc.BalanceResponse.IWavesBalances|null);
                public asset?: (waves.IAmount|null);
                public balance?: ("waves"|"asset");
                public static encode(m: waves.node.grpc.IBalanceResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.BalanceResponse;
            }

            namespace BalanceResponse {

                interface IWavesBalances {
                    regular?: (Long|null);
                    generating?: (Long|null);
                    available?: (Long|null);
                    effective?: (Long|null);
                    leaseIn?: (Long|null);
                    leaseOut?: (Long|null);
                }

                class WavesBalances implements IWavesBalances {
                    constructor(p?: waves.node.grpc.BalanceResponse.IWavesBalances);
                    public regular: Long;
                    public generating: Long;
                    public available: Long;
                    public effective: Long;
                    public leaseIn: Long;
                    public leaseOut: Long;
                    public static encode(m: waves.node.grpc.BalanceResponse.IWavesBalances, w?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.BalanceResponse.WavesBalances;
                }
            }

            interface IDataEntryResponse {
                address?: (Uint8Array|null);
                entry?: (waves.IDataEntry|null);
            }

            class DataEntryResponse implements IDataEntryResponse {
                constructor(p?: waves.node.grpc.IDataEntryResponse);
                public address: Uint8Array;
                public entry?: (waves.IDataEntry|null);
                public static encode(m: waves.node.grpc.IDataEntryResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.DataEntryResponse;
            }

            interface IScriptData {
                scriptBytes?: (Uint8Array|null);
                scriptText?: (string|null);
                complexity?: (Long|null);
            }

            class ScriptData implements IScriptData {
                constructor(p?: waves.node.grpc.IScriptData);
                public scriptBytes: Uint8Array;
                public scriptText: string;
                public complexity: Long;
                public static encode(m: waves.node.grpc.IScriptData, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.ScriptData;
            }

            interface IScriptResponse {
                scriptBytes?: (Uint8Array|null);
                scriptText?: (string|null);
                complexity?: (Long|null);
                publicKey?: (Uint8Array|null);
            }

            class ScriptResponse implements IScriptResponse {
                constructor(p?: waves.node.grpc.IScriptResponse);
                public scriptBytes: Uint8Array;
                public scriptText: string;
                public complexity: Long;
                public publicKey: Uint8Array;
                public static encode(m: waves.node.grpc.IScriptResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.ScriptResponse;
            }

            interface ILeaseResponse {
                leaseId?: (Uint8Array|null);
                originTransactionId?: (Uint8Array|null);
                sender?: (Uint8Array|null);
                recipient?: (waves.IRecipient|null);
                amount?: (Long|null);
                height?: (Long|null);
            }

            class LeaseResponse implements ILeaseResponse {
                constructor(p?: waves.node.grpc.ILeaseResponse);
                public leaseId: Uint8Array;
                public originTransactionId: Uint8Array;
                public sender: Uint8Array;
                public recipient?: (waves.IRecipient|null);
                public amount: Long;
                public height: Long;
                public static encode(m: waves.node.grpc.ILeaseResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.LeaseResponse;
            }

            class AssetsApi extends $protobuf.rpc.Service {
                constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
                public getInfo(request: waves.node.grpc.IAssetRequest, callback: waves.node.grpc.AssetsApi.GetInfoCallback): void;
                public getInfo(request: waves.node.grpc.IAssetRequest): Promise<waves.node.grpc.AssetInfoResponse>;
                public getNFTList(request: waves.node.grpc.INFTRequest, callback: waves.node.grpc.AssetsApi.GetNFTListCallback): void;
                public getNFTList(request: waves.node.grpc.INFTRequest): Promise<waves.node.grpc.NFTResponse>;
            }

            namespace AssetsApi {

                type GetInfoCallback = (error: (Error|null), response?: waves.node.grpc.AssetInfoResponse) => void;

                type GetNFTListCallback = (error: (Error|null), response?: waves.node.grpc.NFTResponse) => void;
            }

            interface IAssetRequest {
                assetId?: (Uint8Array|null);
            }

            class AssetRequest implements IAssetRequest {
                constructor(p?: waves.node.grpc.IAssetRequest);
                public assetId: Uint8Array;
                public static encode(m: waves.node.grpc.IAssetRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.AssetRequest;
            }

            interface INFTRequest {
                address?: (Uint8Array|null);
                limit?: (number|null);
                afterAssetId?: (Uint8Array|null);
            }

            class NFTRequest implements INFTRequest {
                constructor(p?: waves.node.grpc.INFTRequest);
                public address: Uint8Array;
                public limit: number;
                public afterAssetId: Uint8Array;
                public static encode(m: waves.node.grpc.INFTRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.NFTRequest;
            }

            interface INFTResponse {
                assetId?: (Uint8Array|null);
                assetInfo?: (waves.node.grpc.IAssetInfoResponse|null);
            }

            class NFTResponse implements INFTResponse {
                constructor(p?: waves.node.grpc.INFTResponse);
                public assetId: Uint8Array;
                public assetInfo?: (waves.node.grpc.IAssetInfoResponse|null);
                public static encode(m: waves.node.grpc.INFTResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.NFTResponse;
            }

            interface IAssetInfoResponse {
                issuer?: (Uint8Array|null);
                name?: (string|null);
                description?: (string|null);
                decimals?: (number|null);
                reissuable?: (boolean|null);
                totalVolume?: (Long|null);
                script?: (waves.node.grpc.IScriptData|null);
                sponsorship?: (Long|null);
                issueTransaction?: (waves.ISignedTransaction|null);
                sponsorBalance?: (Long|null);
                sequenceInBlock?: (number|null);
                issueHeight?: (number|null);
            }

            class AssetInfoResponse implements IAssetInfoResponse {
                constructor(p?: waves.node.grpc.IAssetInfoResponse);
                public issuer: Uint8Array;
                public name: string;
                public description: string;
                public decimals: number;
                public reissuable: boolean;
                public totalVolume: Long;
                public script?: (waves.node.grpc.IScriptData|null);
                public sponsorship: Long;
                public issueTransaction?: (waves.ISignedTransaction|null);
                public sponsorBalance: Long;
                public sequenceInBlock: number;
                public issueHeight: number;
                public static encode(m: waves.node.grpc.IAssetInfoResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.AssetInfoResponse;
            }

            class BlockchainApi extends $protobuf.rpc.Service {
                constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
                public getActivationStatus(request: waves.node.grpc.IActivationStatusRequest, callback: waves.node.grpc.BlockchainApi.GetActivationStatusCallback): void;
                public getActivationStatus(request: waves.node.grpc.IActivationStatusRequest): Promise<waves.node.grpc.ActivationStatusResponse>;
                public getBaseTarget(request: google.protobuf.IEmpty, callback: waves.node.grpc.BlockchainApi.GetBaseTargetCallback): void;
                public getBaseTarget(request: google.protobuf.IEmpty): Promise<waves.node.grpc.BaseTargetResponse>;
                public getCumulativeScore(request: google.protobuf.IEmpty, callback: waves.node.grpc.BlockchainApi.GetCumulativeScoreCallback): void;
                public getCumulativeScore(request: google.protobuf.IEmpty): Promise<waves.node.grpc.ScoreResponse>;
            }

            namespace BlockchainApi {

                type GetActivationStatusCallback = (error: (Error|null), response?: waves.node.grpc.ActivationStatusResponse) => void;

                type GetBaseTargetCallback = (error: (Error|null), response?: waves.node.grpc.BaseTargetResponse) => void;

                type GetCumulativeScoreCallback = (error: (Error|null), response?: waves.node.grpc.ScoreResponse) => void;
            }

            interface IActivationStatusRequest {
                height?: (number|null);
            }

            class ActivationStatusRequest implements IActivationStatusRequest {
                constructor(p?: waves.node.grpc.IActivationStatusRequest);
                public height: number;
                public static encode(m: waves.node.grpc.IActivationStatusRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.ActivationStatusRequest;
            }

            interface IActivationStatusResponse {
                height?: (number|null);
                votingInterval?: (number|null);
                votingThreshold?: (number|null);
                nextCheck?: (number|null);
                features?: (waves.node.grpc.IFeatureActivationStatus[]|null);
            }

            class ActivationStatusResponse implements IActivationStatusResponse {
                constructor(p?: waves.node.grpc.IActivationStatusResponse);
                public height: number;
                public votingInterval: number;
                public votingThreshold: number;
                public nextCheck: number;
                public features: waves.node.grpc.IFeatureActivationStatus[];
                public static encode(m: waves.node.grpc.IActivationStatusResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.ActivationStatusResponse;
            }

            interface IFeatureActivationStatus {
                id?: (number|null);
                description?: (string|null);
                blockchainStatus?: (waves.node.grpc.FeatureActivationStatus.BlockchainFeatureStatus|null);
                nodeStatus?: (waves.node.grpc.FeatureActivationStatus.NodeFeatureStatus|null);
                activationHeight?: (number|null);
                supportingBlocks?: (number|null);
            }

            class FeatureActivationStatus implements IFeatureActivationStatus {
                constructor(p?: waves.node.grpc.IFeatureActivationStatus);
                public id: number;
                public description: string;
                public blockchainStatus: waves.node.grpc.FeatureActivationStatus.BlockchainFeatureStatus;
                public nodeStatus: waves.node.grpc.FeatureActivationStatus.NodeFeatureStatus;
                public activationHeight: number;
                public supportingBlocks: number;
                public static encode(m: waves.node.grpc.IFeatureActivationStatus, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.FeatureActivationStatus;
            }

            namespace FeatureActivationStatus {

                enum BlockchainFeatureStatus {
                    UNDEFINED = 0,
                    APPROVED = 1,
                    ACTIVATED = 2
                }

                enum NodeFeatureStatus {
                    NOT_IMPLEMENTED = 0,
                    IMPLEMENTED = 1,
                    VOTED = 2
                }
            }

            interface IBaseTargetResponse {
                baseTarget?: (Long|null);
            }

            class BaseTargetResponse implements IBaseTargetResponse {
                constructor(p?: waves.node.grpc.IBaseTargetResponse);
                public baseTarget: Long;
                public static encode(m: waves.node.grpc.IBaseTargetResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.BaseTargetResponse;
            }

            interface IScoreResponse {
                score?: (Uint8Array|null);
            }

            class ScoreResponse implements IScoreResponse {
                constructor(p?: waves.node.grpc.IScoreResponse);
                public score: Uint8Array;
                public static encode(m: waves.node.grpc.IScoreResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.ScoreResponse;
            }

            class BlocksApi extends $protobuf.rpc.Service {
                constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
                public getBlock(request: waves.node.grpc.IBlockRequest, callback: waves.node.grpc.BlocksApi.GetBlockCallback): void;
                public getBlock(request: waves.node.grpc.IBlockRequest): Promise<waves.node.grpc.BlockWithHeight>;
                public getBlockRange(request: waves.node.grpc.IBlockRangeRequest, callback: waves.node.grpc.BlocksApi.GetBlockRangeCallback): void;
                public getBlockRange(request: waves.node.grpc.IBlockRangeRequest): Promise<waves.node.grpc.BlockWithHeight>;
                public getCurrentHeight(request: google.protobuf.IEmpty, callback: waves.node.grpc.BlocksApi.GetCurrentHeightCallback): void;
                public getCurrentHeight(request: google.protobuf.IEmpty): Promise<google.protobuf.UInt32Value>;
            }

            namespace BlocksApi {

                type GetBlockCallback = (error: (Error|null), response?: waves.node.grpc.BlockWithHeight) => void;

                type GetBlockRangeCallback = (error: (Error|null), response?: waves.node.grpc.BlockWithHeight) => void;

                type GetCurrentHeightCallback = (error: (Error|null), response?: google.protobuf.UInt32Value) => void;
            }

            interface IBlockRequest {
                blockId?: (Uint8Array|null);
                height?: (number|null);
                includeTransactions?: (boolean|null);
            }

            class BlockRequest implements IBlockRequest {
                constructor(p?: waves.node.grpc.IBlockRequest);
                public blockId: Uint8Array;
                public height: number;
                public includeTransactions: boolean;
                public request?: ("blockId"|"height");
                public static encode(m: waves.node.grpc.IBlockRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.BlockRequest;
            }

            interface IBlockRangeRequest {
                fromHeight?: (number|null);
                toHeight?: (number|null);
                generatorPublicKey?: (Uint8Array|null);
                generatorAddress?: (Uint8Array|null);
                includeTransactions?: (boolean|null);
            }

            class BlockRangeRequest implements IBlockRangeRequest {
                constructor(p?: waves.node.grpc.IBlockRangeRequest);
                public fromHeight: number;
                public toHeight: number;
                public generatorPublicKey: Uint8Array;
                public generatorAddress: Uint8Array;
                public includeTransactions: boolean;
                public filter?: ("generatorPublicKey"|"generatorAddress");
                public static encode(m: waves.node.grpc.IBlockRangeRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.BlockRangeRequest;
            }

            interface IBlockWithHeight {
                block?: (waves.IBlock|null);
                height?: (number|null);
                vrf?: (Uint8Array|null);
                rewardShares?: (waves.IRewardShare[]|null);
            }

            class BlockWithHeight implements IBlockWithHeight {
                constructor(p?: waves.node.grpc.IBlockWithHeight);
                public block?: (waves.IBlock|null);
                public height: number;
                public vrf: Uint8Array;
                public rewardShares: waves.IRewardShare[];
                public static encode(m: waves.node.grpc.IBlockWithHeight, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.BlockWithHeight;
            }

            class TransactionsApi extends $protobuf.rpc.Service {
                constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
                public getTransactions(request: waves.node.grpc.ITransactionsRequest, callback: waves.node.grpc.TransactionsApi.GetTransactionsCallback): void;
                public getTransactions(request: waves.node.grpc.ITransactionsRequest): Promise<waves.node.grpc.TransactionResponse>;
                public getTransactionSnapshots(request: waves.node.grpc.ITransactionSnapshotsRequest, callback: waves.node.grpc.TransactionsApi.GetTransactionSnapshotsCallback): void;
                public getTransactionSnapshots(request: waves.node.grpc.ITransactionSnapshotsRequest): Promise<waves.node.grpc.TransactionSnapshotResponse>;
                public getStateChanges(request: waves.node.grpc.ITransactionsRequest, callback: waves.node.grpc.TransactionsApi.GetStateChangesCallback): void;
                public getStateChanges(request: waves.node.grpc.ITransactionsRequest): Promise<waves.node.grpc.InvokeScriptResultResponse>;
                public getStatuses(request: waves.node.grpc.ITransactionsByIdRequest, callback: waves.node.grpc.TransactionsApi.GetStatusesCallback): void;
                public getStatuses(request: waves.node.grpc.ITransactionsByIdRequest): Promise<waves.node.grpc.TransactionStatus>;
                public getUnconfirmed(request: waves.node.grpc.ITransactionsRequest, callback: waves.node.grpc.TransactionsApi.GetUnconfirmedCallback): void;
                public getUnconfirmed(request: waves.node.grpc.ITransactionsRequest): Promise<waves.node.grpc.TransactionResponse>;
                public sign(request: waves.node.grpc.ISignRequest, callback: waves.node.grpc.TransactionsApi.SignCallback): void;
                public sign(request: waves.node.grpc.ISignRequest): Promise<waves.SignedTransaction>;
                public broadcast(request: waves.ISignedTransaction, callback: waves.node.grpc.TransactionsApi.BroadcastCallback): void;
                public broadcast(request: waves.ISignedTransaction): Promise<waves.SignedTransaction>;
            }

            namespace TransactionsApi {

                type GetTransactionsCallback = (error: (Error|null), response?: waves.node.grpc.TransactionResponse) => void;

                type GetTransactionSnapshotsCallback = (error: (Error|null), response?: waves.node.grpc.TransactionSnapshotResponse) => void;

                type GetStateChangesCallback = (error: (Error|null), response?: waves.node.grpc.InvokeScriptResultResponse) => void;

                type GetStatusesCallback = (error: (Error|null), response?: waves.node.grpc.TransactionStatus) => void;

                type GetUnconfirmedCallback = (error: (Error|null), response?: waves.node.grpc.TransactionResponse) => void;

                type SignCallback = (error: (Error|null), response?: waves.SignedTransaction) => void;

                type BroadcastCallback = (error: (Error|null), response?: waves.SignedTransaction) => void;
            }

            enum ApplicationStatus {
                UNKNOWN = 0,
                SUCCEEDED = 1,
                SCRIPT_EXECUTION_FAILED = 2,
                ELIDED = 3
            }

            interface ITransactionStatus {
                id?: (Uint8Array|null);
                status?: (waves.node.grpc.TransactionStatus.Status|null);
                height?: (Long|null);
                applicationStatus?: (waves.node.grpc.ApplicationStatus|null);
            }

            class TransactionStatus implements ITransactionStatus {
                constructor(p?: waves.node.grpc.ITransactionStatus);
                public id: Uint8Array;
                public status: waves.node.grpc.TransactionStatus.Status;
                public height: Long;
                public applicationStatus: waves.node.grpc.ApplicationStatus;
                public static encode(m: waves.node.grpc.ITransactionStatus, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.TransactionStatus;
            }

            namespace TransactionStatus {

                enum Status {
                    NOT_EXISTS = 0,
                    UNCONFIRMED = 1,
                    CONFIRMED = 2
                }
            }

            interface ITransactionResponse {
                id?: (Uint8Array|null);
                height?: (Long|null);
                transaction?: (waves.ISignedTransaction|null);
                applicationStatus?: (waves.node.grpc.ApplicationStatus|null);
                invokeScriptResult?: (waves.IInvokeScriptResult|null);
            }

            class TransactionResponse implements ITransactionResponse {
                constructor(p?: waves.node.grpc.ITransactionResponse);
                public id: Uint8Array;
                public height: Long;
                public transaction?: (waves.ISignedTransaction|null);
                public applicationStatus: waves.node.grpc.ApplicationStatus;
                public invokeScriptResult?: (waves.IInvokeScriptResult|null);
                public static encode(m: waves.node.grpc.ITransactionResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.TransactionResponse;
            }

            interface ITransactionsRequest {
                sender?: (Uint8Array|null);
                recipient?: (waves.IRecipient|null);
                transactionIds?: (Uint8Array[]|null);
            }

            class TransactionsRequest implements ITransactionsRequest {
                constructor(p?: waves.node.grpc.ITransactionsRequest);
                public sender: Uint8Array;
                public recipient?: (waves.IRecipient|null);
                public transactionIds: Uint8Array[];
                public static encode(m: waves.node.grpc.ITransactionsRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.TransactionsRequest;
            }

            interface ITransactionSnapshotResponse {
                id?: (Uint8Array|null);
                snapshot?: (waves.ITransactionStateSnapshot|null);
            }

            class TransactionSnapshotResponse implements ITransactionSnapshotResponse {
                constructor(p?: waves.node.grpc.ITransactionSnapshotResponse);
                public id: Uint8Array;
                public snapshot?: (waves.ITransactionStateSnapshot|null);
                public static encode(m: waves.node.grpc.ITransactionSnapshotResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.TransactionSnapshotResponse;
            }

            interface ITransactionSnapshotsRequest {
                transactionIds?: (Uint8Array[]|null);
            }

            class TransactionSnapshotsRequest implements ITransactionSnapshotsRequest {
                constructor(p?: waves.node.grpc.ITransactionSnapshotsRequest);
                public transactionIds: Uint8Array[];
                public static encode(m: waves.node.grpc.ITransactionSnapshotsRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.TransactionSnapshotsRequest;
            }

            interface ITransactionsByIdRequest {
                transactionIds?: (Uint8Array[]|null);
            }

            class TransactionsByIdRequest implements ITransactionsByIdRequest {
                constructor(p?: waves.node.grpc.ITransactionsByIdRequest);
                public transactionIds: Uint8Array[];
                public static encode(m: waves.node.grpc.ITransactionsByIdRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.TransactionsByIdRequest;
            }

            interface ICalculateFeeResponse {
                assetId?: (Uint8Array|null);
                amount?: (Long|null);
            }

            class CalculateFeeResponse implements ICalculateFeeResponse {
                constructor(p?: waves.node.grpc.ICalculateFeeResponse);
                public assetId: Uint8Array;
                public amount: Long;
                public static encode(m: waves.node.grpc.ICalculateFeeResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.CalculateFeeResponse;
            }

            interface ISignRequest {
                transaction?: (waves.ITransaction|null);
                signerPublicKey?: (Uint8Array|null);
            }

            class SignRequest implements ISignRequest {
                constructor(p?: waves.node.grpc.ISignRequest);
                public transaction?: (waves.ITransaction|null);
                public signerPublicKey: Uint8Array;
                public static encode(m: waves.node.grpc.ISignRequest, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.SignRequest;
            }

            interface IInvokeScriptResultResponse {
                transaction?: (waves.ISignedTransaction|null);
                result?: (waves.IInvokeScriptResult|null);
            }

            class InvokeScriptResultResponse implements IInvokeScriptResultResponse {
                constructor(p?: waves.node.grpc.IInvokeScriptResultResponse);
                public transaction?: (waves.ISignedTransaction|null);
                public result?: (waves.IInvokeScriptResult|null);
                public static encode(m: waves.node.grpc.IInvokeScriptResultResponse, w?: $protobuf.Writer): $protobuf.Writer;
                public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.node.grpc.InvokeScriptResultResponse;
            }
        }
    }

    interface IAssetPair {
        amountAssetId?: (Uint8Array|null);
        priceAssetId?: (Uint8Array|null);
    }

    class AssetPair implements IAssetPair {
        constructor(p?: waves.IAssetPair);
        public amountAssetId: Uint8Array;
        public priceAssetId: Uint8Array;
        public static encode(m: waves.IAssetPair, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.AssetPair;
    }

    interface IOrder {
        chainId?: (number|null);
        matcherPublicKey?: (Uint8Array|null);
        assetPair?: (waves.IAssetPair|null);
        orderSide?: (waves.Order.Side|null);
        amount?: (Long|null);
        price?: (Long|null);
        timestamp?: (Long|null);
        expiration?: (Long|null);
        matcherFee?: (waves.IAmount|null);
        version?: (number|null);
        proofs?: (Uint8Array[]|null);
        priceMode?: (waves.Order.PriceMode|null);
        attachment?: (Uint8Array|null);
        senderPublicKey?: (Uint8Array|null);
        eip712Signature?: (Uint8Array|null);
    }

    class Order implements IOrder {
        constructor(p?: waves.IOrder);
        public chainId: number;
        public matcherPublicKey: Uint8Array;
        public assetPair?: (waves.IAssetPair|null);
        public orderSide: waves.Order.Side;
        public amount: Long;
        public price: Long;
        public timestamp: Long;
        public expiration: Long;
        public matcherFee?: (waves.IAmount|null);
        public version: number;
        public proofs: Uint8Array[];
        public priceMode: waves.Order.PriceMode;
        public attachment: Uint8Array;
        public senderPublicKey: Uint8Array;
        public eip712Signature: Uint8Array;
        public sender?: ("senderPublicKey"|"eip712Signature");
        public static encode(m: waves.IOrder, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.Order;
    }

    namespace Order {

        enum Side {
            BUY = 0,
            SELL = 1
        }

        enum PriceMode {
            DEFAULT = 0,
            FIXED_DECIMALS = 1,
            ASSET_DECIMALS = 2
        }
    }

    interface IRecipient {
        publicKeyHash?: (Uint8Array|null);
        alias?: (string|null);
    }

    class Recipient implements IRecipient {
        constructor(p?: waves.IRecipient);
        public publicKeyHash: Uint8Array;
        public alias: string;
        public recipient?: ("publicKeyHash"|"alias");
        public static encode(m: waves.IRecipient, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.Recipient;
    }

    interface IRewardShare {
        address?: (Uint8Array|null);
        reward?: (Long|null);
    }

    class RewardShare implements IRewardShare {
        constructor(p?: waves.IRewardShare);
        public address: Uint8Array;
        public reward: Long;
        public static encode(m: waves.IRewardShare, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.RewardShare;
    }

    interface IBlockSnapshot {
        blockId?: (Uint8Array|null);
        snapshots?: (waves.ITransactionStateSnapshot[]|null);
    }

    class BlockSnapshot implements IBlockSnapshot {
        constructor(p?: waves.IBlockSnapshot);
        public blockId: Uint8Array;
        public snapshots: waves.ITransactionStateSnapshot[];
        public static encode(m: waves.IBlockSnapshot, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.BlockSnapshot;
    }

    interface IMicroBlockSnapshot {
        totalBlockId?: (Uint8Array|null);
        snapshots?: (waves.ITransactionStateSnapshot[]|null);
    }

    class MicroBlockSnapshot implements IMicroBlockSnapshot {
        constructor(p?: waves.IMicroBlockSnapshot);
        public totalBlockId: Uint8Array;
        public snapshots: waves.ITransactionStateSnapshot[];
        public static encode(m: waves.IMicroBlockSnapshot, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.MicroBlockSnapshot;
    }

    interface ITransactionStateSnapshot {
        balances?: (waves.TransactionStateSnapshot.IBalance[]|null);
        leaseBalances?: (waves.TransactionStateSnapshot.ILeaseBalance[]|null);
        newLeases?: (waves.TransactionStateSnapshot.INewLease[]|null);
        cancelledLeases?: (waves.TransactionStateSnapshot.ICancelledLease[]|null);
        assetStatics?: (waves.TransactionStateSnapshot.INewAsset[]|null);
        assetVolumes?: (waves.TransactionStateSnapshot.IAssetVolume[]|null);
        assetNamesAndDescriptions?: (waves.TransactionStateSnapshot.IAssetNameAndDescription[]|null);
        assetScripts?: (waves.TransactionStateSnapshot.IAssetScript|null);
        aliases?: (waves.TransactionStateSnapshot.IAlias|null);
        orderFills?: (waves.TransactionStateSnapshot.IOrderFill[]|null);
        accountScripts?: (waves.TransactionStateSnapshot.IAccountScript|null);
        accountData?: (waves.TransactionStateSnapshot.IAccountData[]|null);
        sponsorships?: (waves.TransactionStateSnapshot.ISponsorship[]|null);
        transactionStatus?: (waves.TransactionStatus|null);
    }

    class TransactionStateSnapshot implements ITransactionStateSnapshot {
        constructor(p?: waves.ITransactionStateSnapshot);
        public balances: waves.TransactionStateSnapshot.IBalance[];
        public leaseBalances: waves.TransactionStateSnapshot.ILeaseBalance[];
        public newLeases: waves.TransactionStateSnapshot.INewLease[];
        public cancelledLeases: waves.TransactionStateSnapshot.ICancelledLease[];
        public assetStatics: waves.TransactionStateSnapshot.INewAsset[];
        public assetVolumes: waves.TransactionStateSnapshot.IAssetVolume[];
        public assetNamesAndDescriptions: waves.TransactionStateSnapshot.IAssetNameAndDescription[];
        public assetScripts?: (waves.TransactionStateSnapshot.IAssetScript|null);
        public aliases?: (waves.TransactionStateSnapshot.IAlias|null);
        public orderFills: waves.TransactionStateSnapshot.IOrderFill[];
        public accountScripts?: (waves.TransactionStateSnapshot.IAccountScript|null);
        public accountData: waves.TransactionStateSnapshot.IAccountData[];
        public sponsorships: waves.TransactionStateSnapshot.ISponsorship[];
        public transactionStatus: waves.TransactionStatus;
        public static encode(m: waves.ITransactionStateSnapshot, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot;
    }

    namespace TransactionStateSnapshot {

        interface IBalance {
            address?: (Uint8Array|null);
            amount?: (waves.IAmount|null);
        }

        class Balance implements IBalance {
            constructor(p?: waves.TransactionStateSnapshot.IBalance);
            public address: Uint8Array;
            public amount?: (waves.IAmount|null);
            public static encode(m: waves.TransactionStateSnapshot.IBalance, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.Balance;
        }

        interface ILeaseBalance {
            address?: (Uint8Array|null);
            "in"?: (Long|null);
            out?: (Long|null);
        }

        class LeaseBalance implements ILeaseBalance {
            constructor(p?: waves.TransactionStateSnapshot.ILeaseBalance);
            public address: Uint8Array;
            public in: Long;
            public out: Long;
            public static encode(m: waves.TransactionStateSnapshot.ILeaseBalance, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.LeaseBalance;
        }

        interface INewLease {
            leaseId?: (Uint8Array|null);
            senderPublicKey?: (Uint8Array|null);
            recipientAddress?: (Uint8Array|null);
            amount?: (Long|null);
        }

        class NewLease implements INewLease {
            constructor(p?: waves.TransactionStateSnapshot.INewLease);
            public leaseId: Uint8Array;
            public senderPublicKey: Uint8Array;
            public recipientAddress: Uint8Array;
            public amount: Long;
            public static encode(m: waves.TransactionStateSnapshot.INewLease, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.NewLease;
        }

        interface ICancelledLease {
            leaseId?: (Uint8Array|null);
        }

        class CancelledLease implements ICancelledLease {
            constructor(p?: waves.TransactionStateSnapshot.ICancelledLease);
            public leaseId: Uint8Array;
            public static encode(m: waves.TransactionStateSnapshot.ICancelledLease, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.CancelledLease;
        }

        interface INewAsset {
            assetId?: (Uint8Array|null);
            issuerPublicKey?: (Uint8Array|null);
            decimals?: (number|null);
            nft?: (boolean|null);
        }

        class NewAsset implements INewAsset {
            constructor(p?: waves.TransactionStateSnapshot.INewAsset);
            public assetId: Uint8Array;
            public issuerPublicKey: Uint8Array;
            public decimals: number;
            public nft: boolean;
            public static encode(m: waves.TransactionStateSnapshot.INewAsset, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.NewAsset;
        }

        interface IAssetVolume {
            assetId?: (Uint8Array|null);
            reissuable?: (boolean|null);
            volume?: (Uint8Array|null);
        }

        class AssetVolume implements IAssetVolume {
            constructor(p?: waves.TransactionStateSnapshot.IAssetVolume);
            public assetId: Uint8Array;
            public reissuable: boolean;
            public volume: Uint8Array;
            public static encode(m: waves.TransactionStateSnapshot.IAssetVolume, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.AssetVolume;
        }

        interface IAssetNameAndDescription {
            assetId?: (Uint8Array|null);
            name?: (string|null);
            description?: (string|null);
        }

        class AssetNameAndDescription implements IAssetNameAndDescription {
            constructor(p?: waves.TransactionStateSnapshot.IAssetNameAndDescription);
            public assetId: Uint8Array;
            public name: string;
            public description: string;
            public static encode(m: waves.TransactionStateSnapshot.IAssetNameAndDescription, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.AssetNameAndDescription;
        }

        interface IAssetScript {
            assetId?: (Uint8Array|null);
            script?: (Uint8Array|null);
        }

        class AssetScript implements IAssetScript {
            constructor(p?: waves.TransactionStateSnapshot.IAssetScript);
            public assetId: Uint8Array;
            public script: Uint8Array;
            public static encode(m: waves.TransactionStateSnapshot.IAssetScript, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.AssetScript;
        }

        interface IAlias {
            address?: (Uint8Array|null);
            alias?: (string|null);
        }

        class Alias implements IAlias {
            constructor(p?: waves.TransactionStateSnapshot.IAlias);
            public address: Uint8Array;
            public alias: string;
            public static encode(m: waves.TransactionStateSnapshot.IAlias, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.Alias;
        }

        interface IOrderFill {
            orderId?: (Uint8Array|null);
            volume?: (Long|null);
            fee?: (Long|null);
        }

        class OrderFill implements IOrderFill {
            constructor(p?: waves.TransactionStateSnapshot.IOrderFill);
            public orderId: Uint8Array;
            public volume: Long;
            public fee: Long;
            public static encode(m: waves.TransactionStateSnapshot.IOrderFill, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.OrderFill;
        }

        interface IAccountScript {
            senderPublicKey?: (Uint8Array|null);
            script?: (Uint8Array|null);
            verifierComplexity?: (Long|null);
        }

        class AccountScript implements IAccountScript {
            constructor(p?: waves.TransactionStateSnapshot.IAccountScript);
            public senderPublicKey: Uint8Array;
            public script: Uint8Array;
            public verifierComplexity: Long;
            public static encode(m: waves.TransactionStateSnapshot.IAccountScript, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.AccountScript;
        }

        interface IAccountData {
            address?: (Uint8Array|null);
            entries?: (waves.IDataEntry[]|null);
        }

        class AccountData implements IAccountData {
            constructor(p?: waves.TransactionStateSnapshot.IAccountData);
            public address: Uint8Array;
            public entries: waves.IDataEntry[];
            public static encode(m: waves.TransactionStateSnapshot.IAccountData, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.AccountData;
        }

        interface ISponsorship {
            assetId?: (Uint8Array|null);
            minFee?: (Long|null);
        }

        class Sponsorship implements ISponsorship {
            constructor(p?: waves.TransactionStateSnapshot.ISponsorship);
            public assetId: Uint8Array;
            public minFee: Long;
            public static encode(m: waves.TransactionStateSnapshot.ISponsorship, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransactionStateSnapshot.Sponsorship;
        }
    }

    enum TransactionStatus {
        SUCCEEDED = 0,
        FAILED = 1,
        ELIDED = 2
    }

    interface ISignedTransaction {
        wavesTransaction?: (waves.ITransaction|null);
        ethereumTransaction?: (Uint8Array|null);
        proofs?: (Uint8Array[]|null);
    }

    class SignedTransaction implements ISignedTransaction {
        constructor(p?: waves.ISignedTransaction);
        public wavesTransaction?: (waves.ITransaction|null);
        public ethereumTransaction: Uint8Array;
        public proofs: Uint8Array[];
        public transaction?: ("wavesTransaction"|"ethereumTransaction");
        public static encode(m: waves.ISignedTransaction, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.SignedTransaction;
    }

    interface ITransaction {
        chainId?: (number|null);
        senderPublicKey?: (Uint8Array|null);
        fee?: (waves.IAmount|null);
        timestamp?: (Long|null);
        version?: (number|null);
        genesis?: (waves.IGenesisTransactionData|null);
        payment?: (waves.IPaymentTransactionData|null);
        issue?: (waves.IIssueTransactionData|null);
        transfer?: (waves.ITransferTransactionData|null);
        reissue?: (waves.IReissueTransactionData|null);
        burn?: (waves.IBurnTransactionData|null);
        exchange?: (waves.IExchangeTransactionData|null);
        lease?: (waves.ILeaseTransactionData|null);
        leaseCancel?: (waves.ILeaseCancelTransactionData|null);
        createAlias?: (waves.ICreateAliasTransactionData|null);
        massTransfer?: (waves.IMassTransferTransactionData|null);
        dataTransaction?: (waves.IDataTransactionData|null);
        setScript?: (waves.ISetScriptTransactionData|null);
        sponsorFee?: (waves.ISponsorFeeTransactionData|null);
        setAssetScript?: (waves.ISetAssetScriptTransactionData|null);
        invokeScript?: (waves.IInvokeScriptTransactionData|null);
        updateAssetInfo?: (waves.IUpdateAssetInfoTransactionData|null);
        invokeExpression?: (waves.IInvokeExpressionTransactionData|null);
    }

    class Transaction implements ITransaction {
        constructor(p?: waves.ITransaction);
        public chainId: number;
        public senderPublicKey: Uint8Array;
        public fee?: (waves.IAmount|null);
        public timestamp: Long;
        public version: number;
        public genesis?: (waves.IGenesisTransactionData|null);
        public payment?: (waves.IPaymentTransactionData|null);
        public issue?: (waves.IIssueTransactionData|null);
        public transfer?: (waves.ITransferTransactionData|null);
        public reissue?: (waves.IReissueTransactionData|null);
        public burn?: (waves.IBurnTransactionData|null);
        public exchange?: (waves.IExchangeTransactionData|null);
        public lease?: (waves.ILeaseTransactionData|null);
        public leaseCancel?: (waves.ILeaseCancelTransactionData|null);
        public createAlias?: (waves.ICreateAliasTransactionData|null);
        public massTransfer?: (waves.IMassTransferTransactionData|null);
        public dataTransaction?: (waves.IDataTransactionData|null);
        public setScript?: (waves.ISetScriptTransactionData|null);
        public sponsorFee?: (waves.ISponsorFeeTransactionData|null);
        public setAssetScript?: (waves.ISetAssetScriptTransactionData|null);
        public invokeScript?: (waves.IInvokeScriptTransactionData|null);
        public updateAssetInfo?: (waves.IUpdateAssetInfoTransactionData|null);
        public invokeExpression?: (waves.IInvokeExpressionTransactionData|null);
        public data?: ("genesis"|"payment"|"issue"|"transfer"|"reissue"|"burn"|"exchange"|"lease"|"leaseCancel"|"createAlias"|"massTransfer"|"dataTransaction"|"setScript"|"sponsorFee"|"setAssetScript"|"invokeScript"|"updateAssetInfo"|"invokeExpression");
        public static encode(m: waves.ITransaction, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.Transaction;
    }

    interface IGenesisTransactionData {
        recipientAddress?: (Uint8Array|null);
        amount?: (Long|null);
    }

    class GenesisTransactionData implements IGenesisTransactionData {
        constructor(p?: waves.IGenesisTransactionData);
        public recipientAddress: Uint8Array;
        public amount: Long;
        public static encode(m: waves.IGenesisTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.GenesisTransactionData;
    }

    interface IPaymentTransactionData {
        recipientAddress?: (Uint8Array|null);
        amount?: (Long|null);
    }

    class PaymentTransactionData implements IPaymentTransactionData {
        constructor(p?: waves.IPaymentTransactionData);
        public recipientAddress: Uint8Array;
        public amount: Long;
        public static encode(m: waves.IPaymentTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.PaymentTransactionData;
    }

    interface ITransferTransactionData {
        recipient?: (waves.IRecipient|null);
        amount?: (waves.IAmount|null);
        attachment?: (Uint8Array|null);
    }

    class TransferTransactionData implements ITransferTransactionData {
        constructor(p?: waves.ITransferTransactionData);
        public recipient?: (waves.IRecipient|null);
        public amount?: (waves.IAmount|null);
        public attachment: Uint8Array;
        public static encode(m: waves.ITransferTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.TransferTransactionData;
    }

    interface ICreateAliasTransactionData {
        alias?: (string|null);
    }

    class CreateAliasTransactionData implements ICreateAliasTransactionData {
        constructor(p?: waves.ICreateAliasTransactionData);
        public alias: string;
        public static encode(m: waves.ICreateAliasTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.CreateAliasTransactionData;
    }

    interface IDataEntry {
        key?: (string|null);
        intValue?: (Long|null);
        boolValue?: (boolean|null);
        binaryValue?: (Uint8Array|null);
        stringValue?: (string|null);
    }

    class DataEntry implements IDataEntry {
        constructor(p?: waves.IDataEntry);
        public key: string;
        public intValue: Long;
        public boolValue: boolean;
        public binaryValue: Uint8Array;
        public stringValue: string;
        public value?: ("intValue"|"boolValue"|"binaryValue"|"stringValue");
        public static encode(m: waves.IDataEntry, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.DataEntry;
    }

    interface IDataTransactionData {
        data?: (waves.IDataEntry[]|null);
    }

    class DataTransactionData implements IDataTransactionData {
        constructor(p?: waves.IDataTransactionData);
        public data: waves.IDataEntry[];
        public static encode(m: waves.IDataTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.DataTransactionData;
    }

    interface IMassTransferTransactionData {
        assetId?: (Uint8Array|null);
        transfers?: (waves.MassTransferTransactionData.ITransfer[]|null);
        attachment?: (Uint8Array|null);
    }

    class MassTransferTransactionData implements IMassTransferTransactionData {
        constructor(p?: waves.IMassTransferTransactionData);
        public assetId: Uint8Array;
        public transfers: waves.MassTransferTransactionData.ITransfer[];
        public attachment: Uint8Array;
        public static encode(m: waves.IMassTransferTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.MassTransferTransactionData;
    }

    namespace MassTransferTransactionData {

        interface ITransfer {
            recipient?: (waves.IRecipient|null);
            amount?: (Long|null);
        }

        class Transfer implements ITransfer {
            constructor(p?: waves.MassTransferTransactionData.ITransfer);
            public recipient?: (waves.IRecipient|null);
            public amount: Long;
            public static encode(m: waves.MassTransferTransactionData.ITransfer, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.MassTransferTransactionData.Transfer;
        }
    }

    interface ILeaseTransactionData {
        recipient?: (waves.IRecipient|null);
        amount?: (Long|null);
    }

    class LeaseTransactionData implements ILeaseTransactionData {
        constructor(p?: waves.ILeaseTransactionData);
        public recipient?: (waves.IRecipient|null);
        public amount: Long;
        public static encode(m: waves.ILeaseTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.LeaseTransactionData;
    }

    interface ILeaseCancelTransactionData {
        leaseId?: (Uint8Array|null);
    }

    class LeaseCancelTransactionData implements ILeaseCancelTransactionData {
        constructor(p?: waves.ILeaseCancelTransactionData);
        public leaseId: Uint8Array;
        public static encode(m: waves.ILeaseCancelTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.LeaseCancelTransactionData;
    }

    interface IBurnTransactionData {
        assetAmount?: (waves.IAmount|null);
    }

    class BurnTransactionData implements IBurnTransactionData {
        constructor(p?: waves.IBurnTransactionData);
        public assetAmount?: (waves.IAmount|null);
        public static encode(m: waves.IBurnTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.BurnTransactionData;
    }

    interface IIssueTransactionData {
        name?: (string|null);
        description?: (string|null);
        amount?: (Long|null);
        decimals?: (number|null);
        reissuable?: (boolean|null);
        script?: (Uint8Array|null);
    }

    class IssueTransactionData implements IIssueTransactionData {
        constructor(p?: waves.IIssueTransactionData);
        public name: string;
        public description: string;
        public amount: Long;
        public decimals: number;
        public reissuable: boolean;
        public script: Uint8Array;
        public static encode(m: waves.IIssueTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.IssueTransactionData;
    }

    interface IReissueTransactionData {
        assetAmount?: (waves.IAmount|null);
        reissuable?: (boolean|null);
    }

    class ReissueTransactionData implements IReissueTransactionData {
        constructor(p?: waves.IReissueTransactionData);
        public assetAmount?: (waves.IAmount|null);
        public reissuable: boolean;
        public static encode(m: waves.IReissueTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.ReissueTransactionData;
    }

    interface ISetAssetScriptTransactionData {
        assetId?: (Uint8Array|null);
        script?: (Uint8Array|null);
    }

    class SetAssetScriptTransactionData implements ISetAssetScriptTransactionData {
        constructor(p?: waves.ISetAssetScriptTransactionData);
        public assetId: Uint8Array;
        public script: Uint8Array;
        public static encode(m: waves.ISetAssetScriptTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.SetAssetScriptTransactionData;
    }

    interface ISetScriptTransactionData {
        script?: (Uint8Array|null);
    }

    class SetScriptTransactionData implements ISetScriptTransactionData {
        constructor(p?: waves.ISetScriptTransactionData);
        public script: Uint8Array;
        public static encode(m: waves.ISetScriptTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.SetScriptTransactionData;
    }

    interface IExchangeTransactionData {
        amount?: (Long|null);
        price?: (Long|null);
        buyMatcherFee?: (Long|null);
        sellMatcherFee?: (Long|null);
        orders?: (waves.IOrder[]|null);
    }

    class ExchangeTransactionData implements IExchangeTransactionData {
        constructor(p?: waves.IExchangeTransactionData);
        public amount: Long;
        public price: Long;
        public buyMatcherFee: Long;
        public sellMatcherFee: Long;
        public orders: waves.IOrder[];
        public static encode(m: waves.IExchangeTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.ExchangeTransactionData;
    }

    interface ISponsorFeeTransactionData {
        minFee?: (waves.IAmount|null);
    }

    class SponsorFeeTransactionData implements ISponsorFeeTransactionData {
        constructor(p?: waves.ISponsorFeeTransactionData);
        public minFee?: (waves.IAmount|null);
        public static encode(m: waves.ISponsorFeeTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.SponsorFeeTransactionData;
    }

    interface IInvokeScriptTransactionData {
        dApp?: (waves.IRecipient|null);
        functionCall?: (Uint8Array|null);
        payments?: (waves.IAmount[]|null);
    }

    class InvokeScriptTransactionData implements IInvokeScriptTransactionData {
        constructor(p?: waves.IInvokeScriptTransactionData);
        public dApp?: (waves.IRecipient|null);
        public functionCall: Uint8Array;
        public payments: waves.IAmount[];
        public static encode(m: waves.IInvokeScriptTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeScriptTransactionData;
    }

    interface IUpdateAssetInfoTransactionData {
        assetId?: (Uint8Array|null);
        name?: (string|null);
        description?: (string|null);
    }

    class UpdateAssetInfoTransactionData implements IUpdateAssetInfoTransactionData {
        constructor(p?: waves.IUpdateAssetInfoTransactionData);
        public assetId: Uint8Array;
        public name: string;
        public description: string;
        public static encode(m: waves.IUpdateAssetInfoTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.UpdateAssetInfoTransactionData;
    }

    interface IInvokeExpressionTransactionData {
        expression?: (Uint8Array|null);
    }

    class InvokeExpressionTransactionData implements IInvokeExpressionTransactionData {
        constructor(p?: waves.IInvokeExpressionTransactionData);
        public expression: Uint8Array;
        public static encode(m: waves.IInvokeExpressionTransactionData, w?: $protobuf.Writer): $protobuf.Writer;
        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): waves.InvokeExpressionTransactionData;
    }
}

export namespace google {

    namespace protobuf {

        interface IDoubleValue {
            value?: (number|null);
        }

        class DoubleValue implements IDoubleValue {
            constructor(p?: google.protobuf.IDoubleValue);
            public value: number;
            public static encode(m: google.protobuf.IDoubleValue, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.DoubleValue;
        }

        interface IFloatValue {
            value?: (number|null);
        }

        class FloatValue implements IFloatValue {
            constructor(p?: google.protobuf.IFloatValue);
            public value: number;
            public static encode(m: google.protobuf.IFloatValue, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.FloatValue;
        }

        interface IInt64Value {
            value?: (Long|null);
        }

        class Int64Value implements IInt64Value {
            constructor(p?: google.protobuf.IInt64Value);
            public value: Long;
            public static encode(m: google.protobuf.IInt64Value, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.Int64Value;
        }

        interface IUInt64Value {
            value?: (Long|null);
        }

        class UInt64Value implements IUInt64Value {
            constructor(p?: google.protobuf.IUInt64Value);
            public value: Long;
            public static encode(m: google.protobuf.IUInt64Value, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.UInt64Value;
        }

        interface IInt32Value {
            value?: (number|null);
        }

        class Int32Value implements IInt32Value {
            constructor(p?: google.protobuf.IInt32Value);
            public value: number;
            public static encode(m: google.protobuf.IInt32Value, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.Int32Value;
        }

        interface IUInt32Value {
            value?: (number|null);
        }

        class UInt32Value implements IUInt32Value {
            constructor(p?: google.protobuf.IUInt32Value);
            public value: number;
            public static encode(m: google.protobuf.IUInt32Value, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.UInt32Value;
        }

        interface IBoolValue {
            value?: (boolean|null);
        }

        class BoolValue implements IBoolValue {
            constructor(p?: google.protobuf.IBoolValue);
            public value: boolean;
            public static encode(m: google.protobuf.IBoolValue, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.BoolValue;
        }

        interface IStringValue {
            value?: (string|null);
        }

        class StringValue implements IStringValue {
            constructor(p?: google.protobuf.IStringValue);
            public value: string;
            public static encode(m: google.protobuf.IStringValue, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.StringValue;
        }

        interface IBytesValue {
            value?: (Uint8Array|null);
        }

        class BytesValue implements IBytesValue {
            constructor(p?: google.protobuf.IBytesValue);
            public value: Uint8Array;
            public static encode(m: google.protobuf.IBytesValue, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.BytesValue;
        }

        interface IEmpty {
        }

        class Empty implements IEmpty {
            constructor(p?: google.protobuf.IEmpty);
            public static encode(m: google.protobuf.IEmpty, w?: $protobuf.Writer): $protobuf.Writer;
            public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): google.protobuf.Empty;
        }
    }
}