syntax = "proto3";
package hush.wallet.sdk.rpc;
option go_package = "walletrpc";

import "compact_formats.proto";

// A BlockID message contains identifiers to select a block: a height or a
// hash. If the hash is present it takes precedence.
message BlockID {
     uint64 height = 1;
     bytes hash = 2;
}

// BlockRange technically allows ranging from hash to hash etc but this is not
// currently intended for support, though there is no reason you couldn't do
// it. Further permutations are left as an exercise.
message BlockRange {
    BlockID start = 1;
    BlockID end = 2;
}

// A TxFilter contains the information needed to identify a particular
// transaction: either a block and an index, or a direct transaction hash.
message TxFilter {
     BlockID block = 1;
     uint64 index = 2;
     bytes hash = 3;
}

// RawTransaction contains the complete transaction data. It also optionally includes 
// the block height in which the transaction was included
message RawTransaction {
    bytes data = 1;
    uint64 height = 2;
}

message SendResponse {
    int32 errorCode = 1;
    string errorMessage = 2;
}

// Empty placeholder. Someday we may want to specify e.g. a particular chain fork.
message ChainSpec {}

message Empty {}

message LightdInfo {
    string version = 1;
    string vendor = 2;
    bool   taddrSupport = 3;
    string chainName = 4;
    uint64 saplingActivationHeight = 5;
    string consensusBranchId = 6;   // This should really be u32 or []byte, but string for readability
    uint64 blockHeight = 7;
    uint64 difficulty = 8;
    uint64 longestchain = 9;
    uint64 notarized = 10;
}
message Coinsupply {
    string result = 1;
    string coin = 2;
    uint64 height = 3;
    uint64 supply = 4;
    uint64 zfunds = 5;
    uint64 total = 6;
}

message TransparentAddress {
    string address = 1;
}

message TransparentAddressBlockFilter {
    string address = 1;
    BlockRange range = 2;
}

message Balance {
    int64 valueZat = 1;
}

message Exclude {
    repeated bytes txid = 1;
}

service CompactTxStreamer {
    // Compact Blocks
    rpc GetLatestBlock(ChainSpec) returns (BlockID) {}
    rpc GetBlock(BlockID) returns (CompactBlock) {}
    rpc GetBlockRange(BlockRange) returns (stream CompactBlock) {}

    // Transactions
    rpc GetTransaction(TxFilter) returns (RawTransaction) {}
    rpc SendTransaction(RawTransaction) returns (SendResponse) {}

    // t-Address support
    rpc GetAddressTxids(TransparentAddressBlockFilter) returns (stream RawTransaction) {}

    // Misc
    rpc GetLightdInfo(Empty) returns (LightdInfo) {}
    rpc GetCoinsupply(Empty) returns (Coinsupply) {}

    // Mempool

    // Return the compact transactions currently in the mempool; the results
    // can be a few seconds out of date. If the Exclude list is empty, return
    // all transactions; otherwise return all *except* those in the Exclude list
    // (if any); this allows the client to avoid receiving transactions that it
    // already has (from an earlier call to this rpc). The transaction IDs in the
    // Exclude list can be shortened to any number of bytes to make the request
    // more bandwidth-efficient; if two or more transactions in the mempool
    // match a shortened txid, they are all sent (none is excluded). Transactions
    // in the exclude list that don't exist in the mempool are ignored.
    rpc GetMempoolTx(Exclude) returns (stream CompactTx) {}

    // Return a stream of current Mempool transactions. This will keep the output stream open while
    // there are mempool transactions. It will close the returned stream when a new block is mined.
    rpc GetMempoolStream(Empty) returns (stream RawTransaction) {}
}