@waves/protobuf-serialization
Version:
Generated types and methods for encoding and decoding protobuf messages as well as working with gRPC services.
2,394 lines • 116 kB
TypeScript
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;
}
}
}