@waves/protobuf-serialization/dist/index.d.ts

Generated types and methods for encoding and decoding protobuf messages as well as working with gRPC services.

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;
            }

            int