diff --git a/p8e-api/build.gradle b/p8e-api/build.gradle index 6864150..4ece0a7 100644 --- a/p8e-api/build.gradle +++ b/p8e-api/build.gradle @@ -15,6 +15,10 @@ buildscript { } } +plugins { + id 'com.google.protobuf' +} + apply plugin: 'idea' apply plugin: 'eclipse' apply plugin: 'kotlin-spring' @@ -22,6 +26,7 @@ apply plugin: 'org.springframework.boot' apply plugin: 'io.spring.dependency-management' apply plugin: "com.google.osdetector" apply plugin: 'jacoco' +apply plugin: 'de.undercouch.download' // In this section you declare where to find the dependencies of your project repositories { @@ -34,11 +39,17 @@ sourceSets { java { srcDirs += 'src/main/kotlin' } + proto { + srcDir "src/main/proto" + } } test { java { srcDirs += 'src/test/kotlin' } + proto { + srcDir "src/main/proto" + } } } @@ -100,6 +111,16 @@ dependencies { implementation('io.netty:netty-transport-native-epoll:4.1.50.Final:linux-x86_64') } + // WebSocket + implementation "com.tinder.scarlet:scarlet:$scarlet_version" + implementation "com.tinder.scarlet:websocket-okhttp:$scarlet_version" + implementation "com.tinder.scarlet:stream-adapter-rxjava2:$scarlet_version" + implementation "com.tinder.scarlet:message-adapter-moshi:$scarlet_version" + implementation 'com.squareup.okhttp3:logging-interceptor:3.14.0' + testImplementation "com.tinder.scarlet:websocket-mockwebserver:$scarlet_version" + testImplementation "com.tinder.scarlet:test-utils:$scarlet_version" + testImplementation "io.reactivex.rxjava2:rxkotlin:2.2.0" + // Spring boot implementation "org.springframework.boot:spring-boot-starter-web:$springboot_version" implementation "org.springframework.boot:spring-boot-starter-integration:$springboot_version" @@ -134,6 +155,12 @@ dependencies { // Test Things testImplementation 'io.grpc:grpc-testing:1.35.0' testImplementation 'com.h2database:h2:1.4.200' + + // grpc for provenance proto compilation + implementation "com.google.protobuf:protobuf-java:$protobuf_version" + implementation "com.google.protobuf:protobuf-java-util:$protobuf_version" + implementation group: 'io.grpc', name: 'grpc-stub', version: "$grpc_version" + implementation group: 'io.grpc', name: 'grpc-protobuf', version: "$grpc_version" } jacocoTestReport { @@ -157,3 +184,64 @@ dependencyManagement { cacheChangingModulesFor 0, 'seconds' } } + +task downloadCosmosProtos(type: Download) { + src "https://github.com/cosmos/cosmos-sdk/tarball/v$cosmos_version" + dest new File(buildDir, "${cosmos_version}.tar.gz") + onlyIfModified true +} + +task downloadAndUntarCosmosProtos(dependsOn: downloadCosmosProtos, type: Copy) { + from(tarTree(downloadCosmosProtos.dest)) { + include "**/*.proto" + eachFile { fcd -> + def relativePath = new RelativePath(true, fcd.relativePath.segments.drop(1)) + def isThirdParty = relativePath.toString().startsWith("third_party") + if (isThirdParty) { + relativePath = new RelativePath(true, relativePath.segments.drop(1)) + } + fcd.relativePath = relativePath + } + includeEmptyDirs = false + } + into 'src/main' +} + +task downloadProvenanceProtos(type: Download) { + src "https://github.com/provenance-io/provenance/releases/download/v${provenance_version}/protos-v${provenance_version}.zip" + dest new File(buildDir, "${provenance_version}.zip") + onlyIfModified true +} + +task downloadAndUnzipProvenanceProtos(dependsOn: [downloadProvenanceProtos, downloadAndUntarCosmosProtos], type: Copy) { + from zipTree(downloadProvenanceProtos.dest) + into 'src/main' +} + +task downloadAllExternalProtos(dependsOn: [downloadAndUnzipProvenanceProtos, downloadAndUntarCosmosProtos]) { + tasks.findByName('downloadAndUnzipProvenanceProtos').mustRunAfter 'downloadAndUntarCosmosProtos' +} + +protobuf { + protoc { + // The artifact spec for the Protobuf Compiler + artifact = "com.google.protobuf:protoc:$protobuf_version" + } + plugins { + // Optional: an artifact spec for a protoc plugin, with "grpc" as + // the identifier, which can be referred to in the "plugins" + // container of the "generateProtoTasks" closure. + grpc { + artifact = 'io.grpc:protoc-gen-grpc-java:1.0.0-pre2' + } + } + generateProtoTasks { + ofSourceSet('main')*.plugins { + // Apply the "grpc" plugin whose spec is defined above, without + // options. Note the braces cannot be omitted, otherwise the + // plugin will not be added. This is because of the implicit way + // NamedDomainObjectContainer binds the methods. + grpc {} + } + } +} diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/batch/Thread.kt b/p8e-api/src/main/kotlin/io/provenance/engine/batch/Thread.kt index f1df08c..a22f2f1 100644 --- a/p8e-api/src/main/kotlin/io/provenance/engine/batch/Thread.kt +++ b/p8e-api/src/main/kotlin/io/provenance/engine/batch/Thread.kt @@ -28,8 +28,14 @@ fun threadFactory(name: String? = null): ThreadFactory = ThreadFactoryBuilder(). fun fixedSizeThreadPool(name: String? = null, numThreads: Int = defaultThreadCount): ExecutorService = threadFactory(name).asFixedPool(numThreads) -fun shutdownHook(fn: () -> Unit) { - Runtime.getRuntime().addShutdownHook(thread(start = false, block = fn)) +fun shutdownHook(fn: () -> Unit): Thread { + return thread(start = false, block = fn).also { + Runtime.getRuntime().addShutdownHook(it) + } +} + +fun removeShutdownHook(hook: Thread) { + Runtime.getRuntime().removeShutdownHook(hook) } /** diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/batch/TxErrorReaper.kt b/p8e-api/src/main/kotlin/io/provenance/engine/batch/TxErrorReaper.kt index 0b592a4..f985223 100644 --- a/p8e-api/src/main/kotlin/io/provenance/engine/batch/TxErrorReaper.kt +++ b/p8e-api/src/main/kotlin/io/provenance/engine/batch/TxErrorReaper.kt @@ -8,11 +8,16 @@ import org.springframework.stereotype.Component import io.provenance.p8e.shared.extension.logger import io.provenance.engine.config.EventStreamProperties import io.provenance.engine.domain.EventStreamRecord +import io.provenance.engine.domain.GetTxResult import io.provenance.engine.domain.TransactionStatusRecord -import io.provenance.pbc.clients.* +import io.provenance.engine.domain.TxResult +import io.provenance.engine.service.TransactionNotFoundError +import io.provenance.engine.service.TransactionQueryService import org.jetbrains.exposed.sql.transactions.transaction import io.provenance.engine.service.TransactionStatusService import io.provenance.engine.stream.ScopeStream +import io.provenance.engine.stream.domain.Attribute +import io.provenance.engine.stream.domain.Event import io.provenance.p8e.shared.index.ScopeEvent import io.provenance.p8e.shared.index.isScopeEventType import io.provenance.p8e.shared.index.toEventType @@ -25,7 +30,7 @@ import java.time.OffsetDateTime @Component class TxErrorReaper( private val transactionStatusService: TransactionStatusService, - private val sc: SimpleClient, + private val transactionQueryService: TransactionQueryService, private val scopeStream: ScopeStream, eventStreamProperties: EventStreamProperties ) { @@ -46,47 +51,45 @@ class TxErrorReaper( }.forEach { try { P8eMDC.set(it.transactionHash.value.toTransactionHashes(), clear = true) - sc.fetchTx(it.transactionHash.value).let { transactionStatus -> + transactionQueryService.fetchTransaction(it.transactionHash.value).let { transactionStatus -> if (transactionStatus.isErrored()) { transaction { transactionStatusService.setError(it, transactionStatus.getError()) } - } else { - P8eMDC.set(transactionStatus.height.toLong().toBlockHeight()) - val blockHeight = transactionStatus.height.toLong() + } else if (transactionStatus.isSuccessful()) { + P8eMDC.set(transactionStatus.height.toBlockHeight()) + val blockHeight = transactionStatus.height if (blockHeight <= latestBlockHeight) { // EventStream is past this height, need to process manually - transactionStatus.events() - ?.also { events -> log.error("indexing ${events.size} events missed by eventStream") } - ?.map { event -> event.toScopeEvent() } - ?.also { events -> scopeStream.queueIndexScopes(blockHeight, events) } + transactionStatus.scopeEvents() + .also { events -> log.error("indexing ${events.size} events missed by eventStream") } + .map { event -> event.toScopeEvent() } + .also { events -> scopeStream.queueIndexScopes(blockHeight, events) } } } } - } catch (e: CosmosRemoteInvocationException) { - if (e.status == HttpStatus.NOT_FOUND.value()) { - log.warn("Retrying transaction not found in mempool with hash ${it.transactionHash.value}") - transaction { transactionStatusService.retryDead(it, e.message) } - } else { - log.error("Error fetching status for tx hash ${it.transactionHash.value}", e) - } + } catch (e: TransactionNotFoundError) { + log.warn("Retrying transaction not found in mempool with hash ${it.transactionHash.value}") + transaction { transactionStatusService.retryDead(it, e.message) } } catch (t: Throwable) { log.warn("Error processing expired transaction", t) } } } - private fun TxQuery.isErrored() = (code ?: 0) > 0 + private fun GetTxResult.isErrored() = txResult?.code != null && txResult?.code > 0 + + private fun GetTxResult.isSuccessful() = txResult?.code == 0 - private fun TxQuery.getError() = logs?.filter { it.log.isNotBlank() }?.takeIf { it.isNotEmpty() }?.joinToString("; ") { it.log } ?: raw_log + private fun GetTxResult.getError() = txResult?.log ?: "Unknown Error" - private fun TxQuery.events(): List? = logs?.flatMap { it.events.filter { it.type.isScopeEventType() } } + private fun GetTxResult.scopeEvents(): List = txResult?.events?.filter { it.type.isScopeEventType() } ?: emptyList() - private fun StdTxEvent.findTxHash(): String = attributes.find { it.key == "tx_hash" }?.value + private fun Event.findTxHash(): String = attributes.find { it.key == "tx_hash" }?.value ?: throw IllegalStateException("Event does not contain a transaction hash") - private fun StdTxEvent.findScope(): Scope = attributes.find { it.key == "scope" }?.toScope() + private fun Event.findScope(): Scope = attributes.find { it.key == "scope" }?.toScope() ?: throw IllegalStateException("Event does not contain a scope") - private fun StdTxEvent.toScopeEvent(): ScopeEvent = ScopeEvent(findTxHash(), findScope(), type.toEventType()) + private fun Event.toScopeEvent(): ScopeEvent = ScopeEvent(findTxHash(), findScope(), type.toEventType()) - private fun StdTxEventAttribute.toScope(): Scope = value?.base64Decode().let { Scope.parseFrom(it) } + private fun Attribute.toScope(): Scope = value.base64Decode().let { Scope.parseFrom(it) } ?: throw IllegalStateException("Event attribute does not contain a scope") } diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/config/AppConfig.kt b/p8e-api/src/main/kotlin/io/provenance/engine/config/AppConfig.kt index 3a16fd9..06c65d5 100644 --- a/p8e-api/src/main/kotlin/io/provenance/engine/config/AppConfig.kt +++ b/p8e-api/src/main/kotlin/io/provenance/engine/config/AppConfig.kt @@ -3,9 +3,18 @@ package io.provenance.engine.config import com.fasterxml.jackson.databind.ObjectMapper import com.fasterxml.jackson.databind.module.SimpleModule import com.timgroup.statsd.NonBlockingStatsDClientBuilder +import com.tinder.scarlet.Scarlet +import com.tinder.scarlet.messageadapter.moshi.MoshiMessageAdapter +import com.tinder.scarlet.streamadapter.rxjava2.RxJava2StreamAdapterFactory +import com.tinder.scarlet.websocket.okhttp.newWebSocketFactory +import feign.Feign +import feign.Logger +import feign.jackson.JacksonDecoder +import feign.jackson.JacksonEncoder import io.p8e.util.configureProvenance import io.provenance.engine.crypto.Account import io.provenance.engine.crypto.PbSigner +import io.provenance.engine.domain.RPCClient import io.provenance.engine.grpc.interceptors.JwtServerInterceptor import io.provenance.engine.grpc.interceptors.UnhandledExceptionInterceptor import io.provenance.engine.index.query.Operation @@ -26,6 +35,7 @@ import io.provenance.pbc.clients.Denom import io.provenance.pbc.clients.SimpleClient import io.provenance.pbc.clients.SimpleClientOpts import io.provenance.pbc.clients.coins +import okhttp3.OkHttpClient import org.apache.http.HttpHost import org.apache.http.auth.AuthScope import org.apache.http.auth.UsernamePasswordCredentials @@ -47,6 +57,7 @@ import org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter import org.springframework.web.servlet.config.annotation.WebMvcConfigurer import java.lang.IllegalArgumentException import java.net.URI +import java.time.Duration @Configuration @EnableCaching @@ -104,6 +115,33 @@ class AppConfig : WebMvcConfigurer { .registerModule(module) } + @Bean + fun rpcClient( + objectMapper: ObjectMapper, + eventStreamProperties: EventStreamProperties + ): RPCClient { + return Feign.builder() + .encoder(JacksonEncoder(objectMapper)) + .decoder(JacksonDecoder(objectMapper)) + .target( + RPCClient::class.java, + eventStreamProperties.rpcUri + ) + } + + @Bean + fun eventStreamBuilder(eventStreamProperties: EventStreamProperties): Scarlet.Builder { + val node = URI(eventStreamProperties.websocketUri) + return Scarlet.Builder() + .webSocketFactory( + OkHttpClient.Builder() + .readTimeout(Duration.ofSeconds(60)) // ~ 12 pbc block cuts + .build() + .newWebSocketFactory("${node.scheme}://${node.host}:${node.port}/websocket")) + .addMessageAdapterFactory(MoshiMessageAdapter.Factory()) + .addStreamAdapterFactory(RxJava2StreamAdapterFactory()) + } + @Bean fun envelopeStateEngine(): EnvelopeStateEngine = EnvelopeStateEngine() diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/config/Properties.kt b/p8e-api/src/main/kotlin/io/provenance/engine/config/Properties.kt index 4971f43..defa48e 100644 --- a/p8e-api/src/main/kotlin/io/provenance/engine/config/Properties.kt +++ b/p8e-api/src/main/kotlin/io/provenance/engine/config/Properties.kt @@ -41,7 +41,8 @@ class MailboxProperties { @Validated class EventStreamProperties { @NotNull lateinit var id: String - @NotNull lateinit var uri: String + @NotNull lateinit var websocketUri: String + @NotNull lateinit var rpcUri: String @NotNull lateinit var epoch: String @NotNull lateinit var key: String } diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/domain/Transaction.kt b/p8e-api/src/main/kotlin/io/provenance/engine/domain/Transaction.kt new file mode 100644 index 0000000..c366e14 --- /dev/null +++ b/p8e-api/src/main/kotlin/io/provenance/engine/domain/Transaction.kt @@ -0,0 +1,111 @@ +package io.provenance.engine.domain + +import com.fasterxml.jackson.annotation.JsonProperty +import feign.Param +import feign.RequestLine +import io.provenance.engine.stream.domain.* +import org.springframework.stereotype.Component + +data class BlockchainInfo( + val lastHeight: Long, + @JsonProperty("block_metas") + val blockMetas: List, +) + +data class BlockMeta( + @JsonProperty("block_id") + val blockId: BlockID, + @JsonProperty("block_size") + val blockSize: Int, + val header: BlockHeader, + @JsonProperty("num_txs") + val numTxs: Int, +) + +data class BlockID( + val hash: String, + val parts: PartSetHeader, +) + +data class PartSetHeader( + val total: Int, + val hash: String, +) + +class BlockchainInfoRequest( + minHeight: Long, + maxHeight: Long +) : RPCRequest("blockchain", BlockchainInfoParams(minHeight.toString(), maxHeight.toString())) + +data class BlockchainInfoParams( + val minHeight: String, + val maxHeight: String +) + +class BlockRequest( + height: Long +) : RPCRequest("block", BlockParams(height.toString())) + +data class BlockParams(val height: String) + +data class BlockResponse( + @JsonProperty("block_id") + val blockId: BlockID, + val block: Block +) + +class BlockResultsRequest( + height: Long +) : RPCRequest("block_results", BlockParams(height.toString())) + +data class BlockResults( + val height: Long, + @JsonProperty("txs_results") + val txsResults: List +) + +data class TxResult( + val code: Int?, + val data: String?, + val log: String, + val info: String, + val gasWanted: Long, + val gasUsed: Long, + val events: List +) + +data class GetTxResult( + val hash: String, + val height: Long, + val index: Int, + @JsonProperty("tx_result") + val txResult: TxResult?, + val tx: String, + val data: String?, +) + +data class ABCIInfoResponse( + val response: ABCIInfo +) + +data class ABCIInfo( + val data: String, + @JsonProperty("last_block_height") + val lastBlockHeight: Long, + @JsonProperty("last_block_app_hash") + val lastBlockAppHash: String +) + +@Component +interface RPCClient { + @RequestLine("GET /") + fun blockchainInfo(request: BlockchainInfoRequest): RPCResponse + @RequestLine("GET /") + fun block(request: BlockRequest): RPCResponse + @RequestLine("GET /") + fun blockResults(request: BlockResultsRequest): RPCResponse + @RequestLine("GET /") + fun abciInfo(request: RPCRequest = RPCRequest("abci_info")): RPCResponse + @RequestLine("GET /tx?hash=0x{hash}") + fun getTransaction(@Param("hash") hash: String): RPCResponse +} diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/service/TransactionQueryService.kt b/p8e-api/src/main/kotlin/io/provenance/engine/service/TransactionQueryService.kt new file mode 100644 index 0000000..5734eb7 --- /dev/null +++ b/p8e-api/src/main/kotlin/io/provenance/engine/service/TransactionQueryService.kt @@ -0,0 +1,41 @@ +package io.provenance.engine.service + +import io.provenance.engine.domain.* +import org.springframework.stereotype.Service + +open class TransactionQueryError(message: String): Throwable(message) +class TransactionNotFoundError(message: String): TransactionQueryError(message) + +@Service +class TransactionQueryService(val rpcClient: RPCClient) { + @Throws(TransactionQueryError::class) + fun fetchTransaction(hash: String): GetTxResult { + return rpcClient.getTransaction(hash).let { + if (it.error != null) { + val message = "${it.error.message} - ${it.error.data}" + if (it.result?.txResult == null) { + throw TransactionNotFoundError(message) + } + throw TransactionQueryError(message) + } + + it.result!! + } + } + + fun blocksWithTransactions(minHeight: Long, maxHeight: Long): List { + val info = blockchainInfo(minHeight, maxHeight) + + return info.blockMetas + .filter { it.numTxs > 0 } + .map { it.header.height } + } + + fun blockchainInfo(minHeight: Long, maxHeight: Long) = rpcClient.blockchainInfo(BlockchainInfoRequest(minHeight, maxHeight)).result!! + + fun block(height: Long) = rpcClient.block(BlockRequest(height)).result!! + + fun blockResults(height: Long) = rpcClient.blockResults(BlockResultsRequest(height)).result!! + + fun abciInfo() = rpcClient.abciInfo().result!!.response +} diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/service/TransactionStatusService.kt b/p8e-api/src/main/kotlin/io/provenance/engine/service/TransactionStatusService.kt index 3742c32..c89a4a4 100644 --- a/p8e-api/src/main/kotlin/io/provenance/engine/service/TransactionStatusService.kt +++ b/p8e-api/src/main/kotlin/io/provenance/engine/service/TransactionStatusService.kt @@ -62,8 +62,10 @@ class TransactionStatusService( envelope.status = Status.SIGNED envelope.chaincodeTime = null - val event = envelope.uuid.value.toProtoUuidProv().toEvent(Event.ENVELOPE_CHAINCODE) - eventService.submitEvent(event, envelope.uuid.value) + if (envelope.isInvoker ?: false) { + val event = envelope.uuid.value.toProtoUuidProv().toEvent(Event.ENVELOPE_CHAINCODE) + eventService.submitEvent(event, envelope.uuid.value) + } } } } diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/stream/EventStream.kt b/p8e-api/src/main/kotlin/io/provenance/engine/stream/EventStream.kt new file mode 100644 index 0000000..8f21194 --- /dev/null +++ b/p8e-api/src/main/kotlin/io/provenance/engine/stream/EventStream.kt @@ -0,0 +1,294 @@ +package io.provenance.engine.stream + +import com.tinder.scarlet.Lifecycle +import com.tinder.scarlet.Scarlet +import com.tinder.scarlet.ShutdownReason +import com.tinder.scarlet.WebSocket +import com.tinder.scarlet.lifecycle.LifecycleRegistry +import io.grpc.netty.NettyChannelBuilder +import io.p8e.crypto.Hash +import io.p8e.engine.threadedMap +import io.p8e.util.ThreadPoolFactory +import io.p8e.util.base64decode +import io.p8e.util.timed +import io.p8e.util.toHexString +import io.provenance.engine.batch.removeShutdownHook +import io.provenance.engine.batch.shutdownHook +import io.provenance.engine.config.EventStreamProperties +import io.provenance.engine.domain.EventStreamRecord +import io.provenance.engine.service.TransactionQueryService +import io.provenance.engine.stream.domain.* +import io.provenance.p8e.shared.extension.logger +import io.reactivex.disposables.Disposable +import org.jetbrains.exposed.sql.transactions.transaction +import org.springframework.stereotype.Component +import tendermint.abci.ABCIApplicationGrpc +import java.net.URI +import java.time.OffsetDateTime +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicLong +import kotlin.concurrent.thread + +class EventStreamStaleException(message: String) : Throwable(message) + +@Component +class EventStreamFactory( + private val eventStreamProperties: EventStreamProperties, + private val transactionQueryService: TransactionQueryService, + private val eventStreamBuilder: Scarlet.Builder +) { + private val log = logger() + +// private val abciService = URI(eventStreamProperties.uri).let { uri -> +// val channel = NettyChannelBuilder.forAddress(uri.host, uri.port) +// // todo: set appropriate options for timeouts and what-not +// .also { +// if (uri.scheme == "grpcs") { +// it.useTransportSecurity() +// } else { +// it.usePlaintext() +// } +// } +// .maxInboundMessageSize(20 * 1024 * 1024) // ~ 20 MB +// .idleTimeout(5, TimeUnit.MINUTES) +// .keepAliveTime(60, TimeUnit.SECONDS) // ~ 12 pbc block cuts +// .keepAliveTimeout(20, TimeUnit.SECONDS) +// .build() +// +// ABCIApplicationGrpc.newBlockingStub(channel) +// } + + fun getStream(eventTypes: List, startHeight: Long, observer: EventStreamResponseObserver): EventStream { + val lifecycle = LifecycleRegistry(0L) + + return EventStream( + eventTypes, + startHeight, + observer, + lifecycle, + eventStreamBuilder.lifecycle(lifecycle).build().create(), + transactionQueryService + ) + } + + class EventStream( + val eventTypes: List, + val startHeight: Long, + private val observer: EventStreamResponseObserver, + private val lifecycle: LifecycleRegistry, + private val eventStreamService: EventStreamService, + private val transactionQueryService: TransactionQueryService + ) { + companion object { + private val HISTORY_BATCH_SIZE = 10 + private val executor = ThreadPoolFactory.newFixedThreadPool(HISTORY_BATCH_SIZE, "event-stream-%d") + } + + private val log = logger() + + private var subscription: Disposable? = null + + private var shuttingDown = CountDownLatch(1) + private var shutdownHook: Thread? = null + + private var lastBlockSeen = AtomicLong(-1) + private val eventMonitor = thread(start = false, isDaemon = true) { + var lastBlockMonitored = lastBlockSeen.get() + while (!shuttingDown.await(30, TimeUnit.SECONDS)) { + val lastBlockSeen = lastBlockSeen.get() + log.debug("Checking for event stream liveliness [lastBlockSeen: $lastBlockSeen vs. lastBlockMonitored: $lastBlockMonitored]") + if (lastBlockSeen <= lastBlockMonitored) { + handleError(EventStreamStaleException("EventStream has not received a block in 30 seconds [lastBlockSeen: $lastBlockSeen vs. lastBlockMonitored: $lastBlockMonitored]")) + break + } + lastBlockMonitored = lastBlockSeen + } + log.info("Exiting event monitor thread") + } + + fun streamEvents() { + // todo: concurrency - need to limit how many times this function is called??? Used to limit based on consumer id... probably need to use redis to do this... and ensure cleaned up when shutting down if do + + // start event loop to start listening for events + startEventLoop() + shutdownHook = shutdownHook { shutdown(false) } // ensure we close socket gracefully when shutting down + + timed("EventStream:streamHistory") { + streamHistory() + } + + eventMonitor.start() + } + + private fun streamHistory() { + if (startHeight <= 0) { + // client only wants live events + return + } + + // get latest block height + val lastBlockHeight = transactionQueryService.abciInfo().also { + info -> log.info("EventStream lastBlockHeight: ${info.lastBlockHeight}") + }.lastBlockHeight + + // Requested start height is in the future + if (startHeight > lastBlockHeight) { + return + } + + // query block heights in batches (concurrent batches) + var height = startHeight + val capacity = HISTORY_BATCH_SIZE + val capacityRange = (0 until capacity).toList() + val chunkSize = 20 // Tendermint limit on how many block metas can be queried in one call. + var numHistoricalEvents = 0 + do { + val batches = capacityRange.threadedMap(executor) { i -> + val beg = height + i * chunkSize + if (beg > lastBlockHeight) { + null + } else { + var end = beg + chunkSize - 1 + if (end > lastBlockHeight) { + end = lastBlockHeight + } + queryBatchRange(beg, end) + } + }.filterNotNull() + .flatten() + + if (batches.isNotEmpty()) { + numHistoricalEvents += batches.fold(0) { acc, batch -> acc + batch.events.size } + + batches.sortedBy { it.height } + .forEach { + handleEventBatch(it) + } + } + + height += capacity * chunkSize + } while (height <= lastBlockHeight) + + log.info("Streamed $numHistoricalEvents historical events") + } + + private fun startEventLoop() { + // subscribe to block events tm.event='NewBlock' + log.info("opening EventStream websocket") + lifecycle.onNext(Lifecycle.State.Started) + subscription = eventStreamService.observeWebSocketEvent() + .filter { + if (it is WebSocket.Event.OnConnectionFailed) { + handleError(it.throwable) + } + + it is WebSocket.Event.OnConnectionOpened<*> + } + .switchMap { + log.info("initializing subscription for tm.event='NewBlock'") + eventStreamService.subscribe(Subscribe("tm.event='NewBlock'")) + eventStreamService.streamEvents() + } + .filter { !it.result!!.query.isNullOrBlank() && it.result.data.value.block.header.height >= startHeight } + .map { event -> event.result!! } + .subscribe( + { handleEvent(it) }, + { handleError(it) } + ) + } + + private fun handleEvent(event: Result) { + val blockHeight = event.data.value.block.header.height + + lastBlockSeen.set(blockHeight) + + queryEvents(blockHeight) + .takeIf { it.isNotEmpty() } + ?.also { + log.info("got batch of ${it.count()} events") + handleEventBatch( + EventBatch(blockHeight, it) + ) + } + } + + private fun handleEventBatch(event: EventBatch) { + observer.onNext(event) + } + + private fun handleError(t: Throwable) { + log.error("EventStream error ${t.message}") + observer.onError(t) + shutdown() + } + + fun shutdown(removeShutdownHook: Boolean = true) { + log.info("Cleaning up EventStream Websocket") + shuttingDown.countDown() + lifecycle.onNext(Lifecycle.State.Stopped.WithReason(ShutdownReason.GRACEFUL)) + subscription + ?.takeIf { !it.isDisposed } + ?.dispose() + observer.onCompleted() + shutdownHook?.takeIf { removeShutdownHook }?.also { removeShutdownHook(it) } + } + + fun queryBatchRange(minHeight: Long, maxHeight: Long): List? { + if (minHeight > maxHeight) { + return null + } + + return transactionQueryService.blocksWithTransactions(minHeight, maxHeight) + .takeIf { it.isNotEmpty() } + ?.map { height -> + EventBatch( + height, + queryEvents(height) + ) + }?.filter { it.events.isNotEmpty() } + ?.takeIf { it.isNotEmpty() } + } + + fun queryEvents(height: Long): List { + val block = transactionQueryService.block(height) + if (block.block.data.txs == null) { // empty block + return listOf() + } + + val results = transactionQueryService.blockResults(height) + + return results.txsResults + .flatMapIndexed { index, tx -> + val txHash = block.block.data.txs[index].hash() + tx.events + .filter { it.shouldStream() } + .map { event -> + StreamEvent( + height = results.height, + eventType = event.type, + resultIndex = index, + txHash = txHash, + attributes = event.attributes + ) + } + } + } + + private fun Event.shouldStream(): Boolean = eventTypes.contains(type) // check for simple event type match first + || eventTypes.isEmpty() // no filtering requested + // Check for "event_type:attribute_key" matches. + || eventTypes.firstOrNull { + it.contains(':') + && it.split(':').let { elements -> + elements.size == 2 + && elements[0] == type // event type match + && attributes.firstOrNull { attribute -> // at least one attribute match + attribute.key == elements[1] + } != null + } + } != null + + fun String.hash(): String = Hash.sha256(base64decode()).toHexString() + } +} diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/stream/ScopeStream.kt b/p8e-api/src/main/kotlin/io/provenance/engine/stream/ScopeStream.kt index 4fb2a3c..31a54f7 100644 --- a/p8e-api/src/main/kotlin/io/provenance/engine/stream/ScopeStream.kt +++ b/p8e-api/src/main/kotlin/io/provenance/engine/stream/ScopeStream.kt @@ -13,6 +13,10 @@ import io.provenance.engine.domain.EventStreamRecord import io.provenance.engine.domain.TransactionStatusRecord import io.provenance.p8e.shared.index.data.IndexScopeRecord import io.provenance.engine.service.EventService +import io.provenance.engine.stream.domain.Attribute +import io.provenance.engine.stream.domain.EventBatch +import io.provenance.engine.stream.domain.EventStreamResponseObserver +import io.provenance.engine.stream.domain.StreamEvent import io.provenance.p8e.shared.domain.EnvelopeRecord import io.provenance.p8e.shared.index.ScopeEvent import io.provenance.p8e.shared.index.ScopeEventType @@ -23,7 +27,6 @@ import io.provenance.p8e.shared.util.toTransactionHashes import io.provenance.pbc.esc.ApiKeyCallCredentials import io.provenance.pbc.esc.EventStreamApiKey import io.provenance.pbc.esc.StreamClientParams -import io.provenance.pbc.ess.proto.EventProtos import io.provenance.pbc.ess.proto.EventStreamGrpc import org.jetbrains.exposed.sql.transactions.transaction import org.springframework.scheduling.annotation.Scheduled @@ -31,34 +34,12 @@ import org.springframework.stereotype.Component import java.net.URI import java.util.concurrent.CountDownLatch import java.util.concurrent.TimeUnit -import io.provenance.pbc.ess.proto.EventProtos.Event as StreamedEvent - -class EventStreamResponseObserver(private val onNextHandler: (T) -> Unit) : StreamObserver { - val finishLatch: CountDownLatch = CountDownLatch(1) - var error: Throwable? = null - - override fun onNext(value: T) { - try { - onNextHandler(value) - } catch (t: Throwable) { - this.onError(t) - } - } - - override fun onCompleted() { - finishLatch.countDown() - } - - override fun onError(t: Throwable?) { - error = t - finishLatch.countDown() - } -} @Component class ScopeStream( private val eventService: EventService, - eventStreamProperties: EventStreamProperties + eventStreamProperties: EventStreamProperties, + private val eventStreamFactory: EventStreamFactory ) { private val log = logger() @@ -68,36 +49,9 @@ class ScopeStream( // The current event stream ID private val eventStreamId = java.util.UUID.fromString(eventStreamProperties.id) - // The event stream service uri - private val uri = URI(eventStreamProperties.uri) - // The p8e -> pbc epoch, before which, no scopes exist on chain. private val epochHeight = eventStreamProperties.epoch.toLong() - // The api key for grpc calls to the event stream server - private val apiKey = eventStreamProperties.key - - private val eventAsyncClient: EventStreamGrpc.EventStreamStub - - init { - val channel = ManagedChannelBuilder.forAddress(uri.host, uri.port) - .also { - if (uri.scheme == "grpcs") { - it.useTransportSecurity() - } else { - it.usePlaintext() - } - } - .maxInboundMessageSize(20 * 1024 * 1024) // ~ 20 MB - .idleTimeout(5, TimeUnit.MINUTES) - .keepAliveTime(60, TimeUnit.SECONDS) // ~ 12 pbc block cuts - .keepAliveTimeout(20, TimeUnit.SECONDS) - .build() - - eventAsyncClient = EventStreamGrpc.newStub(channel) - .withCallCredentials(ApiKeyCallCredentials(EventStreamApiKey(apiKey))) - } - // This is scheduled so if the event streaming server or its proxied blockchain daemon node go down, // we'll attempt to re-connect after a fixed delay. @Scheduled(fixedDelay = 30_000) @@ -106,18 +60,15 @@ class ScopeStream( val record = transaction { EventStreamRecord.findById(eventStreamId) } val lastHeight = record?.lastBlockHeight ?: transaction { EventStreamRecord.insert(eventStreamId, epochHeight) }.lastBlockHeight - val request = EventProtos.EventStreamReq.newBuilder() - .addAllEventTypes(eventTypes) - .setStartHeight(lastHeight + 1) - .setConsumer(StreamClientParams(uri, apiKey).consumer) - .build() - val responseObserver = EventStreamResponseObserver() { batch -> + + val responseObserver = EventStreamResponseObserver() { batch -> queueIndexScopes(batch.height, batch.scopes()) } log.info("Starting event stream at height ${lastHeight + 1}") - eventAsyncClient.streamEvents(request, responseObserver) + eventStreamFactory.getStream(eventTypes, lastHeight + 1, responseObserver) + .streamEvents() while (true) { val isComplete = responseObserver.finishLatch.await(60, TimeUnit.SECONDS) @@ -131,8 +82,8 @@ class ScopeStream( } // Extract all scopes from an event batch - private fun EventProtos.EventBatch.scopes(): List = - this.eventsList.map { event -> + private fun EventBatch.scopes(): List = + this.events.map { event -> ScopeEvent( event.findTxHash(), event.findScope(), @@ -141,18 +92,18 @@ class ScopeStream( } // Find the transaction hash in an event. - private fun StreamedEvent.findTxHash(): String = - this.attributesList.find { it.key.toStringUtf8() == "tx_hash" }?.value?.toStringUtf8() + private fun StreamEvent.findTxHash(): String = + this.attributes.find { it.key == "tx_hash" }?.value ?: throw IllegalStateException("Event does not contain a transaction hash") // Find the scope in an event. - private fun StreamedEvent.findScope(): Scope = - this.attributesList.find { it.key.toStringUtf8() == "scope" }?.toScope() + private fun StreamEvent.findScope(): Scope = + this.attributes.find { it.key == "scope" }?.toScope() ?: throw IllegalStateException("Event does not contain a scope") // Parse a scope from an attribute value. - private fun EventProtos.Attribute.toScope(): Scope = - Scope.parseFrom(this.value.toStringUtf8().base64Decode()) + private fun Attribute.toScope(): Scope = + Scope.parseFrom(this.value.base64Decode()) // Queue a batch of scopes for indexing. fun queueIndexScopes(blockHeight: Long, events: List) = timed("ScopeStream_indexScopes_${events.size}") { diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/stream/domain/EventStreamResponseObserver.kt b/p8e-api/src/main/kotlin/io/provenance/engine/stream/domain/EventStreamResponseObserver.kt new file mode 100644 index 0000000..d4bf999 --- /dev/null +++ b/p8e-api/src/main/kotlin/io/provenance/engine/stream/domain/EventStreamResponseObserver.kt @@ -0,0 +1,26 @@ +package io.provenance.engine.stream.domain + +import io.grpc.stub.StreamObserver +import java.util.concurrent.CountDownLatch + +class EventStreamResponseObserver(private val onNextHandler: (T) -> Unit) : StreamObserver { + val finishLatch: CountDownLatch = CountDownLatch(1) + var error: Throwable? = null + + override fun onNext(value: T) { + try { + onNextHandler(value) + } catch (t: Throwable) { + this.onError(t) + } + } + + override fun onCompleted() { + finishLatch.countDown() + } + + override fun onError(t: Throwable?) { + error = t + finishLatch.countDown() + } +} diff --git a/p8e-api/src/main/kotlin/io/provenance/engine/stream/domain/WebSocket.kt b/p8e-api/src/main/kotlin/io/provenance/engine/stream/domain/WebSocket.kt new file mode 100644 index 0000000..23024fc --- /dev/null +++ b/p8e-api/src/main/kotlin/io/provenance/engine/stream/domain/WebSocket.kt @@ -0,0 +1,94 @@ +package io.provenance.engine.stream.domain + +import com.tinder.scarlet.WebSocket +import com.tinder.scarlet.ws.Receive +import com.tinder.scarlet.ws.Send +import io.reactivex.Flowable + +interface EventStreamService { + @Receive + fun observeWebSocketEvent(): Flowable + @Send + fun subscribe(subscribe: Subscribe) + @Receive + fun streamEvents(): Flowable> +} + +data class Result( + val query: String?, + val data: ResultData +) + +data class ResultData( + val type: String, + val value: ResultValue +) + +data class ResultValue( + val block: Block, +) + +data class Block( + val header: BlockHeader, + val data: BlockData +) + +data class BlockHeader( + val height: Long +) + +data class BlockData( + val txs: List? +) + +data class Event( + val type: String, + val attributes: List +) + +data class EventBatch( + val height: Long, + val events: List +) + +data class StreamEvent( + val height: Long, + val eventType: String, + val attributes: List, + val resultIndex: Int, + val txHash: String +) + +class Attribute( + key: ByteArray, + value: ByteArray +) { + val key = String(key) + val value = String(value) +} + +class Subscribe( + query: String +) : RPCRequest("subscribe", SubscribeParams(query)) + +open class RPCRequest(val method: String, val params: Any? = null) { + val jsonrpc = "2.0" + val id = "0" +} + +data class RPCResponse( + val jsonrpc: String, + val id: String, + val result: T? = null, + val error: RPCError? = null +) + +data class RPCError( + val code: Int, + val message: String, + val data: String +) + +data class SubscribeParams( + val query: String +) diff --git a/p8e-api/src/main/proto/confio/proofs.proto b/p8e-api/src/main/proto/confio/proofs.proto new file mode 100644 index 0000000..6432943 --- /dev/null +++ b/p8e-api/src/main/proto/confio/proofs.proto @@ -0,0 +1,236 @@ +syntax = "proto3"; + +package ics23; +option go_package = "github.com/confio/ics23/go"; +option java_package = "tech.confio.ics23"; +option java_multiple_files = true; + +enum HashOp { + // NO_HASH is the default if no data passed. Note this is an illegal argument some places. + NO_HASH = 0; + SHA256 = 1; + SHA512 = 2; + KECCAK = 3; + RIPEMD160 = 4; + BITCOIN = 5; // ripemd160(sha256(x)) +} + +/** +LengthOp defines how to process the key and value of the LeafOp +to include length information. After encoding the length with the given +algorithm, the length will be prepended to the key and value bytes. +(Each one with it's own encoded length) +*/ +enum LengthOp { + // NO_PREFIX don't include any length info + NO_PREFIX = 0; + // VAR_PROTO uses protobuf (and go-amino) varint encoding of the length + VAR_PROTO = 1; + // VAR_RLP uses rlp int encoding of the length + VAR_RLP = 2; + // FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer + FIXED32_BIG = 3; + // FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer + FIXED32_LITTLE = 4; + // FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer + FIXED64_BIG = 5; + // FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer + FIXED64_LITTLE = 6; + // REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output) + REQUIRE_32_BYTES = 7; + // REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output) + REQUIRE_64_BYTES = 8; +} + +/** +ExistenceProof takes a key and a value and a set of steps to perform on it. +The result of peforming all these steps will provide a "root hash", which can +be compared to the value in a header. + +Since it is computationally infeasible to produce a hash collission for any of the used +cryptographic hash functions, if someone can provide a series of operations to transform +a given key and value into a root hash that matches some trusted root, these key and values +must be in the referenced merkle tree. + +The only possible issue is maliablity in LeafOp, such as providing extra prefix data, +which should be controlled by a spec. Eg. with lengthOp as NONE, + prefix = FOO, key = BAR, value = CHOICE +and + prefix = F, key = OOBAR, value = CHOICE +would produce the same value. + +With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field +in the ProofSpec is valuable to prevent this mutability. And why all trees should +length-prefix the data before hashing it. +*/ +message ExistenceProof { + bytes key = 1; + bytes value = 2; + LeafOp leaf = 3; + repeated InnerOp path = 4; +} + +/* +NonExistenceProof takes a proof of two neighbors, one left of the desired key, +one right of the desired key. If both proofs are valid AND they are neighbors, +then there is no valid proof for the given key. +*/ +message NonExistenceProof { + bytes key = 1; // TODO: remove this as unnecessary??? we prove a range + ExistenceProof left = 2; + ExistenceProof right = 3; +} + +/* +CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages +*/ +message CommitmentProof { + oneof proof { + ExistenceProof exist = 1; + NonExistenceProof nonexist = 2; + BatchProof batch = 3; + CompressedBatchProof compressed = 4; + } +} + +/** +LeafOp represents the raw key-value data we wish to prove, and +must be flexible to represent the internal transformation from +the original key-value pairs into the basis hash, for many existing +merkle trees. + +key and value are passed in. So that the signature of this operation is: + leafOp(key, value) -> output + +To process this, first prehash the keys and values if needed (ANY means no hash in this case): + hkey = prehashKey(key) + hvalue = prehashValue(value) + +Then combine the bytes, and hash it + output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue) +*/ +message LeafOp { + HashOp hash = 1; + HashOp prehash_key = 2; + HashOp prehash_value = 3; + LengthOp length = 4; + // prefix is a fixed bytes that may optionally be included at the beginning to differentiate + // a leaf node from an inner node. + bytes prefix = 5; +} + +/** +InnerOp represents a merkle-proof step that is not a leaf. +It represents concatenating two children and hashing them to provide the next result. + +The result of the previous step is passed in, so the signature of this op is: + innerOp(child) -> output + +The result of applying InnerOp should be: + output = op.hash(op.prefix || child || op.suffix) + + where the || operator is concatenation of binary data, +and child is the result of hashing all the tree below this step. + +Any special data, like prepending child with the length, or prepending the entire operation with +some value to differentiate from leaf nodes, should be included in prefix and suffix. +If either of prefix or suffix is empty, we just treat it as an empty string +*/ +message InnerOp { + HashOp hash = 1; + bytes prefix = 2; + bytes suffix = 3; +} + + +/** +ProofSpec defines what the expected parameters are for a given proof type. +This can be stored in the client and used to validate any incoming proofs. + + verify(ProofSpec, Proof) -> Proof | Error + +As demonstrated in tests, if we don't fix the algorithm used to calculate the +LeafHash for a given tree, there are many possible key-value pairs that can +generate a given hash (by interpretting the preimage differently). +We need this for proper security, requires client knows a priori what +tree format server uses. But not in code, rather a configuration object. +*/ +message ProofSpec { + // any field in the ExistenceProof must be the same as in this spec. + // except Prefix, which is just the first bytes of prefix (spec can be longer) + LeafOp leaf_spec = 1; + InnerSpec inner_spec = 2; + // max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries) + int32 max_depth = 3; + // min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) + int32 min_depth = 4; +} + +/* +InnerSpec contains all store-specific structure info to determine if two proofs from a +given store are neighbors. + +This enables: + + isLeftMost(spec: InnerSpec, op: InnerOp) + isRightMost(spec: InnerSpec, op: InnerOp) + isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp) +*/ +message InnerSpec { + // Child order is the ordering of the children node, must count from 0 + // iavl tree is [0, 1] (left then right) + // merk is [0, 2, 1] (left, right, here) + repeated int32 child_order = 1; + int32 child_size = 2; + int32 min_prefix_length = 3; + int32 max_prefix_length = 4; + // empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0) + bytes empty_child = 5; + // hash is the algorithm that must be used for each InnerOp + HashOp hash = 6; +} + +/* +BatchProof is a group of multiple proof types than can be compressed +*/ +message BatchProof { + repeated BatchEntry entries = 1; +} + +// Use BatchEntry not CommitmentProof, to avoid recursion +message BatchEntry { + oneof proof { + ExistenceProof exist = 1; + NonExistenceProof nonexist = 2; + } +} + + +/****** all items here are compressed forms *******/ + +message CompressedBatchProof { + repeated CompressedBatchEntry entries = 1; + repeated InnerOp lookup_inners = 2; +} + +// Use BatchEntry not CommitmentProof, to avoid recursion +message CompressedBatchEntry { + oneof proof { + CompressedExistenceProof exist = 1; + CompressedNonExistenceProof nonexist = 2; + } +} + +message CompressedExistenceProof { + bytes key = 1; + bytes value = 2; + LeafOp leaf = 3; + // these are indexes into the lookup_inners table in CompressedBatchProof + repeated int32 path = 4; +} + +message CompressedNonExistenceProof { + bytes key = 1; // TODO: remove this as unnecessary??? we prove a range + CompressedExistenceProof left = 2; + CompressedExistenceProof right = 3; +} diff --git a/p8e-api/src/main/proto/cosmos/auth/v1beta1/auth.proto b/p8e-api/src/main/proto/cosmos/auth/v1beta1/auth.proto new file mode 100644 index 0000000..72e1d9e --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/auth/v1beta1/auth.proto @@ -0,0 +1,50 @@ +syntax = "proto3"; +package cosmos.auth.v1beta1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/auth/types"; + +// BaseAccount defines a base account type. It contains all the necessary fields +// for basic account functionality. Any custom account type should extend this +// type for additional functionality (e.g. vesting). +message BaseAccount { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.equal) = false; + + option (cosmos_proto.implements_interface) = "AccountI"; + + string address = 1; + google.protobuf.Any pub_key = 2 + [(gogoproto.jsontag) = "public_key,omitempty", (gogoproto.moretags) = "yaml:\"public_key\""]; + uint64 account_number = 3 [(gogoproto.moretags) = "yaml:\"account_number\""]; + uint64 sequence = 4; +} + +// ModuleAccount defines an account for modules that holds coins on a pool. +message ModuleAccount { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + option (cosmos_proto.implements_interface) = "ModuleAccountI"; + + BaseAccount base_account = 1 [(gogoproto.embed) = true, (gogoproto.moretags) = "yaml:\"base_account\""]; + string name = 2; + repeated string permissions = 3; +} + +// Params defines the parameters for the auth module. +message Params { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + uint64 max_memo_characters = 1 [(gogoproto.moretags) = "yaml:\"max_memo_characters\""]; + uint64 tx_sig_limit = 2 [(gogoproto.moretags) = "yaml:\"tx_sig_limit\""]; + uint64 tx_size_cost_per_byte = 3 [(gogoproto.moretags) = "yaml:\"tx_size_cost_per_byte\""]; + uint64 sig_verify_cost_ed25519 = 4 + [(gogoproto.customname) = "SigVerifyCostED25519", (gogoproto.moretags) = "yaml:\"sig_verify_cost_ed25519\""]; + uint64 sig_verify_cost_secp256k1 = 5 + [(gogoproto.customname) = "SigVerifyCostSecp256k1", (gogoproto.moretags) = "yaml:\"sig_verify_cost_secp256k1\""]; +} diff --git a/p8e-api/src/main/proto/cosmos/auth/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/auth/v1beta1/genesis.proto new file mode 100644 index 0000000..c88b94e --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/auth/v1beta1/genesis.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; +package cosmos.auth.v1beta1; + +import "google/protobuf/any.proto"; +import "gogoproto/gogo.proto"; +import "cosmos/auth/v1beta1/auth.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/auth/types"; + +// GenesisState defines the auth module's genesis state. +message GenesisState { + // params defines all the paramaters of the module. + Params params = 1 [(gogoproto.nullable) = false]; + + // accounts are the accounts present at genesis. + repeated google.protobuf.Any accounts = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/auth/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/auth/v1beta1/query.proto new file mode 100644 index 0000000..a885792 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/auth/v1beta1/query.proto @@ -0,0 +1,47 @@ +syntax = "proto3"; +package cosmos.auth.v1beta1; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/api/annotations.proto"; +import "cosmos/auth/v1beta1/auth.proto"; +import "cosmos_proto/cosmos.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/auth/types"; + +// Query defines the gRPC querier service. +service Query { + // Account returns account details based on address. + rpc Account(QueryAccountRequest) returns (QueryAccountResponse) { + option (google.api.http).get = "/cosmos/auth/v1beta1/accounts/{address}"; + } + + // Params queries all parameters. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/auth/v1beta1/params"; + } +} + +// QueryAccountRequest is the request type for the Query/Account RPC method. +message QueryAccountRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address defines the address to query for. + string address = 1; +} + +// QueryAccountResponse is the response type for the Query/Account RPC method. +message QueryAccountResponse { + // account defines the account of the corresponding address. + google.protobuf.Any account = 1 [(cosmos_proto.accepts_interface) = "AccountI"]; +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/bank/v1beta1/bank.proto b/p8e-api/src/main/proto/cosmos/bank/v1beta1/bank.proto new file mode 100644 index 0000000..5a93833 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/bank/v1beta1/bank.proto @@ -0,0 +1,85 @@ +syntax = "proto3"; +package cosmos.bank.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/bank/types"; + +// Params defines the parameters for the bank module. +message Params { + option (gogoproto.goproto_stringer) = false; + repeated SendEnabled send_enabled = 1 [(gogoproto.moretags) = "yaml:\"send_enabled,omitempty\""]; + bool default_send_enabled = 2 [(gogoproto.moretags) = "yaml:\"default_send_enabled,omitempty\""]; +} + +// SendEnabled maps coin denom to a send_enabled status (whether a denom is +// sendable). +message SendEnabled { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + string denom = 1; + bool enabled = 2; +} + +// Input models transaction input. +message Input { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string address = 1; + repeated cosmos.base.v1beta1.Coin coins = 2 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// Output models transaction outputs. +message Output { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string address = 1; + repeated cosmos.base.v1beta1.Coin coins = 2 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// Supply represents a struct that passively keeps track of the total supply +// amounts in the network. +message Supply { + option (gogoproto.equal) = true; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + option (cosmos_proto.implements_interface) = "*github.com/cosmos/cosmos-sdk/x/bank/exported.SupplyI"; + + repeated cosmos.base.v1beta1.Coin total = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// DenomUnit represents a struct that describes a given +// denomination unit of the basic token. +message DenomUnit { + // denom represents the string name of the given denom unit (e.g uatom). + string denom = 1; + // exponent represents power of 10 exponent that one must + // raise the base_denom to in order to equal the given DenomUnit's denom + // 1 denom = 1^exponent base_denom + // (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with + // exponent = 6, thus: 1 atom = 10^6 uatom). + uint32 exponent = 2; + // aliases is a list of string aliases for the given denom + repeated string aliases = 3; +} + +// Metadata represents a struct that describes +// a basic token. +message Metadata { + string description = 1; + // denom_units represents the list of DenomUnit's for a given coin + repeated DenomUnit denom_units = 2; + // base represents the base denom (should be the DenomUnit with exponent = 0). + string base = 3; + // display indicates the suggested denom that should be + // displayed in clients. + string display = 4; +} diff --git a/p8e-api/src/main/proto/cosmos/bank/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/bank/v1beta1/genesis.proto new file mode 100644 index 0000000..25c80a3 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/bank/v1beta1/genesis.proto @@ -0,0 +1,38 @@ +syntax = "proto3"; +package cosmos.bank.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/bank/v1beta1/bank.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/bank/types"; + +// GenesisState defines the bank module's genesis state. +message GenesisState { + // params defines all the paramaters of the module. + Params params = 1 [(gogoproto.nullable) = false]; + + // balances is an array containing the balances of all the accounts. + repeated Balance balances = 2 [(gogoproto.nullable) = false]; + + // supply represents the total supply. + repeated cosmos.base.v1beta1.Coin supply = 3 + [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", (gogoproto.nullable) = false]; + + // denom_metadata defines the metadata of the differents coins. + repeated Metadata denom_metadata = 4 [(gogoproto.moretags) = "yaml:\"denom_metadata\"", (gogoproto.nullable) = false]; +} + +// Balance defines an account address and balance pair used in the bank module's +// genesis state. +message Balance { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the address of the balance holder. + string address = 1; + + // coins defines the different coins this balance holds. + repeated cosmos.base.v1beta1.Coin coins = 2 + [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", (gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/bank/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/bank/v1beta1/query.proto new file mode 100644 index 0000000..bc5e291 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/bank/v1beta1/query.proto @@ -0,0 +1,150 @@ +syntax = "proto3"; +package cosmos.bank.v1beta1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/bank/v1beta1/bank.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/bank/types"; + +// Query defines the gRPC querier service. +service Query { + // Balance queries the balance of a single coin for a single account. + rpc Balance(QueryBalanceRequest) returns (QueryBalanceResponse) { + option (google.api.http).get = "/cosmos/bank/v1beta1/balances/{address}/{denom}"; + } + + // AllBalances queries the balance of all coins for a single account. + rpc AllBalances(QueryAllBalancesRequest) returns (QueryAllBalancesResponse) { + option (google.api.http).get = "/cosmos/bank/v1beta1/balances/{address}"; + } + + // TotalSupply queries the total supply of all coins. + rpc TotalSupply(QueryTotalSupplyRequest) returns (QueryTotalSupplyResponse) { + option (google.api.http).get = "/cosmos/bank/v1beta1/supply"; + } + + // SupplyOf queries the supply of a single coin. + rpc SupplyOf(QuerySupplyOfRequest) returns (QuerySupplyOfResponse) { + option (google.api.http).get = "/cosmos/bank/v1beta1/supply/{denom}"; + } + + // Params queries the parameters of x/bank module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/bank/v1beta1/params"; + } + + // DenomsMetadata queries the client metadata of a given coin denomination. + rpc DenomMetadata(QueryDenomMetadataRequest) returns (QueryDenomMetadataResponse) { + option (google.api.http).get = "/cosmos/bank/v1beta1/denoms_metadata/{denom}"; + } + + // DenomsMetadata queries the client metadata for all registered coin denominations. + rpc DenomsMetadata(QueryDenomsMetadataRequest) returns (QueryDenomsMetadataResponse) { + option (google.api.http).get = "/cosmos/bank/v1beta1/denoms_metadata"; + } +} + +// QueryBalanceRequest is the request type for the Query/Balance RPC method. +message QueryBalanceRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the address to query balances for. + string address = 1; + + // denom is the coin denom to query balances for. + string denom = 2; +} + +// QueryBalanceResponse is the response type for the Query/Balance RPC method. +message QueryBalanceResponse { + // balance is the balance of the coin. + cosmos.base.v1beta1.Coin balance = 1; +} + +// QueryBalanceRequest is the request type for the Query/AllBalances RPC method. +message QueryAllBalancesRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the address to query balances for. + string address = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryAllBalancesResponse is the response type for the Query/AllBalances RPC +// method. +message QueryAllBalancesResponse { + // balances is the balances of all the coins. + repeated cosmos.base.v1beta1.Coin balances = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryTotalSupplyRequest is the request type for the Query/TotalSupply RPC +// method. +message QueryTotalSupplyRequest {} + +// QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC +// method +message QueryTotalSupplyResponse { + // supply is the supply of the coins + repeated cosmos.base.v1beta1.Coin supply = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// QuerySupplyOfRequest is the request type for the Query/SupplyOf RPC method. +message QuerySupplyOfRequest { + // denom is the coin denom to query balances for. + string denom = 1; +} + +// QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method. +message QuerySupplyOfResponse { + // amount is the supply of the coin. + cosmos.base.v1beta1.Coin amount = 1 [(gogoproto.nullable) = false]; +} + +// QueryParamsRequest defines the request type for querying x/bank parameters. +message QueryParamsRequest {} + +// QueryParamsResponse defines the response type for querying x/bank parameters. +message QueryParamsResponse { + Params params = 1 [(gogoproto.nullable) = false]; +} + +// QueryDenomsMetadataRequest is the request type for the Query/DenomsMetadata RPC method. +message QueryDenomsMetadataRequest { + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryDenomsMetadataResponse is the response type for the Query/DenomsMetadata RPC +// method. +message QueryDenomsMetadataResponse { + // metadata provides the client information for all the registered tokens. + repeated Metadata metadatas = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryDenomMetadataRequest is the request type for the Query/DenomMetadata RPC method. +message QueryDenomMetadataRequest { + // denom is the coin denom to query the metadata for. + string denom = 1; +} + +// QueryDenomMetadataResponse is the response type for the Query/DenomMetadata RPC +// method. +message QueryDenomMetadataResponse { + // metadata describes and provides all the client information for the requested token. + Metadata metadata = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/bank/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/bank/v1beta1/tx.proto new file mode 100644 index 0000000..26b2ab4 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/bank/v1beta1/tx.proto @@ -0,0 +1,42 @@ +syntax = "proto3"; +package cosmos.bank.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/bank/v1beta1/bank.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/bank/types"; + +// Msg defines the bank Msg service. +service Msg { + // Send defines a method for sending coins from one account to another account. + rpc Send(MsgSend) returns (MsgSendResponse); + + // MultiSend defines a method for sending coins from some accounts to other accounts. + rpc MultiSend(MsgMultiSend) returns (MsgMultiSendResponse); +} + +// MsgSend represents a message to send coins from one account to another. +message MsgSend { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string from_address = 1 [(gogoproto.moretags) = "yaml:\"from_address\""]; + string to_address = 2 [(gogoproto.moretags) = "yaml:\"to_address\""]; + repeated cosmos.base.v1beta1.Coin amount = 3 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// MsgSendResponse defines the Msg/Send response type. +message MsgSendResponse {} + +// MsgMultiSend represents an arbitrary multi-in, multi-out send message. +message MsgMultiSend { + option (gogoproto.equal) = false; + + repeated Input inputs = 1 [(gogoproto.nullable) = false]; + repeated Output outputs = 2 [(gogoproto.nullable) = false]; +} + +// MsgMultiSendResponse defines the Msg/MultiSend response type. +message MsgMultiSendResponse {} diff --git a/p8e-api/src/main/proto/cosmos/base/abci/v1beta1/abci.proto b/p8e-api/src/main/proto/cosmos/base/abci/v1beta1/abci.proto new file mode 100644 index 0000000..72da2aa --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/abci/v1beta1/abci.proto @@ -0,0 +1,137 @@ +syntax = "proto3"; +package cosmos.base.abci.v1beta1; + +import "gogoproto/gogo.proto"; +import "tendermint/abci/types.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/types"; +option (gogoproto.goproto_stringer_all) = false; + +// TxResponse defines a structure containing relevant tx data and metadata. The +// tags are stringified and the log is JSON decoded. +message TxResponse { + option (gogoproto.goproto_getters) = false; + // The block height + int64 height = 1; + // The transaction hash. + string txhash = 2 [(gogoproto.customname) = "TxHash"]; + // Namespace for the Code + string codespace = 3; + // Response code. + uint32 code = 4; + // Result bytes, if any. + string data = 5; + // The output of the application's logger (raw string). May be + // non-deterministic. + string raw_log = 6; + // The output of the application's logger (typed). May be non-deterministic. + repeated ABCIMessageLog logs = 7 [(gogoproto.castrepeated) = "ABCIMessageLogs", (gogoproto.nullable) = false]; + // Additional information. May be non-deterministic. + string info = 8; + // Amount of gas requested for transaction. + int64 gas_wanted = 9; + // Amount of gas consumed by transaction. + int64 gas_used = 10; + // The request transaction bytes. + google.protobuf.Any tx = 11; + // Time of the previous block. For heights > 1, it's the weighted median of + // the timestamps of the valid votes in the block.LastCommit. For height == 1, + // it's genesis time. + string timestamp = 12; +} + +// ABCIMessageLog defines a structure containing an indexed tx ABCI message log. +message ABCIMessageLog { + option (gogoproto.stringer) = true; + + uint32 msg_index = 1; + string log = 2; + + // Events contains a slice of Event objects that were emitted during some + // execution. + repeated StringEvent events = 3 [(gogoproto.castrepeated) = "StringEvents", (gogoproto.nullable) = false]; +} + +// StringEvent defines en Event object wrapper where all the attributes +// contain key/value pairs that are strings instead of raw bytes. +message StringEvent { + option (gogoproto.stringer) = true; + + string type = 1; + repeated Attribute attributes = 2 [(gogoproto.nullable) = false]; +} + +// Attribute defines an attribute wrapper where the key and value are +// strings instead of raw bytes. +message Attribute { + string key = 1; + string value = 2; +} + +// GasInfo defines tx execution gas context. +message GasInfo { + // GasWanted is the maximum units of work we allow this tx to perform. + uint64 gas_wanted = 1 [(gogoproto.moretags) = "yaml:\"gas_wanted\""]; + + // GasUsed is the amount of gas actually consumed. + uint64 gas_used = 2 [(gogoproto.moretags) = "yaml:\"gas_used\""]; +} + +// Result is the union of ResponseFormat and ResponseCheckTx. +message Result { + option (gogoproto.goproto_getters) = false; + + // Data is any data returned from message or handler execution. It MUST be + // length prefixed in order to separate data from multiple message executions. + bytes data = 1; + + // Log contains the log information from message or handler execution. + string log = 2; + + // Events contains a slice of Event objects that were emitted during message + // or handler execution. + repeated tendermint.abci.Event events = 3 [(gogoproto.nullable) = false]; +} + +// SimulationResponse defines the response generated when a transaction is +// successfully simulated. +message SimulationResponse { + GasInfo gas_info = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + Result result = 2; +} + +// MsgData defines the data returned in a Result object during message +// execution. +message MsgData { + option (gogoproto.stringer) = true; + + string msg_type = 1; + bytes data = 2; +} + +// TxMsgData defines a list of MsgData. A transaction will have a MsgData object +// for each message. +message TxMsgData { + option (gogoproto.stringer) = true; + + repeated MsgData data = 1; +} + +// SearchTxsResult defines a structure for querying txs pageable +message SearchTxsResult { + option (gogoproto.stringer) = true; + + // Count of all txs + uint64 total_count = 1 [(gogoproto.moretags) = "yaml:\"total_count\"", (gogoproto.jsontag) = "total_count"]; + // Count of txs in current page + uint64 count = 2; + // Index of current page, start from 1 + uint64 page_number = 3 [(gogoproto.moretags) = "yaml:\"page_number\"", (gogoproto.jsontag) = "page_number"]; + // Count of total pages + uint64 page_total = 4 [(gogoproto.moretags) = "yaml:\"page_total\"", (gogoproto.jsontag) = "page_total"]; + // Max count txs per page + uint64 limit = 5; + // List of txs in current page + repeated TxResponse txs = 6; +} diff --git a/p8e-api/src/main/proto/cosmos/base/kv/v1beta1/kv.proto b/p8e-api/src/main/proto/cosmos/base/kv/v1beta1/kv.proto new file mode 100644 index 0000000..4e9b8d2 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/kv/v1beta1/kv.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; +package cosmos.base.kv.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/types/kv"; + +// Pairs defines a repeated slice of Pair objects. +message Pairs { + repeated Pair pairs = 1 [(gogoproto.nullable) = false]; +} + +// Pair defines a key/value bytes tuple. +message Pair { + bytes key = 1; + bytes value = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/base/query/v1beta1/pagination.proto b/p8e-api/src/main/proto/cosmos/base/query/v1beta1/pagination.proto new file mode 100644 index 0000000..2a8cbcc --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/query/v1beta1/pagination.proto @@ -0,0 +1,50 @@ +syntax = "proto3"; +package cosmos.base.query.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/types/query"; + +// PageRequest is to be embedded in gRPC request messages for efficient +// pagination. Ex: +// +// message SomeRequest { +// Foo some_parameter = 1; +// PageRequest pagination = 2; +// } +message PageRequest { + // key is a value returned in PageResponse.next_key to begin + // querying the next page most efficiently. Only one of offset or key + // should be set. + bytes key = 1; + + // offset is a numeric offset that can be used when key is unavailable. + // It is less efficient than using key. Only one of offset or key should + // be set. + uint64 offset = 2; + + // limit is the total number of results to be returned in the result page. + // If left empty it will default to a value to be set by each app. + uint64 limit = 3; + + // count_total is set to true to indicate that the result set should include + // a count of the total number of items available for pagination in UIs. + // count_total is only respected when offset is used. It is ignored when key + // is set. + bool count_total = 4; +} + +// PageResponse is to be embedded in gRPC response messages where the +// corresponding request message has used PageRequest. +// +// message SomeResponse { +// repeated Bar results = 1; +// PageResponse page = 2; +// } +message PageResponse { + // next_key is the key to be passed to PageRequest.key to + // query the next page most efficiently + bytes next_key = 1; + + // total is total number of results available if PageRequest.count_total + // was set, its value is undefined otherwise + uint64 total = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/base/reflection/v1beta1/reflection.proto b/p8e-api/src/main/proto/cosmos/base/reflection/v1beta1/reflection.proto new file mode 100644 index 0000000..22670e7 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/reflection/v1beta1/reflection.proto @@ -0,0 +1,44 @@ +syntax = "proto3"; +package cosmos.base.reflection.v1beta1; + +import "google/api/annotations.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/client/grpc/reflection"; + +// ReflectionService defines a service for interface reflection. +service ReflectionService { + // ListAllInterfaces lists all the interfaces registered in the interface + // registry. + rpc ListAllInterfaces(ListAllInterfacesRequest) returns (ListAllInterfacesResponse) { + option (google.api.http).get = "/cosmos/base/reflection/v1beta1/interfaces"; + }; + + // ListImplementations list all the concrete types that implement a given + // interface. + rpc ListImplementations(ListImplementationsRequest) returns (ListImplementationsResponse) { + option (google.api.http).get = "/cosmos/base/reflection/v1beta1/interfaces/" + "{interface_name}/implementations"; + }; +} + +// ListAllInterfacesRequest is the request type of the ListAllInterfaces RPC. +message ListAllInterfacesRequest {} + +// ListAllInterfacesResponse is the response type of the ListAllInterfaces RPC. +message ListAllInterfacesResponse { + // interface_names is an array of all the registered interfaces. + repeated string interface_names = 1; +} + +// ListImplementationsRequest is the request type of the ListImplementations +// RPC. +message ListImplementationsRequest { + // interface_name defines the interface to query the implementations for. + string interface_name = 1; +} + +// ListImplementationsResponse is the response type of the ListImplementations +// RPC. +message ListImplementationsResponse { + repeated string implementation_message_names = 1; +} diff --git a/p8e-api/src/main/proto/cosmos/base/snapshots/v1beta1/snapshot.proto b/p8e-api/src/main/proto/cosmos/base/snapshots/v1beta1/snapshot.proto new file mode 100644 index 0000000..9ac5a7c --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/snapshots/v1beta1/snapshot.proto @@ -0,0 +1,20 @@ +syntax = "proto3"; +package cosmos.base.snapshots.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/snapshots/types"; + +// Snapshot contains Tendermint state sync snapshot info. +message Snapshot { + uint64 height = 1; + uint32 format = 2; + uint32 chunks = 3; + bytes hash = 4; + Metadata metadata = 5 [(gogoproto.nullable) = false]; +} + +// Metadata contains SDK-specific snapshot metadata. +message Metadata { + repeated bytes chunk_hashes = 1; // SHA-256 chunk hashes +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/cosmos/base/store/v1beta1/commit_info.proto b/p8e-api/src/main/proto/cosmos/base/store/v1beta1/commit_info.proto new file mode 100644 index 0000000..98a33d3 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/store/v1beta1/commit_info.proto @@ -0,0 +1,29 @@ +syntax = "proto3"; +package cosmos.base.store.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/store/types"; + +// CommitInfo defines commit information used by the multi-store when committing +// a version/height. +message CommitInfo { + int64 version = 1; + repeated StoreInfo store_infos = 2 [(gogoproto.nullable) = false]; +} + +// StoreInfo defines store-specific commit information. It contains a reference +// between a store name and the commit ID. +message StoreInfo { + string name = 1; + CommitID commit_id = 2 [(gogoproto.nullable) = false]; +} + +// CommitID defines the committment information when a specific store is +// committed. +message CommitID { + option (gogoproto.goproto_stringer) = false; + + int64 version = 1; + bytes hash = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/base/store/v1beta1/snapshot.proto b/p8e-api/src/main/proto/cosmos/base/store/v1beta1/snapshot.proto new file mode 100644 index 0000000..8348550 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/store/v1beta1/snapshot.proto @@ -0,0 +1,28 @@ +syntax = "proto3"; +package cosmos.base.store.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/store/types"; + +// SnapshotItem is an item contained in a rootmulti.Store snapshot. +message SnapshotItem { + // item is the specific type of snapshot item. + oneof item { + SnapshotStoreItem store = 1; + SnapshotIAVLItem iavl = 2 [(gogoproto.customname) = "IAVL"]; + } +} + +// SnapshotStoreItem contains metadata about a snapshotted store. +message SnapshotStoreItem { + string name = 1; +} + +// SnapshotIAVLItem is an exported IAVL node. +message SnapshotIAVLItem { + bytes key = 1; + bytes value = 2; + int64 version = 3; + int32 height = 4; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/cosmos/base/tendermint/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/base/tendermint/v1beta1/query.proto new file mode 100644 index 0000000..50cb585 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/tendermint/v1beta1/query.proto @@ -0,0 +1,136 @@ +syntax = "proto3"; +package cosmos.base.tendermint.v1beta1; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/api/annotations.proto"; +import "tendermint/p2p/types.proto"; +import "tendermint/types/block.proto"; +import "tendermint/types/types.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/client/grpc/tmservice"; + +// Service defines the gRPC querier service for tendermint queries. +service Service { + // GetNodeInfo queries the current node info. + rpc GetNodeInfo(GetNodeInfoRequest) returns (GetNodeInfoResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/node_info"; + } + // GetSyncing queries node syncing. + rpc GetSyncing(GetSyncingRequest) returns (GetSyncingResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/syncing"; + } + // GetLatestBlock returns the latest block. + rpc GetLatestBlock(GetLatestBlockRequest) returns (GetLatestBlockResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/blocks/latest"; + } + // GetBlockByHeight queries block for given height. + rpc GetBlockByHeight(GetBlockByHeightRequest) returns (GetBlockByHeightResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/blocks/{height}"; + } + + // GetLatestValidatorSet queries latest validator-set. + rpc GetLatestValidatorSet(GetLatestValidatorSetRequest) returns (GetLatestValidatorSetResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/validatorsets/latest"; + } + // GetValidatorSetByHeight queries validator-set at a given height. + rpc GetValidatorSetByHeight(GetValidatorSetByHeightRequest) returns (GetValidatorSetByHeightResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/validatorsets/{height}"; + } +} + +// GetValidatorSetByHeightRequest is the request type for the Query/GetValidatorSetByHeight RPC method. +message GetValidatorSetByHeightRequest { + int64 height = 1; + // pagination defines an pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// GetValidatorSetByHeightResponse is the response type for the Query/GetValidatorSetByHeight RPC method. +message GetValidatorSetByHeightResponse { + int64 block_height = 1; + repeated Validator validators = 2; + // pagination defines an pagination for the response. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} + +// GetLatestValidatorSetRequest is the request type for the Query/GetValidatorSetByHeight RPC method. +message GetLatestValidatorSetRequest { + // pagination defines an pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// GetLatestValidatorSetResponse is the response type for the Query/GetValidatorSetByHeight RPC method. +message GetLatestValidatorSetResponse { + int64 block_height = 1; + repeated Validator validators = 2; + // pagination defines an pagination for the response. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} + +// Validator is the type for the validator-set. +message Validator { + string address = 1; + google.protobuf.Any pub_key = 2; + int64 voting_power = 3; + int64 proposer_priority = 4; +} + +// GetBlockByHeightRequest is the request type for the Query/GetBlockByHeight RPC method. +message GetBlockByHeightRequest { + int64 height = 1; +} + +// GetBlockByHeightResponse is the response type for the Query/GetBlockByHeight RPC method. +message GetBlockByHeightResponse { + .tendermint.types.BlockID block_id = 1; + .tendermint.types.Block block = 2; +} + +// GetLatestBlockRequest is the request type for the Query/GetLatestBlock RPC method. +message GetLatestBlockRequest {} + +// GetLatestBlockResponse is the response type for the Query/GetLatestBlock RPC method. +message GetLatestBlockResponse { + .tendermint.types.BlockID block_id = 1; + .tendermint.types.Block block = 2; +} + +// GetSyncingRequest is the request type for the Query/GetSyncing RPC method. +message GetSyncingRequest {} + +// GetSyncingResponse is the response type for the Query/GetSyncing RPC method. +message GetSyncingResponse { + bool syncing = 1; +} + +// GetNodeInfoRequest is the request type for the Query/GetNodeInfo RPC method. +message GetNodeInfoRequest {} + +// GetNodeInfoResponse is the request type for the Query/GetNodeInfo RPC method. +message GetNodeInfoResponse { + .tendermint.p2p.DefaultNodeInfo default_node_info = 1; + VersionInfo application_version = 2; +} + +// VersionInfo is the type for the GetNodeInfoResponse message. +message VersionInfo { + string name = 1; + string app_name = 2; + string version = 3; + string git_commit = 4; + string build_tags = 5; + string go_version = 6; + repeated Module build_deps = 7; +} + +// Module is the type for VersionInfo +message Module { + // module path + string path = 1; + // module version + string version = 2; + // checksum + string sum = 3; +} diff --git a/p8e-api/src/main/proto/cosmos/base/v1beta1/coin.proto b/p8e-api/src/main/proto/cosmos/base/v1beta1/coin.proto new file mode 100644 index 0000000..fab7528 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/base/v1beta1/coin.proto @@ -0,0 +1,40 @@ +syntax = "proto3"; +package cosmos.base.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/types"; +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.stringer_all) = false; + +// Coin defines a token with a denomination and an amount. +// +// NOTE: The amount field is an Int which implements the custom method +// signatures required by gogoproto. +message Coin { + option (gogoproto.equal) = true; + + string denom = 1; + string amount = 2 [(gogoproto.customtype) = "Int", (gogoproto.nullable) = false]; +} + +// DecCoin defines a token with a denomination and a decimal amount. +// +// NOTE: The amount field is an Dec which implements the custom method +// signatures required by gogoproto. +message DecCoin { + option (gogoproto.equal) = true; + + string denom = 1; + string amount = 2 [(gogoproto.customtype) = "Dec", (gogoproto.nullable) = false]; +} + +// IntProto defines a Protobuf wrapper around an Int object. +message IntProto { + string int = 1 [(gogoproto.customtype) = "Int", (gogoproto.nullable) = false]; +} + +// DecProto defines a Protobuf wrapper around a Dec object. +message DecProto { + string dec = 1 [(gogoproto.customtype) = "Dec", (gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/capability/v1beta1/capability.proto b/p8e-api/src/main/proto/cosmos/capability/v1beta1/capability.proto new file mode 100644 index 0000000..1c8332f --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/capability/v1beta1/capability.proto @@ -0,0 +1,30 @@ +syntax = "proto3"; +package cosmos.capability.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/capability/types"; + +import "gogoproto/gogo.proto"; + +// Capability defines an implementation of an object capability. The index +// provided to a Capability must be globally unique. +message Capability { + option (gogoproto.goproto_stringer) = false; + + uint64 index = 1 [(gogoproto.moretags) = "yaml:\"index\""]; +} + +// Owner defines a single capability owner. An owner is defined by the name of +// capability and the module name. +message Owner { + option (gogoproto.goproto_stringer) = false; + option (gogoproto.goproto_getters) = false; + + string module = 1 [(gogoproto.moretags) = "yaml:\"module\""]; + string name = 2 [(gogoproto.moretags) = "yaml:\"name\""]; +} + +// CapabilityOwners defines a set of owners of a single Capability. The set of +// owners must be unique. +message CapabilityOwners { + repeated Owner owners = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/capability/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/capability/v1beta1/genesis.proto new file mode 100644 index 0000000..05bb0af --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/capability/v1beta1/genesis.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; +package cosmos.capability.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/capability/v1beta1/capability.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/capability/types"; + +// GenesisOwners defines the capability owners with their corresponding index. +message GenesisOwners { + // index is the index of the capability owner. + uint64 index = 1; + + // index_owners are the owners at the given index. + CapabilityOwners index_owners = 2 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"index_owners\""]; +} + +// GenesisState defines the capability module's genesis state. +message GenesisState { + // index is the capability global index. + uint64 index = 1; + + // owners represents a map from index to owners of the capability index + // index key is string to allow amino marshalling. + repeated GenesisOwners owners = 2 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/crisis/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/crisis/v1beta1/genesis.proto new file mode 100644 index 0000000..5b0ff7e --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/crisis/v1beta1/genesis.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; +package cosmos.crisis.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/crisis/types"; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +// GenesisState defines the crisis module's genesis state. +message GenesisState { + // constant_fee is the fee used to verify the invariant in the crisis + // module. + cosmos.base.v1beta1.Coin constant_fee = 3 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"constant_fee\""]; +} diff --git a/p8e-api/src/main/proto/cosmos/crisis/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/crisis/v1beta1/tx.proto new file mode 100644 index 0000000..26457ad --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/crisis/v1beta1/tx.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; +package cosmos.crisis.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/crisis/types"; + +import "gogoproto/gogo.proto"; + +// Msg defines the bank Msg service. +service Msg { + // VerifyInvariant defines a method to verify a particular invariance. + rpc VerifyInvariant(MsgVerifyInvariant) returns (MsgVerifyInvariantResponse); +} + +// MsgVerifyInvariant represents a message to verify a particular invariance. +message MsgVerifyInvariant { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string sender = 1; + string invariant_module_name = 2 [(gogoproto.moretags) = "yaml:\"invariant_module_name\""]; + string invariant_route = 3 [(gogoproto.moretags) = "yaml:\"invariant_route\""]; +} + +// MsgVerifyInvariantResponse defines the Msg/VerifyInvariant response type. +message MsgVerifyInvariantResponse {} diff --git a/p8e-api/src/main/proto/cosmos/crypto/ed25519/keys.proto b/p8e-api/src/main/proto/cosmos/crypto/ed25519/keys.proto new file mode 100644 index 0000000..bed9c29 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/crypto/ed25519/keys.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; +package cosmos.crypto.ed25519; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"; + +// PubKey defines a ed25519 public key +// Key is the compressed form of the pubkey. The first byte depends is a 0x02 byte +// if the y-coordinate is the lexicographically largest of the two associated with +// the x-coordinate. Otherwise the first byte is a 0x03. +// This prefix is followed with the x-coordinate. +message PubKey { + option (gogoproto.goproto_stringer) = false; + + bytes key = 1 [(gogoproto.casttype) = "crypto/ed25519.PublicKey"]; +} + +// PrivKey defines a ed25519 private key. +message PrivKey { + bytes key = 1 [(gogoproto.casttype) = "crypto/ed25519.PrivateKey"]; +} diff --git a/p8e-api/src/main/proto/cosmos/crypto/multisig/keys.proto b/p8e-api/src/main/proto/cosmos/crypto/multisig/keys.proto new file mode 100644 index 0000000..f8398e8 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/crypto/multisig/keys.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; +package cosmos.crypto.multisig; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/crypto/keys/multisig"; + +// LegacyAminoPubKey specifies a public key type +// which nests multiple public keys and a threshold, +// it uses legacy amino address rules. +message LegacyAminoPubKey { + option (gogoproto.goproto_getters) = false; + + uint32 threshold = 1 [(gogoproto.moretags) = "yaml:\"threshold\""]; + repeated google.protobuf.Any public_keys = 2 + [(gogoproto.customname) = "PubKeys", (gogoproto.moretags) = "yaml:\"pubkeys\""]; +} diff --git a/p8e-api/src/main/proto/cosmos/crypto/multisig/v1beta1/multisig.proto b/p8e-api/src/main/proto/cosmos/crypto/multisig/v1beta1/multisig.proto new file mode 100644 index 0000000..bf671f1 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/crypto/multisig/v1beta1/multisig.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; +package cosmos.crypto.multisig.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/crypto/types"; + +// MultiSignature wraps the signatures from a multisig.LegacyAminoPubKey. +// See cosmos.tx.v1betata1.ModeInfo.Multi for how to specify which signers +// signed and with which modes. +message MultiSignature { + option (gogoproto.goproto_unrecognized) = true; + repeated bytes signatures = 1; +} + +// CompactBitArray is an implementation of a space efficient bit array. +// This is used to ensure that the encoded data takes up a minimal amount of +// space after proto encoding. +// This is not thread safe, and is not intended for concurrent usage. +message CompactBitArray { + option (gogoproto.goproto_stringer) = false; + + uint32 extra_bits_stored = 1; + bytes elems = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/crypto/secp256k1/keys.proto b/p8e-api/src/main/proto/cosmos/crypto/secp256k1/keys.proto new file mode 100644 index 0000000..a227257 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/crypto/secp256k1/keys.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; +package cosmos.crypto.secp256k1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"; + +// PubKey defines a secp256k1 public key +// Key is the compressed form of the pubkey. The first byte depends is a 0x02 byte +// if the y-coordinate is the lexicographically largest of the two associated with +// the x-coordinate. Otherwise the first byte is a 0x03. +// This prefix is followed with the x-coordinate. +message PubKey { + option (gogoproto.goproto_stringer) = false; + + bytes key = 1; +} + +// PrivKey defines a secp256k1 private key. +message PrivKey { + bytes key = 1; +} diff --git a/p8e-api/src/main/proto/cosmos/distribution/v1beta1/distribution.proto b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/distribution.proto new file mode 100644 index 0000000..ae98ec0 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/distribution.proto @@ -0,0 +1,157 @@ +syntax = "proto3"; +package cosmos.distribution.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/distribution/types"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +// Params defines the set of params for the distribution module. +message Params { + option (gogoproto.goproto_stringer) = false; + string community_tax = 1 [ + (gogoproto.moretags) = "yaml:\"community_tax\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + string base_proposer_reward = 2 [ + (gogoproto.moretags) = "yaml:\"base_proposer_reward\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + string bonus_proposer_reward = 3 [ + (gogoproto.moretags) = "yaml:\"bonus_proposer_reward\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + bool withdraw_addr_enabled = 4 [(gogoproto.moretags) = "yaml:\"withdraw_addr_enabled\""]; +} + +// ValidatorHistoricalRewards represents historical rewards for a validator. +// Height is implicit within the store key. +// Cumulative reward ratio is the sum from the zeroeth period +// until this period of rewards / tokens, per the spec. +// The reference count indicates the number of objects +// which might need to reference this historical entry at any point. +// ReferenceCount = +// number of outstanding delegations which ended the associated period (and +// might need to read that record) +// + number of slashes which ended the associated period (and might need to +// read that record) +// + one per validator for the zeroeth period, set on initialization +message ValidatorHistoricalRewards { + repeated cosmos.base.v1beta1.DecCoin cumulative_reward_ratio = 1 [ + (gogoproto.moretags) = "yaml:\"cumulative_reward_ratio\"", + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", + (gogoproto.nullable) = false + ]; + uint32 reference_count = 2 [(gogoproto.moretags) = "yaml:\"reference_count\""]; +} + +// ValidatorCurrentRewards represents current rewards and current +// period for a validator kept as a running counter and incremented +// each block as long as the validator's tokens remain constant. +message ValidatorCurrentRewards { + repeated cosmos.base.v1beta1.DecCoin rewards = 1 + [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", (gogoproto.nullable) = false]; + uint64 period = 2; +} + +// ValidatorAccumulatedCommission represents accumulated commission +// for a validator kept as a running counter, can be withdrawn at any time. +message ValidatorAccumulatedCommission { + repeated cosmos.base.v1beta1.DecCoin commission = 1 + [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", (gogoproto.nullable) = false]; +} + +// ValidatorOutstandingRewards represents outstanding (un-withdrawn) rewards +// for a validator inexpensive to track, allows simple sanity checks. +message ValidatorOutstandingRewards { + repeated cosmos.base.v1beta1.DecCoin rewards = 1 [ + (gogoproto.moretags) = "yaml:\"rewards\"", + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", + (gogoproto.nullable) = false + ]; +} + +// ValidatorSlashEvent represents a validator slash event. +// Height is implicit within the store key. +// This is needed to calculate appropriate amount of staking tokens +// for delegations which are withdrawn after a slash has occurred. +message ValidatorSlashEvent { + uint64 validator_period = 1 [(gogoproto.moretags) = "yaml:\"validator_period\""]; + string fraction = 2 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; +} + +// ValidatorSlashEvents is a collection of ValidatorSlashEvent messages. +message ValidatorSlashEvents { + option (gogoproto.goproto_stringer) = false; + repeated ValidatorSlashEvent validator_slash_events = 1 + [(gogoproto.moretags) = "yaml:\"validator_slash_events\"", (gogoproto.nullable) = false]; +} + +// FeePool is the global fee pool for distribution. +message FeePool { + repeated cosmos.base.v1beta1.DecCoin community_pool = 1 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", + (gogoproto.moretags) = "yaml:\"community_pool\"" + ]; +} + +// CommunityPoolSpendProposal details a proposal for use of community funds, +// together with how many coins are proposed to be spent, and to which +// recipient account. +message CommunityPoolSpendProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + string recipient = 3; + repeated cosmos.base.v1beta1.Coin amount = 4 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// DelegatorStartingInfo represents the starting info for a delegator reward +// period. It tracks the previous validator period, the delegation's amount of +// staking token, and the creation height (to check later on if any slashes have +// occurred). NOTE: Even though validators are slashed to whole staking tokens, +// the delegators within the validator may be left with less than a full token, +// thus sdk.Dec is used. +message DelegatorStartingInfo { + uint64 previous_period = 1 [(gogoproto.moretags) = "yaml:\"previous_period\""]; + string stake = 2 [ + (gogoproto.moretags) = "yaml:\"stake\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + uint64 height = 3 [(gogoproto.moretags) = "yaml:\"creation_height\"", (gogoproto.jsontag) = "creation_height"]; +} + +// DelegationDelegatorReward represents the properties +// of a delegator's delegation reward. +message DelegationDelegatorReward { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = true; + + string validator_address = 1 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + + repeated cosmos.base.v1beta1.DecCoin reward = 2 + [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", (gogoproto.nullable) = false]; +} + +// CommunityPoolSpendProposalWithDeposit defines a CommunityPoolSpendProposal +// with a deposit +message CommunityPoolSpendProposalWithDeposit { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = true; + + string title = 1 [(gogoproto.moretags) = "yaml:\"title\""]; + string description = 2 [(gogoproto.moretags) = "yaml:\"description\""]; + string recipient = 3 [(gogoproto.moretags) = "yaml:\"recipient\""]; + string amount = 4 [(gogoproto.moretags) = "yaml:\"amount\""]; + string deposit = 5 [(gogoproto.moretags) = "yaml:\"deposit\""]; +} diff --git a/p8e-api/src/main/proto/cosmos/distribution/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/genesis.proto new file mode 100644 index 0000000..c0b17cd --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/genesis.proto @@ -0,0 +1,155 @@ +syntax = "proto3"; +package cosmos.distribution.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/distribution/types"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/distribution/v1beta1/distribution.proto"; + +// DelegatorWithdrawInfo is the address for where distributions rewards are +// withdrawn to by default this struct is only used at genesis to feed in +// default withdraw addresses. +message DelegatorWithdrawInfo { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_address is the address of the delegator. + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + + // withdraw_address is the address to withdraw the delegation rewards to. + string withdraw_address = 2 [(gogoproto.moretags) = "yaml:\"withdraw_address\""]; +} + +// ValidatorOutstandingRewardsRecord is used for import/export via genesis json. +message ValidatorOutstandingRewardsRecord { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // validator_address is the address of the validator. + string validator_address = 1 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + + // outstanding_rewards represents the oustanding rewards of a validator. + repeated cosmos.base.v1beta1.DecCoin outstanding_rewards = 2 [ + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"outstanding_rewards\"" + ]; +} + +// ValidatorAccumulatedCommissionRecord is used for import / export via genesis +// json. +message ValidatorAccumulatedCommissionRecord { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // validator_address is the address of the validator. + string validator_address = 1 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + + // accumulated is the accumulated commission of a validator. + ValidatorAccumulatedCommission accumulated = 2 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"accumulated\""]; +} + +// ValidatorHistoricalRewardsRecord is used for import / export via genesis +// json. +message ValidatorHistoricalRewardsRecord { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // validator_address is the address of the validator. + string validator_address = 1 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + + // period defines the period the historical rewards apply to. + uint64 period = 2; + + // rewards defines the historical rewards of a validator. + ValidatorHistoricalRewards rewards = 3 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"rewards\""]; +} + +// ValidatorCurrentRewardsRecord is used for import / export via genesis json. +message ValidatorCurrentRewardsRecord { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // validator_address is the address of the validator. + string validator_address = 1 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + + // rewards defines the current rewards of a validator. + ValidatorCurrentRewards rewards = 2 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"rewards\""]; +} + +// DelegatorStartingInfoRecord used for import / export via genesis json. +message DelegatorStartingInfoRecord { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_address is the address of the delegator. + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + + // validator_address is the address of the validator. + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + + // starting_info defines the starting info of a delegator. + DelegatorStartingInfo starting_info = 3 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"starting_info\""]; +} + +// ValidatorSlashEventRecord is used for import / export via genesis json. +message ValidatorSlashEventRecord { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // validator_address is the address of the validator. + string validator_address = 1 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + // height defines the block height at which the slash event occured. + uint64 height = 2; + // period is the period of the slash event. + uint64 period = 3; + // validator_slash_event describes the slash event. + ValidatorSlashEvent validator_slash_event = 4 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"event\""]; +} + +// GenesisState defines the distribution module's genesis state. +message GenesisState { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // params defines all the paramaters of the module. + Params params = 1 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"params\""]; + + // fee_pool defines the fee pool at genesis. + FeePool fee_pool = 2 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"fee_pool\""]; + + // fee_pool defines the delegator withdraw infos at genesis. + repeated DelegatorWithdrawInfo delegator_withdraw_infos = 3 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"delegator_withdraw_infos\""]; + + // fee_pool defines the previous proposer at genesis. + string previous_proposer = 4 [(gogoproto.moretags) = "yaml:\"previous_proposer\""]; + + // fee_pool defines the outstanding rewards of all validators at genesis. + repeated ValidatorOutstandingRewardsRecord outstanding_rewards = 5 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"outstanding_rewards\""]; + + // fee_pool defines the accumulated commisions of all validators at genesis. + repeated ValidatorAccumulatedCommissionRecord validator_accumulated_commissions = 6 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"validator_accumulated_commissions\""]; + + // fee_pool defines the historical rewards of all validators at genesis. + repeated ValidatorHistoricalRewardsRecord validator_historical_rewards = 7 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"validator_historical_rewards\""]; + + // fee_pool defines the current rewards of all validators at genesis. + repeated ValidatorCurrentRewardsRecord validator_current_rewards = 8 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"validator_current_rewards\""]; + + // fee_pool defines the delegator starting infos at genesis. + repeated DelegatorStartingInfoRecord delegator_starting_infos = 9 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"delegator_starting_infos\""]; + + // fee_pool defines the validator slash events at genesis. + repeated ValidatorSlashEventRecord validator_slash_events = 10 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"validator_slash_events\""]; +} diff --git a/p8e-api/src/main/proto/cosmos/distribution/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/query.proto new file mode 100644 index 0000000..2991218 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/query.proto @@ -0,0 +1,218 @@ +syntax = "proto3"; +package cosmos.distribution.v1beta1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/distribution/v1beta1/distribution.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/distribution/types"; + +// Query defines the gRPC querier service for distribution module. +service Query { + // Params queries params of the distribution module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/params"; + } + + // ValidatorOutstandingRewards queries rewards of a validator address. + rpc ValidatorOutstandingRewards(QueryValidatorOutstandingRewardsRequest) + returns (QueryValidatorOutstandingRewardsResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/validators/" + "{validator_address}/outstanding_rewards"; + } + + // ValidatorCommission queries accumulated commission for a validator. + rpc ValidatorCommission(QueryValidatorCommissionRequest) returns (QueryValidatorCommissionResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/validators/" + "{validator_address}/commission"; + } + + // ValidatorSlashes queries slash events of a validator. + rpc ValidatorSlashes(QueryValidatorSlashesRequest) returns (QueryValidatorSlashesResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/validators/{validator_address}/slashes"; + } + + // DelegationRewards queries the total rewards accrued by a delegation. + rpc DelegationRewards(QueryDelegationRewardsRequest) returns (QueryDelegationRewardsResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/" + "{validator_address}"; + } + + // DelegationTotalRewards queries the total rewards accrued by a each + // validator. + rpc DelegationTotalRewards(QueryDelegationTotalRewardsRequest) returns (QueryDelegationTotalRewardsResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards"; + } + + // DelegatorValidators queries the validators of a delegator. + rpc DelegatorValidators(QueryDelegatorValidatorsRequest) returns (QueryDelegatorValidatorsResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/delegators/" + "{delegator_address}/validators"; + } + + // DelegatorWithdrawAddress queries withdraw address of a delegator. + rpc DelegatorWithdrawAddress(QueryDelegatorWithdrawAddressRequest) returns (QueryDelegatorWithdrawAddressResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/delegators/" + "{delegator_address}/withdraw_address"; + } + + // CommunityPool queries the community pool coins. + rpc CommunityPool(QueryCommunityPoolRequest) returns (QueryCommunityPoolResponse) { + option (google.api.http).get = "/cosmos/distribution/v1beta1/community_pool"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; +} + +// QueryValidatorOutstandingRewardsRequest is the request type for the +// Query/ValidatorOutstandingRewards RPC method. +message QueryValidatorOutstandingRewardsRequest { + // validator_address defines the validator address to query for. + string validator_address = 1; +} + +// QueryValidatorOutstandingRewardsResponse is the response type for the +// Query/ValidatorOutstandingRewards RPC method. +message QueryValidatorOutstandingRewardsResponse { + ValidatorOutstandingRewards rewards = 1 [(gogoproto.nullable) = false]; +} + +// QueryValidatorCommissionRequest is the request type for the +// Query/ValidatorCommission RPC method +message QueryValidatorCommissionRequest { + // validator_address defines the validator address to query for. + string validator_address = 1; +} + +// QueryValidatorCommissionResponse is the response type for the +// Query/ValidatorCommission RPC method +message QueryValidatorCommissionResponse { + // commission defines the commision the validator received. + ValidatorAccumulatedCommission commission = 1 [(gogoproto.nullable) = false]; +} + +// QueryValidatorSlashesRequest is the request type for the +// Query/ValidatorSlashes RPC method +message QueryValidatorSlashesRequest { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = true; + + // validator_address defines the validator address to query for. + string validator_address = 1; + // starting_height defines the optional starting height to query the slashes. + uint64 starting_height = 2; + // starting_height defines the optional ending height to query the slashes. + uint64 ending_height = 3; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 4; +} + +// QueryValidatorSlashesResponse is the response type for the +// Query/ValidatorSlashes RPC method. +message QueryValidatorSlashesResponse { + // slashes defines the slashes the validator received. + repeated ValidatorSlashEvent slashes = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryDelegationRewardsRequest is the request type for the +// Query/DelegationRewards RPC method. +message QueryDelegationRewardsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_address defines the delegator address to query for. + string delegator_address = 1; + // validator_address defines the validator address to query for. + string validator_address = 2; +} + +// QueryDelegationRewardsResponse is the response type for the +// Query/DelegationRewards RPC method. +message QueryDelegationRewardsResponse { + // rewards defines the rewards accrued by a delegation. + repeated cosmos.base.v1beta1.DecCoin rewards = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins"]; +} + +// QueryDelegationTotalRewardsRequest is the request type for the +// Query/DelegationTotalRewards RPC method. +message QueryDelegationTotalRewardsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // delegator_address defines the delegator address to query for. + string delegator_address = 1; +} + +// QueryDelegationTotalRewardsResponse is the response type for the +// Query/DelegationTotalRewards RPC method. +message QueryDelegationTotalRewardsResponse { + // rewards defines all the rewards accrued by a delegator. + repeated DelegationDelegatorReward rewards = 1 [(gogoproto.nullable) = false]; + // total defines the sum of all the rewards. + repeated cosmos.base.v1beta1.DecCoin total = 2 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins"]; +} + +// QueryDelegatorValidatorsRequest is the request type for the +// Query/DelegatorValidators RPC method. +message QueryDelegatorValidatorsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_address defines the delegator address to query for. + string delegator_address = 1; +} + +// QueryDelegatorValidatorsResponse is the response type for the +// Query/DelegatorValidators RPC method. +message QueryDelegatorValidatorsResponse { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // validators defines the validators a delegator is delegating for. + repeated string validators = 1; +} + +// QueryDelegatorWithdrawAddressRequest is the request type for the +// Query/DelegatorWithdrawAddress RPC method. +message QueryDelegatorWithdrawAddressRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_address defines the delegator address to query for. + string delegator_address = 1; +} + +// QueryDelegatorWithdrawAddressResponse is the response type for the +// Query/DelegatorWithdrawAddress RPC method. +message QueryDelegatorWithdrawAddressResponse { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // withdraw_address defines the delegator address to query for. + string withdraw_address = 1; +} + +// QueryCommunityPoolRequest is the request type for the Query/CommunityPool RPC +// method. +message QueryCommunityPoolRequest {} + +// QueryCommunityPoolResponse is the response type for the Query/CommunityPool +// RPC method. +message QueryCommunityPoolResponse { + // pool defines community pool's coins. + repeated cosmos.base.v1beta1.DecCoin pool = 1 + [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", (gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/distribution/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/tx.proto new file mode 100644 index 0000000..e6ce478 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/distribution/v1beta1/tx.proto @@ -0,0 +1,79 @@ +syntax = "proto3"; +package cosmos.distribution.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/distribution/types"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +// Msg defines the distribution Msg service. +service Msg { + // SetWithdrawAddress defines a method to change the withdraw address + // for a delegator (or validator self-delegation). + rpc SetWithdrawAddress(MsgSetWithdrawAddress) returns (MsgSetWithdrawAddressResponse); + + // WithdrawDelegatorReward defines a method to withdraw rewards of delegator + // from a single validator. + rpc WithdrawDelegatorReward(MsgWithdrawDelegatorReward) returns (MsgWithdrawDelegatorRewardResponse); + + // WithdrawValidatorCommission defines a method to withdraw the + // full commission to the validator address. + rpc WithdrawValidatorCommission(MsgWithdrawValidatorCommission) returns (MsgWithdrawValidatorCommissionResponse); + + // FundCommunityPool defines a method to allow an account to directly + // fund the community pool. + rpc FundCommunityPool(MsgFundCommunityPool) returns (MsgFundCommunityPoolResponse); +} + +// MsgSetWithdrawAddress sets the withdraw address for +// a delegator (or validator self-delegation). +message MsgSetWithdrawAddress { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string withdraw_address = 2 [(gogoproto.moretags) = "yaml:\"withdraw_address\""]; +} + +// MsgSetWithdrawAddressResponse defines the Msg/SetWithdrawAddress response type. +message MsgSetWithdrawAddressResponse {} + +// MsgWithdrawDelegatorReward represents delegation withdrawal to a delegator +// from a single validator. +message MsgWithdrawDelegatorReward { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; +} + +// MsgWithdrawDelegatorRewardResponse defines the Msg/WithdrawDelegatorReward response type. +message MsgWithdrawDelegatorRewardResponse {} + +// MsgWithdrawValidatorCommission withdraws the full commission to the validator +// address. +message MsgWithdrawValidatorCommission { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string validator_address = 1 [(gogoproto.moretags) = "yaml:\"validator_address\""]; +} + +// MsgWithdrawValidatorCommissionResponse defines the Msg/WithdrawValidatorCommission response type. +message MsgWithdrawValidatorCommissionResponse {} + +// MsgFundCommunityPool allows an account to directly +// fund the community pool. +message MsgFundCommunityPool { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + repeated cosmos.base.v1beta1.Coin amount = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; + string depositor = 2; +} + +// MsgFundCommunityPoolResponse defines the Msg/FundCommunityPool response type. +message MsgFundCommunityPoolResponse {} diff --git a/p8e-api/src/main/proto/cosmos/evidence/v1beta1/evidence.proto b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/evidence.proto new file mode 100644 index 0000000..14612c3 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/evidence.proto @@ -0,0 +1,21 @@ +syntax = "proto3"; +package cosmos.evidence.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/evidence/types"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; +import "google/protobuf/timestamp.proto"; + +// Equivocation implements the Evidence interface and defines evidence of double +// signing misbehavior. +message Equivocation { + option (gogoproto.goproto_stringer) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.equal) = false; + + int64 height = 1; + google.protobuf.Timestamp time = 2 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + int64 power = 3; + string consensus_address = 4 [(gogoproto.moretags) = "yaml:\"consensus_address\""]; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/cosmos/evidence/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/genesis.proto new file mode 100644 index 0000000..199f446 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/genesis.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; +package cosmos.evidence.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/evidence/types"; + +import "google/protobuf/any.proto"; + +// GenesisState defines the evidence module's genesis state. +message GenesisState { + // evidence defines all the evidence at genesis. + repeated google.protobuf.Any evidence = 1; +} diff --git a/p8e-api/src/main/proto/cosmos/evidence/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/query.proto new file mode 100644 index 0000000..eda0054 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/query.proto @@ -0,0 +1,51 @@ +syntax = "proto3"; +package cosmos.evidence.v1beta1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/api/annotations.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/evidence/types"; + +// Query defines the gRPC querier service. +service Query { + // Evidence queries evidence based on evidence hash. + rpc Evidence(QueryEvidenceRequest) returns (QueryEvidenceResponse) { + option (google.api.http).get = "/cosmos/evidence/v1beta1/evidence/{evidence_hash}"; + } + + // AllEvidence queries all evidence. + rpc AllEvidence(QueryAllEvidenceRequest) returns (QueryAllEvidenceResponse) { + option (google.api.http).get = "/cosmos/evidence/v1beta1/evidence"; + } +} + +// QueryEvidenceRequest is the request type for the Query/Evidence RPC method. +message QueryEvidenceRequest { + // evidence_hash defines the hash of the requested evidence. + bytes evidence_hash = 1 [(gogoproto.casttype) = "github.com/tendermint/tendermint/libs/bytes.HexBytes"]; +} + +// QueryEvidenceResponse is the response type for the Query/Evidence RPC method. +message QueryEvidenceResponse { + // evidence returns the requested evidence. + google.protobuf.Any evidence = 1; +} + +// QueryEvidenceRequest is the request type for the Query/AllEvidence RPC +// method. +message QueryAllEvidenceRequest { + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC +// method. +message QueryAllEvidenceResponse { + // evidence returns all evidences. + repeated google.protobuf.Any evidence = 1; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/evidence/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/tx.proto new file mode 100644 index 0000000..38795f2 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/evidence/v1beta1/tx.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; +package cosmos.evidence.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/evidence/types"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "cosmos_proto/cosmos.proto"; + +// Msg defines the evidence Msg service. +service Msg { + // SubmitEvidence submits an arbitrary Evidence of misbehavior such as equivocation or + // counterfactual signing. + rpc SubmitEvidence(MsgSubmitEvidence) returns (MsgSubmitEvidenceResponse); +} + +// MsgSubmitEvidence represents a message that supports submitting arbitrary +// Evidence of misbehavior such as equivocation or counterfactual signing. +message MsgSubmitEvidence { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string submitter = 1; + google.protobuf.Any evidence = 2 [(cosmos_proto.accepts_interface) = "Evidence"]; +} + +// MsgSubmitEvidenceResponse defines the Msg/SubmitEvidence response type. +message MsgSubmitEvidenceResponse { + // hash defines the hash of the evidence. + bytes hash = 4; +} diff --git a/p8e-api/src/main/proto/cosmos/genutil/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/genutil/v1beta1/genesis.proto new file mode 100644 index 0000000..a020779 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/genutil/v1beta1/genesis.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; +package cosmos.genutil.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/genutil/types"; + +// GenesisState defines the raw genesis transaction in JSON. +message GenesisState { + // gen_txs defines the genesis transactions. + repeated bytes gen_txs = 1 [ + (gogoproto.casttype) = "encoding/json.RawMessage", + (gogoproto.jsontag) = "gentxs", + (gogoproto.moretags) = "yaml:\"gentxs\"" + ]; +} diff --git a/p8e-api/src/main/proto/cosmos/gov/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/gov/v1beta1/genesis.proto new file mode 100644 index 0000000..a999500 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/gov/v1beta1/genesis.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; + +package cosmos.gov.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/gov/v1beta1/gov.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/gov/types"; + +// GenesisState defines the gov module's genesis state. +message GenesisState { + // starting_proposal_id is the ID of the starting proposal. + uint64 starting_proposal_id = 1 [(gogoproto.moretags) = "yaml:\"starting_proposal_id\""]; + // deposits defines all the deposits present at genesis. + repeated Deposit deposits = 2 [(gogoproto.castrepeated) = "Deposits", (gogoproto.nullable) = false]; + // votes defines all the votes present at genesis. + repeated Vote votes = 3 [(gogoproto.castrepeated) = "Votes", (gogoproto.nullable) = false]; + // proposals defines all the proposals present at genesis. + repeated Proposal proposals = 4 [(gogoproto.castrepeated) = "Proposals", (gogoproto.nullable) = false]; + // params defines all the paramaters of related to deposit. + DepositParams deposit_params = 5 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"deposit_params\""]; + // params defines all the paramaters of related to voting. + VotingParams voting_params = 6 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"voting_params\""]; + // params defines all the paramaters of related to tally. + TallyParams tally_params = 7 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"tally_params\""]; +} diff --git a/p8e-api/src/main/proto/cosmos/gov/v1beta1/gov.proto b/p8e-api/src/main/proto/cosmos/gov/v1beta1/gov.proto new file mode 100644 index 0000000..1d72e64 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/gov/v1beta1/gov.proto @@ -0,0 +1,183 @@ +syntax = "proto3"; +package cosmos.gov.v1beta1; + +import "cosmos/base/v1beta1/coin.proto"; +import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/gov/types"; +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.stringer_all) = false; +option (gogoproto.goproto_getters_all) = false; + +// VoteOption enumerates the valid vote options for a given governance proposal. +enum VoteOption { + option (gogoproto.goproto_enum_prefix) = false; + + // VOTE_OPTION_UNSPECIFIED defines a no-op vote option. + VOTE_OPTION_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "OptionEmpty"]; + // VOTE_OPTION_YES defines a yes vote option. + VOTE_OPTION_YES = 1 [(gogoproto.enumvalue_customname) = "OptionYes"]; + // VOTE_OPTION_ABSTAIN defines an abstain vote option. + VOTE_OPTION_ABSTAIN = 2 [(gogoproto.enumvalue_customname) = "OptionAbstain"]; + // VOTE_OPTION_NO defines a no vote option. + VOTE_OPTION_NO = 3 [(gogoproto.enumvalue_customname) = "OptionNo"]; + // VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option. + VOTE_OPTION_NO_WITH_VETO = 4 [(gogoproto.enumvalue_customname) = "OptionNoWithVeto"]; +} + +// TextProposal defines a standard text proposal whose changes need to be +// manually updated in case of approval. +message TextProposal { + option (cosmos_proto.implements_interface) = "Content"; + + option (gogoproto.equal) = true; + + string title = 1; + string description = 2; +} + +// Deposit defines an amount deposited by an account address to an active +// proposal. +message Deposit { + option (gogoproto.goproto_getters) = false; + option (gogoproto.equal) = false; + + uint64 proposal_id = 1 [(gogoproto.moretags) = "yaml:\"proposal_id\""]; + string depositor = 2; + repeated cosmos.base.v1beta1.Coin amount = 3 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// Proposal defines the core field members of a governance proposal. +message Proposal { + option (gogoproto.equal) = true; + + uint64 proposal_id = 1 [(gogoproto.jsontag) = "id", (gogoproto.moretags) = "yaml:\"id\""]; + google.protobuf.Any content = 2 [(cosmos_proto.accepts_interface) = "Content"]; + ProposalStatus status = 3 [(gogoproto.moretags) = "yaml:\"proposal_status\""]; + TallyResult final_tally_result = 4 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"final_tally_result\""]; + google.protobuf.Timestamp submit_time = 5 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"submit_time\""]; + google.protobuf.Timestamp deposit_end_time = 6 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"deposit_end_time\""]; + repeated cosmos.base.v1beta1.Coin total_deposit = 7 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"total_deposit\"" + ]; + google.protobuf.Timestamp voting_start_time = 8 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"voting_start_time\""]; + google.protobuf.Timestamp voting_end_time = 9 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"voting_end_time\""]; +} + +// ProposalStatus enumerates the valid statuses of a proposal. +enum ProposalStatus { + option (gogoproto.goproto_enum_prefix) = false; + + // PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status. + PROPOSAL_STATUS_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "StatusNil"]; + // PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit + // period. + PROPOSAL_STATUS_DEPOSIT_PERIOD = 1 [(gogoproto.enumvalue_customname) = "StatusDepositPeriod"]; + // PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting + // period. + PROPOSAL_STATUS_VOTING_PERIOD = 2 [(gogoproto.enumvalue_customname) = "StatusVotingPeriod"]; + // PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has + // passed. + PROPOSAL_STATUS_PASSED = 3 [(gogoproto.enumvalue_customname) = "StatusPassed"]; + // PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has + // been rejected. + PROPOSAL_STATUS_REJECTED = 4 [(gogoproto.enumvalue_customname) = "StatusRejected"]; + // PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has + // failed. + PROPOSAL_STATUS_FAILED = 5 [(gogoproto.enumvalue_customname) = "StatusFailed"]; +} + +// TallyResult defines a standard tally for a governance proposal. +message TallyResult { + option (gogoproto.equal) = true; + + string yes = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false]; + string abstain = 2 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false]; + string no = 3 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false]; + string no_with_veto = 4 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"no_with_veto\"" + ]; +} + +// Vote defines a vote on a governance proposal. +// A Vote consists of a proposal ID, the voter, and the vote option. +message Vote { + option (gogoproto.goproto_stringer) = false; + option (gogoproto.equal) = false; + + uint64 proposal_id = 1 [(gogoproto.moretags) = "yaml:\"proposal_id\""]; + string voter = 2; + VoteOption option = 3; +} + +// DepositParams defines the params for deposits on governance proposals. +message DepositParams { + // Minimum deposit for a proposal to enter voting period. + repeated cosmos.base.v1beta1.Coin min_deposit = 1 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"min_deposit\"", + (gogoproto.jsontag) = "min_deposit,omitempty" + ]; + + // Maximum period for Atom holders to deposit on a proposal. Initial value: 2 + // months. + google.protobuf.Duration max_deposit_period = 2 [ + (gogoproto.nullable) = false, + (gogoproto.stdduration) = true, + (gogoproto.jsontag) = "max_deposit_period,omitempty", + (gogoproto.moretags) = "yaml:\"max_deposit_period\"" + ]; +} + +// VotingParams defines the params for voting on governance proposals. +message VotingParams { + // Length of the voting period. + google.protobuf.Duration voting_period = 1 [ + (gogoproto.nullable) = false, + (gogoproto.stdduration) = true, + (gogoproto.jsontag) = "voting_period,omitempty", + (gogoproto.moretags) = "yaml:\"voting_period\"" + ]; +} + +// TallyParams defines the params for tallying votes on governance proposals. +message TallyParams { + // Minimum percentage of total stake needed to vote for a result to be + // considered valid. + bytes quorum = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false, + (gogoproto.jsontag) = "quorum,omitempty" + ]; + + // Minimum proportion of Yes votes for proposal to pass. Default value: 0.5. + bytes threshold = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false, + (gogoproto.jsontag) = "threshold,omitempty" + ]; + + // Minimum value of Veto votes to Total votes ratio for proposal to be + // vetoed. Default value: 1/3. + bytes veto_threshold = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false, + (gogoproto.jsontag) = "veto_threshold,omitempty", + (gogoproto.moretags) = "yaml:\"veto_threshold\"" + ]; +} diff --git a/p8e-api/src/main/proto/cosmos/gov/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/gov/v1beta1/query.proto new file mode 100644 index 0000000..da62bdb --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/gov/v1beta1/query.proto @@ -0,0 +1,190 @@ +syntax = "proto3"; +package cosmos.gov.v1beta1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/gov/v1beta1/gov.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/gov/types"; + +// Query defines the gRPC querier service for gov module +service Query { + // Proposal queries proposal details based on ProposalID. + rpc Proposal(QueryProposalRequest) returns (QueryProposalResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/proposals/{proposal_id}"; + } + + // Proposals queries all proposals based on given status. + rpc Proposals(QueryProposalsRequest) returns (QueryProposalsResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/proposals"; + } + + // Vote queries voted information based on proposalID, voterAddr. + rpc Vote(QueryVoteRequest) returns (QueryVoteResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes/{voter}"; + } + + // Votes queries votes of a given proposal. + rpc Votes(QueryVotesRequest) returns (QueryVotesResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes"; + } + + // Params queries all parameters of the gov module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/params/{params_type}"; + } + + // Deposit queries single deposit information based proposalID, depositAddr. + rpc Deposit(QueryDepositRequest) returns (QueryDepositResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits/{depositor}"; + } + + // Deposits queries all deposits of a single proposal. + rpc Deposits(QueryDepositsRequest) returns (QueryDepositsResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits"; + } + + // TallyResult queries the tally of a proposal vote. + rpc TallyResult(QueryTallyResultRequest) returns (QueryTallyResultResponse) { + option (google.api.http).get = "/cosmos/gov/v1beta1/proposals/{proposal_id}/tally"; + } +} + +// QueryProposalRequest is the request type for the Query/Proposal RPC method. +message QueryProposalRequest { + // proposal_id defines the unique id of the proposal. + uint64 proposal_id = 1; +} + +// QueryProposalResponse is the response type for the Query/Proposal RPC method. +message QueryProposalResponse { + Proposal proposal = 1 [(gogoproto.nullable) = false]; +} + +// QueryProposalsRequest is the request type for the Query/Proposals RPC method. +message QueryProposalsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // proposal_status defines the status of the proposals. + ProposalStatus proposal_status = 1; + + // voter defines the voter address for the proposals. + string voter = 2; + + // depositor defines the deposit addresses from the proposals. + string depositor = 3; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 4; +} + +// QueryProposalsResponse is the response type for the Query/Proposals RPC +// method. +message QueryProposalsResponse { + repeated Proposal proposals = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryVoteRequest is the request type for the Query/Vote RPC method. +message QueryVoteRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // proposal_id defines the unique id of the proposal. + uint64 proposal_id = 1; + + // voter defines the oter address for the proposals. + string voter = 2; +} + +// QueryVoteResponse is the response type for the Query/Vote RPC method. +message QueryVoteResponse { + // vote defined the queried vote. + Vote vote = 1 [(gogoproto.nullable) = false]; +} + +// QueryVotesRequest is the request type for the Query/Votes RPC method. +message QueryVotesRequest { + // proposal_id defines the unique id of the proposal. + uint64 proposal_id = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryVotesResponse is the response type for the Query/Votes RPC method. +message QueryVotesResponse { + // votes defined the queried votes. + repeated Vote votes = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest { + // params_type defines which parameters to query for, can be one of "voting", + // "tallying" or "deposit". + string params_type = 1; +} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // voting_params defines the parameters related to voting. + VotingParams voting_params = 1 [(gogoproto.nullable) = false]; + // deposit_params defines the parameters related to deposit. + DepositParams deposit_params = 2 [(gogoproto.nullable) = false]; + // tally_params defines the parameters related to tally. + TallyParams tally_params = 3 [(gogoproto.nullable) = false]; +} + +// QueryDepositRequest is the request type for the Query/Deposit RPC method. +message QueryDepositRequest { + option (gogoproto.goproto_getters) = false; + option (gogoproto.equal) = false; + + // proposal_id defines the unique id of the proposal. + uint64 proposal_id = 1; + + // depositor defines the deposit addresses from the proposals. + string depositor = 2; +} + +// QueryDepositResponse is the response type for the Query/Deposit RPC method. +message QueryDepositResponse { + // deposit defines the requested deposit. + Deposit deposit = 1 [(gogoproto.nullable) = false]; +} + +// QueryDepositsRequest is the request type for the Query/Deposits RPC method. +message QueryDepositsRequest { + // proposal_id defines the unique id of the proposal. + uint64 proposal_id = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryDepositsResponse is the response type for the Query/Deposits RPC method. +message QueryDepositsResponse { + repeated Deposit deposits = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryTallyResultRequest is the request type for the Query/Tally RPC method. +message QueryTallyResultRequest { + // proposal_id defines the unique id of the proposal. + uint64 proposal_id = 1; +} + +// QueryTallyResultResponse is the response type for the Query/Tally RPC method. +message QueryTallyResultResponse { + // tally defines the requested tally. + TallyResult tally = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/gov/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/gov/v1beta1/tx.proto new file mode 100644 index 0000000..d4f0c1f --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/gov/v1beta1/tx.proto @@ -0,0 +1,75 @@ +syntax = "proto3"; +package cosmos.gov.v1beta1; + +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/gov/v1beta1/gov.proto"; +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/gov/types"; + +// Msg defines the bank Msg service. +service Msg { + // SubmitProposal defines a method to create new proposal given a content. + rpc SubmitProposal(MsgSubmitProposal) returns (MsgSubmitProposalResponse); + + // Vote defines a method to add a vote on a specific proposal. + rpc Vote(MsgVote) returns (MsgVoteResponse); + + // Deposit defines a method to add deposit on a specific proposal. + rpc Deposit(MsgDeposit) returns (MsgDepositResponse); +} + +// MsgSubmitProposal defines an sdk.Msg type that supports submitting arbitrary +// proposal Content. +message MsgSubmitProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + google.protobuf.Any content = 1 [(cosmos_proto.accepts_interface) = "Content"]; + repeated cosmos.base.v1beta1.Coin initial_deposit = 2 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"initial_deposit\"" + ]; + string proposer = 3; +} + +// MsgSubmitProposalResponse defines the Msg/SubmitProposal response type. +message MsgSubmitProposalResponse { + uint64 proposal_id = 1 [(gogoproto.jsontag) = "proposal_id", (gogoproto.moretags) = "yaml:\"proposal_id\""]; +} + +// MsgVote defines a message to cast a vote. +message MsgVote { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + uint64 proposal_id = 1 [(gogoproto.jsontag) = "proposal_id", (gogoproto.moretags) = "yaml:\"proposal_id\""]; + string voter = 2; + VoteOption option = 3; +} + +// MsgVoteResponse defines the Msg/Vote response type. +message MsgVoteResponse {} + +// MsgDeposit defines a message to submit a deposit to an existing proposal. +message MsgDeposit { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + uint64 proposal_id = 1 [(gogoproto.jsontag) = "proposal_id", (gogoproto.moretags) = "yaml:\"proposal_id\""]; + string depositor = 2; + repeated cosmos.base.v1beta1.Coin amount = 3 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// MsgDepositResponse defines the Msg/Deposit response type. +message MsgDepositResponse {} diff --git a/p8e-api/src/main/proto/cosmos/mint/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/mint/v1beta1/genesis.proto new file mode 100644 index 0000000..4e783fb --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/mint/v1beta1/genesis.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; +package cosmos.mint.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/mint/v1beta1/mint.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/mint/types"; + +// GenesisState defines the mint module's genesis state. +message GenesisState { + // minter is a space for holding current inflation information. + Minter minter = 1 [(gogoproto.nullable) = false]; + + // params defines all the paramaters of the module. + Params params = 2 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/mint/v1beta1/mint.proto b/p8e-api/src/main/proto/cosmos/mint/v1beta1/mint.proto new file mode 100644 index 0000000..f94d4ae --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/mint/v1beta1/mint.proto @@ -0,0 +1,53 @@ +syntax = "proto3"; +package cosmos.mint.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/mint/types"; + +import "gogoproto/gogo.proto"; + +// Minter represents the minting state. +message Minter { + // current annual inflation rate + string inflation = 1 + [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; + // current annual expected provisions + string annual_provisions = 2 [ + (gogoproto.moretags) = "yaml:\"annual_provisions\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; +} + +// Params holds parameters for the mint module. +message Params { + option (gogoproto.goproto_stringer) = false; + + // type of coin to mint + string mint_denom = 1; + // maximum annual change in inflation rate + string inflation_rate_change = 2 [ + (gogoproto.moretags) = "yaml:\"inflation_rate_change\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + // maximum inflation rate + string inflation_max = 3 [ + (gogoproto.moretags) = "yaml:\"inflation_max\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + // minimum inflation rate + string inflation_min = 4 [ + (gogoproto.moretags) = "yaml:\"inflation_min\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + // goal of percent bonded atoms + string goal_bonded = 5 [ + (gogoproto.moretags) = "yaml:\"goal_bonded\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + // expected blocks per year + uint64 blocks_per_year = 6 [(gogoproto.moretags) = "yaml:\"blocks_per_year\""]; +} diff --git a/p8e-api/src/main/proto/cosmos/mint/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/mint/v1beta1/query.proto new file mode 100644 index 0000000..acd341d --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/mint/v1beta1/query.proto @@ -0,0 +1,57 @@ +syntax = "proto3"; +package cosmos.mint.v1beta1; + +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/mint/v1beta1/mint.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/mint/types"; + +// Query provides defines the gRPC querier service. +service Query { + // Params returns the total set of minting parameters. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/mint/v1beta1/params"; + } + + // Inflation returns the current minting inflation value. + rpc Inflation(QueryInflationRequest) returns (QueryInflationResponse) { + option (google.api.http).get = "/cosmos/mint/v1beta1/inflation"; + } + + // AnnualProvisions current minting annual provisions value. + rpc AnnualProvisions(QueryAnnualProvisionsRequest) returns (QueryAnnualProvisionsResponse) { + option (google.api.http).get = "/cosmos/mint/v1beta1/annual_provisions"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; +} + +// QueryInflationRequest is the request type for the Query/Inflation RPC method. +message QueryInflationRequest {} + +// QueryInflationResponse is the response type for the Query/Inflation RPC +// method. +message QueryInflationResponse { + // inflation is the current minting inflation value. + bytes inflation = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; +} + +// QueryAnnualProvisionsRequest is the request type for the +// Query/AnnualProvisions RPC method. +message QueryAnnualProvisionsRequest {} + +// QueryAnnualProvisionsResponse is the response type for the +// Query/AnnualProvisions RPC method. +message QueryAnnualProvisionsResponse { + // annual_provisions is the current minting annual provisions value. + bytes annual_provisions = 1 + [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/params/v1beta1/params.proto b/p8e-api/src/main/proto/cosmos/params/v1beta1/params.proto new file mode 100644 index 0000000..5382fd7 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/params/v1beta1/params.proto @@ -0,0 +1,27 @@ +syntax = "proto3"; +package cosmos.params.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/params/types/proposal"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; + +// ParameterChangeProposal defines a proposal to change one or more parameters. +message ParameterChangeProposal { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + repeated ParamChange changes = 3 [(gogoproto.nullable) = false]; +} + +// ParamChange defines an individual parameter change, for use in +// ParameterChangeProposal. +message ParamChange { + option (gogoproto.goproto_stringer) = false; + + string subspace = 1; + string key = 2; + string value = 3; +} diff --git a/p8e-api/src/main/proto/cosmos/params/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/params/v1beta1/query.proto new file mode 100644 index 0000000..1078e02 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/params/v1beta1/query.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; +package cosmos.params.v1beta1; + +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/params/v1beta1/params.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/params/types/proposal"; + +// Query defines the gRPC querier service. +service Query { + // Params queries a specific parameter of a module, given its subspace and + // key. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/params/v1beta1/params"; + } +} + +// QueryParamsRequest is request type for the Query/Params RPC method. +message QueryParamsRequest { + // subspace defines the module to query the parameter for. + string subspace = 1; + + // key defines the key of the parameter in the subspace. + string key = 2; +} + +// QueryParamsResponse is response type for the Query/Params RPC method. +message QueryParamsResponse { + // param defines the queried parameter. + ParamChange param = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/slashing/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/genesis.proto new file mode 100644 index 0000000..c813561 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/genesis.proto @@ -0,0 +1,50 @@ +syntax = "proto3"; +package cosmos.slashing.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/slashing/types"; + +import "gogoproto/gogo.proto"; +import "cosmos/slashing/v1beta1/slashing.proto"; + +// GenesisState defines the slashing module's genesis state. +message GenesisState { + // params defines all the paramaters of related to deposit. + Params params = 1 [(gogoproto.nullable) = false]; + + // signing_infos represents a map between validator addresses and their + // signing infos. + repeated SigningInfo signing_infos = 2 + [(gogoproto.moretags) = "yaml:\"signing_infos\"", (gogoproto.nullable) = false]; + + // signing_infos represents a map between validator addresses and their + // missed blocks. + repeated ValidatorMissedBlocks missed_blocks = 3 + [(gogoproto.moretags) = "yaml:\"missed_blocks\"", (gogoproto.nullable) = false]; +} + +// SigningInfo stores validator signing info of corresponding address. +message SigningInfo { + // address is the validator address. + string address = 1; + // validator_signing_info represents the signing info of this validator. + ValidatorSigningInfo validator_signing_info = 2 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"validator_signing_info\""]; +} + +// ValidatorMissedBlocks contains array of missed blocks of corresponding +// address. +message ValidatorMissedBlocks { + // address is the validator address. + string address = 1; + // missed_blocks is an array of missed blocks by the validator. + repeated MissedBlock missed_blocks = 2 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"missed_blocks\""]; +} + +// MissedBlock contains height and missed status as boolean. +message MissedBlock { + // index is the height at which the block was missed. + int64 index = 1; + // missed is the missed status. + bool missed = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/slashing/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/query.proto new file mode 100644 index 0000000..869049a --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/query.proto @@ -0,0 +1,63 @@ +syntax = "proto3"; +package cosmos.slashing.v1beta1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/slashing/v1beta1/slashing.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/slashing/types"; + +// Query provides defines the gRPC querier service +service Query { + // Params queries the parameters of slashing module + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/slashing/v1beta1/params"; + } + + // SigningInfo queries the signing info of given cons address + rpc SigningInfo(QuerySigningInfoRequest) returns (QuerySigningInfoResponse) { + option (google.api.http).get = "/cosmos/slashing/v1beta1/signing_infos/{cons_address}"; + } + + // SigningInfos queries signing info of all validators + rpc SigningInfos(QuerySigningInfosRequest) returns (QuerySigningInfosResponse) { + option (google.api.http).get = "/cosmos/slashing/v1beta1/signing_infos"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method +message QueryParamsResponse { + Params params = 1 [(gogoproto.nullable) = false]; +} + +// QuerySigningInfoRequest is the request type for the Query/SigningInfo RPC +// method +message QuerySigningInfoRequest { + // cons_address is the address to query signing info of + string cons_address = 1; +} + +// QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC +// method +message QuerySigningInfoResponse { + // val_signing_info is the signing info of requested val cons address + ValidatorSigningInfo val_signing_info = 1 [(gogoproto.nullable) = false]; +} + +// QuerySigningInfosRequest is the request type for the Query/SigningInfos RPC +// method +message QuerySigningInfosRequest { + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC +// method +message QuerySigningInfosResponse { + // info is the signing info of all validators + repeated cosmos.slashing.v1beta1.ValidatorSigningInfo info = 1 [(gogoproto.nullable) = false]; + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/slashing/v1beta1/slashing.proto b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/slashing.proto new file mode 100644 index 0000000..657a90f --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/slashing.proto @@ -0,0 +1,55 @@ +syntax = "proto3"; +package cosmos.slashing.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/slashing/types"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; + +// ValidatorSigningInfo defines a validator's signing info for monitoring their +// liveness activity. +message ValidatorSigningInfo { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string address = 1; + // height at which validator was first a candidate OR was unjailed + int64 start_height = 2 [(gogoproto.moretags) = "yaml:\"start_height\""]; + // index offset into signed block bit array + int64 index_offset = 3 [(gogoproto.moretags) = "yaml:\"index_offset\""]; + // timestamp validator cannot be unjailed until + google.protobuf.Timestamp jailed_until = 4 + [(gogoproto.moretags) = "yaml:\"jailed_until\"", (gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + // whether or not a validator has been tombstoned (killed out of validator + // set) + bool tombstoned = 5; + // missed blocks counter (to avoid scanning the array every time) + int64 missed_blocks_counter = 6 [(gogoproto.moretags) = "yaml:\"missed_blocks_counter\""]; +} + +// Params represents the parameters used for by the slashing module. +message Params { + int64 signed_blocks_window = 1 [(gogoproto.moretags) = "yaml:\"signed_blocks_window\""]; + bytes min_signed_per_window = 2 [ + (gogoproto.moretags) = "yaml:\"min_signed_per_window\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + google.protobuf.Duration downtime_jail_duration = 3 [ + (gogoproto.nullable) = false, + (gogoproto.stdduration) = true, + (gogoproto.moretags) = "yaml:\"downtime_jail_duration\"" + ]; + bytes slash_fraction_double_sign = 4 [ + (gogoproto.moretags) = "yaml:\"slash_fraction_double_sign\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + bytes slash_fraction_downtime = 5 [ + (gogoproto.moretags) = "yaml:\"slash_fraction_downtime\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; +} diff --git a/p8e-api/src/main/proto/cosmos/slashing/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/tx.proto new file mode 100644 index 0000000..4d63370 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/slashing/v1beta1/tx.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; +package cosmos.slashing.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/slashing/types"; +option (gogoproto.equal_all) = true; + +import "gogoproto/gogo.proto"; + +// Msg defines the slashing Msg service. +service Msg { + // Unjail defines a method for unjailing a jailed validator, thus returning + // them into the bonded validator set, so they can begin receiving provisions + // and rewards again. + rpc Unjail(MsgUnjail) returns (MsgUnjailResponse); +} + +// MsgUnjail defines the Msg/Unjail request type +message MsgUnjail { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = true; + + string validator_addr = 1 [(gogoproto.moretags) = "yaml:\"address\"", (gogoproto.jsontag) = "address"]; +} + +// MsgUnjailResponse defines the Msg/Unjail response type +message MsgUnjailResponse {} \ No newline at end of file diff --git a/p8e-api/src/main/proto/cosmos/staking/v1beta1/genesis.proto b/p8e-api/src/main/proto/cosmos/staking/v1beta1/genesis.proto new file mode 100644 index 0000000..d1563db --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/staking/v1beta1/genesis.proto @@ -0,0 +1,53 @@ +syntax = "proto3"; +package cosmos.staking.v1beta1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/staking/types"; + +import "gogoproto/gogo.proto"; +import "cosmos/staking/v1beta1/staking.proto"; + +// GenesisState defines the staking module's genesis state. +message GenesisState { + // params defines all the paramaters of related to deposit. + Params params = 1 [(gogoproto.nullable) = false]; + + // last_total_power tracks the total amounts of bonded tokens recorded during + // the previous end block. + bytes last_total_power = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"last_total_power\"", + (gogoproto.nullable) = false + ]; + + // last_validator_powers is a special index that provides a historical list + // of the last-block's bonded validators. + repeated LastValidatorPower last_validator_powers = 3 + [(gogoproto.moretags) = "yaml:\"last_validator_powers\"", (gogoproto.nullable) = false]; + + // delegations defines the validator set at genesis. + repeated Validator validators = 4 [(gogoproto.nullable) = false]; + + // delegations defines the delegations active at genesis. + repeated Delegation delegations = 5 [(gogoproto.nullable) = false]; + + // unbonding_delegations defines the unbonding delegations active at genesis. + repeated UnbondingDelegation unbonding_delegations = 6 + [(gogoproto.moretags) = "yaml:\"unbonding_delegations\"", (gogoproto.nullable) = false]; + + // redelegations defines the redelegations active at genesis. + repeated Redelegation redelegations = 7 [(gogoproto.nullable) = false]; + + bool exported = 8; +} + +// LastValidatorPower required for validator set update logic. +message LastValidatorPower { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the address of the validator. + string address = 1; + + // power defines the power of the validator. + int64 power = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/staking/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/staking/v1beta1/query.proto new file mode 100644 index 0000000..4852c53 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/staking/v1beta1/query.proto @@ -0,0 +1,348 @@ +syntax = "proto3"; +package cosmos.staking.v1beta1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "cosmos/staking/v1beta1/staking.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/staking/types"; + +// Query defines the gRPC querier service. +service Query { + // Validators queries all validators that match the given status. + rpc Validators(QueryValidatorsRequest) returns (QueryValidatorsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/validators"; + } + + // Validator queries validator info for given validator address. + rpc Validator(QueryValidatorRequest) returns (QueryValidatorResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/validators/{validator_addr}"; + } + + // ValidatorDelegations queries delegate info for given validator. + rpc ValidatorDelegations(QueryValidatorDelegationsRequest) returns (QueryValidatorDelegationsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations"; + } + + // ValidatorUnbondingDelegations queries unbonding delegations of a validator. + rpc ValidatorUnbondingDelegations(QueryValidatorUnbondingDelegationsRequest) + returns (QueryValidatorUnbondingDelegationsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/validators/" + "{validator_addr}/unbonding_delegations"; + } + + // Delegation queries delegate info for given validator delegator pair. + rpc Delegation(QueryDelegationRequest) returns (QueryDelegationResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/" + "{delegator_addr}"; + } + + // UnbondingDelegation queries unbonding info for given validator delegator + // pair. + rpc UnbondingDelegation(QueryUnbondingDelegationRequest) returns (QueryUnbondingDelegationResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/" + "{delegator_addr}/unbonding_delegation"; + } + + // DelegatorDelegations queries all delegations of a given delegator address. + rpc DelegatorDelegations(QueryDelegatorDelegationsRequest) returns (QueryDelegatorDelegationsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/delegations/{delegator_addr}"; + } + + // DelegatorUnbondingDelegations queries all unbonding delegations of a given + // delegator address. + rpc DelegatorUnbondingDelegations(QueryDelegatorUnbondingDelegationsRequest) + returns (QueryDelegatorUnbondingDelegationsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/delegators/" + "{delegator_addr}/unbonding_delegations"; + } + + // Redelegations queries redelegations of given address. + rpc Redelegations(QueryRedelegationsRequest) returns (QueryRedelegationsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations"; + } + + // DelegatorValidators queries all validators info for given delegator + // address. + rpc DelegatorValidators(QueryDelegatorValidatorsRequest) returns (QueryDelegatorValidatorsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators"; + } + + // DelegatorValidator queries validator info for given delegator validator + // pair. + rpc DelegatorValidator(QueryDelegatorValidatorRequest) returns (QueryDelegatorValidatorResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/" + "{validator_addr}"; + } + + // HistoricalInfo queries the historical info for given height. + rpc HistoricalInfo(QueryHistoricalInfoRequest) returns (QueryHistoricalInfoResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/historical_info/{height}"; + } + + // Pool queries the pool info. + rpc Pool(QueryPoolRequest) returns (QueryPoolResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/pool"; + } + + // Parameters queries the staking parameters. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/cosmos/staking/v1beta1/params"; + } +} + +// QueryValidatorsRequest is request type for Query/Validators RPC method. +message QueryValidatorsRequest { + // status enables to query for validators matching a given status. + string status = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryValidatorsResponse is response type for the Query/Validators RPC method +message QueryValidatorsResponse { + // validators contains all the queried validators. + repeated Validator validators = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryValidatorRequest is response type for the Query/Validator RPC method +message QueryValidatorRequest { + // validator_addr defines the validator address to query for. + string validator_addr = 1; +} + +// QueryValidatorResponse is response type for the Query/Validator RPC method +message QueryValidatorResponse { + // validator defines the the validator info. + Validator validator = 1 [(gogoproto.nullable) = false]; +} + +// QueryValidatorDelegationsRequest is request type for the +// Query/ValidatorDelegations RPC method +message QueryValidatorDelegationsRequest { + // validator_addr defines the validator address to query for. + string validator_addr = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryValidatorDelegationsResponse is response type for the +// Query/ValidatorDelegations RPC method +message QueryValidatorDelegationsResponse { + repeated DelegationResponse delegation_responses = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "DelegationResponses"]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryValidatorUnbondingDelegationsRequest is required type for the +// Query/ValidatorUnbondingDelegations RPC method +message QueryValidatorUnbondingDelegationsRequest { + // validator_addr defines the validator address to query for. + string validator_addr = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryValidatorUnbondingDelegationsResponse is response type for the +// Query/ValidatorUnbondingDelegations RPC method. +message QueryValidatorUnbondingDelegationsResponse { + repeated UnbondingDelegation unbonding_responses = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryDelegationRequest is request type for the Query/Delegation RPC method. +message QueryDelegationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_addr defines the delegator address to query for. + string delegator_addr = 1; + + // validator_addr defines the validator address to query for. + string validator_addr = 2; +} + +// QueryDelegationResponse is response type for the Query/Delegation RPC method. +message QueryDelegationResponse { + // delegation_responses defines the delegation info of a delegation. + DelegationResponse delegation_response = 1; +} + +// QueryUnbondingDelegationRequest is request type for the +// Query/UnbondingDelegation RPC method. +message QueryUnbondingDelegationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_addr defines the delegator address to query for. + string delegator_addr = 1; + + // validator_addr defines the validator address to query for. + string validator_addr = 2; +} + +// QueryDelegationResponse is response type for the Query/UnbondingDelegation +// RPC method. +message QueryUnbondingDelegationResponse { + // unbond defines the unbonding information of a delegation. + UnbondingDelegation unbond = 1 [(gogoproto.nullable) = false]; +} + +// QueryDelegatorDelegationsRequest is request type for the +// Query/DelegatorDelegations RPC method. +message QueryDelegatorDelegationsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_addr defines the delegator address to query for. + string delegator_addr = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryDelegatorDelegationsResponse is response type for the +// Query/DelegatorDelegations RPC method. +message QueryDelegatorDelegationsResponse { + // delegation_responses defines all the delegations' info of a delegator. + repeated DelegationResponse delegation_responses = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryDelegatorUnbondingDelegationsRequest is request type for the +// Query/DelegatorUnbondingDelegations RPC method. +message QueryDelegatorUnbondingDelegationsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_addr defines the delegator address to query for. + string delegator_addr = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryUnbondingDelegatorDelegationsResponse is response type for the +// Query/UnbondingDelegatorDelegations RPC method. +message QueryDelegatorUnbondingDelegationsResponse { + repeated UnbondingDelegation unbonding_responses = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryRedelegationsRequest is request type for the Query/Redelegations RPC +// method. +message QueryRedelegationsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_addr defines the delegator address to query for. + string delegator_addr = 1; + + // src_validator_addr defines the validator address to redelegate from. + string src_validator_addr = 2; + + // dst_validator_addr defines the validator address to redelegate to. + string dst_validator_addr = 3; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 4; +} + +// QueryRedelegationsResponse is response type for the Query/Redelegations RPC +// method. +message QueryRedelegationsResponse { + repeated RedelegationResponse redelegation_responses = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryDelegatorValidatorsRequest is request type for the +// Query/DelegatorValidators RPC method. +message QueryDelegatorValidatorsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_addr defines the delegator address to query for. + string delegator_addr = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryDelegatorValidatorsResponse is response type for the +// Query/DelegatorValidators RPC method. +message QueryDelegatorValidatorsResponse { + // validators defines the the validators' info of a delegator. + repeated Validator validators = 1 [(gogoproto.nullable) = false]; + + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryDelegatorValidatorRequest is request type for the +// Query/DelegatorValidator RPC method. +message QueryDelegatorValidatorRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // delegator_addr defines the delegator address to query for. + string delegator_addr = 1; + + // validator_addr defines the validator address to query for. + string validator_addr = 2; +} + +// QueryDelegatorValidatorResponse response type for the +// Query/DelegatorValidator RPC method. +message QueryDelegatorValidatorResponse { + // validator defines the the validator info. + Validator validator = 1 [(gogoproto.nullable) = false]; +} + +// QueryHistoricalInfoRequest is request type for the Query/HistoricalInfo RPC +// method. +message QueryHistoricalInfoRequest { + // height defines at which height to query the historical info. + int64 height = 1; +} + +// QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC +// method. +message QueryHistoricalInfoResponse { + // hist defines the historical info at the given height. + HistoricalInfo hist = 1; +} + +// QueryPoolRequest is request type for the Query/Pool RPC method. +message QueryPoolRequest {} + +// QueryPoolResponse is response type for the Query/Pool RPC method. +message QueryPoolResponse { + // pool defines the pool info. + Pool pool = 1 [(gogoproto.nullable) = false]; +} + +// QueryParamsRequest is request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is response type for the Query/Params RPC method. +message QueryParamsResponse { + // params holds all the parameters of this module. + Params params = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos/staking/v1beta1/staking.proto b/p8e-api/src/main/proto/cosmos/staking/v1beta1/staking.proto new file mode 100644 index 0000000..e37b28b --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/staking/v1beta1/staking.proto @@ -0,0 +1,334 @@ +syntax = "proto3"; +package cosmos.staking.v1beta1; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; + +import "cosmos_proto/cosmos.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "tendermint/types/types.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/staking/types"; + +// HistoricalInfo contains header and validator information for a given block. +// It is stored as part of staking module's state, which persists the `n` most +// recent HistoricalInfo +// (`n` is set by the staking module's `historical_entries` parameter). +message HistoricalInfo { + tendermint.types.Header header = 1 [(gogoproto.nullable) = false]; + repeated Validator valset = 2 [(gogoproto.nullable) = false]; +} + +// CommissionRates defines the initial commission rates to be used for creating +// a validator. +message CommissionRates { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + // rate is the commission rate charged to delegators, as a fraction. + string rate = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; + // max_rate defines the maximum commission rate which validator can ever charge, as a fraction. + string max_rate = 2 [ + (gogoproto.moretags) = "yaml:\"max_rate\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + // max_change_rate defines the maximum daily increase of the validator commission, as a fraction. + string max_change_rate = 3 [ + (gogoproto.moretags) = "yaml:\"max_change_rate\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; +} + +// Commission defines commission parameters for a given validator. +message Commission { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + // commission_rates defines the initial commission rates to be used for creating a validator. + CommissionRates commission_rates = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + // update_time is the last time the commission rate was changed. + google.protobuf.Timestamp update_time = 2 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"update_time\""]; +} + +// Description defines a validator description. +message Description { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + // moniker defines a human-readable name for the validator. + string moniker = 1; + // identity defines an optional identity signature (ex. UPort or Keybase). + string identity = 2; + // website defines an optional website link. + string website = 3; + // security_contact defines an optional email for security contact. + string security_contact = 4 [(gogoproto.moretags) = "yaml:\"security_contact\""]; + // details define other optional details. + string details = 5; +} + +// Validator defines a validator, together with the total amount of the +// Validator's bond shares and their exchange rate to coins. Slashing results in +// a decrease in the exchange rate, allowing correct calculation of future +// undelegations without iterating over delegators. When coins are delegated to +// this validator, the validator is credited with a delegation whose number of +// bond shares is based on the amount of coins delegated divided by the current +// exchange rate. Voting power can be calculated as total bonded shares +// multiplied by exchange rate. +message Validator { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.goproto_getters) = false; + + // operator_address defines the address of the validator's operator; bech encoded in JSON. + string operator_address = 1 [(gogoproto.moretags) = "yaml:\"operator_address\""]; + // consensus_pubkey is the consensus public key of the validator, as a Protobuf Any. + google.protobuf.Any consensus_pubkey = 2 + [(cosmos_proto.accepts_interface) = "cosmos.crypto.PubKey", (gogoproto.moretags) = "yaml:\"consensus_pubkey\""]; + // jailed defined whether the validator has been jailed from bonded status or not. + bool jailed = 3; + // status is the validator status (bonded/unbonding/unbonded). + BondStatus status = 4; + // tokens define the delegated tokens (incl. self-delegation). + string tokens = 5 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false]; + // delegator_shares defines total shares issued to a validator's delegators. + string delegator_shares = 6 [ + (gogoproto.moretags) = "yaml:\"delegator_shares\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + // description defines the description terms for the validator. + Description description = 7 [(gogoproto.nullable) = false]; + // unbonding_height defines, if unbonding, the height at which this validator has begun unbonding. + int64 unbonding_height = 8 [(gogoproto.moretags) = "yaml:\"unbonding_height\""]; + // unbonding_time defines, if unbonding, the min time for the validator to complete unbonding. + google.protobuf.Timestamp unbonding_time = 9 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"unbonding_time\""]; + // commission defines the commission parameters. + Commission commission = 10 [(gogoproto.nullable) = false]; + // min_self_delegation is the validator's self declared minimum self delegation. + string min_self_delegation = 11 [ + (gogoproto.moretags) = "yaml:\"min_self_delegation\"", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} + +// BondStatus is the status of a validator. +enum BondStatus { + option (gogoproto.goproto_enum_prefix) = false; + + // UNSPECIFIED defines an invalid validator status. + BOND_STATUS_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unspecified"]; + // UNBONDED defines a validator that is not bonded. + BOND_STATUS_UNBONDED = 1 [(gogoproto.enumvalue_customname) = "Unbonded"]; + // UNBONDING defines a validator that is unbonding. + BOND_STATUS_UNBONDING = 2 [(gogoproto.enumvalue_customname) = "Unbonding"]; + // BONDED defines a validator that is bonded. + BOND_STATUS_BONDED = 3 [(gogoproto.enumvalue_customname) = "Bonded"]; +} + +// ValAddresses defines a repeated set of validator addresses. +message ValAddresses { + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = true; + + repeated string addresses = 1; +} + +// DVPair is struct that just has a delegator-validator pair with no other data. +// It is intended to be used as a marshalable pointer. For example, a DVPair can +// be used to construct the key to getting an UnbondingDelegation from state. +message DVPair { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; +} + +// DVPairs defines an array of DVPair objects. +message DVPairs { + repeated DVPair pairs = 1 [(gogoproto.nullable) = false]; +} + +// DVVTriplet is struct that just has a delegator-validator-validator triplet +// with no other data. It is intended to be used as a marshalable pointer. For +// example, a DVVTriplet can be used to construct the key to getting a +// Redelegation from state. +message DVVTriplet { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_src_address = 2 [(gogoproto.moretags) = "yaml:\"validator_src_address\""]; + string validator_dst_address = 3 [(gogoproto.moretags) = "yaml:\"validator_dst_address\""]; +} + +// DVVTriplets defines an array of DVVTriplet objects. +message DVVTriplets { + repeated DVVTriplet triplets = 1 [(gogoproto.nullable) = false]; +} + +// Delegation represents the bond with tokens held by an account. It is +// owned by one delegator, and is associated with the voting power of one +// validator. +message Delegation { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + // delegator_address is the bech32-encoded address of the delegator. + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + // validator_address is the bech32-encoded address of the validator. + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + // shares define the delegation shares received. + string shares = 3 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; +} + +// UnbondingDelegation stores all of a single delegator's unbonding bonds +// for a single validator in an time-ordered list. +message UnbondingDelegation { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + // delegator_address is the bech32-encoded address of the delegator. + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + // validator_address is the bech32-encoded address of the validator. + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + // entries are the unbonding delegation entries. + repeated UnbondingDelegationEntry entries = 3 [(gogoproto.nullable) = false]; // unbonding delegation entries +} + +// UnbondingDelegationEntry defines an unbonding object with relevant metadata. +message UnbondingDelegationEntry { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + // creation_height is the height which the unbonding took place. + int64 creation_height = 1 [(gogoproto.moretags) = "yaml:\"creation_height\""]; + // completion_time is the unix time for unbonding completion. + google.protobuf.Timestamp completion_time = 2 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"completion_time\""]; + // initial_balance defines the tokens initially scheduled to receive at completion. + string initial_balance = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"initial_balance\"" + ]; + // balance defines the tokens to receive at completion. + string balance = 4 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false]; +} + +// RedelegationEntry defines a redelegation object with relevant metadata. +message RedelegationEntry { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + // creation_height defines the height which the redelegation took place. + int64 creation_height = 1 [(gogoproto.moretags) = "yaml:\"creation_height\""]; + // completion_time defines the unix time for redelegation completion. + google.protobuf.Timestamp completion_time = 2 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"completion_time\""]; + // initial_balance defines the initial balance when redelegation started. + string initial_balance = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"initial_balance\"" + ]; + // shares_dst is the amount of destination-validator shares created by redelegation. + string shares_dst = 4 + [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; +} + +// Redelegation contains the list of a particular delegator's redelegating bonds +// from a particular source validator to a particular destination validator. +message Redelegation { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + // delegator_address is the bech32-encoded address of the delegator. + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + // validator_src_address is the validator redelegation source operator address. + string validator_src_address = 2 [(gogoproto.moretags) = "yaml:\"validator_src_address\""]; + // validator_dst_address is the validator redelegation destination operator address. + string validator_dst_address = 3 [(gogoproto.moretags) = "yaml:\"validator_dst_address\""]; + // entries are the redelegation entries. + repeated RedelegationEntry entries = 4 [(gogoproto.nullable) = false]; // redelegation entries +} + +// Params defines the parameters for the staking module. +message Params { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + // unbonding_time is the time duration of unbonding. + google.protobuf.Duration unbonding_time = 1 + [(gogoproto.nullable) = false, (gogoproto.stdduration) = true, (gogoproto.moretags) = "yaml:\"unbonding_time\""]; + // max_validators is the maximum number of validators. + uint32 max_validators = 2 [(gogoproto.moretags) = "yaml:\"max_validators\""]; + // max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio). + uint32 max_entries = 3 [(gogoproto.moretags) = "yaml:\"max_entries\""]; + // historical_entries is the number of historical entries to persist. + uint32 historical_entries = 4 [(gogoproto.moretags) = "yaml:\"historical_entries\""]; + // bond_denom defines the bondable coin denomination. + string bond_denom = 5 [(gogoproto.moretags) = "yaml:\"bond_denom\""]; +} + +// DelegationResponse is equivalent to Delegation except that it contains a +// balance in addition to shares which is more suitable for client responses. +message DelegationResponse { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + + Delegation delegation = 1 [(gogoproto.nullable) = false]; + + cosmos.base.v1beta1.Coin balance = 2 [(gogoproto.nullable) = false]; +} + +// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it +// contains a balance in addition to shares which is more suitable for client +// responses. +message RedelegationEntryResponse { + option (gogoproto.equal) = true; + + RedelegationEntry redelegation_entry = 1 [(gogoproto.nullable) = false]; + string balance = 4 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false]; +} + +// RedelegationResponse is equivalent to a Redelegation except that its entries +// contain a balance in addition to shares which is more suitable for client +// responses. +message RedelegationResponse { + option (gogoproto.equal) = false; + + Redelegation redelegation = 1 [(gogoproto.nullable) = false]; + repeated RedelegationEntryResponse entries = 2 [(gogoproto.nullable) = false]; +} + +// Pool is used for tracking bonded and not-bonded token supply of the bond +// denomination. +message Pool { + option (gogoproto.description) = true; + option (gogoproto.equal) = true; + string not_bonded_tokens = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.jsontag) = "not_bonded_tokens", + (gogoproto.nullable) = false + ]; + string bonded_tokens = 2 [ + (gogoproto.jsontag) = "bonded_tokens", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"bonded_tokens\"" + ]; +} diff --git a/p8e-api/src/main/proto/cosmos/staking/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/staking/v1beta1/tx.proto new file mode 100644 index 0000000..7b05d89 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/staking/v1beta1/tx.proto @@ -0,0 +1,126 @@ +syntax = "proto3"; +package cosmos.staking.v1beta1; + +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; +import "gogoproto/gogo.proto"; + +import "cosmos_proto/cosmos.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/staking/v1beta1/staking.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/staking/types"; + +// Msg defines the staking Msg service. +service Msg { + // CreateValidator defines a method for creating a new validator. + rpc CreateValidator(MsgCreateValidator) returns (MsgCreateValidatorResponse); + + // EditValidator defines a method for editing an existing validator. + rpc EditValidator(MsgEditValidator) returns (MsgEditValidatorResponse); + + // Delegate defines a method for performing a delegation of coins + // from a delegator to a validator. + rpc Delegate(MsgDelegate) returns (MsgDelegateResponse); + + // BeginRedelegate defines a method for performing a redelegation + // of coins from a delegator and source validator to a destination validator. + rpc BeginRedelegate(MsgBeginRedelegate) returns (MsgBeginRedelegateResponse); + + // Undelegate defines a method for performing an undelegation from a + // delegate and a validator. + rpc Undelegate(MsgUndelegate) returns (MsgUndelegateResponse); +} + +// MsgCreateValidator defines a SDK message for creating a new validator. +message MsgCreateValidator { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + Description description = 1 [(gogoproto.nullable) = false]; + CommissionRates commission = 2 [(gogoproto.nullable) = false]; + string min_self_delegation = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"min_self_delegation\"", + (gogoproto.nullable) = false + ]; + string delegator_address = 4 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_address = 5 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + google.protobuf.Any pubkey = 6 [(cosmos_proto.accepts_interface) = "cosmos.crypto.PubKey"]; + cosmos.base.v1beta1.Coin value = 7 [(gogoproto.nullable) = false]; +} + +// MsgCreateValidatorResponse defines the Msg/CreateValidator response type. +message MsgCreateValidatorResponse {} + +// MsgEditValidator defines a SDK message for editing an existing validator. +message MsgEditValidator { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + Description description = 1 [(gogoproto.nullable) = false]; + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"address\""]; + + // We pass a reference to the new commission rate and min self delegation as + // it's not mandatory to update. If not updated, the deserialized rate will be + // zero with no way to distinguish if an update was intended. + // REF: #2373 + string commission_rate = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.moretags) = "yaml:\"commission_rate\"" + ]; + string min_self_delegation = 4 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"min_self_delegation\"" + ]; +} + +// MsgEditValidatorResponse defines the Msg/EditValidator response type. +message MsgEditValidatorResponse {} + +// MsgDelegate defines a SDK message for performing a delegation of coins +// from a delegator to a validator. +message MsgDelegate { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} + +// MsgDelegateResponse defines the Msg/Delegate response type. +message MsgDelegateResponse {} + +// MsgBeginRedelegate defines a SDK message for performing a redelegation +// of coins from a delegator and source validator to a destination validator. +message MsgBeginRedelegate { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_src_address = 2 [(gogoproto.moretags) = "yaml:\"validator_src_address\""]; + string validator_dst_address = 3 [(gogoproto.moretags) = "yaml:\"validator_dst_address\""]; + cosmos.base.v1beta1.Coin amount = 4 [(gogoproto.nullable) = false]; +} + +// MsgBeginRedelegateResponse defines the Msg/BeginRedelegate response type. +message MsgBeginRedelegateResponse { + google.protobuf.Timestamp completion_time = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; +} + +// MsgUndelegate defines a SDK message for performing an undelegation from a +// delegate and a validator. +message MsgUndelegate { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} + +// MsgUndelegateResponse defines the Msg/Undelegate response type. +message MsgUndelegateResponse { + google.protobuf.Timestamp completion_time = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; +} diff --git a/p8e-api/src/main/proto/cosmos/tx/signing/v1beta1/signing.proto b/p8e-api/src/main/proto/cosmos/tx/signing/v1beta1/signing.proto new file mode 100644 index 0000000..4c1be40 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/tx/signing/v1beta1/signing.proto @@ -0,0 +1,79 @@ +syntax = "proto3"; +package cosmos.tx.signing.v1beta1; + +import "cosmos/crypto/multisig/v1beta1/multisig.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/types/tx/signing"; + +// SignMode represents a signing mode with its own security guarantees. +enum SignMode { + // SIGN_MODE_UNSPECIFIED specifies an unknown signing mode and will be + // rejected + SIGN_MODE_UNSPECIFIED = 0; + + // SIGN_MODE_DIRECT specifies a signing mode which uses SignDoc and is + // verified with raw bytes from Tx + SIGN_MODE_DIRECT = 1; + + // SIGN_MODE_TEXTUAL is a future signing mode that will verify some + // human-readable textual representation on top of the binary representation + // from SIGN_MODE_DIRECT + SIGN_MODE_TEXTUAL = 2; + + // SIGN_MODE_LEGACY_AMINO_JSON is a backwards compatibility mode which uses + // Amino JSON and will be removed in the future + SIGN_MODE_LEGACY_AMINO_JSON = 127; +} + +// SignatureDescriptors wraps multiple SignatureDescriptor's. +message SignatureDescriptors { + // signatures are the signature descriptors + repeated SignatureDescriptor signatures = 1; +} + +// SignatureDescriptor is a convenience type which represents the full data for +// a signature including the public key of the signer, signing modes and the +// signature itself. It is primarily used for coordinating signatures between +// clients. +message SignatureDescriptor { + // public_key is the public key of the signer + google.protobuf.Any public_key = 1; + + Data data = 2; + + // sequence is the sequence of the account, which describes the + // number of committed transactions signed by a given address. It is used to prevent + // replay attacks. + uint64 sequence = 3; + + // Data represents signature data + message Data { + // sum is the oneof that specifies whether this represents single or multi-signature data + oneof sum { + // single represents a single signer + Single single = 1; + + // multi represents a multisig signer + Multi multi = 2; + } + + // Single is the signature data for a single signer + message Single { + // mode is the signing mode of the single signer + SignMode mode = 1; + + // signature is the raw signature bytes + bytes signature = 2; + } + + // Multi is the signature data for a multisig public key + message Multi { + // bitarray specifies which keys within the multisig are signing + cosmos.crypto.multisig.v1beta1.CompactBitArray bitarray = 1; + + // signatures is the signatures of the multi-signature + repeated Data signatures = 2; + } + } +} diff --git a/p8e-api/src/main/proto/cosmos/tx/v1beta1/service.proto b/p8e-api/src/main/proto/cosmos/tx/v1beta1/service.proto new file mode 100644 index 0000000..25214c4 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/tx/v1beta1/service.proto @@ -0,0 +1,129 @@ +syntax = "proto3"; +package cosmos.tx.v1beta1; + +import "google/api/annotations.proto"; +import "cosmos/base/abci/v1beta1/abci.proto"; +import "cosmos/tx/v1beta1/tx.proto"; +import "gogoproto/gogo.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; + +option (gogoproto.goproto_registration) = true; +option go_package = "github.com/cosmos/cosmos-sdk/types/tx"; + +// Service defines a gRPC service for interacting with transactions. +service Service { + // Simulate simulates executing a transaction for estimating gas usage. + rpc Simulate(SimulateRequest) returns (SimulateResponse) { + option (google.api.http) = { + post: "/cosmos/tx/v1beta1/simulate" + body: "*" + }; + } + // GetTx fetches a tx by hash. + rpc GetTx(GetTxRequest) returns (GetTxResponse) { + option (google.api.http).get = "/cosmos/tx/v1beta1/txs/{hash}"; + } + // BroadcastTx broadcast transaction. + rpc BroadcastTx(BroadcastTxRequest) returns (BroadcastTxResponse) { + option (google.api.http) = { + post: "/cosmos/tx/v1beta1/txs" + body: "*" + }; + } + // GetTxsEvent fetches txs by event. + rpc GetTxsEvent(GetTxsEventRequest) returns (GetTxsEventResponse) { + option (google.api.http).get = "/cosmos/tx/v1beta1/txs"; + } +} + +// GetTxsEventRequest is the request type for the Service.TxsByEvents +// RPC method. +message GetTxsEventRequest { + // events is the list of transaction event type. + repeated string events = 1; + // pagination defines an pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; + OrderBy order_by = 3; +} + +// OrderBy defines the sorting order +enum OrderBy { + // ORDER_BY_UNSPECIFIED specifies an unknown sorting order. OrderBy defaults to ASC in this case. + ORDER_BY_UNSPECIFIED = 0; + // ORDER_BY_ASC defines ascending order + ORDER_BY_ASC = 1; + // ORDER_BY_DESC defines descending order + ORDER_BY_DESC = 2; +} + +// GetTxsEventResponse is the response type for the Service.TxsByEvents +// RPC method. +message GetTxsEventResponse { + // txs is the list of queried transactions. + repeated cosmos.tx.v1beta1.Tx txs = 1; + // tx_responses is the list of queried TxResponses. + repeated cosmos.base.abci.v1beta1.TxResponse tx_responses = 2; + // pagination defines an pagination for the response. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} + +// BroadcastTxRequest is the request type for the Service.BroadcastTxRequest +// RPC method. +message BroadcastTxRequest { + // tx_bytes is the raw transaction. + bytes tx_bytes = 1; + BroadcastMode mode = 2; +} + +// BroadcastMode specifies the broadcast mode for the TxService.Broadcast RPC method. +enum BroadcastMode { + // zero-value for mode ordering + BROADCAST_MODE_UNSPECIFIED = 0; + // BROADCAST_MODE_BLOCK defines a tx broadcasting mode where the client waits for + // the tx to be committed in a block. + BROADCAST_MODE_BLOCK = 1; + // BROADCAST_MODE_SYNC defines a tx broadcasting mode where the client waits for + // a CheckTx execution response only. + BROADCAST_MODE_SYNC = 2; + // BROADCAST_MODE_ASYNC defines a tx broadcasting mode where the client returns + // immediately. + BROADCAST_MODE_ASYNC = 3; +} + +// BroadcastTxResponse is the response type for the +// Service.BroadcastTx method. +message BroadcastTxResponse { + // tx_response is the queried TxResponses. + cosmos.base.abci.v1beta1.TxResponse tx_response = 1; +} + +// SimulateRequest is the request type for the Service.Simulate +// RPC method. +message SimulateRequest { + // tx is the transaction to simulate. + cosmos.tx.v1beta1.Tx tx = 1; +} + +// SimulateResponse is the response type for the +// Service.SimulateRPC method. +message SimulateResponse { + // gas_info is the information about gas used in the simulation. + cosmos.base.abci.v1beta1.GasInfo gas_info = 1; + // result is the result of the simulation. + cosmos.base.abci.v1beta1.Result result = 2; +} + +// GetTxRequest is the request type for the Service.GetTx +// RPC method. +message GetTxRequest { + // hash is the tx hash to query, encoded as a hex string. + string hash = 1; +} + +// GetTxResponse is the response type for the Service.GetTx method. +message GetTxResponse { + // tx is the queried transaction. + cosmos.tx.v1beta1.Tx tx = 1; + // tx_response is the queried TxResponses. + cosmos.base.abci.v1beta1.TxResponse tx_response = 2; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/cosmos/tx/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/tx/v1beta1/tx.proto new file mode 100644 index 0000000..2b02874 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/tx/v1beta1/tx.proto @@ -0,0 +1,181 @@ +syntax = "proto3"; +package cosmos.tx.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/crypto/multisig/v1beta1/multisig.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/tx/signing/v1beta1/signing.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/types/tx"; + +// Tx is the standard type used for broadcasting transactions. +message Tx { + // body is the processable content of the transaction + TxBody body = 1; + + // auth_info is the authorization related content of the transaction, + // specifically signers, signer modes and fee + AuthInfo auth_info = 2; + + // signatures is a list of signatures that matches the length and order of + // AuthInfo's signer_infos to allow connecting signature meta information like + // public key and signing mode by position. + repeated bytes signatures = 3; +} + +// TxRaw is a variant of Tx that pins the signer's exact binary representation +// of body and auth_info. This is used for signing, broadcasting and +// verification. The binary `serialize(tx: TxRaw)` is stored in Tendermint and +// the hash `sha256(serialize(tx: TxRaw))` becomes the "txhash", commonly used +// as the transaction ID. +message TxRaw { + // body_bytes is a protobuf serialization of a TxBody that matches the + // representation in SignDoc. + bytes body_bytes = 1; + + // auth_info_bytes is a protobuf serialization of an AuthInfo that matches the + // representation in SignDoc. + bytes auth_info_bytes = 2; + + // signatures is a list of signatures that matches the length and order of + // AuthInfo's signer_infos to allow connecting signature meta information like + // public key and signing mode by position. + repeated bytes signatures = 3; +} + +// SignDoc is the type used for generating sign bytes for SIGN_MODE_DIRECT. +message SignDoc { + // body_bytes is protobuf serialization of a TxBody that matches the + // representation in TxRaw. + bytes body_bytes = 1; + + // auth_info_bytes is a protobuf serialization of an AuthInfo that matches the + // representation in TxRaw. + bytes auth_info_bytes = 2; + + // chain_id is the unique identifier of the chain this transaction targets. + // It prevents signed transactions from being used on another chain by an + // attacker + string chain_id = 3; + + // account_number is the account number of the account in state + uint64 account_number = 4; +} + +// TxBody is the body of a transaction that all signers sign over. +message TxBody { + // messages is a list of messages to be executed. The required signers of + // those messages define the number and order of elements in AuthInfo's + // signer_infos and Tx's signatures. Each required signer address is added to + // the list only the first time it occurs. + // By convention, the first required signer (usually from the first message) + // is referred to as the primary signer and pays the fee for the whole + // transaction. + repeated google.protobuf.Any messages = 1; + + // memo is any arbitrary memo to be added to the transaction + string memo = 2; + + // timeout is the block height after which this transaction will not + // be processed by the chain + uint64 timeout_height = 3; + + // extension_options are arbitrary options that can be added by chains + // when the default options are not sufficient. If any of these are present + // and can't be handled, the transaction will be rejected + repeated google.protobuf.Any extension_options = 1023; + + // extension_options are arbitrary options that can be added by chains + // when the default options are not sufficient. If any of these are present + // and can't be handled, they will be ignored + repeated google.protobuf.Any non_critical_extension_options = 2047; +} + +// AuthInfo describes the fee and signer modes that are used to sign a +// transaction. +message AuthInfo { + // signer_infos defines the signing modes for the required signers. The number + // and order of elements must match the required signers from TxBody's + // messages. The first element is the primary signer and the one which pays + // the fee. + repeated SignerInfo signer_infos = 1; + + // Fee is the fee and gas limit for the transaction. The first signer is the + // primary signer and the one which pays the fee. The fee can be calculated + // based on the cost of evaluating the body and doing signature verification + // of the signers. This can be estimated via simulation. + Fee fee = 2; +} + +// SignerInfo describes the public key and signing mode of a single top-level +// signer. +message SignerInfo { + // public_key is the public key of the signer. It is optional for accounts + // that already exist in state. If unset, the verifier can use the required \ + // signer address for this position and lookup the public key. + google.protobuf.Any public_key = 1; + + // mode_info describes the signing mode of the signer and is a nested + // structure to support nested multisig pubkey's + ModeInfo mode_info = 2; + + // sequence is the sequence of the account, which describes the + // number of committed transactions signed by a given address. It is used to + // prevent replay attacks. + uint64 sequence = 3; +} + +// ModeInfo describes the signing mode of a single or nested multisig signer. +message ModeInfo { + // sum is the oneof that specifies whether this represents a single or nested + // multisig signer + oneof sum { + // single represents a single signer + Single single = 1; + + // multi represents a nested multisig signer + Multi multi = 2; + } + + // Single is the mode info for a single signer. It is structured as a message + // to allow for additional fields such as locale for SIGN_MODE_TEXTUAL in the + // future + message Single { + // mode is the signing mode of the single signer + cosmos.tx.signing.v1beta1.SignMode mode = 1; + } + + // Multi is the mode info for a multisig public key + message Multi { + // bitarray specifies which keys within the multisig are signing + cosmos.crypto.multisig.v1beta1.CompactBitArray bitarray = 1; + + // mode_infos is the corresponding modes of the signers of the multisig + // which could include nested multisig public keys + repeated ModeInfo mode_infos = 2; + } +} + +// Fee includes the amount of coins paid in fees and the maximum +// gas to be used by the transaction. The ratio yields an effective "gasprice", +// which must be above some miminum to be accepted into the mempool. +message Fee { + // amount is the amount of coins to be paid as a fee + repeated cosmos.base.v1beta1.Coin amount = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; + + // gas_limit is the maximum gas that can be used in transaction processing + // before an out of gas error occurs + uint64 gas_limit = 2; + + // if unset, the first signer is responsible for paying the fees. If set, the specified account must pay the fees. + // the payer must be a tx signer (and thus have signed this field in AuthInfo). + // setting this field does *not* change the ordering of required signers for the transaction. + string payer = 3; + + // if set, the fee payer (either the first signer or the value of the payer field) requests that a fee grant be used + // to pay fees instead of the fee payer's own balance. If an appropriate fee grant does not exist or the chain does + // not support fee grants, this will fail + string granter = 4; +} diff --git a/p8e-api/src/main/proto/cosmos/upgrade/v1beta1/query.proto b/p8e-api/src/main/proto/cosmos/upgrade/v1beta1/query.proto new file mode 100644 index 0000000..9eab27e --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/upgrade/v1beta1/query.proto @@ -0,0 +1,68 @@ +syntax = "proto3"; +package cosmos.upgrade.v1beta1; + +import "google/protobuf/any.proto"; +import "google/api/annotations.proto"; +import "cosmos/upgrade/v1beta1/upgrade.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/upgrade/types"; + +// Query defines the gRPC upgrade querier service. +service Query { + // CurrentPlan queries the current upgrade plan. + rpc CurrentPlan(QueryCurrentPlanRequest) returns (QueryCurrentPlanResponse) { + option (google.api.http).get = "/cosmos/upgrade/v1beta1/current_plan"; + } + + // AppliedPlan queries a previously applied upgrade plan by its name. + rpc AppliedPlan(QueryAppliedPlanRequest) returns (QueryAppliedPlanResponse) { + option (google.api.http).get = "/cosmos/upgrade/v1beta1/applied_plan/{name}"; + } + + // UpgradedConsensusState queries the consensus state that will serve + // as a trusted kernel for the next version of this chain. It will only be + // stored at the last height of this chain. + // UpgradedConsensusState RPC not supported with legacy querier + rpc UpgradedConsensusState(QueryUpgradedConsensusStateRequest) returns (QueryUpgradedConsensusStateResponse) { + option (google.api.http).get = "/cosmos/upgrade/v1beta1/upgraded_consensus_state/{last_height}"; + } +} + +// QueryCurrentPlanRequest is the request type for the Query/CurrentPlan RPC +// method. +message QueryCurrentPlanRequest {} + +// QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC +// method. +message QueryCurrentPlanResponse { + // plan is the current upgrade plan. + Plan plan = 1; +} + +// QueryCurrentPlanRequest is the request type for the Query/AppliedPlan RPC +// method. +message QueryAppliedPlanRequest { + // name is the name of the applied plan to query for. + string name = 1; +} + +// QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC +// method. +message QueryAppliedPlanResponse { + // height is the block height at which the plan was applied. + int64 height = 1; +} + +// QueryUpgradedConsensusStateRequest is the request type for the Query/UpgradedConsensusState +// RPC method. +message QueryUpgradedConsensusStateRequest { + // last height of the current chain must be sent in request + // as this is the height under which next consensus state is stored + int64 last_height = 1; +} + +// QueryUpgradedConsensusStateResponse is the response type for the Query/UpgradedConsensusState +// RPC method. +message QueryUpgradedConsensusStateResponse { + google.protobuf.Any upgraded_consensus_state = 1; +} diff --git a/p8e-api/src/main/proto/cosmos/upgrade/v1beta1/upgrade.proto b/p8e-api/src/main/proto/cosmos/upgrade/v1beta1/upgrade.proto new file mode 100644 index 0000000..6d6839c --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/upgrade/v1beta1/upgrade.proto @@ -0,0 +1,62 @@ +syntax = "proto3"; +package cosmos.upgrade.v1beta1; + +import "google/protobuf/any.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/upgrade/types"; +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_getters_all) = false; + +// Plan specifies information about a planned upgrade and when it should occur. +message Plan { + option (gogoproto.equal) = true; + + // Sets the name for the upgrade. This name will be used by the upgraded + // version of the software to apply any special "on-upgrade" commands during + // the first BeginBlock method after the upgrade is applied. It is also used + // to detect whether a software version can handle a given upgrade. If no + // upgrade handler with this name has been set in the software, it will be + // assumed that the software is out-of-date when the upgrade Time or Height is + // reached and the software will exit. + string name = 1; + + // The time after which the upgrade must be performed. + // Leave set to its zero value to use a pre-defined Height instead. + google.protobuf.Timestamp time = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + + // The height at which the upgrade must be performed. + // Only used if Time is not set. + int64 height = 3; + + // Any application specific upgrade info to be included on-chain + // such as a git commit that validators could automatically upgrade to + string info = 4; + + // IBC-enabled chains can opt-in to including the upgraded client state in its upgrade plan + // This will make the chain commit to the correct upgraded (self) client state before the upgrade occurs, + // so that connecting chains can verify that the new upgraded client is valid by verifying a proof on the + // previous version of the chain. + // This will allow IBC connections to persist smoothly across planned chain upgrades + google.protobuf.Any upgraded_client_state = 5 [(gogoproto.moretags) = "yaml:\"upgraded_client_state\""]; +} + +// SoftwareUpgradeProposal is a gov Content type for initiating a software +// upgrade. +message SoftwareUpgradeProposal { + option (gogoproto.equal) = true; + + string title = 1; + string description = 2; + Plan plan = 3 [(gogoproto.nullable) = false]; +} + +// CancelSoftwareUpgradeProposal is a gov Content type for cancelling a software +// upgrade. +message CancelSoftwareUpgradeProposal { + option (gogoproto.equal) = true; + + string title = 1; + string description = 2; +} diff --git a/p8e-api/src/main/proto/cosmos/vesting/v1beta1/tx.proto b/p8e-api/src/main/proto/cosmos/vesting/v1beta1/tx.proto new file mode 100644 index 0000000..c49be80 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/vesting/v1beta1/tx.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; +package cosmos.vesting.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"; + +// Msg defines the bank Msg service. +service Msg { + // CreateVestingAccount defines a method that enables creating a vesting + // account. + rpc CreateVestingAccount(MsgCreateVestingAccount) returns (MsgCreateVestingAccountResponse); +} + +// MsgCreateVestingAccount defines a message that enables creating a vesting +// account. +message MsgCreateVestingAccount { + option (gogoproto.equal) = true; + + string from_address = 1 [(gogoproto.moretags) = "yaml:\"from_address\""]; + string to_address = 2 [(gogoproto.moretags) = "yaml:\"to_address\""]; + repeated cosmos.base.v1beta1.Coin amount = 3 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; + + int64 end_time = 4 [(gogoproto.moretags) = "yaml:\"end_time\""]; + bool delayed = 5; +} + +// MsgCreateVestingAccountResponse defines the Msg/CreateVestingAccount response type. +message MsgCreateVestingAccountResponse {} \ No newline at end of file diff --git a/p8e-api/src/main/proto/cosmos/vesting/v1beta1/vesting.proto b/p8e-api/src/main/proto/cosmos/vesting/v1beta1/vesting.proto new file mode 100644 index 0000000..6bdbbf0 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos/vesting/v1beta1/vesting.proto @@ -0,0 +1,73 @@ +syntax = "proto3"; +package cosmos.vesting.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/auth/v1beta1/auth.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"; + +// BaseVestingAccount implements the VestingAccount interface. It contains all +// the necessary fields needed for any vesting account implementation. +message BaseVestingAccount { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + cosmos.auth.v1beta1.BaseAccount base_account = 1 [(gogoproto.embed) = true]; + repeated cosmos.base.v1beta1.Coin original_vesting = 2 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"original_vesting\"" + ]; + repeated cosmos.base.v1beta1.Coin delegated_free = 3 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"delegated_free\"" + ]; + repeated cosmos.base.v1beta1.Coin delegated_vesting = 4 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"delegated_vesting\"" + ]; + int64 end_time = 5 [(gogoproto.moretags) = "yaml:\"end_time\""]; +} + +// ContinuousVestingAccount implements the VestingAccount interface. It +// continuously vests by unlocking coins linearly with respect to time. +message ContinuousVestingAccount { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + BaseVestingAccount base_vesting_account = 1 [(gogoproto.embed) = true]; + int64 start_time = 2 [(gogoproto.moretags) = "yaml:\"start_time\""]; +} + +// DelayedVestingAccount implements the VestingAccount interface. It vests all +// coins after a specific time, but non prior. In other words, it keeps them +// locked until a specified time. +message DelayedVestingAccount { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + BaseVestingAccount base_vesting_account = 1 [(gogoproto.embed) = true]; +} + +// Period defines a length of time and amount of coins that will vest. +message Period { + option (gogoproto.goproto_stringer) = false; + + int64 length = 1; + repeated cosmos.base.v1beta1.Coin amount = 2 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// PeriodicVestingAccount implements the VestingAccount interface. It +// periodically vests by unlocking coins during each specified period. +message PeriodicVestingAccount { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + BaseVestingAccount base_vesting_account = 1 [(gogoproto.embed) = true]; + int64 start_time = 2 [(gogoproto.moretags) = "yaml:\"start_time\""]; + repeated Period vesting_periods = 3 [(gogoproto.moretags) = "yaml:\"vesting_periods\"", (gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/cosmos_proto/cosmos.proto b/p8e-api/src/main/proto/cosmos_proto/cosmos.proto new file mode 100644 index 0000000..167b170 --- /dev/null +++ b/p8e-api/src/main/proto/cosmos_proto/cosmos.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; +package cosmos_proto; + +import "google/protobuf/descriptor.proto"; + +option go_package = "github.com/regen-network/cosmos-proto"; + +extend google.protobuf.MessageOptions { + string interface_type = 93001; + + string implements_interface = 93002; +} + +extend google.protobuf.FieldOptions { + string accepts_interface = 93001; +} diff --git a/p8e-api/src/main/proto/gogoproto/gogo.proto b/p8e-api/src/main/proto/gogoproto/gogo.proto new file mode 100644 index 0000000..49e78f9 --- /dev/null +++ b/p8e-api/src/main/proto/gogoproto/gogo.proto @@ -0,0 +1,145 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto2"; +package gogoproto; + +import "google/protobuf/descriptor.proto"; + +option java_package = "com.google.protobuf"; +option java_outer_classname = "GoGoProtos"; +option go_package = "github.com/gogo/protobuf/gogoproto"; + +extend google.protobuf.EnumOptions { + optional bool goproto_enum_prefix = 62001; + optional bool goproto_enum_stringer = 62021; + optional bool enum_stringer = 62022; + optional string enum_customname = 62023; + optional bool enumdecl = 62024; +} + +extend google.protobuf.EnumValueOptions { + optional string enumvalue_customname = 66001; +} + +extend google.protobuf.FileOptions { + optional bool goproto_getters_all = 63001; + optional bool goproto_enum_prefix_all = 63002; + optional bool goproto_stringer_all = 63003; + optional bool verbose_equal_all = 63004; + optional bool face_all = 63005; + optional bool gostring_all = 63006; + optional bool populate_all = 63007; + optional bool stringer_all = 63008; + optional bool onlyone_all = 63009; + + optional bool equal_all = 63013; + optional bool description_all = 63014; + optional bool testgen_all = 63015; + optional bool benchgen_all = 63016; + optional bool marshaler_all = 63017; + optional bool unmarshaler_all = 63018; + optional bool stable_marshaler_all = 63019; + + optional bool sizer_all = 63020; + + optional bool goproto_enum_stringer_all = 63021; + optional bool enum_stringer_all = 63022; + + optional bool unsafe_marshaler_all = 63023; + optional bool unsafe_unmarshaler_all = 63024; + + optional bool goproto_extensions_map_all = 63025; + optional bool goproto_unrecognized_all = 63026; + optional bool gogoproto_import = 63027; + optional bool protosizer_all = 63028; + optional bool compare_all = 63029; + optional bool typedecl_all = 63030; + optional bool enumdecl_all = 63031; + + optional bool goproto_registration = 63032; + optional bool messagename_all = 63033; + + optional bool goproto_sizecache_all = 63034; + optional bool goproto_unkeyed_all = 63035; +} + +extend google.protobuf.MessageOptions { + optional bool goproto_getters = 64001; + optional bool goproto_stringer = 64003; + optional bool verbose_equal = 64004; + optional bool face = 64005; + optional bool gostring = 64006; + optional bool populate = 64007; + optional bool stringer = 67008; + optional bool onlyone = 64009; + + optional bool equal = 64013; + optional bool description = 64014; + optional bool testgen = 64015; + optional bool benchgen = 64016; + optional bool marshaler = 64017; + optional bool unmarshaler = 64018; + optional bool stable_marshaler = 64019; + + optional bool sizer = 64020; + + optional bool unsafe_marshaler = 64023; + optional bool unsafe_unmarshaler = 64024; + + optional bool goproto_extensions_map = 64025; + optional bool goproto_unrecognized = 64026; + + optional bool protosizer = 64028; + optional bool compare = 64029; + + optional bool typedecl = 64030; + + optional bool messagename = 64033; + + optional bool goproto_sizecache = 64034; + optional bool goproto_unkeyed = 64035; +} + +extend google.protobuf.FieldOptions { + optional bool nullable = 65001; + optional bool embed = 65002; + optional string customtype = 65003; + optional string customname = 65004; + optional string jsontag = 65005; + optional string moretags = 65006; + optional string casttype = 65007; + optional string castkey = 65008; + optional string castvalue = 65009; + + optional bool stdtime = 65010; + optional bool stdduration = 65011; + optional bool wktpointer = 65012; + + optional string castrepeated = 65013; +} diff --git a/p8e-api/src/main/proto/google/api/annotations.proto b/p8e-api/src/main/proto/google/api/annotations.proto new file mode 100644 index 0000000..85c361b --- /dev/null +++ b/p8e-api/src/main/proto/google/api/annotations.proto @@ -0,0 +1,31 @@ +// Copyright (c) 2015, Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package google.api; + +import "google/api/http.proto"; +import "google/protobuf/descriptor.proto"; + +option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; +option java_multiple_files = true; +option java_outer_classname = "AnnotationsProto"; +option java_package = "com.google.api"; +option objc_class_prefix = "GAPI"; + +extend google.protobuf.MethodOptions { + // See `HttpRule`. + HttpRule http = 72295728; +} diff --git a/p8e-api/src/main/proto/google/api/http.proto b/p8e-api/src/main/proto/google/api/http.proto new file mode 100644 index 0000000..2bd3a19 --- /dev/null +++ b/p8e-api/src/main/proto/google/api/http.proto @@ -0,0 +1,318 @@ +// Copyright 2018 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package google.api; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; +option java_multiple_files = true; +option java_outer_classname = "HttpProto"; +option java_package = "com.google.api"; +option objc_class_prefix = "GAPI"; + + +// Defines the HTTP configuration for an API service. It contains a list of +// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method +// to one or more HTTP REST API methods. +message Http { + // A list of HTTP configuration rules that apply to individual API methods. + // + // **NOTE:** All service configuration rules follow "last one wins" order. + repeated HttpRule rules = 1; + + // When set to true, URL path parmeters will be fully URI-decoded except in + // cases of single segment matches in reserved expansion, where "%2F" will be + // left encoded. + // + // The default behavior is to not decode RFC 6570 reserved characters in multi + // segment matches. + bool fully_decode_reserved_expansion = 2; +} + +// `HttpRule` defines the mapping of an RPC method to one or more HTTP +// REST API methods. The mapping specifies how different portions of the RPC +// request message are mapped to URL path, URL query parameters, and +// HTTP request body. The mapping is typically specified as an +// `google.api.http` annotation on the RPC method, +// see "google/api/annotations.proto" for details. +// +// The mapping consists of a field specifying the path template and +// method kind. The path template can refer to fields in the request +// message, as in the example below which describes a REST GET +// operation on a resource collection of messages: +// +// +// service Messaging { +// rpc GetMessage(GetMessageRequest) returns (Message) { +// option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}"; +// } +// } +// message GetMessageRequest { +// message SubMessage { +// string subfield = 1; +// } +// string message_id = 1; // mapped to the URL +// SubMessage sub = 2; // `sub.subfield` is url-mapped +// } +// message Message { +// string text = 1; // content of the resource +// } +// +// The same http annotation can alternatively be expressed inside the +// `GRPC API Configuration` YAML file. +// +// http: +// rules: +// - selector: .Messaging.GetMessage +// get: /v1/messages/{message_id}/{sub.subfield} +// +// This definition enables an automatic, bidrectional mapping of HTTP +// JSON to RPC. Example: +// +// HTTP | RPC +// -----|----- +// `GET /v1/messages/123456/foo` | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))` +// +// In general, not only fields but also field paths can be referenced +// from a path pattern. Fields mapped to the path pattern cannot be +// repeated and must have a primitive (non-message) type. +// +// Any fields in the request message which are not bound by the path +// pattern automatically become (optional) HTTP query +// parameters. Assume the following definition of the request message: +// +// +// service Messaging { +// rpc GetMessage(GetMessageRequest) returns (Message) { +// option (google.api.http).get = "/v1/messages/{message_id}"; +// } +// } +// message GetMessageRequest { +// message SubMessage { +// string subfield = 1; +// } +// string message_id = 1; // mapped to the URL +// int64 revision = 2; // becomes a parameter +// SubMessage sub = 3; // `sub.subfield` becomes a parameter +// } +// +// +// This enables a HTTP JSON to RPC mapping as below: +// +// HTTP | RPC +// -----|----- +// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))` +// +// Note that fields which are mapped to HTTP parameters must have a +// primitive type or a repeated primitive type. Message types are not +// allowed. In the case of a repeated type, the parameter can be +// repeated in the URL, as in `...?param=A¶m=B`. +// +// For HTTP method kinds which allow a request body, the `body` field +// specifies the mapping. Consider a REST update method on the +// message resource collection: +// +// +// service Messaging { +// rpc UpdateMessage(UpdateMessageRequest) returns (Message) { +// option (google.api.http) = { +// put: "/v1/messages/{message_id}" +// body: "message" +// }; +// } +// } +// message UpdateMessageRequest { +// string message_id = 1; // mapped to the URL +// Message message = 2; // mapped to the body +// } +// +// +// The following HTTP JSON to RPC mapping is enabled, where the +// representation of the JSON in the request body is determined by +// protos JSON encoding: +// +// HTTP | RPC +// -----|----- +// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" message { text: "Hi!" })` +// +// The special name `*` can be used in the body mapping to define that +// every field not bound by the path template should be mapped to the +// request body. This enables the following alternative definition of +// the update method: +// +// service Messaging { +// rpc UpdateMessage(Message) returns (Message) { +// option (google.api.http) = { +// put: "/v1/messages/{message_id}" +// body: "*" +// }; +// } +// } +// message Message { +// string message_id = 1; +// string text = 2; +// } +// +// +// The following HTTP JSON to RPC mapping is enabled: +// +// HTTP | RPC +// -----|----- +// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" text: "Hi!")` +// +// Note that when using `*` in the body mapping, it is not possible to +// have HTTP parameters, as all fields not bound by the path end in +// the body. This makes this option more rarely used in practice of +// defining REST APIs. The common usage of `*` is in custom methods +// which don't use the URL at all for transferring data. +// +// It is possible to define multiple HTTP methods for one RPC by using +// the `additional_bindings` option. Example: +// +// service Messaging { +// rpc GetMessage(GetMessageRequest) returns (Message) { +// option (google.api.http) = { +// get: "/v1/messages/{message_id}" +// additional_bindings { +// get: "/v1/users/{user_id}/messages/{message_id}" +// } +// }; +// } +// } +// message GetMessageRequest { +// string message_id = 1; +// string user_id = 2; +// } +// +// +// This enables the following two alternative HTTP JSON to RPC +// mappings: +// +// HTTP | RPC +// -----|----- +// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` +// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: "123456")` +// +// # Rules for HTTP mapping +// +// The rules for mapping HTTP path, query parameters, and body fields +// to the request message are as follows: +// +// 1. The `body` field specifies either `*` or a field path, or is +// omitted. If omitted, it indicates there is no HTTP request body. +// 2. Leaf fields (recursive expansion of nested messages in the +// request) can be classified into three types: +// (a) Matched in the URL template. +// (b) Covered by body (if body is `*`, everything except (a) fields; +// else everything under the body field) +// (c) All other fields. +// 3. URL query parameters found in the HTTP request are mapped to (c) fields. +// 4. Any body sent with an HTTP request can contain only (b) fields. +// +// The syntax of the path template is as follows: +// +// Template = "/" Segments [ Verb ] ; +// Segments = Segment { "/" Segment } ; +// Segment = "*" | "**" | LITERAL | Variable ; +// Variable = "{" FieldPath [ "=" Segments ] "}" ; +// FieldPath = IDENT { "." IDENT } ; +// Verb = ":" LITERAL ; +// +// The syntax `*` matches a single path segment. The syntax `**` matches zero +// or more path segments, which must be the last part of the path except the +// `Verb`. The syntax `LITERAL` matches literal text in the path. +// +// The syntax `Variable` matches part of the URL path as specified by its +// template. A variable template must not contain other variables. If a variable +// matches a single path segment, its template may be omitted, e.g. `{var}` +// is equivalent to `{var=*}`. +// +// If a variable contains exactly one path segment, such as `"{var}"` or +// `"{var=*}"`, when such a variable is expanded into a URL path, all characters +// except `[-_.~0-9a-zA-Z]` are percent-encoded. Such variables show up in the +// Discovery Document as `{var}`. +// +// If a variable contains one or more path segments, such as `"{var=foo/*}"` +// or `"{var=**}"`, when such a variable is expanded into a URL path, all +// characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. Such variables +// show up in the Discovery Document as `{+var}`. +// +// NOTE: While the single segment variable matches the semantics of +// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 +// Simple String Expansion, the multi segment variable **does not** match +// RFC 6570 Reserved Expansion. The reason is that the Reserved Expansion +// does not expand special characters like `?` and `#`, which would lead +// to invalid URLs. +// +// NOTE: the field paths in variables and in the `body` must not refer to +// repeated fields or map fields. +message HttpRule { + // Selects methods to which this rule applies. + // + // Refer to [selector][google.api.DocumentationRule.selector] for syntax details. + string selector = 1; + + // Determines the URL pattern is matched by this rules. This pattern can be + // used with any of the {get|put|post|delete|patch} methods. A custom method + // can be defined using the 'custom' field. + oneof pattern { + // Used for listing and getting information about resources. + string get = 2; + + // Used for updating a resource. + string put = 3; + + // Used for creating a resource. + string post = 4; + + // Used for deleting a resource. + string delete = 5; + + // Used for updating a resource. + string patch = 6; + + // The custom pattern is used for specifying an HTTP method that is not + // included in the `pattern` field, such as HEAD, or "*" to leave the + // HTTP method unspecified for this rule. The wild-card rule is useful + // for services that provide content to Web (HTML) clients. + CustomHttpPattern custom = 8; + } + + // The name of the request field whose value is mapped to the HTTP body, or + // `*` for mapping all fields not captured by the path pattern to the HTTP + // body. NOTE: the referred field must not be a repeated field and must be + // present at the top-level of request message type. + string body = 7; + + // Optional. The name of the response field whose value is mapped to the HTTP + // body of response. Other response fields are ignored. When + // not set, the response message will be used as HTTP body of response. + string response_body = 12; + + // Additional HTTP bindings for the selector. Nested bindings must + // not contain an `additional_bindings` field themselves (that is, + // the nesting may only be one level deep). + repeated HttpRule additional_bindings = 11; +} + +// A custom pattern is used for defining custom HTTP verb. +message CustomHttpPattern { + // The name of this custom HTTP verb. + string kind = 1; + + // The path matched by this custom verb. + string path = 2; +} diff --git a/p8e-api/src/main/proto/google/api/httpbody.proto b/p8e-api/src/main/proto/google/api/httpbody.proto new file mode 100644 index 0000000..4428515 --- /dev/null +++ b/p8e-api/src/main/proto/google/api/httpbody.proto @@ -0,0 +1,78 @@ +// Copyright 2018 Google LLC. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +syntax = "proto3"; + +package google.api; + +import "google/protobuf/any.proto"; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/genproto/googleapis/api/httpbody;httpbody"; +option java_multiple_files = true; +option java_outer_classname = "HttpBodyProto"; +option java_package = "com.google.api"; +option objc_class_prefix = "GAPI"; + +// Message that represents an arbitrary HTTP body. It should only be used for +// payload formats that can't be represented as JSON, such as raw binary or +// an HTML page. +// +// +// This message can be used both in streaming and non-streaming API methods in +// the request as well as the response. +// +// It can be used as a top-level request field, which is convenient if one +// wants to extract parameters from either the URL or HTTP template into the +// request fields and also want access to the raw HTTP body. +// +// Example: +// +// message GetResourceRequest { +// // A unique request id. +// string request_id = 1; +// +// // The raw HTTP body is bound to this field. +// google.api.HttpBody http_body = 2; +// } +// +// service ResourceService { +// rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); +// rpc UpdateResource(google.api.HttpBody) returns +// (google.protobuf.Empty); +// } +// +// Example with streaming methods: +// +// service CaldavService { +// rpc GetCalendar(stream google.api.HttpBody) +// returns (stream google.api.HttpBody); +// rpc UpdateCalendar(stream google.api.HttpBody) +// returns (stream google.api.HttpBody); +// } +// +// Use of this type only changes how the request and response bodies are +// handled, all other features will continue to work unchanged. +message HttpBody { + // The HTTP Content-Type header value specifying the content type of the body. + string content_type = 1; + + // The HTTP request/response body as raw binary. + bytes data = 2; + + // Application specific response metadata. Must be set in the first response + // for streaming APIs. + repeated google.protobuf.Any extensions = 3; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/google/protobuf/any.proto b/p8e-api/src/main/proto/google/protobuf/any.proto new file mode 100644 index 0000000..1431810 --- /dev/null +++ b/p8e-api/src/main/proto/google/protobuf/any.proto @@ -0,0 +1,161 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +import "gogoproto/gogo.proto"; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "types"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "AnyProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; + +// `Any` contains an arbitrary serialized protocol buffer message along with a +// URL that describes the type of the serialized message. +// +// Protobuf library provides support to pack/unpack Any values in the form +// of utility functions or additional generated methods of the Any type. +// +// Example 1: Pack and unpack a message in C++. +// +// Foo foo = ...; +// Any any; +// any.PackFrom(foo); +// ... +// if (any.UnpackTo(&foo)) { +// ... +// } +// +// Example 2: Pack and unpack a message in Java. +// +// Foo foo = ...; +// Any any = Any.pack(foo); +// ... +// if (any.is(Foo.class)) { +// foo = any.unpack(Foo.class); +// } +// +// Example 3: Pack and unpack a message in Python. +// +// foo = Foo(...) +// any = Any() +// any.Pack(foo) +// ... +// if any.Is(Foo.DESCRIPTOR): +// any.Unpack(foo) +// ... +// +// Example 4: Pack and unpack a message in Go +// +// foo := &pb.Foo{...} +// any, err := ptypes.MarshalAny(foo) +// ... +// foo := &pb.Foo{} +// if err := ptypes.UnmarshalAny(any, foo); err != nil { +// ... +// } +// +// The pack methods provided by protobuf library will by default use +// 'type.googleapis.com/full.type.name' as the type URL and the unpack +// methods only use the fully qualified type name after the last '/' +// in the type URL, for example "foo.bar.com/x/y.z" will yield type +// name "y.z". +// +// +// JSON +// ==== +// The JSON representation of an `Any` value uses the regular +// representation of the deserialized, embedded message, with an +// additional field `@type` which contains the type URL. Example: +// +// package google.profile; +// message Person { +// string first_name = 1; +// string last_name = 2; +// } +// +// { +// "@type": "type.googleapis.com/google.profile.Person", +// "firstName": , +// "lastName": +// } +// +// If the embedded message type is well-known and has a custom JSON +// representation, that representation will be embedded adding a field +// `value` which holds the custom JSON in addition to the `@type` +// field. Example (for message [google.protobuf.Duration][]): +// +// { +// "@type": "type.googleapis.com/google.protobuf.Duration", +// "value": "1.212s" +// } +// +message Any { + // A URL/resource name that uniquely identifies the type of the serialized + // protocol buffer message. This string must contain at least + // one "/" character. The last segment of the URL's path must represent + // the fully qualified name of the type (as in + // `path/google.protobuf.Duration`). The name should be in a canonical form + // (e.g., leading "." is not accepted). + // + // In practice, teams usually precompile into the binary all types that they + // expect it to use in the context of Any. However, for URLs which use the + // scheme `http`, `https`, or no scheme, one can optionally set up a type + // server that maps type URLs to message definitions as follows: + // + // * If no scheme is provided, `https` is assumed. + // * An HTTP GET on the URL must yield a [google.protobuf.Type][] + // value in binary format, or produce an error. + // * Applications are allowed to cache lookup results based on the + // URL, or have them precompiled into a binary to avoid any + // lookup. Therefore, binary compatibility needs to be preserved + // on changes to types. (Use versioned type names to manage + // breaking changes.) + // + // Note: this functionality is not currently available in the official + // protobuf release, and it is not used for type URLs beginning with + // type.googleapis.com. + // + // Schemes other than `http`, `https` (or the empty scheme) might be + // used with implementation specific semantics. + // + string type_url = 1; + + // Must be a valid serialized protocol buffer of the above specified type. + bytes value = 2; + + option (gogoproto.typedecl) = false; +} + +option (gogoproto.goproto_registration) = false; diff --git a/p8e-api/src/main/proto/google/protobuf/descriptor.proto b/p8e-api/src/main/proto/google/protobuf/descriptor.proto new file mode 100644 index 0000000..9f0ce6c --- /dev/null +++ b/p8e-api/src/main/proto/google/protobuf/descriptor.proto @@ -0,0 +1,909 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// The messages in this file describe the definitions found in .proto files. +// A valid .proto file can be translated directly to a FileDescriptorProto +// without any other information (e.g. without reading its imports). + + +syntax = "proto2"; + +package google.protobuf; + +option go_package = "google.golang.org/protobuf/types/descriptorpb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "DescriptorProtos"; +option csharp_namespace = "Google.Protobuf.Reflection"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; + +// descriptor.proto must be optimized for speed because reflection-based +// algorithms don't work during bootstrapping. +option optimize_for = SPEED; + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +message FileDescriptorSet { + repeated FileDescriptorProto file = 1; +} + +// Describes a complete .proto file. +message FileDescriptorProto { + optional string name = 1; // file name, relative to root of source tree + optional string package = 2; // e.g. "foo", "foo.bar", etc. + + // Names of files imported by this file. + repeated string dependency = 3; + // Indexes of the public imported files in the dependency list above. + repeated int32 public_dependency = 10; + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + repeated int32 weak_dependency = 11; + + // All top-level definitions in this file. + repeated DescriptorProto message_type = 4; + repeated EnumDescriptorProto enum_type = 5; + repeated ServiceDescriptorProto service = 6; + repeated FieldDescriptorProto extension = 7; + + optional FileOptions options = 8; + + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + optional SourceCodeInfo source_code_info = 9; + + // The syntax of the proto file. + // The supported values are "proto2" and "proto3". + optional string syntax = 12; +} + +// Describes a message type. +message DescriptorProto { + optional string name = 1; + + repeated FieldDescriptorProto field = 2; + repeated FieldDescriptorProto extension = 6; + + repeated DescriptorProto nested_type = 3; + repeated EnumDescriptorProto enum_type = 4; + + message ExtensionRange { + optional int32 start = 1; // Inclusive. + optional int32 end = 2; // Exclusive. + + optional ExtensionRangeOptions options = 3; + } + repeated ExtensionRange extension_range = 5; + + repeated OneofDescriptorProto oneof_decl = 8; + + optional MessageOptions options = 7; + + // Range of reserved tag numbers. Reserved tag numbers may not be used by + // fields or extension ranges in the same message. Reserved ranges may + // not overlap. + message ReservedRange { + optional int32 start = 1; // Inclusive. + optional int32 end = 2; // Exclusive. + } + repeated ReservedRange reserved_range = 9; + // Reserved field names, which may not be used by fields in the same message. + // A given name may only be reserved once. + repeated string reserved_name = 10; +} + +message ExtensionRangeOptions { + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +// Describes a field within a message. +message FieldDescriptorProto { + enum Type { + // 0 is reserved for errors. + // Order is weird for historical reasons. + TYPE_DOUBLE = 1; + TYPE_FLOAT = 2; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + TYPE_INT64 = 3; + TYPE_UINT64 = 4; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + TYPE_INT32 = 5; + TYPE_FIXED64 = 6; + TYPE_FIXED32 = 7; + TYPE_BOOL = 8; + TYPE_STRING = 9; + // Tag-delimited aggregate. + // Group type is deprecated and not supported in proto3. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. + TYPE_GROUP = 10; + TYPE_MESSAGE = 11; // Length-delimited aggregate. + + // New in version 2. + TYPE_BYTES = 12; + TYPE_UINT32 = 13; + TYPE_ENUM = 14; + TYPE_SFIXED32 = 15; + TYPE_SFIXED64 = 16; + TYPE_SINT32 = 17; // Uses ZigZag encoding. + TYPE_SINT64 = 18; // Uses ZigZag encoding. + } + + enum Label { + // 0 is reserved for errors + LABEL_OPTIONAL = 1; + LABEL_REQUIRED = 2; + LABEL_REPEATED = 3; + } + + optional string name = 1; + optional int32 number = 3; + optional Label label = 4; + + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + optional Type type = 5; + + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + optional string type_name = 6; + + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + optional string extendee = 2; + + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + // TODO(kenton): Base-64 encode? + optional string default_value = 7; + + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. + optional int32 oneof_index = 9; + + // JSON name of this field. The value is set by protocol compiler. If the + // user has set a "json_name" option on this field, that option's value + // will be used. Otherwise, it's deduced from the field's name by converting + // it to camelCase. + optional string json_name = 10; + + optional FieldOptions options = 8; + + // If true, this is a proto3 "optional". When a proto3 field is optional, it + // tracks presence regardless of field type. + // + // When proto3_optional is true, this field must be belong to a oneof to + // signal to old proto3 clients that presence is tracked for this field. This + // oneof is known as a "synthetic" oneof, and this field must be its sole + // member (each proto3 optional field gets its own synthetic oneof). Synthetic + // oneofs exist in the descriptor only, and do not generate any API. Synthetic + // oneofs must be ordered after all "real" oneofs. + // + // For message fields, proto3_optional doesn't create any semantic change, + // since non-repeated message fields always track presence. However it still + // indicates the semantic detail of whether the user wrote "optional" or not. + // This can be useful for round-tripping the .proto file. For consistency we + // give message fields a synthetic oneof also, even though it is not required + // to track presence. This is especially important because the parser can't + // tell if a field is a message or an enum, so it must always create a + // synthetic oneof. + // + // Proto2 optional fields do not set this flag, because they already indicate + // optional with `LABEL_OPTIONAL`. + optional bool proto3_optional = 17; +} + +// Describes a oneof. +message OneofDescriptorProto { + optional string name = 1; + optional OneofOptions options = 2; +} + +// Describes an enum type. +message EnumDescriptorProto { + optional string name = 1; + + repeated EnumValueDescriptorProto value = 2; + + optional EnumOptions options = 3; + + // Range of reserved numeric values. Reserved values may not be used by + // entries in the same enum. Reserved ranges may not overlap. + // + // Note that this is distinct from DescriptorProto.ReservedRange in that it + // is inclusive such that it can appropriately represent the entire int32 + // domain. + message EnumReservedRange { + optional int32 start = 1; // Inclusive. + optional int32 end = 2; // Inclusive. + } + + // Range of reserved numeric values. Reserved numeric values may not be used + // by enum values in the same enum declaration. Reserved ranges may not + // overlap. + repeated EnumReservedRange reserved_range = 4; + + // Reserved enum value names, which may not be reused. A given name may only + // be reserved once. + repeated string reserved_name = 5; +} + +// Describes a value within an enum. +message EnumValueDescriptorProto { + optional string name = 1; + optional int32 number = 2; + + optional EnumValueOptions options = 3; +} + +// Describes a service. +message ServiceDescriptorProto { + optional string name = 1; + repeated MethodDescriptorProto method = 2; + + optional ServiceOptions options = 3; +} + +// Describes a method of a service. +message MethodDescriptorProto { + optional string name = 1; + + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + optional string input_type = 2; + optional string output_type = 3; + + optional MethodOptions options = 4; + + // Identifies if client streams multiple client messages + optional bool client_streaming = 5 [default = false]; + // Identifies if server streams multiple server messages + optional bool server_streaming = 6 [default = false]; +} + + +// =================================================================== +// Options + +// Each of the definitions above may have "options" attached. These are +// just annotations which may cause code to be generated slightly differently +// or may contain hints for code that manipulates protocol messages. +// +// Clients may define custom options as extensions of the *Options messages. +// These extensions may not yet be known at parsing time, so the parser cannot +// store the values in them. Instead it stores them in a field in the *Options +// message called uninterpreted_option. This field must have the same name +// across all *Options messages. We then use this field to populate the +// extensions when we build a descriptor, at which point all protos have been +// parsed and so all extensions are known. +// +// Extension numbers for custom options may be chosen as follows: +// * For options which will only be used within a single application or +// organization, or for experimental options, use field numbers 50000 +// through 99999. It is up to you to ensure that you do not use the +// same number for multiple options. +// * For options which will be published and used publicly by multiple +// independent entities, e-mail protobuf-global-extension-registry@google.com +// to reserve extension numbers. Simply provide your project name (e.g. +// Objective-C plugin) and your project website (if available) -- there's no +// need to explain how you intend to use them. Usually you only need one +// extension number. You can declare multiple options with only one extension +// number by putting them in a sub-message. See the Custom Options section of +// the docs for examples: +// https://developers.google.com/protocol-buffers/docs/proto#options +// If this turns out to be popular, a web service will be set up +// to automatically assign option numbers. + +message FileOptions { + + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + optional string java_package = 1; + + + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + optional string java_outer_classname = 8; + + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + optional bool java_multiple_files = 10 [default = false]; + + // This option does nothing. + optional bool java_generate_equals_and_hash = 20 [deprecated=true]; + + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + optional bool java_string_check_utf8 = 27 [default = false]; + + + // Generated classes can be optimized for speed or code size. + enum OptimizeMode { + SPEED = 1; // Generate complete code for parsing, serialization, + // etc. + CODE_SIZE = 2; // Use ReflectionOps to implement these methods. + LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime. + } + optional OptimizeMode optimize_for = 9 [default = SPEED]; + + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + optional string go_package = 11; + + + + + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + optional bool cc_generic_services = 16 [default = false]; + optional bool java_generic_services = 17 [default = false]; + optional bool py_generic_services = 18 [default = false]; + optional bool php_generic_services = 42 [default = false]; + + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + optional bool deprecated = 23 [default = false]; + + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + optional bool cc_enable_arenas = 31 [default = true]; + + + // Sets the objective c class prefix which is prepended to all objective c + // generated classes from this .proto. There is no default. + optional string objc_class_prefix = 36; + + // Namespace for generated classes; defaults to the package. + optional string csharp_namespace = 37; + + // By default Swift generators will take the proto package and CamelCase it + // replacing '.' with underscore and use that to prefix the types/symbols + // defined. When this options is provided, they will use this value instead + // to prefix the types/symbols defined. + optional string swift_prefix = 39; + + // Sets the php class prefix which is prepended to all php generated classes + // from this .proto. Default is empty. + optional string php_class_prefix = 40; + + // Use this option to change the namespace of php generated classes. Default + // is empty. When this option is empty, the package name will be used for + // determining the namespace. + optional string php_namespace = 41; + + // Use this option to change the namespace of php generated metadata classes. + // Default is empty. When this option is empty, the proto file name will be + // used for determining the namespace. + optional string php_metadata_namespace = 44; + + // Use this option to change the package of ruby generated classes. Default + // is empty. When this option is not set, the package name will be used for + // determining the ruby package. + optional string ruby_package = 45; + + + // The parser stores options it doesn't recognize here. + // See the documentation for the "Options" section above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. + // See the documentation for the "Options" section above. + extensions 1000 to max; + + reserved 38; +} + +message MessageOptions { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + optional bool message_set_wire_format = 1 [default = false]; + + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + optional bool no_standard_descriptor_accessor = 2 [default = false]; + + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + optional bool deprecated = 3 [default = false]; + + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementations still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + optional bool map_entry = 7; + + reserved 8; // javalite_serializable + reserved 9; // javanano_as_lite + + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message FieldOptions { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + optional CType ctype = 1 [default = STRING]; + enum CType { + // Default mode. + STRING = 0; + + CORD = 1; + + STRING_PIECE = 2; + } + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. In proto3, only explicit setting it to + // false will avoid using packed encoding. + optional bool packed = 2; + + // The jstype option determines the JavaScript type used for values of the + // field. The option is permitted only for 64 bit integral and fixed types + // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + // is represented as JavaScript string, which avoids loss of precision that + // can happen when a large value is converted to a floating point JavaScript. + // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + // use the JavaScript "number" type. The behavior of the default option + // JS_NORMAL is implementation dependent. + // + // This option is an enum to permit additional types to be added, e.g. + // goog.math.Integer. + optional JSType jstype = 6 [default = JS_NORMAL]; + enum JSType { + // Use the default type. + JS_NORMAL = 0; + + // Use JavaScript strings. + JS_STRING = 1; + + // Use JavaScript numbers. + JS_NUMBER = 2; + } + + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // + // Note that implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outer message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + optional bool lazy = 5 [default = false]; + + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + optional bool deprecated = 3 [default = false]; + + // For Google-internal migration only. Do not use. + optional bool weak = 10 [default = false]; + + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; + + reserved 4; // removed jtype +} + +message OneofOptions { + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumOptions { + + // Set this option to true to allow mapping different tag names to the same + // value. + optional bool allow_alias = 2; + + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + optional bool deprecated = 3 [default = false]; + + reserved 5; // javanano_as_lite + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumValueOptions { + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + optional bool deprecated = 1 [default = false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message ServiceOptions { + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + optional bool deprecated = 33 [default = false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message MethodOptions { + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + optional bool deprecated = 33 [default = false]; + + // Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + // or neither? HTTP based RPC implementation may choose GET verb for safe + // methods, and PUT verb for idempotent methods instead of the default POST. + enum IdempotencyLevel { + IDEMPOTENCY_UNKNOWN = 0; + NO_SIDE_EFFECTS = 1; // implies idempotent + IDEMPOTENT = 2; // idempotent, but may have side effects + } + optional IdempotencyLevel idempotency_level = 34 + [default = IDEMPOTENCY_UNKNOWN]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +message UninterpretedOption { + // The name of the uninterpreted option. Each string represents a segment in + // a dot-separated name. is_extension is true iff a segment represents an + // extension (denoted with parentheses in options specs in .proto files). + // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents + // "foo.(bar.baz).qux". + message NamePart { + required string name_part = 1; + required bool is_extension = 2; + } + repeated NamePart name = 2; + + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + optional string identifier_value = 3; + optional uint64 positive_int_value = 4; + optional int64 negative_int_value = 5; + optional double double_value = 6; + optional bytes string_value = 7; + optional string aggregate_value = 8; +} + +// =================================================================== +// Optional source code info + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +message SourceCodeInfo { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendant. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + repeated Location location = 1; + message Location { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition. For + // example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + repeated int32 path = 1 [packed = true]; + + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + repeated int32 span = 2 [packed = true]; + + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // leading_detached_comments will keep paragraphs of comments that appear + // before (but not connected to) the current element. Each paragraph, + // separated by empty lines, will be one comment element in the repeated + // field. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // // Detached comment for corge. This is not leading or trailing comments + // // to qux or corge because there are blank lines separating it from + // // both. + // + // // Detached comment for corge paragraph 2. + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + // + // // ignored detached comments. + optional string leading_comments = 3; + optional string trailing_comments = 4; + repeated string leading_detached_comments = 6; + } +} + +// Describes the relationship between generated code and its original source +// file. A GeneratedCodeInfo message is associated with only one generated +// source file, but may contain references to different source .proto files. +message GeneratedCodeInfo { + // An Annotation connects some span of text in generated code to an element + // of its generating .proto file. + repeated Annotation annotation = 1; + message Annotation { + // Identifies the element in the original source .proto file. This field + // is formatted the same as SourceCodeInfo.Location.path. + repeated int32 path = 1 [packed = true]; + + // Identifies the filesystem path to the original source .proto. + optional string source_file = 2; + + // Identifies the starting offset in bytes in the generated code + // that relates to the identified object. + optional int32 begin = 3; + + // Identifies the ending offset in bytes in the generated code that + // relates to the identified offset. The end offset should be one past + // the last relevant byte (so the length of the text = end - begin). + optional int32 end = 4; + } +} diff --git a/p8e-api/src/main/proto/ibc/applications/transfer/v1/genesis.proto b/p8e-api/src/main/proto/ibc/applications/transfer/v1/genesis.proto new file mode 100644 index 0000000..98cf229 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/applications/transfer/v1/genesis.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; +package ibc.applications.transfer.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/applications/transfer/types"; + +import "gogoproto/gogo.proto"; +import "ibc/applications/transfer/v1/transfer.proto"; + +// GenesisState defines the ibc-transfer genesis state +message GenesisState { + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + repeated DenomTrace denom_traces = 2 [ + (gogoproto.castrepeated) = "Traces", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"denom_traces\"" + ]; + Params params = 3 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/ibc/applications/transfer/v1/query.proto b/p8e-api/src/main/proto/ibc/applications/transfer/v1/query.proto new file mode 100644 index 0000000..e9cbd02 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/applications/transfer/v1/query.proto @@ -0,0 +1,66 @@ +syntax = "proto3"; +package ibc.applications.transfer.v1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "ibc/applications/transfer/v1/transfer.proto"; +import "google/api/annotations.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/applications/transfer/types"; + +// Query provides defines the gRPC querier service. +service Query { + // DenomTrace queries a denomination trace information. + rpc DenomTrace(QueryDenomTraceRequest) returns (QueryDenomTraceResponse) { + option (google.api.http).get = "/ibc/applications/transfer/v1beta1/denom_traces/{hash}"; + } + + // DenomTraces queries all denomination traces. + rpc DenomTraces(QueryDenomTracesRequest) returns (QueryDenomTracesResponse) { + option (google.api.http).get = "/ibc/applications/transfer/v1beta1/denom_traces"; + } + + // Params queries all parameters of the ibc-transfer module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/ibc/applications/transfer/v1beta1/params"; + } +} + +// QueryDenomTraceRequest is the request type for the Query/DenomTrace RPC +// method +message QueryDenomTraceRequest { + // hash (in hex format) of the denomination trace information. + string hash = 1; +} + +// QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC +// method. +message QueryDenomTraceResponse { + // denom_trace returns the requested denomination trace information. + DenomTrace denom_trace = 1; +} + +// QueryConnectionsRequest is the request type for the Query/DenomTraces RPC +// method +message QueryDenomTracesRequest { + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryConnectionsResponse is the response type for the Query/DenomTraces RPC +// method. +message QueryDenomTracesResponse { + // denom_traces returns all denominations trace information. + repeated DenomTrace denom_traces = 1 [(gogoproto.castrepeated) = "Traces", (gogoproto.nullable) = false]; + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1; +} diff --git a/p8e-api/src/main/proto/ibc/applications/transfer/v1/transfer.proto b/p8e-api/src/main/proto/ibc/applications/transfer/v1/transfer.proto new file mode 100644 index 0000000..b388c3b --- /dev/null +++ b/p8e-api/src/main/proto/ibc/applications/transfer/v1/transfer.proto @@ -0,0 +1,43 @@ +syntax = "proto3"; +package ibc.applications.transfer.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/applications/transfer/types"; + +import "gogoproto/gogo.proto"; + +// FungibleTokenPacketData defines a struct for the packet payload +// See FungibleTokenPacketData spec: +// https://github.com/cosmos/ics/tree/master/spec/ics-020-fungible-token-transfer#data-structures +message FungibleTokenPacketData { + // the token denomination to be transferred + string denom = 1; + // the token amount to be transferred + uint64 amount = 2; + // the sender address + string sender = 3; + // the recipient address on the destination chain + string receiver = 4; +} + +// DenomTrace contains the base denomination for ICS20 fungible tokens and the +// source tracing information path. +message DenomTrace { + // path defines the chain of port/channel identifiers used for tracing the + // source of the fungible token. + string path = 1; + // base denomination of the relayed fungible token. + string base_denom = 2; +} + +// Params defines the set of IBC transfer parameters. +// NOTE: To prevent a single token from being transferred, set the +// TransfersEnabled parameter to true and then set the bank module's SendEnabled +// parameter for the denomination to false. +message Params { + // send_enabled enables or disables all cross-chain token transfers from this + // chain. + bool send_enabled = 1 [(gogoproto.moretags) = "yaml:\"send_enabled\""]; + // receive_enabled enables or disables all cross-chain token transfers to this + // chain. + bool receive_enabled = 2 [(gogoproto.moretags) = "yaml:\"receive_enabled\""]; +} diff --git a/p8e-api/src/main/proto/ibc/applications/transfer/v1/tx.proto b/p8e-api/src/main/proto/ibc/applications/transfer/v1/tx.proto new file mode 100644 index 0000000..a0f0827 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/applications/transfer/v1/tx.proto @@ -0,0 +1,43 @@ +syntax = "proto3"; +package ibc.applications.transfer.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/applications/transfer/types"; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "ibc/core/client/v1/client.proto"; + +// Msg defines the ibc/transfer Msg service. +service Msg { + // Transfer defines a rpc handler method for MsgTransfer. + rpc Transfer(MsgTransfer) returns (MsgTransferResponse); +} + +// MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between +// ICS20 enabled chains. See ICS Spec here: +// https://github.com/cosmos/ics/tree/master/spec/ics-020-fungible-token-transfer#data-structures +message MsgTransfer { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // the port on which the packet will be sent + string source_port = 1 [(gogoproto.moretags) = "yaml:\"source_port\""]; + // the channel by which the packet will be sent + string source_channel = 2 [(gogoproto.moretags) = "yaml:\"source_channel\""]; + // the tokens to be transferred + cosmos.base.v1beta1.Coin token = 3 [(gogoproto.nullable) = false]; + // the sender address + string sender = 4; + // the recipient address on the destination chain + string receiver = 5; + // Timeout height relative to the current block height. + // The timeout is disabled when set to 0. + ibc.core.client.v1.Height timeout_height = 6 + [(gogoproto.moretags) = "yaml:\"timeout_height\"", (gogoproto.nullable) = false]; + // Timeout timestamp (in nanoseconds) relative to the current block timestamp. + // The timeout is disabled when set to 0. + uint64 timeout_timestamp = 7 [(gogoproto.moretags) = "yaml:\"timeout_timestamp\""]; +} + +// MsgTransferResponse defines the Msg/Transfer response type. +message MsgTransferResponse {} diff --git a/p8e-api/src/main/proto/ibc/core/channel/v1/channel.proto b/p8e-api/src/main/proto/ibc/core/channel/v1/channel.proto new file mode 100644 index 0000000..302a480 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/channel/v1/channel.proto @@ -0,0 +1,147 @@ +syntax = "proto3"; +package ibc.core.channel.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/04-channel/types"; + +import "gogoproto/gogo.proto"; +import "ibc/core/client/v1/client.proto"; + +// Channel defines pipeline for exactly-once packet delivery between specific +// modules on separate blockchains, which has at least one end capable of +// sending packets and one end capable of receiving packets. +message Channel { + option (gogoproto.goproto_getters) = false; + + // current state of the channel end + State state = 1; + // whether the channel is ordered or unordered + Order ordering = 2; + // counterparty channel end + Counterparty counterparty = 3 [(gogoproto.nullable) = false]; + // list of connection identifiers, in order, along which packets sent on + // this channel will travel + repeated string connection_hops = 4 [(gogoproto.moretags) = "yaml:\"connection_hops\""]; + // opaque channel version, which is agreed upon during the handshake + string version = 5; +} + +// IdentifiedChannel defines a channel with additional port and channel +// identifier fields. +message IdentifiedChannel { + option (gogoproto.goproto_getters) = false; + + // current state of the channel end + State state = 1; + // whether the channel is ordered or unordered + Order ordering = 2; + // counterparty channel end + Counterparty counterparty = 3 [(gogoproto.nullable) = false]; + // list of connection identifiers, in order, along which packets sent on + // this channel will travel + repeated string connection_hops = 4 [(gogoproto.moretags) = "yaml:\"connection_hops\""]; + // opaque channel version, which is agreed upon during the handshake + string version = 5; + // port identifier + string port_id = 6; + // channel identifier + string channel_id = 7; +} + +// State defines if a channel is in one of the following states: +// CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED. +enum State { + option (gogoproto.goproto_enum_prefix) = false; + + // Default State + STATE_UNINITIALIZED_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "UNINITIALIZED"]; + // A channel has just started the opening handshake. + STATE_INIT = 1 [(gogoproto.enumvalue_customname) = "INIT"]; + // A channel has acknowledged the handshake step on the counterparty chain. + STATE_TRYOPEN = 2 [(gogoproto.enumvalue_customname) = "TRYOPEN"]; + // A channel has completed the handshake. Open channels are + // ready to send and receive packets. + STATE_OPEN = 3 [(gogoproto.enumvalue_customname) = "OPEN"]; + // A channel has been closed and can no longer be used to send or receive + // packets. + STATE_CLOSED = 4 [(gogoproto.enumvalue_customname) = "CLOSED"]; +} + +// Order defines if a channel is ORDERED or UNORDERED +enum Order { + option (gogoproto.goproto_enum_prefix) = false; + + // zero-value for channel ordering + ORDER_NONE_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "NONE"]; + // packets can be delivered in any order, which may differ from the order in + // which they were sent. + ORDER_UNORDERED = 1 [(gogoproto.enumvalue_customname) = "UNORDERED"]; + // packets are delivered exactly in the order which they were sent + ORDER_ORDERED = 2 [(gogoproto.enumvalue_customname) = "ORDERED"]; +} + +// Counterparty defines a channel end counterparty +message Counterparty { + option (gogoproto.goproto_getters) = false; + + // port on the counterparty chain which owns the other end of the channel. + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + // channel end on the counterparty chain + string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; +} + +// Packet defines a type that carries data across different chains through IBC +message Packet { + option (gogoproto.goproto_getters) = false; + + // number corresponds to the order of sends and receives, where a Packet + // with an earlier sequence number must be sent and received before a Packet + // with a later sequence number. + uint64 sequence = 1; + // identifies the port on the sending chain. + string source_port = 2 [(gogoproto.moretags) = "yaml:\"source_port\""]; + // identifies the channel end on the sending chain. + string source_channel = 3 [(gogoproto.moretags) = "yaml:\"source_channel\""]; + // identifies the port on the receiving chain. + string destination_port = 4 [(gogoproto.moretags) = "yaml:\"destination_port\""]; + // identifies the channel end on the receiving chain. + string destination_channel = 5 [(gogoproto.moretags) = "yaml:\"destination_channel\""]; + // actual opaque bytes transferred directly to the application module + bytes data = 6; + // block height after which the packet times out + ibc.core.client.v1.Height timeout_height = 7 + [(gogoproto.moretags) = "yaml:\"timeout_height\"", (gogoproto.nullable) = false]; + // block timestamp (in nanoseconds) after which the packet times out + uint64 timeout_timestamp = 8 [(gogoproto.moretags) = "yaml:\"timeout_timestamp\""]; +} + +// PacketState defines the generic type necessary to retrieve and store +// packet commitments, acknowledgements, and receipts. +// Caller is responsible for knowing the context necessary to interpret this +// state as a commitment, acknowledgement, or a receipt. +message PacketState { + option (gogoproto.goproto_getters) = false; + + // channel port identifier. + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + // channel unique identifier. + string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; + // packet sequence. + uint64 sequence = 3; + // embedded data that represents packet state. + bytes data = 4; +} + +// Acknowledgement is the recommended acknowledgement format to be used by +// app-specific protocols. +// NOTE: The field numbers 21 and 22 were explicitly chosen to avoid accidental +// conflicts with other protobuf message formats used for acknowledgements. +// The first byte of any message with this format will be the non-ASCII values +// `0xaa` (result) or `0xb2` (error). Implemented as defined by ICS: +// https://github.com/cosmos/ics/tree/master/spec/ics-004-channel-and-packet-semantics#acknowledgement-envelope +message Acknowledgement { + // response contains either a result or an error and must be non-empty + oneof response { + bytes result = 21; + string error = 22; + } +} diff --git a/p8e-api/src/main/proto/ibc/core/channel/v1/genesis.proto b/p8e-api/src/main/proto/ibc/core/channel/v1/genesis.proto new file mode 100644 index 0000000..d3b2c04 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/channel/v1/genesis.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; +package ibc.core.channel.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/04-channel/types"; + +import "gogoproto/gogo.proto"; +import "ibc/core/channel/v1/channel.proto"; + +// GenesisState defines the ibc channel submodule's genesis state. +message GenesisState { + repeated IdentifiedChannel channels = 1 [(gogoproto.casttype) = "IdentifiedChannel", (gogoproto.nullable) = false]; + repeated PacketState acknowledgements = 2 [(gogoproto.nullable) = false]; + repeated PacketState commitments = 3 [(gogoproto.nullable) = false]; + repeated PacketState receipts = 4 [(gogoproto.nullable) = false]; + repeated PacketSequence send_sequences = 5 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"send_sequences\""]; + repeated PacketSequence recv_sequences = 6 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"recv_sequences\""]; + repeated PacketSequence ack_sequences = 7 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"ack_sequences\""]; + // the sequence for the next generated channel identifier + uint64 next_channel_sequence = 8 [(gogoproto.moretags) = "yaml:\"next_channel_sequence\""]; +} + +// PacketSequence defines the genesis type necessary to retrieve and store +// next send and receive sequences. +message PacketSequence { + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; + uint64 sequence = 3; +} diff --git a/p8e-api/src/main/proto/ibc/core/channel/v1/query.proto b/p8e-api/src/main/proto/ibc/core/channel/v1/query.proto new file mode 100644 index 0000000..d9e3ceb --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/channel/v1/query.proto @@ -0,0 +1,367 @@ +syntax = "proto3"; +package ibc.core.channel.v1; + +import "ibc/core/client/v1/client.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "ibc/core/channel/v1/channel.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/04-channel/types"; + +// Query provides defines the gRPC querier service +service Query { + // Channel queries an IBC Channel. + rpc Channel(QueryChannelRequest) returns (QueryChannelResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}"; + } + + // Channels queries all the IBC channels of a chain. + rpc Channels(QueryChannelsRequest) returns (QueryChannelsResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/channels"; + } + + // ConnectionChannels queries all the channels associated with a connection + // end. + rpc ConnectionChannels(QueryConnectionChannelsRequest) returns (QueryConnectionChannelsResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/connections/{connection}/channels"; + } + + // ChannelClientState queries for the client state for the channel associated + // with the provided channel identifiers. + rpc ChannelClientState(QueryChannelClientStateRequest) returns (QueryChannelClientStateResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state"; + } + + // ChannelConsensusState queries for the consensus state for the channel + // associated with the provided channel identifiers. + rpc ChannelConsensusState(QueryChannelConsensusStateRequest) returns (QueryChannelConsensusStateResponse) { + option (google.api.http).get = + "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/" + "{revision_number}/height/{revision_height}"; + } + + // PacketCommitment queries a stored packet commitment hash. + rpc PacketCommitment(QueryPacketCommitmentRequest) returns (QueryPacketCommitmentResponse) { + option (google.api.http).get = + "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}"; + } + + // PacketCommitments returns all the packet commitments hashes associated + // with a channel. + rpc PacketCommitments(QueryPacketCommitmentsRequest) returns (QueryPacketCommitmentsResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments"; + } + + // PacketReceipt queries if a given packet sequence has been received on the queried chain + rpc PacketReceipt(QueryPacketReceiptRequest) returns (QueryPacketReceiptResponse) { + option (google.api.http).get = + "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}"; + } + + // PacketAcknowledgement queries a stored packet acknowledgement hash. + rpc PacketAcknowledgement(QueryPacketAcknowledgementRequest) returns (QueryPacketAcknowledgementResponse) { + option (google.api.http).get = + "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}"; + } + + // PacketAcknowledgements returns all the packet acknowledgements associated + // with a channel. + rpc PacketAcknowledgements(QueryPacketAcknowledgementsRequest) returns (QueryPacketAcknowledgementsResponse) { + option (google.api.http).get = + "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements"; + } + + // UnreceivedPackets returns all the unreceived IBC packets associated with a + // channel and sequences. + rpc UnreceivedPackets(QueryUnreceivedPacketsRequest) returns (QueryUnreceivedPacketsResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/" + "{packet_commitment_sequences}/unreceived_packets"; + } + + // UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a + // channel and sequences. + rpc UnreceivedAcks(QueryUnreceivedAcksRequest) returns (QueryUnreceivedAcksResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/" + "{packet_ack_sequences}/unreceived_acks"; + } + + // NextSequenceReceive returns the next receive sequence for a given channel. + rpc NextSequenceReceive(QueryNextSequenceReceiveRequest) returns (QueryNextSequenceReceiveResponse) { + option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence"; + } +} + +// QueryChannelRequest is the request type for the Query/Channel RPC method +message QueryChannelRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; +} + +// QueryChannelResponse is the response type for the Query/Channel RPC method. +// Besides the Channel end, it includes a proof and the height from which the +// proof was retrieved. +message QueryChannelResponse { + // channel associated with the request identifiers + ibc.core.channel.v1.Channel channel = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryChannelsRequest is the request type for the Query/Channels RPC method +message QueryChannelsRequest { + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryChannelsResponse is the response type for the Query/Channels RPC method. +message QueryChannelsResponse { + // list of stored channels of the chain. + repeated ibc.core.channel.v1.IdentifiedChannel channels = 1; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; + // query block height + ibc.core.client.v1.Height height = 3 [(gogoproto.nullable) = false]; +} + +// QueryConnectionChannelsRequest is the request type for the +// Query/QueryConnectionChannels RPC method +message QueryConnectionChannelsRequest { + // connection unique identifier + string connection = 1; + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryConnectionChannelsResponse is the Response type for the +// Query/QueryConnectionChannels RPC method +message QueryConnectionChannelsResponse { + // list of channels associated with a connection. + repeated ibc.core.channel.v1.IdentifiedChannel channels = 1; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; + // query block height + ibc.core.client.v1.Height height = 3 [(gogoproto.nullable) = false]; +} + +// QueryChannelClientStateRequest is the request type for the Query/ClientState +// RPC method +message QueryChannelClientStateRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; +} + +// QueryChannelClientStateResponse is the Response type for the +// Query/QueryChannelClientState RPC method +message QueryChannelClientStateResponse { + // client state associated with the channel + ibc.core.client.v1.IdentifiedClientState identified_client_state = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryChannelConsensusStateRequest is the request type for the +// Query/ConsensusState RPC method +message QueryChannelConsensusStateRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // revision number of the consensus state + uint64 revision_number = 3; + // revision height of the consensus state + uint64 revision_height = 4; +} + +// QueryChannelClientStateResponse is the Response type for the +// Query/QueryChannelClientState RPC method +message QueryChannelConsensusStateResponse { + // consensus state associated with the channel + google.protobuf.Any consensus_state = 1; + // client ID associated with the consensus state + string client_id = 2; + // merkle proof of existence + bytes proof = 3; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false]; +} + +// QueryPacketCommitmentRequest is the request type for the +// Query/PacketCommitment RPC method +message QueryPacketCommitmentRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // packet sequence + uint64 sequence = 3; +} + +// QueryPacketCommitmentResponse defines the client query response for a packet +// which also includes a proof and the height from which the proof was +// retrieved +message QueryPacketCommitmentResponse { + // packet associated with the request fields + bytes commitment = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryPacketCommitmentsRequest is the request type for the +// Query/QueryPacketCommitments RPC method +message QueryPacketCommitmentsRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 3; +} + +// QueryPacketCommitmentsResponse is the request type for the +// Query/QueryPacketCommitments RPC method +message QueryPacketCommitmentsResponse { + repeated ibc.core.channel.v1.PacketState commitments = 1; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; + // query block height + ibc.core.client.v1.Height height = 3 [(gogoproto.nullable) = false]; +} + +// QueryPacketReceiptRequest is the request type for the +// Query/PacketReceipt RPC method +message QueryPacketReceiptRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // packet sequence + uint64 sequence = 3; +} + +// QueryPacketReceiptResponse defines the client query response for a packet receipt +// which also includes a proof, and the height from which the proof was +// retrieved +message QueryPacketReceiptResponse { + // success flag for if receipt exists + bool received = 2; + // merkle proof of existence + bytes proof = 3; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false]; +} + +// QueryPacketAcknowledgementRequest is the request type for the +// Query/PacketAcknowledgement RPC method +message QueryPacketAcknowledgementRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // packet sequence + uint64 sequence = 3; +} + +// QueryPacketAcknowledgementResponse defines the client query response for a +// packet which also includes a proof and the height from which the +// proof was retrieved +message QueryPacketAcknowledgementResponse { + // packet associated with the request fields + bytes acknowledgement = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryPacketAcknowledgementsRequest is the request type for the +// Query/QueryPacketCommitments RPC method +message QueryPacketAcknowledgementsRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 3; +} + +// QueryPacketAcknowledgemetsResponse is the request type for the +// Query/QueryPacketAcknowledgements RPC method +message QueryPacketAcknowledgementsResponse { + repeated ibc.core.channel.v1.PacketState acknowledgements = 1; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; + // query block height + ibc.core.client.v1.Height height = 3 [(gogoproto.nullable) = false]; +} + +// QueryUnreceivedPacketsRequest is the request type for the +// Query/UnreceivedPackets RPC method +message QueryUnreceivedPacketsRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // list of packet sequences + repeated uint64 packet_commitment_sequences = 3; +} + +// QueryUnreceivedPacketsResponse is the response type for the +// Query/UnreceivedPacketCommitments RPC method +message QueryUnreceivedPacketsResponse { + // list of unreceived packet sequences + repeated uint64 sequences = 1; + // query block height + ibc.core.client.v1.Height height = 2 [(gogoproto.nullable) = false]; +} + +// QueryUnreceivedAcks is the request type for the +// Query/UnreceivedAcks RPC method +message QueryUnreceivedAcksRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; + // list of acknowledgement sequences + repeated uint64 packet_ack_sequences = 3; +} + +// QueryUnreceivedAcksResponse is the response type for the +// Query/UnreceivedAcks RPC method +message QueryUnreceivedAcksResponse { + // list of unreceived acknowledgement sequences + repeated uint64 sequences = 1; + // query block height + ibc.core.client.v1.Height height = 2 [(gogoproto.nullable) = false]; +} + +// QueryNextSequenceReceiveRequest is the request type for the +// Query/QueryNextSequenceReceiveRequest RPC method +message QueryNextSequenceReceiveRequest { + // port unique identifier + string port_id = 1; + // channel unique identifier + string channel_id = 2; +} + +// QuerySequenceResponse is the request type for the +// Query/QueryNextSequenceReceiveResponse RPC method +message QueryNextSequenceReceiveResponse { + // next sequence receive number + uint64 next_sequence_receive = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/ibc/core/channel/v1/tx.proto b/p8e-api/src/main/proto/ibc/core/channel/v1/tx.proto new file mode 100644 index 0000000..5f84264 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/channel/v1/tx.proto @@ -0,0 +1,207 @@ +syntax = "proto3"; +package ibc.core.channel.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/04-channel/types"; + +import "gogoproto/gogo.proto"; +import "ibc/core/client/v1/client.proto"; +import "ibc/core/channel/v1/channel.proto"; + +// Msg defines the ibc/channel Msg service. +service Msg { + // ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit. + rpc ChannelOpenInit(MsgChannelOpenInit) returns (MsgChannelOpenInitResponse); + + // ChannelOpenTry defines a rpc handler method for MsgChannelOpenTry. + rpc ChannelOpenTry(MsgChannelOpenTry) returns (MsgChannelOpenTryResponse); + + // ChannelOpenAck defines a rpc handler method for MsgChannelOpenAck. + rpc ChannelOpenAck(MsgChannelOpenAck) returns (MsgChannelOpenAckResponse); + + // ChannelOpenConfirm defines a rpc handler method for MsgChannelOpenConfirm. + rpc ChannelOpenConfirm(MsgChannelOpenConfirm) returns (MsgChannelOpenConfirmResponse); + + // ChannelCloseInit defines a rpc handler method for MsgChannelCloseInit. + rpc ChannelCloseInit(MsgChannelCloseInit) returns (MsgChannelCloseInitResponse); + + // ChannelCloseConfirm defines a rpc handler method for MsgChannelCloseConfirm. + rpc ChannelCloseConfirm(MsgChannelCloseConfirm) returns (MsgChannelCloseConfirmResponse); + + // RecvPacket defines a rpc handler method for MsgRecvPacket. + rpc RecvPacket(MsgRecvPacket) returns (MsgRecvPacketResponse); + + // Timeout defines a rpc handler method for MsgTimeout. + rpc Timeout(MsgTimeout) returns (MsgTimeoutResponse); + + // TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose. + rpc TimeoutOnClose(MsgTimeoutOnClose) returns (MsgTimeoutOnCloseResponse); + + // Acknowledgement defines a rpc handler method for MsgAcknowledgement. + rpc Acknowledgement(MsgAcknowledgement) returns (MsgAcknowledgementResponse); +} + +// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It +// is called by a relayer on Chain A. +message MsgChannelOpenInit { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + Channel channel = 2 [(gogoproto.nullable) = false]; + string signer = 3; +} + +// MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. +message MsgChannelOpenInitResponse {} + +// MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel +// on Chain B. +message MsgChannelOpenTry { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + // in the case of crossing hello's, when both chains call OpenInit, we need the channel identifier + // of the previous channel in state INIT + string previous_channel_id = 2 [(gogoproto.moretags) = "yaml:\"previous_channel_id\""]; + Channel channel = 3 [(gogoproto.nullable) = false]; + string counterparty_version = 4 [(gogoproto.moretags) = "yaml:\"counterparty_version\""]; + bytes proof_init = 5 [(gogoproto.moretags) = "yaml:\"proof_init\""]; + ibc.core.client.v1.Height proof_height = 6 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + string signer = 7; +} + +// MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. +message MsgChannelOpenTryResponse {} + +// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge +// the change of channel state to TRYOPEN on Chain B. +message MsgChannelOpenAck { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; + string counterparty_channel_id = 3 [(gogoproto.moretags) = "yaml:\"counterparty_channel_id\""]; + string counterparty_version = 4 [(gogoproto.moretags) = "yaml:\"counterparty_version\""]; + bytes proof_try = 5 [(gogoproto.moretags) = "yaml:\"proof_try\""]; + ibc.core.client.v1.Height proof_height = 6 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + string signer = 7; +} + +// MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. +message MsgChannelOpenAckResponse {} + +// MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to +// acknowledge the change of channel state to OPEN on Chain A. +message MsgChannelOpenConfirm { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; + bytes proof_ack = 3 [(gogoproto.moretags) = "yaml:\"proof_ack\""]; + ibc.core.client.v1.Height proof_height = 4 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + string signer = 5; +} + +// MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response type. +message MsgChannelOpenConfirmResponse {} + +// MsgChannelCloseInit defines a msg sent by a Relayer to Chain A +// to close a channel with Chain B. +message MsgChannelCloseInit { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; + string signer = 3; +} + +// MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. +message MsgChannelCloseInitResponse {} + +// MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B +// to acknowledge the change of channel state to CLOSED on Chain A. +message MsgChannelCloseConfirm { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; + string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; + bytes proof_init = 3 [(gogoproto.moretags) = "yaml:\"proof_init\""]; + ibc.core.client.v1.Height proof_height = 4 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + string signer = 5; +} + +// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response type. +message MsgChannelCloseConfirmResponse {} + +// MsgRecvPacket receives incoming IBC packet +message MsgRecvPacket { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + Packet packet = 1 [(gogoproto.nullable) = false]; + bytes proof_commitment = 2 [(gogoproto.moretags) = "yaml:\"proof_commitment\""]; + ibc.core.client.v1.Height proof_height = 3 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + string signer = 4; +} + +// MsgRecvPacketResponse defines the Msg/RecvPacket response type. +message MsgRecvPacketResponse {} + +// MsgTimeout receives timed-out packet +message MsgTimeout { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + Packet packet = 1 [(gogoproto.nullable) = false]; + bytes proof_unreceived = 2 [(gogoproto.moretags) = "yaml:\"proof_unreceived\""]; + ibc.core.client.v1.Height proof_height = 3 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + uint64 next_sequence_recv = 4 [(gogoproto.moretags) = "yaml:\"next_sequence_recv\""]; + string signer = 5; +} + +// MsgTimeoutResponse defines the Msg/Timeout response type. +message MsgTimeoutResponse {} + +// MsgTimeoutOnClose timed-out packet upon counterparty channel closure. +message MsgTimeoutOnClose { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + Packet packet = 1 [(gogoproto.nullable) = false]; + bytes proof_unreceived = 2 [(gogoproto.moretags) = "yaml:\"proof_unreceived\""]; + bytes proof_close = 3 [(gogoproto.moretags) = "yaml:\"proof_close\""]; + ibc.core.client.v1.Height proof_height = 4 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + uint64 next_sequence_recv = 5 [(gogoproto.moretags) = "yaml:\"next_sequence_recv\""]; + string signer = 6; +} + +// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. +message MsgTimeoutOnCloseResponse {} + +// MsgAcknowledgement receives incoming IBC acknowledgement +message MsgAcknowledgement { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + Packet packet = 1 [(gogoproto.nullable) = false]; + bytes acknowledgement = 2; + bytes proof_acked = 3 [(gogoproto.moretags) = "yaml:\"proof_acked\""]; + ibc.core.client.v1.Height proof_height = 4 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + string signer = 5; +} + +// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. +message MsgAcknowledgementResponse {} diff --git a/p8e-api/src/main/proto/ibc/core/client/v1/client.proto b/p8e-api/src/main/proto/ibc/core/client/v1/client.proto new file mode 100644 index 0000000..11d2195 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/client/v1/client.proto @@ -0,0 +1,74 @@ +syntax = "proto3"; +package ibc.core.client.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; + +// IdentifiedClientState defines a client state with an additional client +// identifier field. +message IdentifiedClientState { + // client identifier + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // client state + google.protobuf.Any client_state = 2 [(gogoproto.moretags) = "yaml:\"client_state\""]; +} + +// ConsensusStateWithHeight defines a consensus state with an additional height field. +message ConsensusStateWithHeight { + // consensus state height + Height height = 1 [(gogoproto.nullable) = false]; + // consensus state + google.protobuf.Any consensus_state = 2 [(gogoproto.moretags) = "yaml\"consensus_state\""]; +} + +// ClientConsensusStates defines all the stored consensus states for a given +// client. +message ClientConsensusStates { + // client identifier + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // consensus states and their heights associated with the client + repeated ConsensusStateWithHeight consensus_states = 2 + [(gogoproto.moretags) = "yaml:\"consensus_states\"", (gogoproto.nullable) = false]; +} + +// ClientUpdateProposal is a governance proposal. If it passes, the client is +// updated with the provided header. The update may fail if the header is not +// valid given certain conditions specified by the client implementation. +message ClientUpdateProposal { + option (gogoproto.goproto_getters) = false; + // the title of the update proposal + string title = 1; + // the description of the proposal + string description = 2; + // the client identifier for the client to be updated if the proposal passes + string client_id = 3 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // the header used to update the client if the proposal passes + google.protobuf.Any header = 4; +} + +// Height is a monotonically increasing data type +// that can be compared against another Height for the purposes of updating and +// freezing clients +// +// Normally the RevisionHeight is incremented at each height while keeping RevisionNumber +// the same. However some consensus algorithms may choose to reset the +// height in certain conditions e.g. hard forks, state-machine breaking changes +// In these cases, the RevisionNumber is incremented so that height continues to +// be monitonically increasing even as the RevisionHeight gets reset +message Height { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + // the revision that the client is currently on + uint64 revision_number = 1 [(gogoproto.moretags) = "yaml:\"revision_number\""]; + // the height within the given revision + uint64 revision_height = 2 [(gogoproto.moretags) = "yaml:\"revision_height\""]; +} + +// Params defines the set of IBC light client parameters. +message Params { + // allowed_clients defines the list of allowed client state types. + repeated string allowed_clients = 1 [(gogoproto.moretags) = "yaml:\"allowed_clients\""]; +} diff --git a/p8e-api/src/main/proto/ibc/core/client/v1/genesis.proto b/p8e-api/src/main/proto/ibc/core/client/v1/genesis.proto new file mode 100644 index 0000000..16febbc --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/client/v1/genesis.proto @@ -0,0 +1,46 @@ +syntax = "proto3"; +package ibc.core.client.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"; + +import "ibc/core/client/v1/client.proto"; +import "gogoproto/gogo.proto"; + +// GenesisState defines the ibc client submodule's genesis state. +message GenesisState { + // client states with their corresponding identifiers + repeated IdentifiedClientState clients = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "IdentifiedClientStates"]; + // consensus states from each client + repeated ClientConsensusStates clients_consensus = 2 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "ClientsConsensusStates", + (gogoproto.moretags) = "yaml:\"clients_consensus\"" + ]; + // metadata from each client + repeated IdentifiedGenesisMetadata clients_metadata = 3 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"clients_metadata\""]; + Params params = 4 [(gogoproto.nullable) = false]; + // create localhost on initialization + bool create_localhost = 5 [(gogoproto.moretags) = "yaml:\"create_localhost\""]; + // the sequence for the next generated client identifier + uint64 next_client_sequence = 6 [(gogoproto.moretags) = "yaml:\"next_client_sequence\""]; +} + +// GenesisMetadata defines the genesis type for metadata that clients may return +// with ExportMetadata +message GenesisMetadata { + option (gogoproto.goproto_getters) = false; + + // store key of metadata without clientID-prefix + bytes key = 1; + // metadata value + bytes value = 2; +} + +// IdentifiedGenesisMetadata has the client metadata with the corresponding client id. +message IdentifiedGenesisMetadata { + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + repeated GenesisMetadata client_metadata = 2 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"client_metadata\""]; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/ibc/core/client/v1/query.proto b/p8e-api/src/main/proto/ibc/core/client/v1/query.proto new file mode 100644 index 0000000..97f3acd --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/client/v1/query.proto @@ -0,0 +1,130 @@ +syntax = "proto3"; +package ibc.core.client.v1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "ibc/core/client/v1/client.proto"; +import "google/protobuf/any.proto"; +import "google/api/annotations.proto"; +import "gogoproto/gogo.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"; + +// Query provides defines the gRPC querier service +service Query { + // ClientState queries an IBC light client. + rpc ClientState(QueryClientStateRequest) returns (QueryClientStateResponse) { + option (google.api.http).get = "/ibc/core/client/v1beta1/client_states/{client_id}"; + } + + // ClientStates queries all the IBC light clients of a chain. + rpc ClientStates(QueryClientStatesRequest) returns (QueryClientStatesResponse) { + option (google.api.http).get = "/ibc/core/client/v1beta1/client_states"; + } + + // ConsensusState queries a consensus state associated with a client state at + // a given height. + rpc ConsensusState(QueryConsensusStateRequest) returns (QueryConsensusStateResponse) { + option (google.api.http).get = "/ibc/core/client/v1beta1/consensus_states/{client_id}/revision/{revision_number}/" + "height/{revision_height}"; + } + + // ConsensusStates queries all the consensus state associated with a given + // client. + rpc ConsensusStates(QueryConsensusStatesRequest) returns (QueryConsensusStatesResponse) { + option (google.api.http).get = "/ibc/core/client/v1beta1/consensus_states/{client_id}"; + } + + // ClientParams queries all parameters of the ibc client. + rpc ClientParams(QueryClientParamsRequest) returns (QueryClientParamsResponse) { + option (google.api.http).get = "/ibc/client/v1beta1/params"; + } +} + +// QueryClientStateRequest is the request type for the Query/ClientState RPC +// method +message QueryClientStateRequest { + // client state unique identifier + string client_id = 1; +} + +// QueryClientStateResponse is the response type for the Query/ClientState RPC +// method. Besides the client state, it includes a proof and the height from +// which the proof was retrieved. +message QueryClientStateResponse { + // client state associated with the request identifier + google.protobuf.Any client_state = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryClientStatesRequest is the request type for the Query/ClientStates RPC +// method +message QueryClientStatesRequest { + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryClientStatesResponse is the response type for the Query/ClientStates RPC +// method. +message QueryClientStatesResponse { + // list of stored ClientStates of the chain. + repeated IdentifiedClientState client_states = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "IdentifiedClientStates"]; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryConsensusStateRequest is the request type for the Query/ConsensusState +// RPC method. Besides the consensus state, it includes a proof and the height +// from which the proof was retrieved. +message QueryConsensusStateRequest { + // client identifier + string client_id = 1; + // consensus state revision number + uint64 revision_number = 2; + // consensus state revision height + uint64 revision_height = 3; + // latest_height overrrides the height field and queries the latest stored + // ConsensusState + bool latest_height = 4; +} + +// QueryConsensusStateResponse is the response type for the Query/ConsensusState +// RPC method +message QueryConsensusStateResponse { + // consensus state associated with the client identifier at the given height + google.protobuf.Any consensus_state = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates +// RPC method. +message QueryConsensusStatesRequest { + // client identifier + string client_id = 1; + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryConsensusStatesResponse is the response type for the +// Query/ConsensusStates RPC method +message QueryConsensusStatesResponse { + // consensus states associated with the identifier + repeated ConsensusStateWithHeight consensus_states = 1 [(gogoproto.nullable) = false]; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryClientParamsRequest is the request type for the Query/ClientParams RPC method. +message QueryClientParamsRequest {} + +// QueryClientParamsResponse is the response type for the Query/ClientParams RPC method. +message QueryClientParamsResponse { + // params defines the parameters of the module. + Params params = 1; +} diff --git a/p8e-api/src/main/proto/ibc/core/client/v1/tx.proto b/p8e-api/src/main/proto/ibc/core/client/v1/tx.proto new file mode 100644 index 0000000..a30ec8b --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/client/v1/tx.proto @@ -0,0 +1,96 @@ +syntax = "proto3"; +package ibc.core.client.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "ibc/core/client/v1/client.proto"; + +// Msg defines the ibc/client Msg service. +service Msg { + // CreateClient defines a rpc handler method for MsgCreateClient. + rpc CreateClient(MsgCreateClient) returns (MsgCreateClientResponse); + + // UpdateClient defines a rpc handler method for MsgUpdateClient. + rpc UpdateClient(MsgUpdateClient) returns (MsgUpdateClientResponse); + + // UpgradeClient defines a rpc handler method for MsgUpgradeClient. + rpc UpgradeClient(MsgUpgradeClient) returns (MsgUpgradeClientResponse); + + // SubmitMisbehaviour defines a rpc handler method for MsgSubmitMisbehaviour. + rpc SubmitMisbehaviour(MsgSubmitMisbehaviour) returns (MsgSubmitMisbehaviourResponse); +} + +// MsgCreateClient defines a message to create an IBC client +message MsgCreateClient { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // light client state + google.protobuf.Any client_state = 1 [(gogoproto.moretags) = "yaml:\"client_state\""]; + // consensus state associated with the client that corresponds to a given + // height. + google.protobuf.Any consensus_state = 2 [(gogoproto.moretags) = "yaml:\"consensus_state\""]; + // signer address + string signer = 3; +} + +// MsgCreateClientResponse defines the Msg/CreateClient response type. +message MsgCreateClientResponse {} + +// MsgUpdateClient defines an sdk.Msg to update a IBC client state using +// the given header. +message MsgUpdateClient { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // client unique identifier + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // header to update the light client + google.protobuf.Any header = 2; + // signer address + string signer = 3; +} + +// MsgUpdateClientResponse defines the Msg/UpdateClient response type. +message MsgUpdateClientResponse {} + +// MsgUpgradeClient defines an sdk.Msg to upgrade an IBC client to a new client state +message MsgUpgradeClient { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // client unique identifier + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // upgraded client state + google.protobuf.Any client_state = 2 [(gogoproto.moretags) = "yaml:\"client_state\""]; + // upgraded consensus state, only contains enough information to serve as a basis of trust in update logic + google.protobuf.Any consensus_state = 3 [(gogoproto.moretags) = "yaml:\"consensus_state\""]; + // proof that old chain committed to new client + bytes proof_upgrade_client = 4 [(gogoproto.moretags) = "yaml:\"proof_upgrade_client\""]; + // proof that old chain committed to new consensus state + bytes proof_upgrade_consensus_state = 5 [(gogoproto.moretags) = "yaml:\"proof_upgrade_consensus_state\""]; + // signer address + string signer = 6; +} + +// MsgUpgradeClientResponse defines the Msg/UpgradeClient response type. +message MsgUpgradeClientResponse {} + +// MsgSubmitMisbehaviour defines an sdk.Msg type that submits Evidence for +// light client misbehaviour. +message MsgSubmitMisbehaviour { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // client unique identifier + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // misbehaviour used for freezing the light client + google.protobuf.Any misbehaviour = 2; + // signer address + string signer = 3; +} + +// MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response type. +message MsgSubmitMisbehaviourResponse {} diff --git a/p8e-api/src/main/proto/ibc/core/commitment/v1/commitment.proto b/p8e-api/src/main/proto/ibc/core/commitment/v1/commitment.proto new file mode 100644 index 0000000..51c1027 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/commitment/v1/commitment.proto @@ -0,0 +1,40 @@ +syntax = "proto3"; +package ibc.core.commitment.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"; + +import "gogoproto/gogo.proto"; +import "confio/proofs.proto"; + +// MerkleRoot defines a merkle root hash. +// In the Cosmos SDK, the AppHash of a block header becomes the root. +message MerkleRoot { + option (gogoproto.goproto_getters) = false; + + bytes hash = 1; +} + +// MerklePrefix is merkle path prefixed to the key. +// The constructed key from the Path and the key will be append(Path.KeyPath, +// append(Path.KeyPrefix, key...)) +message MerklePrefix { + bytes key_prefix = 1 [(gogoproto.moretags) = "yaml:\"key_prefix\""]; +} + +// MerklePath is the path used to verify commitment proofs, which can be an +// arbitrary structured object (defined by a commitment type). +// MerklePath is represented from root-to-leaf +message MerklePath { + option (gogoproto.goproto_stringer) = false; + + repeated string key_path = 1 [(gogoproto.moretags) = "yaml:\"key_path\""]; +} + +// MerkleProof is a wrapper type over a chain of CommitmentProofs. +// It demonstrates membership or non-membership for an element or set of +// elements, verifiable in conjunction with a known commitment root. Proofs +// should be succinct. +// MerkleProofs are ordered from leaf-to-root +message MerkleProof { + repeated ics23.CommitmentProof proofs = 1; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/ibc/core/connection/v1/connection.proto b/p8e-api/src/main/proto/ibc/core/connection/v1/connection.proto new file mode 100644 index 0000000..d21e595 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/connection/v1/connection.proto @@ -0,0 +1,104 @@ +syntax = "proto3"; +package ibc.core.connection.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/03-connection/types"; + +import "gogoproto/gogo.proto"; +import "ibc/core/commitment/v1/commitment.proto"; + +// ICS03 - Connection Data Structures as defined in +// https://github.com/cosmos/ics/tree/master/spec/ics-003-connection-semantics#data-structures + +// ConnectionEnd defines a stateful object on a chain connected to another +// separate one. +// NOTE: there must only be 2 defined ConnectionEnds to establish +// a connection between two chains. +message ConnectionEnd { + option (gogoproto.goproto_getters) = false; + // client associated with this connection. + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // IBC version which can be utilised to determine encodings or protocols for + // channels or packets utilising this connection. + repeated Version versions = 2; + // current state of the connection end. + State state = 3; + // counterparty chain associated with this connection. + Counterparty counterparty = 4 [(gogoproto.nullable) = false]; + // delay period that must pass before a consensus state can be used for packet-verification + // NOTE: delay period logic is only implemented by some clients. + uint64 delay_period = 5 [(gogoproto.moretags) = "yaml:\"delay_period\""]; +} + +// IdentifiedConnection defines a connection with additional connection +// identifier field. +message IdentifiedConnection { + option (gogoproto.goproto_getters) = false; + // connection identifier. + string id = 1 [(gogoproto.moretags) = "yaml:\"id\""]; + // client associated with this connection. + string client_id = 2 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // IBC version which can be utilised to determine encodings or protocols for + // channels or packets utilising this connection + repeated Version versions = 3; + // current state of the connection end. + State state = 4; + // counterparty chain associated with this connection. + Counterparty counterparty = 5 [(gogoproto.nullable) = false]; + // delay period associated with this connection. + uint64 delay_period = 6 [(gogoproto.moretags) = "yaml:\"delay_period\""]; +} + +// State defines if a connection is in one of the following states: +// INIT, TRYOPEN, OPEN or UNINITIALIZED. +enum State { + option (gogoproto.goproto_enum_prefix) = false; + + // Default State + STATE_UNINITIALIZED_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "UNINITIALIZED"]; + // A connection end has just started the opening handshake. + STATE_INIT = 1 [(gogoproto.enumvalue_customname) = "INIT"]; + // A connection end has acknowledged the handshake step on the counterparty + // chain. + STATE_TRYOPEN = 2 [(gogoproto.enumvalue_customname) = "TRYOPEN"]; + // A connection end has completed the handshake. + STATE_OPEN = 3 [(gogoproto.enumvalue_customname) = "OPEN"]; +} + +// Counterparty defines the counterparty chain associated with a connection end. +message Counterparty { + option (gogoproto.goproto_getters) = false; + + // identifies the client on the counterparty chain associated with a given + // connection. + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // identifies the connection end on the counterparty chain associated with a + // given connection. + string connection_id = 2 [(gogoproto.moretags) = "yaml:\"connection_id\""]; + // commitment merkle prefix of the counterparty chain. + ibc.core.commitment.v1.MerklePrefix prefix = 3 [(gogoproto.nullable) = false]; +} + +// ClientPaths define all the connection paths for a client state. +message ClientPaths { + // list of connection paths + repeated string paths = 1; +} + +// ConnectionPaths define all the connection paths for a given client state. +message ConnectionPaths { + // client state unique identifier + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // list of connection paths + repeated string paths = 2; +} + +// Version defines the versioning scheme used to negotiate the IBC verison in +// the connection handshake. +message Version { + option (gogoproto.goproto_getters) = false; + + // unique version identifier + string identifier = 1; + // list of features compatible with the specified identifier + repeated string features = 2; +} diff --git a/p8e-api/src/main/proto/ibc/core/connection/v1/genesis.proto b/p8e-api/src/main/proto/ibc/core/connection/v1/genesis.proto new file mode 100644 index 0000000..11df4ba --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/connection/v1/genesis.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; +package ibc.core.connection.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/03-connection/types"; + +import "gogoproto/gogo.proto"; +import "ibc/core/connection/v1/connection.proto"; + +// GenesisState defines the ibc connection submodule's genesis state. +message GenesisState { + repeated IdentifiedConnection connections = 1 [(gogoproto.nullable) = false]; + repeated ConnectionPaths client_connection_paths = 2 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"client_connection_paths\""]; + // the sequence for the next generated connection identifier + uint64 next_connection_sequence = 3 [(gogoproto.moretags) = "yaml:\"next_connection_sequence\""]; +} diff --git a/p8e-api/src/main/proto/ibc/core/connection/v1/query.proto b/p8e-api/src/main/proto/ibc/core/connection/v1/query.proto new file mode 100644 index 0000000..c5085a1 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/connection/v1/query.proto @@ -0,0 +1,137 @@ +syntax = "proto3"; +package ibc.core.connection.v1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "ibc/core/client/v1/client.proto"; +import "ibc/core/connection/v1/connection.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/03-connection/types"; + +// Query provides defines the gRPC querier service +service Query { + // Connection queries an IBC connection end. + rpc Connection(QueryConnectionRequest) returns (QueryConnectionResponse) { + option (google.api.http).get = "/ibc/core/connection/v1beta1/connections/{connection_id}"; + } + + // Connections queries all the IBC connections of a chain. + rpc Connections(QueryConnectionsRequest) returns (QueryConnectionsResponse) { + option (google.api.http).get = "/ibc/core/connection/v1beta1/connections"; + } + + // ClientConnections queries the connection paths associated with a client + // state. + rpc ClientConnections(QueryClientConnectionsRequest) returns (QueryClientConnectionsResponse) { + option (google.api.http).get = "/ibc/core/connection/v1beta1/client_connections/{client_id}"; + } + + // ConnectionClientState queries the client state associated with the + // connection. + rpc ConnectionClientState(QueryConnectionClientStateRequest) returns (QueryConnectionClientStateResponse) { + option (google.api.http).get = "/ibc/core/connection/v1beta1/connections/{connection_id}/client_state"; + } + + // ConnectionConsensusState queries the consensus state associated with the + // connection. + rpc ConnectionConsensusState(QueryConnectionConsensusStateRequest) returns (QueryConnectionConsensusStateResponse) { + option (google.api.http).get = "/ibc/core/connection/v1beta1/connections/{connection_id}/consensus_state/" + "revision/{revision_number}/height/{revision_height}"; + } +} + +// QueryConnectionRequest is the request type for the Query/Connection RPC +// method +message QueryConnectionRequest { + // connection unique identifier + string connection_id = 1; +} + +// QueryConnectionResponse is the response type for the Query/Connection RPC +// method. Besides the connection end, it includes a proof and the height from +// which the proof was retrieved. +message QueryConnectionResponse { + // connection associated with the request identifier + ibc.core.connection.v1.ConnectionEnd connection = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryConnectionsRequest is the request type for the Query/Connections RPC +// method +message QueryConnectionsRequest { + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryConnectionsResponse is the response type for the Query/Connections RPC +// method. +message QueryConnectionsResponse { + // list of stored connections of the chain. + repeated ibc.core.connection.v1.IdentifiedConnection connections = 1; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; + // query block height + ibc.core.client.v1.Height height = 3 [(gogoproto.nullable) = false]; +} + +// QueryClientConnectionsRequest is the request type for the +// Query/ClientConnections RPC method +message QueryClientConnectionsRequest { + // client identifier associated with a connection + string client_id = 1; +} + +// QueryClientConnectionsResponse is the response type for the +// Query/ClientConnections RPC method +message QueryClientConnectionsResponse { + // slice of all the connection paths associated with a client. + repeated string connection_paths = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was generated + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryConnectionClientStateRequest is the request type for the +// Query/ConnectionClientState RPC method +message QueryConnectionClientStateRequest { + // connection identifier + string connection_id = 1 [(gogoproto.moretags) = "yaml:\"connection_id\""]; +} + +// QueryConnectionClientStateResponse is the response type for the +// Query/ConnectionClientState RPC method +message QueryConnectionClientStateResponse { + // client state associated with the channel + ibc.core.client.v1.IdentifiedClientState identified_client_state = 1; + // merkle proof of existence + bytes proof = 2; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false]; +} + +// QueryConnectionConsensusStateRequest is the request type for the +// Query/ConnectionConsensusState RPC method +message QueryConnectionConsensusStateRequest { + // connection identifier + string connection_id = 1 [(gogoproto.moretags) = "yaml:\"connection_id\""]; + uint64 revision_number = 2; + uint64 revision_height = 3; +} + +// QueryConnectionConsensusStateResponse is the response type for the +// Query/ConnectionConsensusState RPC method +message QueryConnectionConsensusStateResponse { + // consensus state associated with the channel + google.protobuf.Any consensus_state = 1; + // client ID associated with the consensus state + string client_id = 2; + // merkle proof of existence + bytes proof = 3; + // height at which the proof was retrieved + ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/ibc/core/connection/v1/tx.proto b/p8e-api/src/main/proto/ibc/core/connection/v1/tx.proto new file mode 100644 index 0000000..19b40c6 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/connection/v1/tx.proto @@ -0,0 +1,115 @@ +syntax = "proto3"; +package ibc.core.connection.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/03-connection/types"; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "ibc/core/client/v1/client.proto"; +import "ibc/core/connection/v1/connection.proto"; + +// Msg defines the ibc/connection Msg service. +service Msg { + // ConnectionOpenInit defines a rpc handler method for MsgConnectionOpenInit. + rpc ConnectionOpenInit(MsgConnectionOpenInit) returns (MsgConnectionOpenInitResponse); + + // ConnectionOpenTry defines a rpc handler method for MsgConnectionOpenTry. + rpc ConnectionOpenTry(MsgConnectionOpenTry) returns (MsgConnectionOpenTryResponse); + + // ConnectionOpenAck defines a rpc handler method for MsgConnectionOpenAck. + rpc ConnectionOpenAck(MsgConnectionOpenAck) returns (MsgConnectionOpenAckResponse); + + // ConnectionOpenConfirm defines a rpc handler method for MsgConnectionOpenConfirm. + rpc ConnectionOpenConfirm(MsgConnectionOpenConfirm) returns (MsgConnectionOpenConfirmResponse); +} + +// MsgConnectionOpenInit defines the msg sent by an account on Chain A to +// initialize a connection with Chain B. +message MsgConnectionOpenInit { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + Counterparty counterparty = 2 [(gogoproto.nullable) = false]; + Version version = 3; + uint64 delay_period = 4 [(gogoproto.moretags) = "yaml:\"delay_period\""]; + string signer = 5; +} + +// MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response type. +message MsgConnectionOpenInitResponse {} + +// MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a +// connection on Chain B. +message MsgConnectionOpenTry { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // in the case of crossing hello's, when both chains call OpenInit, we need the connection identifier + // of the previous connection in state INIT + string previous_connection_id = 2 [(gogoproto.moretags) = "yaml:\"previous_connection_id\""]; + google.protobuf.Any client_state = 3 [(gogoproto.moretags) = "yaml:\"client_state\""]; + Counterparty counterparty = 4 [(gogoproto.nullable) = false]; + uint64 delay_period = 5 [(gogoproto.moretags) = "yaml:\"delay_period\""]; + repeated Version counterparty_versions = 6 [(gogoproto.moretags) = "yaml:\"counterparty_versions\""]; + ibc.core.client.v1.Height proof_height = 7 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + // proof of the initialization the connection on Chain A: `UNITIALIZED -> + // INIT` + bytes proof_init = 8 [(gogoproto.moretags) = "yaml:\"proof_init\""]; + // proof of client state included in message + bytes proof_client = 9 [(gogoproto.moretags) = "yaml:\"proof_client\""]; + // proof of client consensus state + bytes proof_consensus = 10 [(gogoproto.moretags) = "yaml:\"proof_consensus\""]; + ibc.core.client.v1.Height consensus_height = 11 + [(gogoproto.moretags) = "yaml:\"consensus_height\"", (gogoproto.nullable) = false]; + string signer = 12; +} + +// MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type. +message MsgConnectionOpenTryResponse {} + +// MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to +// acknowledge the change of connection state to TRYOPEN on Chain B. +message MsgConnectionOpenAck { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string connection_id = 1 [(gogoproto.moretags) = "yaml:\"connection_id\""]; + string counterparty_connection_id = 2 [(gogoproto.moretags) = "yaml:\"counterparty_connection_id\""]; + Version version = 3; + google.protobuf.Any client_state = 4 [(gogoproto.moretags) = "yaml:\"client_state\""]; + ibc.core.client.v1.Height proof_height = 5 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + // proof of the initialization the connection on Chain B: `UNITIALIZED -> + // TRYOPEN` + bytes proof_try = 6 [(gogoproto.moretags) = "yaml:\"proof_try\""]; + // proof of client state included in message + bytes proof_client = 7 [(gogoproto.moretags) = "yaml:\"proof_client\""]; + // proof of client consensus state + bytes proof_consensus = 8 [(gogoproto.moretags) = "yaml:\"proof_consensus\""]; + ibc.core.client.v1.Height consensus_height = 9 + [(gogoproto.moretags) = "yaml:\"consensus_height\"", (gogoproto.nullable) = false]; + string signer = 10; +} + +// MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type. +message MsgConnectionOpenAckResponse {} + +// MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to +// acknowledge the change of connection state to OPEN on Chain A. +message MsgConnectionOpenConfirm { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string connection_id = 1 [(gogoproto.moretags) = "yaml:\"connection_id\""]; + // proof for the change of the connection state on Chain A: `INIT -> OPEN` + bytes proof_ack = 2 [(gogoproto.moretags) = "yaml:\"proof_ack\""]; + ibc.core.client.v1.Height proof_height = 3 + [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; + string signer = 4; +} + +// MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm response type. +message MsgConnectionOpenConfirmResponse {} diff --git a/p8e-api/src/main/proto/ibc/core/types/v1/genesis.proto b/p8e-api/src/main/proto/ibc/core/types/v1/genesis.proto new file mode 100644 index 0000000..ace5085 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/core/types/v1/genesis.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; +package ibc.core.types.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/types"; + +import "gogoproto/gogo.proto"; +import "ibc/core/client/v1/genesis.proto"; +import "ibc/core/connection/v1/genesis.proto"; +import "ibc/core/channel/v1/genesis.proto"; + +// GenesisState defines the ibc module's genesis state. +message GenesisState { + // ICS002 - Clients genesis state + ibc.core.client.v1.GenesisState client_genesis = 1 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"client_genesis\""]; + // ICS003 - Connections genesis state + ibc.core.connection.v1.GenesisState connection_genesis = 2 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"connection_genesis\""]; + // ICS004 - Channel genesis state + ibc.core.channel.v1.GenesisState channel_genesis = 3 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"channel_genesis\""]; +} diff --git a/p8e-api/src/main/proto/ibc/lightclients/localhost/v1/localhost.proto b/p8e-api/src/main/proto/ibc/lightclients/localhost/v1/localhost.proto new file mode 100644 index 0000000..d48a1c0 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/lightclients/localhost/v1/localhost.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; +package ibc.lightclients.localhost.v1; + +import "gogoproto/gogo.proto"; +import "ibc/core/client/v1/client.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/light-clients/09-localhost/types"; + +// ClientState defines a loopback (localhost) client. It requires (read-only) +// access to keys outside the client prefix. +message ClientState { + option (gogoproto.goproto_getters) = false; + // self chain ID + string chain_id = 1 [(gogoproto.moretags) = "yaml:\"chain_id\""]; + // self latest block height + ibc.core.client.v1.Height height = 2 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/ibc/lightclients/solomachine/v1/solomachine.proto b/p8e-api/src/main/proto/ibc/lightclients/solomachine/v1/solomachine.proto new file mode 100644 index 0000000..89686f3 --- /dev/null +++ b/p8e-api/src/main/proto/ibc/lightclients/solomachine/v1/solomachine.proto @@ -0,0 +1,186 @@ +syntax = "proto3"; +package ibc.lightclients.solomachine.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/light-clients/06-solomachine/types"; + +import "ibc/core/connection/v1/connection.proto"; +import "ibc/core/channel/v1/channel.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; + +// ClientState defines a solo machine client that tracks the current consensus +// state and if the client is frozen. +message ClientState { + option (gogoproto.goproto_getters) = false; + // latest sequence of the client state + uint64 sequence = 1; + // frozen sequence of the solo machine + uint64 frozen_sequence = 2 [(gogoproto.moretags) = "yaml:\"frozen_sequence\""]; + ConsensusState consensus_state = 3 [(gogoproto.moretags) = "yaml:\"consensus_state\""]; + // when set to true, will allow governance to update a solo machine client. + // The client will be unfrozen if it is frozen. + bool allow_update_after_proposal = 4 [(gogoproto.moretags) = "yaml:\"allow_update_after_proposal\""]; +} + +// ConsensusState defines a solo machine consensus state. The sequence of a consensus state +// is contained in the "height" key used in storing the consensus state. +message ConsensusState { + option (gogoproto.goproto_getters) = false; + // public key of the solo machine + google.protobuf.Any public_key = 1 [(gogoproto.moretags) = "yaml:\"public_key\""]; + // diversifier allows the same public key to be re-used across different solo machine clients + // (potentially on different chains) without being considered misbehaviour. + string diversifier = 2; + uint64 timestamp = 3; +} + +// Header defines a solo machine consensus header +message Header { + option (gogoproto.goproto_getters) = false; + // sequence to update solo machine public key at + uint64 sequence = 1; + uint64 timestamp = 2; + bytes signature = 3; + google.protobuf.Any new_public_key = 4 [(gogoproto.moretags) = "yaml:\"new_public_key\""]; + string new_diversifier = 5 [(gogoproto.moretags) = "yaml:\"new_diversifier\""]; +} + +// Misbehaviour defines misbehaviour for a solo machine which consists +// of a sequence and two signatures over different messages at that sequence. +message Misbehaviour { + option (gogoproto.goproto_getters) = false; + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + uint64 sequence = 2; + SignatureAndData signature_one = 3 [(gogoproto.moretags) = "yaml:\"signature_one\""]; + SignatureAndData signature_two = 4 [(gogoproto.moretags) = "yaml:\"signature_two\""]; +} + +// SignatureAndData contains a signature and the data signed over to create that +// signature. +message SignatureAndData { + option (gogoproto.goproto_getters) = false; + bytes signature = 1; + DataType data_type = 2 [(gogoproto.moretags) = "yaml:\"data_type\""]; + bytes data = 3; + uint64 timestamp = 4; +} + +// TimestampedSignatureData contains the signature data and the timestamp of the +// signature. +message TimestampedSignatureData { + option (gogoproto.goproto_getters) = false; + bytes signature_data = 1 [(gogoproto.moretags) = "yaml:\"signature_data\""]; + uint64 timestamp = 2; +} + +// SignBytes defines the signed bytes used for signature verification. +message SignBytes { + option (gogoproto.goproto_getters) = false; + + uint64 sequence = 1; + uint64 timestamp = 2; + string diversifier = 3; + // type of the data used + DataType data_type = 4 [(gogoproto.moretags) = "yaml:\"data_type\""]; + // marshaled data + bytes data = 5; +} + +// DataType defines the type of solo machine proof being created. This is done to preserve uniqueness of different +// data sign byte encodings. +enum DataType { + option (gogoproto.goproto_enum_prefix) = false; + + // Default State + DATA_TYPE_UNINITIALIZED_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "UNSPECIFIED"]; + // Data type for client state verification + DATA_TYPE_CLIENT_STATE = 1 [(gogoproto.enumvalue_customname) = "CLIENT"]; + // Data type for consensus state verification + DATA_TYPE_CONSENSUS_STATE = 2 [(gogoproto.enumvalue_customname) = "CONSENSUS"]; + // Data type for connection state verification + DATA_TYPE_CONNECTION_STATE = 3 [(gogoproto.enumvalue_customname) = "CONNECTION"]; + // Data type for channel state verification + DATA_TYPE_CHANNEL_STATE = 4 [(gogoproto.enumvalue_customname) = "CHANNEL"]; + // Data type for packet commitment verification + DATA_TYPE_PACKET_COMMITMENT = 5 [(gogoproto.enumvalue_customname) = "PACKETCOMMITMENT"]; + // Data type for packet acknowledgement verification + DATA_TYPE_PACKET_ACKNOWLEDGEMENT = 6 [(gogoproto.enumvalue_customname) = "PACKETACKNOWLEDGEMENT"]; + // Data type for packet receipt absence verification + DATA_TYPE_PACKET_RECEIPT_ABSENCE = 7 [(gogoproto.enumvalue_customname) = "PACKETRECEIPTABSENCE"]; + // Data type for next sequence recv verification + DATA_TYPE_NEXT_SEQUENCE_RECV = 8 [(gogoproto.enumvalue_customname) = "NEXTSEQUENCERECV"]; + // Data type for header verification + DATA_TYPE_HEADER = 9 [(gogoproto.enumvalue_customname) = "HEADER"]; +} + +// HeaderData returns the SignBytes data for update verification. +message HeaderData { + option (gogoproto.goproto_getters) = false; + + // header public key + google.protobuf.Any new_pub_key = 1 [(gogoproto.moretags) = "yaml:\"new_pub_key\""]; + // header diversifier + string new_diversifier = 2 [(gogoproto.moretags) = "yaml:\"new_diversifier\""]; +} + +// ClientStateData returns the SignBytes data for client state verification. +message ClientStateData { + option (gogoproto.goproto_getters) = false; + + bytes path = 1; + google.protobuf.Any client_state = 2 [(gogoproto.moretags) = "yaml:\"client_state\""]; +} + +// ConsensusStateData returns the SignBytes data for consensus state +// verification. +message ConsensusStateData { + option (gogoproto.goproto_getters) = false; + + bytes path = 1; + google.protobuf.Any consensus_state = 2 [(gogoproto.moretags) = "yaml:\"consensus_state\""]; +} + +// ConnectionStateData returns the SignBytes data for connection state +// verification. +message ConnectionStateData { + option (gogoproto.goproto_getters) = false; + + bytes path = 1; + ibc.core.connection.v1.ConnectionEnd connection = 2; +} + +// ChannelStateData returns the SignBytes data for channel state +// verification. +message ChannelStateData { + option (gogoproto.goproto_getters) = false; + + bytes path = 1; + ibc.core.channel.v1.Channel channel = 2; +} + +// PacketCommitmentData returns the SignBytes data for packet commitment +// verification. +message PacketCommitmentData { + bytes path = 1; + bytes commitment = 2; +} + +// PacketAcknowledgementData returns the SignBytes data for acknowledgement +// verification. +message PacketAcknowledgementData { + bytes path = 1; + bytes acknowledgement = 2; +} + +// PacketReceiptAbsenceData returns the SignBytes data for +// packet receipt absence verification. +message PacketReceiptAbsenceData { + bytes path = 1; +} + +// NextSequenceRecvData returns the SignBytes data for verification of the next +// sequence to be received. +message NextSequenceRecvData { + bytes path = 1; + uint64 next_seq_recv = 2 [(gogoproto.moretags) = "yaml:\"next_seq_recv\""]; +} diff --git a/p8e-api/src/main/proto/ibc/lightclients/tendermint/v1/tendermint.proto b/p8e-api/src/main/proto/ibc/lightclients/tendermint/v1/tendermint.proto new file mode 100644 index 0000000..a6882bf --- /dev/null +++ b/p8e-api/src/main/proto/ibc/lightclients/tendermint/v1/tendermint.proto @@ -0,0 +1,111 @@ +syntax = "proto3"; +package ibc.lightclients.tendermint.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/light-clients/07-tendermint/types"; + +import "tendermint/types/validator.proto"; +import "tendermint/types/types.proto"; +import "confio/proofs.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "ibc/core/client/v1/client.proto"; +import "ibc/core/commitment/v1/commitment.proto"; +import "gogoproto/gogo.proto"; + +// ClientState from Tendermint tracks the current validator set, latest height, +// and a possible frozen height. +message ClientState { + option (gogoproto.goproto_getters) = false; + + string chain_id = 1; + Fraction trust_level = 2 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"trust_level\""]; + // duration of the period since the LastestTimestamp during which the + // submitted headers are valid for upgrade + google.protobuf.Duration trusting_period = 3 + [(gogoproto.nullable) = false, (gogoproto.stdduration) = true, (gogoproto.moretags) = "yaml:\"trusting_period\""]; + // duration of the staking unbonding period + google.protobuf.Duration unbonding_period = 4 [ + (gogoproto.nullable) = false, + (gogoproto.stdduration) = true, + (gogoproto.moretags) = "yaml:\"unbonding_period\"" + ]; + // defines how much new (untrusted) header's Time can drift into the future. + google.protobuf.Duration max_clock_drift = 5 + [(gogoproto.nullable) = false, (gogoproto.stdduration) = true, (gogoproto.moretags) = "yaml:\"max_clock_drift\""]; + // Block height when the client was frozen due to a misbehaviour + ibc.core.client.v1.Height frozen_height = 6 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"frozen_height\""]; + // Latest height the client was updated to + ibc.core.client.v1.Height latest_height = 7 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"latest_height\""]; + + // Proof specifications used in verifying counterparty state + repeated ics23.ProofSpec proof_specs = 8 [(gogoproto.moretags) = "yaml:\"proof_specs\""]; + + // Path at which next upgraded client will be committed. + // Each element corresponds to the key for a single CommitmentProof in the chained proof. + // NOTE: ClientState must stored under `{upgradePath}/{upgradeHeight}/clientState` + // ConsensusState must be stored under `{upgradepath}/{upgradeHeight}/consensusState` + // For SDK chains using the default upgrade module, upgrade_path should be []string{"upgrade", "upgradedIBCState"}` + repeated string upgrade_path = 9 [(gogoproto.moretags) = "yaml:\"upgrade_path\""]; + + // This flag, when set to true, will allow governance to recover a client + // which has expired + bool allow_update_after_expiry = 10 [(gogoproto.moretags) = "yaml:\"allow_update_after_expiry\""]; + // This flag, when set to true, will allow governance to unfreeze a client + // whose chain has experienced a misbehaviour event + bool allow_update_after_misbehaviour = 11 [(gogoproto.moretags) = "yaml:\"allow_update_after_misbehaviour\""]; +} + +// ConsensusState defines the consensus state from Tendermint. +message ConsensusState { + option (gogoproto.goproto_getters) = false; + + // timestamp that corresponds to the block height in which the ConsensusState + // was stored. + google.protobuf.Timestamp timestamp = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + // commitment root (i.e app hash) + ibc.core.commitment.v1.MerkleRoot root = 2 [(gogoproto.nullable) = false]; + bytes next_validators_hash = 3 [ + (gogoproto.casttype) = "github.com/tendermint/tendermint/libs/bytes.HexBytes", + (gogoproto.moretags) = "yaml:\"next_validators_hash\"" + ]; +} + +// Misbehaviour is a wrapper over two conflicting Headers +// that implements Misbehaviour interface expected by ICS-02 +message Misbehaviour { + option (gogoproto.goproto_getters) = false; + + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + Header header_1 = 2 [(gogoproto.customname) = "Header1", (gogoproto.moretags) = "yaml:\"header_1\""]; + Header header_2 = 3 [(gogoproto.customname) = "Header2", (gogoproto.moretags) = "yaml:\"header_2\""]; +} + +// Header defines the Tendermint client consensus Header. +// It encapsulates all the information necessary to update from a trusted +// Tendermint ConsensusState. The inclusion of TrustedHeight and +// TrustedValidators allows this update to process correctly, so long as the +// ConsensusState for the TrustedHeight exists, this removes race conditions +// among relayers The SignedHeader and ValidatorSet are the new untrusted update +// fields for the client. The TrustedHeight is the height of a stored +// ConsensusState on the client that will be used to verify the new untrusted +// header. The Trusted ConsensusState must be within the unbonding period of +// current time in order to correctly verify, and the TrustedValidators must +// hash to TrustedConsensusState.NextValidatorsHash since that is the last +// trusted validator set at the TrustedHeight. +message Header { + .tendermint.types.SignedHeader signed_header = 1 + [(gogoproto.embed) = true, (gogoproto.moretags) = "yaml:\"signed_header\""]; + + .tendermint.types.ValidatorSet validator_set = 2 [(gogoproto.moretags) = "yaml:\"validator_set\""]; + ibc.core.client.v1.Height trusted_height = 3 + [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"trusted_height\""]; + .tendermint.types.ValidatorSet trusted_validators = 4 [(gogoproto.moretags) = "yaml:\"trusted_validators\""]; +} + +// Fraction defines the protobuf message type for tmmath.Fraction that only supports positive values. +message Fraction { + uint64 numerator = 1; + uint64 denominator = 2; +} diff --git a/p8e-api/src/main/proto/provenance/attribute/v1/attribute.proto b/p8e-api/src/main/proto/provenance/attribute/v1/attribute.proto new file mode 100644 index 0000000..a32e734 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/attribute/v1/attribute.proto @@ -0,0 +1,51 @@ +syntax = "proto3"; +package provenance.attribute.v1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/provenance-io/provenance/x/attribute/types"; + +option java_package = "io.provenance.attribute.v1"; +option java_multiple_files = true; + +// Params defines the set of params for the attribute module. +message Params { + option (gogoproto.goproto_stringer) = false; + // maximum length of data to allow in an attribute value + uint32 max_value_length = 1; +} + +// Attribute holds a typed key/value structure for data associated with an account +message Attribute { + option (gogoproto.goproto_stringer) = false; + // The attribute name. + string name = 1; + // The attribute value. + bytes value = 2; + // The attribute value type. + AttributeType attribute_type = 3; + // The address the attribute is bound to + string address = 4; +} + +// AttributeType defines the type of the data stored in the attribute value +enum AttributeType { + // ATTRIBUTE_TYPE_UNSPECIFIED defines an unknown/invalid type + ATTRIBUTE_TYPE_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unspecified"]; + // ATTRIBUTE_TYPE_UUID defines an attribute value that contains a string value representation of a V4 uuid + ATTRIBUTE_TYPE_UUID = 1 [(gogoproto.enumvalue_customname) = "UUID"]; + // ATTRIBUTE_TYPE_JSON defines an attribute value that contains a byte string containing json data + ATTRIBUTE_TYPE_JSON = 2 [(gogoproto.enumvalue_customname) = "JSON"]; + // ATTRIBUTE_TYPE_STRING defines an attribute value that contains a generic string value + ATTRIBUTE_TYPE_STRING = 3 [(gogoproto.enumvalue_customname) = "String"]; + // ATTRIBUTE_TYPE_URI defines an attribute value that contains a URI + ATTRIBUTE_TYPE_URI = 4 [(gogoproto.enumvalue_customname) = "Uri"]; + // ATTRIBUTE_TYPE_INT defines an attribute value that contains an integer (cast as int64) + ATTRIBUTE_TYPE_INT = 5 [(gogoproto.enumvalue_customname) = "Int"]; + // ATTRIBUTE_TYPE_FLOAT defines an attribute value that contains a float + ATTRIBUTE_TYPE_FLOAT = 6 [(gogoproto.enumvalue_customname) = "Float"]; + // ATTRIBUTE_TYPE_PROTO defines an attribute value that contains a serialized proto value in bytes + ATTRIBUTE_TYPE_PROTO = 7 [(gogoproto.enumvalue_customname) = "Proto"]; + // ATTRIBUTE_TYPE_BYTES defines an attribute value that contains an untyped array of bytes + ATTRIBUTE_TYPE_BYTES = 8 [(gogoproto.enumvalue_customname) = "Bytes"]; +} diff --git a/p8e-api/src/main/proto/provenance/attribute/v1/genesis.proto b/p8e-api/src/main/proto/provenance/attribute/v1/genesis.proto new file mode 100644 index 0000000..36d5399 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/attribute/v1/genesis.proto @@ -0,0 +1,21 @@ +syntax = "proto3"; +package provenance.attribute.v1; + +import "gogoproto/gogo.proto"; +import "provenance/attribute/v1/attribute.proto"; + +option go_package = "github.com/provenance-io/provenance/x/attribute/types"; +option java_package = "io.provenance.attribute.v1"; +option java_multiple_files = true; + +// GenesisState defines the attribute module's genesis state. +message GenesisState { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // params defines all the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; + + // deposits defines all the deposits present at genesis. + repeated Attribute attributes = 2 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/provenance/attribute/v1/query.proto b/p8e-api/src/main/proto/provenance/attribute/v1/query.proto new file mode 100644 index 0000000..2d37969 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/attribute/v1/query.proto @@ -0,0 +1,115 @@ +syntax = "proto3"; +package provenance.attribute.v1; + +option go_package = "github.com/provenance-io/provenance/x/attribute/types"; + +option java_package = "io.provenance.attribute.v1"; +option java_multiple_files = true; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "provenance/attribute/v1/attribute.proto"; + +// Query defines the gRPC querier service for attribute module. +service Query { + // Params queries params of the attribute module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/provenance/attribute/v1/params"; + } + + // Attribute queries attributes on a given account (address) for one (or more) with the given name + rpc Attribute(QueryAttributeRequest) returns (QueryAttributeResponse) { + option (google.api.http).get = "/provenance/attribute/v1/attribute/{account}/{name}"; + } + + // Attributes queries attributes on a given account (address) for any defined attributes + rpc Attributes(QueryAttributesRequest) returns (QueryAttributesResponse) { + option (google.api.http).get = "/provenance/attribute/v1/attributes/{account}"; + } + + // Scan queries attributes on a given account (address) for any that match the provided suffix + rpc Scan(QueryScanRequest) returns (QueryScanResponse) { + option (google.api.http).get = "/provenance/attribute/v1/attribute/{account}/scan/{suffix}"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; +} + +// QueryAttributeRequest is the request type for the Query/Attribute method. +message QueryAttributeRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // account defines the address to query for. + string account = 1; + // name is the attribute name to query for + string name = 2; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 3; +} + +// QueryAttributeResponse is the response type for the Query/Attribute method. +message QueryAttributeResponse { + // a string containing the address of the account the attributes are assigned to. + string account = 1; + // a list of attribute values + repeated Attribute attributes = 2 [(gogoproto.nullable) = false]; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} + +// QueryAttributesRequest is the request type for the Query/Attributes method. +message QueryAttributesRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // account defines the address to query for. + string account = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryAttributesResponse is the response type for the Query/Attribute method. +message QueryAttributesResponse { + // a string containing the address of the account the attributes are assigned to= + string account = 1; + // a list of attribute values + repeated Attribute attributes = 2 [(gogoproto.nullable) = false]; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} + +// QueryScanRequest is the request type for the Query/Scan account attributes method. +message QueryScanRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // account defines the address to query for. + string account = 1; + + // name defines the partial attribute name to search for base on names being in RDNS format. + string suffix = 2; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 3; +} + +// QueryScanResponse is the response type for the Query/Attribute method. +message QueryScanResponse { + // a string containing the address of the account the attributes are assigned to= + string account = 1; + // a list of attribute values + repeated Attribute attributes = 2 [(gogoproto.nullable) = false]; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/attribute/v1/tx.proto b/p8e-api/src/main/proto/provenance/attribute/v1/tx.proto new file mode 100644 index 0000000..f7f7192 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/attribute/v1/tx.proto @@ -0,0 +1,61 @@ +syntax = "proto3"; +package provenance.attribute.v1; + +option go_package = "github.com/provenance-io/provenance/x/attribute/types"; + +option java_package = "io.provenance.attribute.v1"; +option java_multiple_files = true; + +import "gogoproto/gogo.proto"; +import "provenance/attribute/v1/attribute.proto"; + +// Msg defines the bank Msg service. +service Msg { + // AddAttribute defines a method to verify a particular invariance. + rpc AddAttribute(MsgAddAttributeRequest) returns (MsgAddAttributeResponse); + + // DeleteAttribute defines a method to verify a particular invariance. + rpc DeleteAttribute(MsgDeleteAttributeRequest) returns (MsgDeleteAttributeResponse); +} + +// MsgAddAttributeRequest defines an sdk.Msg type that is used to add a new attribute to an account +// Attributes may only be set in an account by the account that the attribute name resolves to. +message MsgAddAttributeRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // The attribute name. + string name = 1; + // The attribute value. + bytes value = 2; + // The attribute value type. + AttributeType attribute_type = 3; + // The account to add the attribute to. + string account = 4; + // The address that the name must resolve to. + string owner = 5; +} + +// MsgAddAttributeResponse defines the Msg/Vote response type. +message MsgAddAttributeResponse {} + +// MsgDeleteAttributeRequest defines a message to delete an attribute from an account +// Attributes may only be remove from an account by the account that the attribute name resolves to. +message MsgDeleteAttributeRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // The attribute name. + string name = 1; + // The account to add the attribute to. + string account = 2; + // The address that the name must resolve to. + string owner = 3; +} + +// MsgDeleteAttributeResponse defines the Msg/Vote response type. +message MsgDeleteAttributeResponse {} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/marker/v1/accessgrant.proto b/p8e-api/src/main/proto/provenance/marker/v1/accessgrant.proto new file mode 100644 index 0000000..fe58463 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/marker/v1/accessgrant.proto @@ -0,0 +1,46 @@ +syntax = "proto3"; +package provenance.marker.v1; + +import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; + +option go_package = "github.com/provenance-io/provenance/x/marker/types"; + +option java_package = "io.provenance.marker.v1"; +option java_multiple_files = true; +option java_outer_classname = "AccessGrantProto"; + +// AccessGrant associates a colelction of permisssions with an address for delegated marker account control. +message AccessGrant { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.equal) = true; + + option (cosmos_proto.implements_interface) = "AccessGrantI"; + + string address = 1; + repeated Access permissions = 2 [(gogoproto.castrepeated) = "AccessList"]; +} + +// Access defines the different types of permissions that a marker supports granting to an address. +enum Access { + // ACCESS_UNSPECIFIED defines a no-op vote option. + ACCESS_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unknown"]; + // ACCESS_MINT is the ability to increase the supply of a marker + ACCESS_MINT = 1 [(gogoproto.enumvalue_customname) = "Mint"]; + // ACCESS_BURN is the ability to decrease the supply of the marker using coin held by the marker. + ACCESS_BURN = 2 [(gogoproto.enumvalue_customname) = "Burn"]; + // ACCESS_DEPOSIT is the ability to set a marker reference to this marker in the metadata/scopes module + ACCESS_DEPOSIT = 3 [(gogoproto.enumvalue_customname) = "Deposit"]; + // ACCESS_WITHDRAW is the ability to remove marker references to this marker in from metadata/scopes or + // transfer coin from this marker account to another account. + ACCESS_WITHDRAW = 4 [(gogoproto.enumvalue_customname) = "Withdraw"]; + // ACCESS_DELETE is the ability to move a proposed, finalized or active marker into the cancelled state. This + // access also allows cancelled markers to be marked for deletion + ACCESS_DELETE = 5 [(gogoproto.enumvalue_customname) = "Delete"]; + // ACCESS_ADMIN is the ability to add access grants for accounts to the list of marker permissions. + ACCESS_ADMIN = 6 [(gogoproto.enumvalue_customname) = "Admin"]; + // ACCESS_TRANSFER is the ability to invoke a send operation using the marker module to facilitate exchange. + // This capability is useful when the marker denomination has "send enabled = false" preventing normal bank transfer + ACCESS_TRANSFER = 7 [(gogoproto.enumvalue_customname) = "Transfer"]; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/marker/v1/genesis.proto b/p8e-api/src/main/proto/provenance/marker/v1/genesis.proto new file mode 100644 index 0000000..6445c28 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/marker/v1/genesis.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; +package provenance.marker.v1; + +option go_package = "github.com/provenance-io/provenance/x/marker/types"; + +option java_package = "io.provenance.marker.v1"; +option java_multiple_files = true; + +import "gogoproto/gogo.proto"; +import "provenance/marker/v1/marker.proto"; + +// GenesisState defines the account module's genesis state. +message GenesisState { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // params defines all the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; + + // A collection of marker accounts to create on start + repeated MarkerAccount markers = 2 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/provenance/marker/v1/marker.proto b/p8e-api/src/main/proto/provenance/marker/v1/marker.proto new file mode 100644 index 0000000..9edb008 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/marker/v1/marker.proto @@ -0,0 +1,88 @@ +syntax = "proto3"; +package provenance.marker.v1; + +import "gogoproto/gogo.proto"; +import "cosmos/auth/v1beta1/auth.proto"; +import "cosmos_proto/cosmos.proto"; +import "provenance/marker/v1/accessgrant.proto"; + +option go_package = "github.com/provenance-io/provenance/x/marker/types"; +option java_package = "io.provenance.marker.v1"; +option java_multiple_files = true; + +// Params defines the set of params for the account module. +message Params { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + + // maximum amount of supply to allow a marker to be created with + uint64 max_total_supply = 1 [(gogoproto.customtype) = "uint64", (gogoproto.nullable) = false]; + // indicates if governance based controls of markers is allowed. + bool enable_governance = 2; + // a regular expression used to validate marker denom values from normal create requests (governance + // requests are only subject to platform coin validation denom expression) + string unrestricted_denom_regex = 3; +} + +// MarkerAccount holds the marker configuration information in addition to a base account structure. +message MarkerAccount { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + option (cosmos_proto.implements_interface) = "MarkerAccountI"; + + // base cosmos account information including address and coin holdings. + cosmos.auth.v1beta1.BaseAccount base_account = 1 + [(gogoproto.embed) = true, (gogoproto.moretags) = "yaml:\"base_account\""]; + // Address that owns the marker configuration. This account must sign any requests + // to change marker config (only valid for statuses prior to finalization) + string manager = 2 [(gogoproto.moretags) = "json:\"manager,omitempty\""]; + // Access control lists + repeated AccessGrant access_control = 3 [(gogoproto.nullable) = false]; + // Indicates the current status of this marker record. + MarkerStatus status = 4; + // value denomination and total supply for the token. + string denom = 5; + // the total supply expected for a marker. This is the amount that is minted when a marker is created. + string supply = 6 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "json:\"total_supply\" yaml:\"total_supply\"" + ]; + // Marker type information + MarkerType marker_type = 7 [(gogoproto.moretags) = "json:\"marker_type,omitempty\""]; + // A fixed supply will mint additional coin automatically if the total supply decreases below a set value. This + // may occur if the coin is burned or an account holding the coin is slashed. (default: true) + bool supply_fixed = 8; + // indicates that governance based control is allowed for this marker + bool allow_governance_control = 9; +} + +// MarkerType defines the types of marker +enum MarkerType { + // MARKER_TYPE_UNSPECIFIED is an invalid/unknown marker type. + MARKER_TYPE_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unknown"]; + // MARKER_TYPE_COIN is a marker that represents a standard fungible coin (default). + MARKER_TYPE_COIN = 1 [(gogoproto.enumvalue_customname) = "Coin"]; + // MARKER_TYPE_RESTRICTED is a marker that represents a denom with send_enabled = false. + MARKER_TYPE_RESTRICTED = 2 [(gogoproto.enumvalue_customname) = "RestrictedCoin"]; +} + +// MarkerStatus defines the various states a marker account can be in. +enum MarkerStatus { + option (gogoproto.goproto_enum_prefix) = false; + option (gogoproto.goproto_enum_stringer) = false; + + // MARKER_STATUS_UNSPECIFIED - Unknown/Invalid Marker Status + MARKER_STATUS_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "StatusUndefined"]; + // MARKER_STATUS_PROPOSED - Initial configuration period, updates allowed, token supply not created. + MARKER_STATUS_PROPOSED = 1 [(gogoproto.enumvalue_customname) = "StatusProposed"]; + // MARKER_STATUS_FINALIZED - Configuration finalized, ready for supply creation + MARKER_STATUS_FINALIZED = 2 [(gogoproto.enumvalue_customname) = "StatusFinalized"]; + // MARKER_STATUS_ACTIVE - Supply is created, rules are in force. + MARKER_STATUS_ACTIVE = 3 [(gogoproto.enumvalue_customname) = "StatusActive"]; + // MARKER_STATUS_CANCELLED - Marker has been cancelled, pending destroy + MARKER_STATUS_CANCELLED = 4 [(gogoproto.enumvalue_customname) = "StatusCancelled"]; + // MARKER_STATUS_DESTROYED - Marker supply has all been recalled, marker is considered destroyed and no further + // actions allowed. + MARKER_STATUS_DESTROYED = 5 [(gogoproto.enumvalue_customname) = "StatusDestroyed"]; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/marker/v1/proposals.proto b/p8e-api/src/main/proto/provenance/marker/v1/proposals.proto new file mode 100644 index 0000000..ff75177 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/marker/v1/proposals.proto @@ -0,0 +1,103 @@ +syntax = "proto3"; +package provenance.marker.v1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "provenance/marker/v1/marker.proto"; +import "provenance/marker/v1/accessgrant.proto"; + +option go_package = "github.com/provenance-io/provenance/x/marker/types"; + +option java_package = "io.provenance.marker.v1"; +option java_multiple_files = true; + +// AddMarkerProposal defines defines a governance proposal to create a new marker +message AddMarkerProposal { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + + cosmos.base.v1beta1.Coin amount = 3 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Coin"]; + string manager = 4; + MarkerStatus status = 5; + MarkerType marker_type = 6; + repeated AccessGrant access_list = 7 [(gogoproto.nullable) = false]; + bool supply_fixed = 8; + bool allow_governance_control = 9; +} + +// SupplyIncreaseProposal defines a governance proposal to administer a marker and increase total supply of the marker +// through minting coin and placing it within the marker or assigning it directly to an account +message SupplyIncreaseProposal { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + cosmos.base.v1beta1.Coin amount = 3 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Coin"]; + string target_adddress = 4; // an optional target address for the minted coin from this request +} + +// SupplyDecreaseProposal defines a governance proposal to administer a marker and decrease the total supply through +// burning coin held within the marker +message SupplyDecreaseProposal { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + cosmos.base.v1beta1.Coin amount = 3 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Coin"]; +} + +// SetAdministratorProposal defines a governance proposal to administer a marker and set administrators with specific +// access on the marker +message SetAdministratorProposal { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + string denom = 3; + repeated AccessGrant access = 4 [(gogoproto.nullable) = false]; +} + +// RemoveAdministratorProposal defines a governance proposal to administer a marker and remove all permissions for a +// given address +message RemoveAdministratorProposal { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + string denom = 3; + repeated string removed_address = 4; +} + +// ChangeStatusProposal defines a governance proposal to administer a marker to change its status +message ChangeStatusProposal { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + string denom = 3; + MarkerStatus new_status = 4; +} + +// WithdrawEscrowProposal defines a governance proposal to withdraw escrow coins from a marker +message WithdrawEscrowProposal { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + string denom = 3; + repeated cosmos.base.v1beta1.Coin amount = 4 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; + string target_adddress = 5; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/marker/v1/query.proto b/p8e-api/src/main/proto/provenance/marker/v1/query.proto new file mode 100644 index 0000000..d4161e4 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/marker/v1/query.proto @@ -0,0 +1,160 @@ +syntax = "proto3"; +package provenance.marker.v1; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/bank/v1beta1/bank.proto"; +import "cosmos_proto/cosmos.proto"; +import "google/api/annotations.proto"; +import "provenance/marker/v1/marker.proto"; +import "provenance/marker/v1/accessgrant.proto"; + +option go_package = "github.com/provenance-io/provenance/x/marker/types"; +option java_package = "io.provenance.marker.v1"; +option java_multiple_files = true; + +// Query defines the gRPC querier service for marker module. +service Query { + // Params queries the parameters of x/bank module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/provenance/marker/v1/params"; + } + + // Returns a list of all markers on the blockchain + rpc AllMarkers(QueryAllMarkersRequest) returns (QueryAllMarkersResponse) { + option (google.api.http).get = "/provenance/marker/v1/all"; + } + + // query for a single marker by denom or address + rpc Marker(QueryMarkerRequest) returns (QueryMarkerResponse) { + option (google.api.http).get = "/provenance/marker/v1/detail/{id}"; + } + + // query for all accounts holding the given marker coins + rpc Holding(QueryHoldingRequest) returns (QueryHoldingResponse) { + option (google.api.http).get = "/provenance/marker/v1/holding/{id}"; + } + + // query for supply of coin on a marker account + rpc Supply(QuerySupplyRequest) returns (QuerySupplyResponse) { + option (google.api.http).get = "/provenance/marker/v1/supply/{id}"; + } + + // query for coins on a marker account + rpc Escrow(QueryEscrowRequest) returns (QueryEscrowResponse) { + option (google.api.http).get = "/provenance/marker/v1/escrow/{id}"; + } + + // query for access records on an account + rpc Access(QueryAccessRequest) returns (QueryAccessResponse) { + option (google.api.http).get = "/provenance/marker/v1/accesscontrol/{id}"; + } + + // query for access records on an account + rpc DenomMetadata(QueryDenomMetadataRequest) returns (QueryDenomMetadataResponse) { + option (google.api.http).get = "/provenance/marker/v1/getdenommetadata/{denom}"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; +} + +// QueryAllMarkersRequest is the request type for the Query/AllMarkers method. +message QueryAllMarkersRequest { + // Optional status to filter request + MarkerStatus status = 1; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} +// QueryAllMarkersResponse is the response type for the Query/AllMarkers method. +message QueryAllMarkersResponse { + repeated google.protobuf.Any markers = 1 [(cosmos_proto.accepts_interface) = "MarkerAccountI"]; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryMarkerRequest is the request type for the Query/Marker method. +message QueryMarkerRequest { + // the address or denom of the marker + string id = 1; +} +// QueryMarkerResponse is the response type for the Query/Marker method. +message QueryMarkerResponse { + google.protobuf.Any marker = 1 [(cosmos_proto.accepts_interface) = "MarkerAccountI"]; +} + +// QueryHoldingRequest is the request type for the Query/MarkerHolders method. +message QueryHoldingRequest { + // the address or denom of the marker + string id = 1; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} +// QueryHoldingResponse is the response type for the Query/MarkerHolders method. +message QueryHoldingResponse { + repeated Balance balances = 1 [(gogoproto.nullable) = false]; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QuerySupplyRequest is the request type for the Query/MarkerSupply method. +message QuerySupplyRequest { + // address or denom for the marker + string id = 1; +} +// QuerySupplyResponse is the response type for the Query/MarkerSupply method. +message QuerySupplyResponse { + // amount is the supply of the marker. + cosmos.base.v1beta1.Coin amount = 1 [(gogoproto.nullable) = false]; +} + +// QueryEscrowRequest is the request type for the Query/MarkerEscrow method. +message QueryEscrowRequest { + // address or denom for the marker + string id = 1; +} +// QueryEscrowResponse is the response type for the Query/MarkerEscrow method. +message QueryEscrowResponse { + repeated cosmos.base.v1beta1.Coin escrow = 1 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} + +// QueryAccessRequest is the request type for the Query/MarkerAccess method. +message QueryAccessRequest { + // address or denom for the marker + string id = 1; +} +// QueryAccessResponse is the response type for the Query/MarkerAccess method. +message QueryAccessResponse { + repeated AccessGrant accounts = 1 [(gogoproto.nullable) = false]; +} + +// QueryDenomMetadataRequest is the request type for Query/DenomMetadata +message QueryDenomMetadataRequest { + string denom = 1; +} +// QueryDenomMetadataResponse is the response type for the Query/DenomMetadata +message QueryDenomMetadataResponse { + cosmos.bank.v1beta1.Metadata metadata = 1 [(gogoproto.nullable) = false]; +} + +// Balance defines an account address and balance pair used in queries for accounts holding a marker +message Balance { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the address of the balance holder. + string address = 1; + + // coins defines the different coins this balance holds. + repeated cosmos.base.v1beta1.Coin coins = 2 + [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", (gogoproto.nullable) = false]; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/marker/v1/tx.proto b/p8e-api/src/main/proto/provenance/marker/v1/tx.proto new file mode 100644 index 0000000..fedd5fc --- /dev/null +++ b/p8e-api/src/main/proto/provenance/marker/v1/tx.proto @@ -0,0 +1,159 @@ +syntax = "proto3"; +package provenance.marker.v1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/bank/v1beta1/bank.proto"; +import "provenance/marker/v1/marker.proto"; +import "provenance/marker/v1/accessgrant.proto"; + +option go_package = "github.com/provenance-io/provenance/x/marker/types"; + +option java_package = "io.provenance.marker.v1"; +option java_multiple_files = true; + +// Msg defines the Marker Msg service. +service Msg { + // Finalize + rpc Finalize(MsgFinalizeRequest) returns (MsgFinalizeResponse); + // Activate + rpc Activate(MsgActivateRequest) returns (MsgActivateResponse); + // Cancel + rpc Cancel(MsgCancelRequest) returns (MsgCancelResponse); + // Delete + rpc Delete(MsgDeleteRequest) returns (MsgDeleteResponse); + // Mint + rpc Mint(MsgMintRequest) returns (MsgMintResponse); + // Burn + rpc Burn(MsgBurnRequest) returns (MsgBurnResponse); + // AddAccess + rpc AddAccess(MsgAddAccessRequest) returns (MsgAddAccessResponse); + // DeleteAccess + rpc DeleteAccess(MsgDeleteAccessRequest) returns (MsgDeleteAccessResponse); + // Withdraw + rpc Withdraw(MsgWithdrawRequest) returns (MsgWithdrawResponse); + // AddMarker + rpc AddMarker(MsgAddMarkerRequest) returns (MsgAddMarkerResponse); + // Transfer marker denominated coin between accounts + rpc Transfer(MsgTransferRequest) returns (MsgTransferResponse); + // Allows Denom Metadata (see bank module) to be set for the Marker's Denom + rpc SetDenomMetadata(MsgSetDenomMetadataRequest) returns (MsgSetDenomMetadataResponse); +} + +// MsgAddMarkerRequest defines the Msg/AddMarker request type +message MsgAddMarkerRequest { + cosmos.base.v1beta1.Coin amount = 1 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Coin"]; + string manager = 3; + string from_address = 4; + MarkerStatus status = 5; + MarkerType marker_type = 6; + repeated AccessGrant access_list = 7 [(gogoproto.nullable) = false]; + bool supply_fixed = 8; + bool allow_governance_control = 9; +} + +// MsgAddMarkerResponse defines the Msg/AddMarker response type +message MsgAddMarkerResponse {} + +// MsgAddAccessRequest defines the Msg/AddAccess request type +message MsgAddAccessRequest { + string denom = 1; + string administrator = 2; + repeated AccessGrant access = 3 [(gogoproto.nullable) = false]; +} + +// MsgAddAccessResponse defines the Msg/AddAccess response type +message MsgAddAccessResponse {} + +// MsgDeleteAccessRequest defines the Msg/DeleteAccess request type +message MsgDeleteAccessRequest { + string denom = 1; + string administrator = 2; + string removed_address = 3; +} +// MsgDeleteAccessResponse defines the Msg/DeleteAccess response type +message MsgDeleteAccessResponse {} + +// MsgFinalizeRequest defines the Msg/Finalize request type +message MsgFinalizeRequest { + string denom = 1; + string administrator = 2; +} +// MsgFinalizeResponse defines the Msg/Finalize response type +message MsgFinalizeResponse {} + +// MsgActivateRequest defines the Msg/Activate request type +message MsgActivateRequest { + string denom = 1; + string administrator = 2; +} +// MsgActivateResponse defines the Msg/Activate response type +message MsgActivateResponse {} + +// MsgCancelRequest defines the Msg/Cancel request type +message MsgCancelRequest { + string denom = 1; + string administrator = 2; +} +// MsgCancelResponse defines the Msg/Cancel response type +message MsgCancelResponse {} + +// MsgDeleteRequest defines the Msg/Delete request type +message MsgDeleteRequest { + string denom = 1; + string administrator = 2; +} +// MsgDeleteResponse defines the Msg/Delete response type +message MsgDeleteResponse {} + +// MsgMintRequest defines the Msg/Mint request type +message MsgMintRequest { + cosmos.base.v1beta1.Coin amount = 1 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Coin"]; + string administrator = 2; +} +// MsgMintResponse defines the Msg/Mint response type +message MsgMintResponse {} + +// MsgBurnRequest defines the Msg/Burn request type +message MsgBurnRequest { + cosmos.base.v1beta1.Coin amount = 1 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Coin"]; + string administrator = 2; +} +// MsgBurnResponse defines the Msg/Burn response type +message MsgBurnResponse {} + +// MsgWithdrawRequest defines the Msg/Withdraw request type +message MsgWithdrawRequest { + string denom = 1; + string administrator = 2; + string to_address = 3; + repeated cosmos.base.v1beta1.Coin amount = 4 + [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; +} +// MsgWithdrawResponse defines the Msg/Withdraw response type +message MsgWithdrawResponse {} + +// MsgTransferRequest defines the Msg/Transfer request type +message MsgTransferRequest { + cosmos.base.v1beta1.Coin amount = 1 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Coin"]; + string administrator = 3; + string from_address = 4; + string to_address = 5; +} + +// MsgTransferResponse defines the Msg/Transfer response type +message MsgTransferResponse {} + +// MsgSetDenomMetadataRequest defines the Msg/SetDenomMetadata request type +message MsgSetDenomMetadataRequest { + cosmos.bank.v1beta1.Metadata metadata = 1 + [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/x/bank/types.Metadata"]; + string administrator = 2; +} + +// MsgSetDenomMetadataResponse defines the Msg/SetDenomMetadata response type +message MsgSetDenomMetadataResponse {} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v0/contract.proto b/p8e-api/src/main/proto/provenance/metadata/v0/contract.proto new file mode 100644 index 0000000..e6cc88d --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v0/contract.proto @@ -0,0 +1,88 @@ +syntax = "proto3"; + +package contract; + +option go_package = "github.com/provenance-io/provenance/x/metadata/legacy/v039"; +option java_package = "io.provenance.metadata.v0"; +option java_multiple_files = true; + +import "gogoproto/gogo.proto"; +import "provenance/metadata/v0/spec.proto"; +import "provenance/metadata/v0/types.proto"; + +import "google/protobuf/timestamp.proto"; + +message Recital { + types.PartyType signer_role = 1; + types.SigningAndEncryptionPublicKeys signer = 2; + bytes address = 3; +} + +message Recitals { + repeated Recital parties = 1; +} + +message Contract { + spec.DefinitionSpec definition = 1; + + // Points to the proto for the contractSpec + types.Fact spec = 2; + + // Invoker of this contract + types.SigningAndEncryptionPublicKeys invoker = 3; + + // Constructor arguments. + // These are always the output of a previously recorded consideration. + repeated types.Fact inputs = 4; + + repeated contract.Condition conditions = 5; + repeated contract.Consideration considerations = 6; + + repeated contract.Recital recitals = 7; + + int32 times_executed = 8; + + // This is only set once when the contract is initially executed + google.protobuf.Timestamp start_time = 9 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"start_time\""]; + ; +} + +message Condition { + string condition_name = 1; + contract.ExecutionResult result = 2; +} + +message Consideration { + string consideration_name = 1; + + // Data pushed to a consideration that will ultimately match the output_spec of the consideration + repeated contract.ProposedFact inputs = 2; + + contract.ExecutionResult result = 3; +} + +// Input to a consideration defined at runtime, and emitted as a proposed fact for inclusion on the blockchain. +message ProposedFact { + string name = 1; + string hash = 2; + string classname = 3; + types.ProvenanceReference ancestor = 4; +} + +enum ExecutionResultType { + RESULT_TYPE_UNKNOWN = 0; + RESULT_TYPE_PASS = 1; + // Couldn't process the condition/consideration due to missing facts being generated by other considerations. + RESULT_TYPE_SKIP = 2; + RESULT_TYPE_FAIL = 3; +} + +message ExecutionResult { + contract.ProposedFact output = 1; + contract.ExecutionResultType result = 2; + google.protobuf.Timestamp recorded_at = 3 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"recorded_at\""]; + ; + string error_message = 4; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v0/query.proto b/p8e-api/src/main/proto/provenance/metadata/v0/query.proto new file mode 100644 index 0000000..88d210d --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v0/query.proto @@ -0,0 +1,29 @@ +syntax = "proto3"; +package query; + +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "provenance/metadata/v0/scope.proto"; + +option go_package = "github.com/provenance-io/provenance/x/metadata/legacy/v039"; + +option java_package = "io.provenance.metadata.v0"; +option java_multiple_files = true; + +// Query defines the Metadata Query service. +service Query { + // Scope returns a specific scope by id + rpc Scope(ScopeRequest) returns (ScopeResponse) { + option (google.api.http).get = "/provenance/metadata/v0/scope/{scope_id}"; + } +} + +// ScopeRequest is used for requesting a scope by id +message ScopeRequest { + string scope_id = 1; +} + +// ScopeResponse is the response to a scope request. +message ScopeResponse { + scope.Scope scope = 1 [(gogoproto.nullable) = false]; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v0/scope.proto b/p8e-api/src/main/proto/provenance/metadata/v0/scope.proto new file mode 100644 index 0000000..4b8991c --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v0/scope.proto @@ -0,0 +1,110 @@ +syntax = "proto3"; + +package scope; + +option go_package = "github.com/provenance-io/provenance/x/metadata/legacy/v039"; +option java_package = "io.provenance.metadata.v0"; +option java_multiple_files = true; + +import "provenance/metadata/v0/contract.proto"; +import "provenance/metadata/v0/types.proto"; + +import "google/protobuf/descriptor.proto"; + +// +// Overview +// +// When memorializing a contract the only pieces that matter are the results and facts. We scope these inside the +// contract_group structure to represent a scope around this information and keep the controlling parties (recitals) +// attached which prevents a co-mingling of the rights to change/update these records. The proof submitted to record +// the facts is part of the readset (the submitted Contract package) and is not important now that the information has +// been recorded. If the source is required it can be pulled from the ReadSet and referenced (or any of the members +// that stored it under the associated URI. + +// Event references in relation to scope +message Event { + types.UUID group_uuid = 1; + types.UUID execution_uuid = 2; +} + +// A ContractScope is a context that binds multiple p8e working together to create a set of facts managed a defined +// set of affiliates. +message Scope { + // Unique ID for building up ProvenanceReferences + types.UUID uuid = 1; + // Required parties on this scope. These are union with any contract specific recital requirements + repeated contract.Recital parties = 2; + // Each contract memorialized in this scope is stored in this list of contract_group. The list of groups is keyed + // as a hashmap based on the contract_spec_ref as a unique key. + repeated scope.RecordGroup record_group = 3; + // Last event that resulted in scope changes. + scope.Event last_event = 4; +} + +// A collection wrapper around scopes +message ScopeCollection { + repeated scope.Scope scopes = 1; +} + +// An record group is created for each contract memorialized against a scope. This tracks who controls each record for +// future use. +message RecordGroup { + // contract.spec.data_location.hash -- the specific contract specification that was used to create this group. + string specification = 1; + // Unique ID for building up ProvenanceReferences. Set to the value on of group_uuid on the incoming contract ref. + types.UUID group_uuid = 2; + // Identity that is memorializing this contract + types.SigningAndEncryptionPublicKeys executor = 3; + // Set of identities that signed this contract + repeated contract.Recital parties = 4; + // Accumulated records (of fact) resulting from Considerations + repeated scope.Record records = 5; + // name of the class associated with this record group specification + string classname = 6; + // Created by, updated by, timestamps, version number, and related info. + types.AuditFields audit = 99; +} + +// A record (of fact) is attached to an group or each consideration output from a contract. +message Record { + // ConsiderationSpec.func_name <--> ConsiderationProto.consideration_name (method on the classname below that + // generated this) + string name = 1; + // ConsiderationSpec.outputSpec.spec.resourceLocation.ref.hash (this is the hash of the consideration which generated + // the record, see also result_hash) + string hash = 2; + // ContractSpec.definition.resourceLocation.classname (class that contains the method 'name' as given above) + string classname = 3; + // ConsiderationProto.inputs for reference with ConsiderationSpec.input_spec for type + repeated RecordInput inputs = 4; + // ConsiderationProto.result.result (indicates SKIP [not allowed], PASS, or FAIL result) + contract.ExecutionResultType result = 5; + // ConsiderationProto.result.output.name + string result_name = 6; + // ConsiderationProto.result.output.hash (the hash of the data output from the consideration) + string result_hash = 7; +} + +// RecordInputType indicates if an input is data on or off chain. +enum RecordInputType { + // invalid status + RECORD_INPUT_TYPE_UNKNOWN = 0; + // input is proposed data for recording to the blockchain + RECORD_INPUT_TYPE_PROPOSED = 1; + // input is a data element referencing an existing scope/record on chain + RECORD_INPUT_TYPE_FACT = 2; +} + +// Tracks the inputs used with a Consideration to establish the output record. +// FACT references must have come from the input fact list. +// For proposed we will only have the hash +message RecordInput { + // Name value included to link back to the definition spec. + string name = 1; + // For proposed facts we only have the hash ... for facts this hash maps to something in the input list. + string hash = 2; + // from proposed fact structure to unmarshal + string classname = 3; + // Indicates if this input was a recorded fact on chain or just a given hashed input + scope.RecordInputType type = 4; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v0/spec.proto b/p8e-api/src/main/proto/provenance/metadata/v0/spec.proto new file mode 100644 index 0000000..06f2579 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v0/spec.proto @@ -0,0 +1,51 @@ +syntax = 'proto3'; + +package spec; + +option go_package = "github.com/provenance-io/provenance/x/metadata/legacy/v039"; +option java_package = "io.provenance.metadata.v0"; +option java_multiple_files = true; + +import "provenance/metadata/v0/types.proto"; + +enum DefinitionSpecType { + DEFINITION_SPEC_TYPE_UNKNOWN = 0; + DEFINITION_SPEC_TYPE_PROPOSED = 1; + DEFINITION_SPEC_TYPE_FACT = 2; + DEFINITION_SPEC_TYPE_FACT_LIST = 3; +} + +message DefinitionSpec { + string name = 1; + types.Location resource_location = 2; + types.Signature signature = 3; + spec.DefinitionSpecType type = 4; +} + +message ContractSpec { + spec.DefinitionSpec definition = 1; + repeated spec.DefinitionSpec input_specs = 2; + repeated types.PartyType parties_involved = 3; + repeated spec.ConditionSpec condition_specs = 4; + repeated spec.ConsiderationSpec consideration_specs = 5; +} + +message ConditionSpec { + string func_name = 1; + repeated spec.DefinitionSpec input_specs = 2; + spec.OutputSpec output_spec = 3; +} + +message ConsiderationSpec { + string func_name = 1; + + // Invoking party + types.PartyType responsible_party = 2; + + repeated spec.DefinitionSpec input_specs = 3; + spec.OutputSpec output_spec = 4; +} + +message OutputSpec { + spec.DefinitionSpec spec = 1; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v0/tx.proto b/p8e-api/src/main/proto/provenance/metadata/v0/tx.proto new file mode 100644 index 0000000..9b97b86 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v0/tx.proto @@ -0,0 +1,61 @@ +syntax = "proto3"; +package tx; + +import "gogoproto/gogo.proto"; +import "provenance/metadata/v0/contract.proto"; +import "provenance/metadata/v0/types.proto"; + +option go_package = "github.com/provenance-io/provenance/x/metadata/legacy/v039"; + +option java_package = "io.provenance.metadata.v0"; +option java_multiple_files = true; + +// Msg defines the Metadata Msg service. +service Msg { + // MemorializeContract records the results of a P8e contract execution as a record group and set of records in a scope + rpc MemorializeContract(MsgMemorializeContractRequest) returns (MemorializeContractResponse); + // ChangeOwnership allows P8e contracts to record a new set of owners on a scope + rpc ChangeOwnership(MsgChangeOwnershipRequest) returns (ChangeOwnershipResponse); +} + +// MsgMemorializeContractRequest is a request from a P8e execution environment to record results of a contract +message MsgMemorializeContractRequest { + // The scope of the object being modified on blockchain. + string scope_id = 1; + // The uuid of the contract execution. + string group_id = 2; + // Unique identifier for determining contract/group execution instance + string execution_id = 3; + // The executed contract. + contract.Contract contract = 4 [(gogoproto.nullable) = false]; + // The contract signatures + types.SignatureSet signatures = 5 [(gogoproto.nullable) = false]; + // ID of the scope snapshot reference for executing + string ScopeRefID = 6; + // The address of the notary (ie the broadcaster of this message). + string notary = 7; +} + +// MemorializeContractResponse from a contract execution memorialization request +message MemorializeContractResponse {} + +// MsgChangeOwnershipRequest records the result of a change ownership p8e contract execution +message MsgChangeOwnershipRequest { + // The scope of the object being modified on blockchain. + string scope_id = 1; + // The uuid of the contract execution. + string group_id = 2; + // Unique identifier for determining contract/group execution instance + string execution_id = 3; + // The recitals to use for the scope parties + contract.Recitals recitals = 4 [(gogoproto.nullable) = false]; + // The executed contract. + contract.Contract contract = 5 [(gogoproto.nullable) = false]; + // The contract signatures + types.SignatureSet signatures = 6 [(gogoproto.nullable) = false]; + // The address of the notary (ie the broadcaster of this message). + string notary = 7; +} + +// ChangeOwnershipResponse from a contract execution ownership change request +message ChangeOwnershipResponse {} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v0/types.proto b/p8e-api/src/main/proto/provenance/metadata/v0/types.proto new file mode 100644 index 0000000..e23f3e7 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v0/types.proto @@ -0,0 +1,112 @@ +syntax = 'proto3'; + +package types; + +option go_package = "github.com/provenance-io/provenance/x/metadata/legacy/v039"; +option java_package = "io.provenance.metadata.v0"; +option java_multiple_files = true; + +// Wrapper for an ISO8601 date string. EX: "2020-05-22" +message Date { + string value = 1; +} + +// Wrapper type for a standard uuid. +message UUID { + string value = 1; +} + +// Wrap a boolean result type. +message BooleanResult { + bool value = 1; +} + +// Wrap a location. +message Location { + types.ProvenanceReference ref = 1; + string classname = 2; +} + +// Wrap a factual data element. +message Fact { + string name = 1; + types.Location data_location = 2; +} + +message ProvenanceReference { + // [Req] [Scope.uuid] + // Scope ID + types.UUID scope_uuid = 1; + // [Opt] [RecordGroup.group_uuid] + // require record to be within a specific group + types.UUID group_uuid = 2; + // [Opt] [Record.result_hash] + // specify a specific record inside a scope (and group) by result-hash + string hash = 3; + // [Opt] [Record.result_name] + // specify a result-name of a record within a scope + string name = 4; +} + +// Wrapper around a standard signature. +message Signature { + // Signature Detail + string algo = 1; + string provider = 2; + string signature = 3; + + // Identity of signer + types.SigningAndEncryptionPublicKeys signer = 4; +} + +// A collection of signatures +message SignatureSet { + repeated Signature signatures = 1; +} + +enum PublicKeyType { ELLIPTIC = 0; } + +enum PublicKeyCurve { + SECP256K1 = 0; + P256 = 1; +} + +message PublicKey { + bytes public_key_bytes = 1; + PublicKeyType type = 2; + PublicKeyCurve curve = 3; +} + +message SigningAndEncryptionPublicKeys { + types.PublicKey signing_public_key = 1; + types.PublicKey encryption_public_key = 2; +} + +enum PartyType { + PARTY_TYPE_UNKNOWN = 0; + PARTY_TYPE_ORIGINATOR = 1; + PARTY_TYPE_SERVICER = 2; + PARTY_TYPE_INVESTOR = 3; + PARTY_TYPE_CUSTODIAN = 4; + PARTY_TYPE_OWNER = 5; + PARTY_TYPE_AFFILIATE = 6; + PARTY_TYPE_OMNIBUS = 7; + PARTY_TYPE_PROVENANCE = 8; + PARTY_TYPE_MARKER = 9; +} + +// Audit +message AuditFields { + GogoTimeHack created_date = 1; + string created_by = 2; + GogoTimeHack updated_date = 3; + string updated_by = 4; + int32 version = 5; + string message = 6; +} + +// proto 3 timestamp structure (hack to get around gogo issues with invalid dates) +message GogoTimeHack { + int64 seconds = 1; + int32 nanos = 2; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/genesis.proto b/p8e-api/src/main/proto/provenance/metadata/v1/genesis.proto new file mode 100644 index 0000000..e037c3b --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/genesis.proto @@ -0,0 +1,34 @@ +syntax = "proto3"; +package provenance.metadata.v1; + +option go_package = "github.com/provenance-io/provenance/x/metadata/types"; + +option java_package = "io.provenance.metadata.v1"; +option java_multiple_files = true; + +import "gogoproto/gogo.proto"; +import "provenance/metadata/v1/metadata.proto"; +import "provenance/metadata/v1/scope.proto"; +import "provenance/metadata/v1/specification.proto"; +import "provenance/metadata/v1/objectstore.proto"; + +// GenesisState defines the account module's genesis state. +message GenesisState { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // params defines all the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; + + // A collection of metadata scopes and specs to create on start + repeated Scope scopes = 2 [(gogoproto.nullable) = false]; + repeated Session sessions = 3 [(gogoproto.nullable) = false]; + repeated Record records = 4 [(gogoproto.nullable) = false]; + + repeated ScopeSpecification scope_specifications = 5 [(gogoproto.nullable) = false]; + repeated ContractSpecification contract_specifications = 6 [(gogoproto.nullable) = false]; + repeated RecordSpecification record_specifications = 7 [(gogoproto.nullable) = false]; + + OSLocatorParams o_s_locator_params = 8 [(gogoproto.nullable) = false]; + repeated ObjectStoreLocator object_store_locators = 9 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/metadata.proto b/p8e-api/src/main/proto/provenance/metadata/v1/metadata.proto new file mode 100644 index 0000000..9899305 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/metadata.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; +package provenance.metadata.v1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/provenance-io/provenance/x/metadata/types"; + +option java_package = "io.provenance.metadata.v1"; +option java_multiple_files = true; + +// Params defines the set of params for the metadata module. +message Params { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; +} diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/objectstore.proto b/p8e-api/src/main/proto/provenance/metadata/v1/objectstore.proto new file mode 100644 index 0000000..bcf43f0 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/objectstore.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; +package provenance.metadata.v1; +import "gogoproto/gogo.proto"; +option go_package = "github.com/provenance-io/provenance/x/metadata/types"; + +option java_package = "io.provenance.metadata.v1"; +option java_multiple_files = true; + +// Defines an Locator object stored on chain, which represents a owner( blockchain address) associated with a endpoint +// uri for it's associated object store. +message ObjectStoreLocator { + // account address the endpoint is owned by + string owner = 1; + // locator endpoint uri + string locator_uri = 2; +} + +// Params defines the parameters for the metadata-locator module methods. +message OSLocatorParams { + uint32 max_uri_length = 1 [ + (gogoproto.customtype) = "uint32", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"max_uri_length\"" + ]; +} diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/p8e/p8e.proto b/p8e-api/src/main/proto/provenance/metadata/v1/p8e/p8e.proto new file mode 100644 index 0000000..4dc600b --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/p8e/p8e.proto @@ -0,0 +1,214 @@ +syntax = "proto3"; +package provenance.metadata.v1.p8e; + +option go_package = "github.com/provenance-io/provenance/x/metadata/types/p8e"; + +option java_package = "io.provenance.metadata.v1.p8e"; +option java_multiple_files = true; + +// This stuff only exists to help facilitate the transition to new stuff. +// It is copied from (or modeled after) old stuff. +// The goal is to remove this entire file (and everything defined in it) in the near future. + +// The rest of the messages defined in here were copied from the old provenance repo. +// Changes: +// * locations of types were updated, e.g. types.PartyType became just PartyType +// * Lots of comments added to conform with new requirements. + +message Contract { + DefinitionSpec definition = 1; + + // Points to the proto for the contractSpec + Fact spec = 2; + + // Invoker of this contract + SigningAndEncryptionPublicKeys invoker = 3; + + // Constructor arguments. + // These are always the output of a previously recorded consideration. + repeated Fact inputs = 4; + + repeated Condition conditions = 5; + repeated Consideration considerations = 6; + + repeated Recital recitals = 7; + + int32 times_executed = 8; + + // This is only set once when the contract is initially executed + Timestamp start_time = 9; +} + +message DefinitionSpec { + string name = 1; + Location resource_location = 2; + Signature signature = 3; + DefinitionSpecType type = 4; +} + +message Fact { + string name = 1; + Location data_location = 2; +} + +message Condition { + string condition_name = 1; + ExecutionResult result = 2; +} + +message Consideration { + string consideration_name = 1; + + // Data pushed to a consideration that will ultimately match the output_spec of the consideration + repeated ProposedFact inputs = 2; + + ExecutionResult result = 3; +} + +message ProposedFact { + string name = 1; + string hash = 2; + string classname = 3; + ProvenanceReference ancestor = 4; +} + +message ExecutionResult { + ProposedFact output = 1; + ExecutionResultType result = 2; + Timestamp recorded_at = 3; + string error_message = 4; +} + +message Recitals { + repeated Recital parties = 1; +} + +message Recital { + PartyType signer_role = 1; + SigningAndEncryptionPublicKeys signer = 2; + bytes address = 3; +} + +message Location { + ProvenanceReference ref = 1; + string classname = 2; +} + +message ProvenanceReference { + // [Req] [Scope.uuid] + // Scope ID + UUID scope_uuid = 1; + // [Opt] [RecordGroup.group_uuid] + // require record to be within a specific group + UUID group_uuid = 2; + // [Opt] [Record.result_hash] + // specify a specific record inside a scope (and group) by result-hash + string hash = 3; + // [Opt] [Record.result_name] + // specify a result-name of a record within a scope + string name = 4; +} + +message SignatureSet { + repeated Signature signatures = 1; +} + +message Signature { + // Signature Detail + string algo = 1; + string provider = 2; + string signature = 3; + + // Identity of signer + SigningAndEncryptionPublicKeys signer = 4; +} + +message SigningAndEncryptionPublicKeys { + PublicKey signing_public_key = 1; + PublicKey encryption_public_key = 2; +} + +message PublicKey { + bytes public_key_bytes = 1; + PublicKeyType type = 2; + PublicKeyCurve curve = 3; +} + +message UUID { + string value = 1; +} + +enum DefinitionSpecType { + DEFINITION_SPEC_TYPE_UNKNOWN = 0; + DEFINITION_SPEC_TYPE_PROPOSED = 1; + DEFINITION_SPEC_TYPE_FACT = 2; + DEFINITION_SPEC_TYPE_FACT_LIST = 3; +} + +enum PublicKeyCurve { + SECP256K1 = 0; + P256 = 1; +} + +enum PublicKeyType { ELLIPTIC = 0; } + +enum ExecutionResultType { + RESULT_TYPE_UNKNOWN = 0; + RESULT_TYPE_PASS = 1; + // Couldn't process the condition/consideration due to missing facts being generated by other considerations. + RESULT_TYPE_SKIP = 2; + RESULT_TYPE_FAIL = 3; +} + +enum PartyType { + PARTY_TYPE_UNKNOWN = 0; + PARTY_TYPE_ORIGINATOR = 1; + PARTY_TYPE_SERVICER = 2; + PARTY_TYPE_INVESTOR = 3; + PARTY_TYPE_CUSTODIAN = 4; + PARTY_TYPE_OWNER = 5; + PARTY_TYPE_AFFILIATE = 6; + PARTY_TYPE_OMNIBUS = 7; + PARTY_TYPE_PROVENANCE = 8; + PARTY_TYPE_MARKER = 9; +} + +// Copied from google/protobuf/timestamp.proto into here because using that version results in generated code looking +// for methods that don't exist: MarshalToSizedBuffer, Size, and Unmarshal. + +// A Timestamp represents a point in time using values relative to the epoch. +message Timestamp { + // Represents seconds of UTC time since Unix epoch + int64 seconds = 1; + + // Non-negative fractions of a second at nanosecond resolution. + int32 nanos = 2; +} + +message ContractSpec { + DefinitionSpec definition = 1; + repeated DefinitionSpec input_specs = 2; + repeated PartyType parties_involved = 3; + repeated ConditionSpec condition_specs = 4; + repeated ConsiderationSpec consideration_specs = 5; +} + +message ConditionSpec { + string func_name = 1; + repeated DefinitionSpec input_specs = 2; + OutputSpec output_spec = 3; +} + +message ConsiderationSpec { + string func_name = 1; + + // Invoking party + PartyType responsible_party = 2; + + repeated DefinitionSpec input_specs = 3; + OutputSpec output_spec = 4; +} + +message OutputSpec { + DefinitionSpec spec = 1; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/query.proto b/p8e-api/src/main/proto/provenance/metadata/v1/query.proto new file mode 100644 index 0000000..01fd2ce --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/query.proto @@ -0,0 +1,357 @@ +syntax = "proto3"; +package provenance.metadata.v1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "google/api/annotations.proto"; +import "provenance/metadata/v1/metadata.proto"; +import "provenance/metadata/v1/scope.proto"; +import "provenance/metadata/v1/specification.proto"; +import "provenance/metadata/v1/objectstore.proto"; + +option go_package = "github.com/provenance-io/provenance/x/metadata/types"; + +option java_package = "io.provenance.metadata.v1"; +option java_multiple_files = true; + +// Query defines the Metadata Query service. +service Query { + // Params queries the parameters of x/metadata module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/provenance/metadata/v1/params"; + } + + // Scope returns a specific scope by id + rpc Scope(ScopeRequest) returns (ScopeResponse) { + option (google.api.http).get = "/provenance/metadata/v1/scope/{scope_uuid}"; + } + + // SessionContextByUUID returns a specific session context within a scope (or all sessions) + rpc SessionContextByUUID(SessionContextByUUIDRequest) returns (SessionContextByUUIDResponse) { + option (google.api.http).get = "/provenance/metadata/v1/scope/uuid/{scope_uuid}/session/{session_uuid}"; + } + + // SessionContextByID returns a specific session context within a scope (or all sessions) + rpc SessionContextByID(SessionContextByIDRequest) returns (SessionContextByIDResponse) { + option (google.api.http).get = "/provenance/metadata/v1/scope/id/{scope_id}/session/{session_id}"; + } + + // RecordsByScopeUUID returns a collection of the records in a scope by scope uuid or a specific one by name + rpc RecordsByScopeUUID(RecordsByScopeUUIDRequest) returns (RecordsByScopeUUIDResponse) { + option (google.api.http).get = "/provenance/metadata/v1/scope/uuid/{scope_uuid}/records/{name}"; + } + + // RecordsByScopeID returns a collection of the records in a scope by scope bech32 id or a specific one by name + rpc RecordsByScopeID(RecordsByScopeIDRequest) returns (RecordsByScopeIDResponse) { + option (google.api.http).get = "/provenance/metadata/v1/scope/id/{scope_id}/records/{name}"; + } + + // Ownership returns a list of scope identifiers that list the given address as a data or value owner + rpc Ownership(OwnershipRequest) returns (OwnershipResponse) { + option (google.api.http).get = "/provenance/metadata/v1/ownership/{address}"; + } + + // ValueOwnership returns a list of scope identifiers that list the given address as the value owner + rpc ValueOwnership(ValueOwnershipRequest) returns (ValueOwnershipResponse) { + option (google.api.http).get = "/provenance/metadata/v1/valueownership/{address}"; + } + + // ScopeSpecification returns a scope specification for the given specification uuid + rpc ScopeSpecification(ScopeSpecificationRequest) returns (ScopeSpecificationResponse) { + option (google.api.http).get = "/provenance/metadata/v1/scopespec/{specification_uuid}"; + } + + // ContractSpecification returns a contract specification for the given specification uuid + rpc ContractSpecification(ContractSpecificationRequest) returns (ContractSpecificationResponse) { + option (google.api.http).get = "/provenance/metadata/v1/contractspec/{specification_uuid}"; + } + + // ContractSpecification returns a contract specification and record specifications for the given contract + // specification uuid + rpc ContractSpecificationExtended(ContractSpecificationExtendedRequest) + returns (ContractSpecificationExtendedResponse) { + option (google.api.http).get = "/provenance/metadata/v1/contractspec/{specification_uuid}/extended"; + } + + // RecordSpecificationsForContractSpecification returns the record specifications for the given contract specification + // uuid + rpc RecordSpecificationsForContractSpecification(RecordSpecificationsForContractSpecificationRequest) + returns (RecordSpecificationsForContractSpecificationResponse) { + option (google.api.http).get = "/provenance/metadata/v1/contractspec/{contract_specification_uuid}/recordspecs"; + } + + // RecordSpecification returns a record specification for the given contract specification uuid and record name + rpc RecordSpecification(RecordSpecificationRequest) returns (RecordSpecificationResponse) { + option (google.api.http).get = "/provenance/metadata/v1/recordspec/{contract_specification_uuid}/{name}"; + } + + // RecordSpecificationByID returns a record specification for the given record specification id + rpc RecordSpecificationByID(RecordSpecificationByIDRequest) returns (RecordSpecificationByIDResponse) { + option (google.api.http).get = "/provenance/metadata/v1/recordspec/id/{record_specification_id}"; + } + + // ---- OS locator methods ----- + // Params queries all parameters for os locator sub module. + rpc OSLocatorParams(OSLocatorParamsRequest) returns (OSLocatorParamsResponse) { + option (google.api.http).get = "/provenance/metadata/v1/locator/params"; + } + + // for querying oslocator by address. + rpc OSLocator(OSLocatorRequest) returns (OSLocatorResponse) { + option (google.api.http).get = "/provenance/metadata/v1/locator/{owner}"; + } + + // for querying oslocator by uri. + rpc OSLocatorByURI(OSLocatorByURIRequest) returns (OSLocatorByURIResponse) { + option (google.api.http).get = "/provenance/metadata/v1/locator/uri/{uri}"; + } + // for querying all the oslocator for all signer's present in a scope uuid. + rpc OSLocatorByScopeUUID(OSLocatorByScopeUUIDRequest) returns (OSLocatorByScopeUUIDResponse) { + option (google.api.http).get = "/provenance/metadata/v1/locator/scope/{scope_uuid}"; + } + + // get all os locators + rpc OSAllLocators(OSAllLocatorsRequest) returns (OSAllLocatorsResponse) { + option (google.api.http).get = "/provenance/metadata/v1/locators/all"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// AllOSLocatorsRequest get all os locator's request. +message OSAllLocatorsRequest { + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; +} + +// ScopeRequest is used for requesting a scope by id +message ScopeRequest { + string scope_uuid = 1 [(gogoproto.moretags) = "yaml:\"scope_uuid\""]; +} + +// OSLocatorScopeRequest is used for requesting all the OSLocator associated with a scope_id +message OSLocatorByScopeUUIDRequest { + string scope_uuid = 1 [(gogoproto.moretags) = "yaml:\"scope_uuid\""]; +} + +// ScopeResponse is the response to a scope request. +message ScopeResponse { + Scope scope = 1; + repeated Session sessions = 2; + repeated Record records = 3; + string scope_uuid = 4 [(gogoproto.moretags) = "yaml:\"scope_uuid\""]; +} + +// OwnershipRequest looks for all scope level resources associated with the given addrss +message OwnershipRequest { + string address = 1; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// OwnershipResponse is the reponse to the ownership request and includes a list of scope identifiers +message OwnershipResponse { + // A list of scope ids (uuid) associated with the given address. + repeated string scope_uuids = 1 [(gogoproto.moretags) = "yaml:\"scope_uuids\""]; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// ValueOwnershipRequest looks for all scope level resources that have the address as the value owner +message ValueOwnershipRequest { + string address = 1; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// ValueOwnershipResponse is the reponse to the Valueownership request and includes a list of scope identifiers +message ValueOwnershipResponse { + // A list of scope ids (uuid) associated with the given address. + repeated string scope_uuids = 1 [(gogoproto.moretags) = "yaml:\"scope_uuids\""]; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// SessionContextByUUIDRequest returns the record sessions for a given scope identifer or optionally a specific record +// session +message SessionContextByUUIDRequest { + string scope_uuid = 1 [(gogoproto.moretags) = "yaml:\"scope_uuid\""]; + string session_uuid = 2 [(gogoproto.moretags) = "yaml:\"session_uuid\""]; +} + +// SessionContextByUUIDResponse is the response to a SessionContextByUUIDRequest +message SessionContextByUUIDResponse { + string scope_id = 1 [(gogoproto.moretags) = "yaml:\"scope_id\""]; + string session_id = 2 [(gogoproto.moretags) = "yaml:\"session_id\""]; + + repeated Session sessions = 3; +} + +// SessionContextByIDRequest returns the record sessions for a given scope identifer or optionally a specific record +// session +message SessionContextByIDRequest { + string scope_id = 1 [(gogoproto.moretags) = "yaml:\"scope_id\""]; + string session_id = 2 [(gogoproto.moretags) = "yaml:\"session_id\""]; +} + +// SessionContextByIDResponse is the response to a SessionContextByIDRequest +message SessionContextByIDResponse { + string scope_id = 1 [(gogoproto.moretags) = "yaml:\"scope_id\""]; + string session_id = 2 [(gogoproto.moretags) = "yaml:\"session_id\""]; + repeated Session sessions = 3; +} + +// RecordsByScopeUUIDRequest is a request for all of the records in a specific scope by uuid or a specific record if a +// name is given. +message RecordsByScopeUUIDRequest { + string scope_uuid = 1 [(gogoproto.moretags) = "yaml:\"scope_uuid\""]; + string name = 2; +} + +// RecordsByScopeUUIDResponse is the response to a RecordsByScopeUUIDRequest +message RecordsByScopeUUIDResponse { + string scope_uuid = 1 [(gogoproto.moretags) = "yaml:\"scope_uuid\""]; + string scope_id = 2 [(gogoproto.moretags) = "yaml:\"scope_id\""]; + repeated Record records = 3; +} + +// RecordsByScopeIDRequest is a request for all of the records in a specific scope by bech32 id or a specific record if +// a name is given. +message RecordsByScopeIDRequest { + string scope_id = 1 [(gogoproto.moretags) = "yaml:\"scope_id\""]; + string name = 2; +} + +// RecordsByScopeIDResponse is the response to a RecordsByScopeIDRequest +message RecordsByScopeIDResponse { + string scope_uuid = 1 [(gogoproto.moretags) = "yaml:\"scope_uuid\""]; + string scope_id = 2 [(gogoproto.moretags) = "yaml:\"scope_id\""]; + repeated Record records = 3; +} + +// ScopeSpecificationRequest is used for requesting a scope specification by uuid +message ScopeSpecificationRequest { + string specification_uuid = 1 [(gogoproto.moretags) = "yaml:\"specification_uuid\""]; +} + +// ScopeSpecification is the response to a scope specification request. +message ScopeSpecificationResponse { + ScopeSpecification scope_specification = 1 [(gogoproto.moretags) = "yaml:\"scope_specification\""]; + string specification_uuid = 2 [(gogoproto.moretags) = "yaml:\"specification_uuid\""]; +} + +// ContractSpecificationRequest is used for requesting a contract specification by uuid +message ContractSpecificationRequest { + string specification_uuid = 1 [(gogoproto.moretags) = "yaml:\"specification_uuid\""]; +} + +// ContractSpecificationResponse is the response to a contract specification request. +message ContractSpecificationResponse { + ContractSpecification contract_specification = 1 [(gogoproto.moretags) = "yaml:\"contract_specification\""]; + string contract_specification_uuid = 2 [(gogoproto.moretags) = "yaml:\"contract_specification_uuid\""]; +} + +// ContractSpecificationExtendedRequest is used for requesting a contract specification with extended data by contract +// specification uuid +message ContractSpecificationExtendedRequest { + string specification_uuid = 1 [(gogoproto.moretags) = "yaml:\"specification_uuid\""]; +} + +// ContractSpecificationExtendedResponse is the response to a contract specification extended request. +message ContractSpecificationExtendedResponse { + ContractSpecification contract_specification = 1 [(gogoproto.moretags) = "yaml:\"contract_specification\""]; + repeated RecordSpecification record_specifications = 2 [(gogoproto.moretags) = "yaml:\"record_specifications\""]; + string contract_specification_uuid = 3 [(gogoproto.moretags) = "yaml:\"contract_specification_uuid\""]; +} + +// RecordSpecificationsForContractSpecificationRequest is used for requesting record specifications by contract +// specification uuid +message RecordSpecificationsForContractSpecificationRequest { + string contract_specification_uuid = 1 [(gogoproto.moretags) = "yaml:\"contract_specification_uuid\""]; +} + +// RecordSpecificationResponseResponse is the response to a record specification for contract specification request. +message RecordSpecificationsForContractSpecificationResponse { + repeated RecordSpecification record_specifications = 1 [(gogoproto.moretags) = "yaml:\"record_specifications\""]; + string contract_specification_uuid = 2 [(gogoproto.moretags) = "yaml:\"contract_specification_uuid\""]; +} + +// RecordSpecificationRequest is used for requesting a record specification by contract spec uuid and record name +message RecordSpecificationRequest { + string contract_specification_uuid = 1 [(gogoproto.moretags) = "yaml:\"contract_specification_uuid\""]; + string name = 2; +} + +// RecordSpecificationResponse is the response to a record specification request. +message RecordSpecificationResponse { + RecordSpecification record_specification = 1 [(gogoproto.moretags) = "yaml:\"record_specification\""]; + string contract_specification_uuid = 2 [(gogoproto.moretags) = "yaml:\"contract_specification_uuid\""]; + string name = 3; +} + +// RecordSpecificationByIDRequest is used for requesting a record specification by id +message RecordSpecificationByIDRequest { + string record_specification_id = 1 [(gogoproto.moretags) = "yaml:\"record_specification_id\""]; +} + +// RecordSpecificationByIDResponse is the response to a record specification by id request. +message RecordSpecificationByIDResponse { + RecordSpecification record_specification = 1 [(gogoproto.moretags) = "yaml:\"record_specification\""]; + string record_specification_id = 2 [(gogoproto.moretags) = "yaml:\"record_specification_id\""]; +} + +// OSLocationRequest is used for requesting a Objectstore location by owner +message OSLocatorRequest { + string owner = 1; +} + +// OSLocatorByURIRequest get os locator's by uri +message OSLocatorByURIRequest { + string uri = 1; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// OSLocatorResponse is the response to a os locator request. +message OSLocatorResponse { + ObjectStoreLocator locator = 1; +} + +// OSLocatorParamsRequest is the request type for the Query/Params RPC method. +message OSLocatorParamsRequest {} + +// OSLocatorParamsResponse is the response type for the Query/Params RPC method. +message OSLocatorParamsResponse { + // params defines the parameters of the module. + OSLocatorParams params = 1 [(gogoproto.nullable) = false]; +} + +// OSLocatorByURIResponse is an array of ObjectStoreLocator with pagination info +message OSLocatorByURIResponse { + repeated ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// OSLocatorByScopeUUIDResponse is an array of ObjectStoreLocator. +message OSLocatorByScopeUUIDResponse { + repeated ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; +} + +// OSAllLocatorsResponse is an array of ObjectStoreLocator with pagination info +message OSAllLocatorsResponse { + repeated ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/scope.proto b/p8e-api/src/main/proto/provenance/metadata/v1/scope.proto new file mode 100644 index 0000000..218ef1e --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/scope.proto @@ -0,0 +1,240 @@ +syntax = "proto3"; +package provenance.metadata.v1; + +option go_package = "github.com/provenance-io/provenance/x/metadata/types"; + +option java_package = "io.provenance.metadata.v1"; +option java_multiple_files = true; + +import "gogoproto/gogo.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/descriptor.proto"; +import "provenance/metadata/v1/specification.proto"; + +/** + +Overview + +The structures in this file are used to efficiently store the data for the metadata module. The structure the core +concept of the Metadata module is a Scope that contains a list of Records/Facts. Updates to scopes are performed +in a session with details persisted in a Session. Each session contains a specification that details +constraints on parties that must sign, inputs, and outputs that can be recorded. Each Scope may contain a list of +allowed specifications that may be used. + + +Data Structures + + Metadata Scope + + A metadata scope contains a collection of records of data, each made up of a hash, data type, and ownership + information that establishes provenance. + + Sessions + + Typically multiple records will be established within a scope at the same time (see: Contract Memorialization). A + Session contains context for the recording of these records linking a set of records into a common process/ + execution associated with a specification indicating allowed and required values. + + Record + + A single record collects information about a process that generated it, a collection of inputs, and one or more + outputs into a structure identified by a name that is unique within a scope. + + +KVStore State Data + +Iterators +- Get All Scopes () []Scope +- Get All Sessions (:) []Session + * This method would be used to list all current session/transaction contexts with Records set on the scope +- Get All Scope Records (:) : []Record + + +Direct Access +- Get Scope (:) Scope +- Get Session (::) : Session +- Get Record (::) : Record + + +Indexes (special kvstore records for efficient cross reference/queries) +- Get Session Records - use filtered iterator over all scope records +- Get all scopes for a party/address? +- Get all scopes of a specific type (scope spec)? +- Get all sessions of a specific specification type? +- Get all Records of a type? + + +*/ + +// Scope defines a root reference for a collection of records owned by one or more parties. +message Scope { + option (gogoproto.goproto_stringer) = false; + + // Unique ID for this scope. Implements sdk.Address interface for use where addresses are required in Cosmos + bytes scope_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"scope_id\"" + ]; + // the scope specification that contains the specifications for data elements allowed within this scope + bytes specification_id = 2 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + // These parties represent top level owners of the records within. These parties must sign any requests that modify + // the data within the scope. These addresses are in union with parties listed on the sessions. + repeated Party owners = 3 [(gogoproto.nullable) = false]; + // Addessses in this list are authorized to recieve off-chain data associated with this scope. + repeated string data_access = 4 [(gogoproto.moretags) = "yaml:\"data_access\""]; + // An address that controls the value associated with this scope. Standard blockchain accounts and marker accounts + // are supported for this value. This attribute may only be changed by the entity indicated once it is set. + string value_owner_address = 5 [(gogoproto.moretags) = "yaml:\"value_owner_address\""]; +} + +/* +A Session is created for an execution context against a specific specification instance + +The context will have a specification and set of parties involved. The Session may be updated several +times so long as the parties listed are signers on the transaction. NOTE: When there are no Records within a Scope +that reference a Session it is removed. +*/ +message Session { + option (gogoproto.goproto_stringer) = false; + + bytes session_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "json:\"session_id\" yaml:\"session_id\"" + ]; + // unique id of the contract specification that was used to create this session. + bytes specification_id = 2 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + // Set of identities that signed this contract + repeated Party parties = 3 [(gogoproto.nullable) = false]; + // name to associate with this session execution context, typically classname + string name = 4 [(gogoproto.jsontag) = "type", (gogoproto.moretags) = "yaml:\"type\""]; + // Created by, updated by, timestamps, version number, and related info. + AuditFields audit = 99 [(gogoproto.moretags) = "json:\"audit,omitempty\" yaml:\"audit,omitempty\""]; +} + +// A record (of fact) is attached to a session or each consideration output from a contract +message Record { + option (gogoproto.goproto_stringer) = false; + + // name/identifier for this record. Value must be unique within the scope. Also known as a Fact name + string name = 1 [(gogoproto.jsontag) = "id", (gogoproto.moretags) = "yaml:\"id\""]; + // id of the session context that was used to create this record (use with filtered kvprefix iterator) + bytes session_id = 2 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "json:\"session_id\" yaml:\"session_id\"" + ]; + // process contain information used to uniquely identify an execution on or off chain that generated this record + Process process = 3 [(gogoproto.nullable) = false]; + // inputs used with the process to achieve the output on this record + repeated RecordInput inputs = 4 [(gogoproto.nullable) = false]; + // output(s) is the results of executing the process on the given process indicated in this record + repeated RecordOutput outputs = 5 [(gogoproto.nullable) = false]; +} + +// Process contains information used to uniquely identify what was used to generate this record +message Process { + option (gogoproto.goproto_stringer) = false; + // unique identifier for this process + oneof process_id { + // the address of a smart contract used for this process + string address = 1; + // the hash of an off-chain process used + string hash = 2; + } + // a name associated with the process (type_name, classname or smart contract common name) + string name = 3; + // method is a name or reference to a specific operation (method) within a class/contract that was invoked + string method = 4; +} + +// Tracks the inputs used to establish this record +message RecordInput { + option (gogoproto.goproto_stringer) = false; + // Name value included to link back to the definition spec. + string name = 1; + // data source + oneof source { + // the address of a record on chain (For Established Records) + bytes record_id = 2 + [(gogoproto.customtype) = "MetadataAddress", (gogoproto.moretags) = "json:\"record_id\" yaml:\"record_id\""]; + // the hash of an off-chain piece of information (For Proposed Records) + string hash = 3; + } + // from proposed fact structure to unmarshal + string type_name = 4 [(gogoproto.moretags) = "yaml:\"type_name\""]; + // Indicates if this input was a recorded fact on chain or just a given hashed input + RecordInputStatus status = 5; +} + +// A set of types for inputs on a record (of fact) +enum RecordInputStatus { + // RECORD_INPUT_STATUS_UNSPECIFIED indicates an invalid/unknown input type + RECORD_INPUT_STATUS_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unknown"]; + // RECORD_INPUT_STATUS_PROPOSED indicates this input was an arbitrary piece of data that was hashed + RECORD_INPUT_STATUS_PROPOSED = 1 [(gogoproto.enumvalue_customname) = "Proposed"]; + // RECORD_INPUT_STATUS_RECORD indicates this input is a reference to a previously recorded fact on blockchain + RECORD_INPUT_STATUS_RECORD = 2 [(gogoproto.enumvalue_customname) = "Record"]; +} + +// RecordOutput encapsulates the output of a process recorded on chain +message RecordOutput { + option (gogoproto.goproto_stringer) = false; + + // Hash of the data output that was output/generated for this record + string hash = 1; + // Status of the process execution associated with this output indicating success,failure, or pending + ResultStatus status = 2; +} + +// ResultStatus indicates the various states of execution of a record +enum ResultStatus { + // RESULT_STATUS_UNSPECIFIED indicates an unset condition + RESULT_STATUS_UNSPECIFIED = 0; + // RESULT_STATUS_PASS indicates the execution was successfult + RESULT_STATUS_PASS = 1; + // RESULT_STATUS_SKIP indicates condition/consideration was skipped due to missing inputs or delayed execution + RESULT_STATUS_SKIP = 2; + // RESULT_STATUS_FAIL indicates the execution of the condition/consideration failed. + RESULT_STATUS_FAIL = 3; +} + +// A Party is an address with/in a given role associated with a contract +message Party { + option (gogoproto.goproto_stringer) = false; + + // address of the account (on chain) + string address = 1; + // a role for this account within the context of the processes used + PartyType role = 2; +} + +// AuditFields capture information about the last account to make modifications and when they were made +message AuditFields { + // the date/time when this entry was created + google.protobuf.Timestamp created_date = 1 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"created_date\""]; + // the address of the account that created this record + string created_by = 2 [(gogoproto.moretags) = "yaml:\"created_by\""]; + // the date/time when this entry was last updated + google.protobuf.Timestamp updated_date = 3 [ + (gogoproto.stdtime) = true, + (gogoproto.nullable) = false, + (gogoproto.moretags) = "json:\"updated_date,omitempty\" yaml:\"updated_date,omitempty\"" + ]; + // the address of the account that modified this record + string updated_by = 4 [(gogoproto.moretags) = "json:\"updated_by,omitempty\" yaml:\"updated_by,omitempty\""]; + // an optional version number that is incremented with each update + uint32 version = 5; + // an optional message associated with the creation/update event + string message = 6 [(gogoproto.moretags) = "json:\"message,omitempty\" yaml:\"message,omitempty\""]; +} diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/specification.proto b/p8e-api/src/main/proto/provenance/metadata/v1/specification.proto new file mode 100644 index 0000000..1308d05 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/specification.proto @@ -0,0 +1,175 @@ +syntax = "proto3"; +package provenance.metadata.v1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/provenance-io/provenance/x/metadata/types"; +option java_package = "io.provenance.metadata.v1"; +option java_multiple_files = true; + +// Specifications are a heirarchy of references to existing on chain data as well as a list of requirements that +// incoming requests to record data against a scope must meet. Typical requirements included hashes that must be +// supplied corosponding to process/executable that must be ran, required signatures and sources of accounts that +// must sign requests, and allowed attributes/records that may be added to a scope. +// +// Scope Specification +// The top level specification for a scope indicates a set of allowed ContractSpecifications (see add contract spec) +// that are allowed to be used against a given scope to perform updates. Requests to record data that do not derive +// from these contractspecifications are not allowed. +// +// Record Specification +// The specifics of which records are allowed within a group (and by extension the scope overall) are outlined using +// Consideration_Specs. These considerations include required inputs, output format, and parties that must be +// associated with any request to record. +// +// Contract Specification +// The primary function of contract specifications is to denote the Contracts/Processes that will be used to manage +// the data within a scope. These specifications control what information may be recorded on chain. The use of +// definitions for inputs can build a chain of data references that must be in place in order for records to be +// added to the chain. +// +// Example: +// A ContractSpecification may list a RecordSpecification that requires an input of type "Record" (indicating a +// reference to a scope/record must exist on chain) in order for a specific Consideration (process/method) to be +// executed and have an output_spec ultimately result in a record added to the scope. + +// ScopeSpecification defines the required parties, resources, conditions, and consideration outputs for a contract +message ScopeSpecification { + option (gogoproto.goproto_stringer) = false; + + // unique identifier for this specification on chain + bytes specification_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + // General information about this scope specification. + Description description = 2; + // Addresses of the owners of this scope specification. + repeated string owner_addresses = 3 [(gogoproto.moretags) = "yaml:\"owner_addresses\""]; + // A list of parties that must be present on a scope (and their associated roles) + repeated PartyType parties_involved = 4 [(gogoproto.moretags) = "yaml:\"parties_involved\""]; + // A list of contract specification ids allowed for a scope based on this specification. + repeated bytes contract_spec_ids = 5 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"contract_spec_ids\"" + ]; +} + +// ContractSpecification defines the required parties, resources, conditions, and consideration outputs for a contract +message ContractSpecification { + option (gogoproto.goproto_stringer) = false; + + // unique identifier for this specification on chain + bytes specification_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + // Description information for this contract specification + Description description = 2; + // Address of the account that owns this specificaiton + repeated string owner_addresses = 3 [(gogoproto.moretags) = "yaml:\"owner_addresses\""]; + // a list of party roles that must be fullfilled when signing a transaction for this contract specification + repeated PartyType parties_involved = 4 [(gogoproto.moretags) = "yaml:\"parties_involved\""]; + // Reference to a metadata record with a hash and type information for the instance of code that will process this + // contract + oneof source { + // the address of a record on chain that represents this contract + bytes resource_id = 5 [(gogoproto.customtype) = "MetadataAddress", (gogoproto.moretags) = "yaml:\"resource_id\""]; + // the hash of contract binary (off-chain instance) + string hash = 6; + } + // name of the class/type of this contract executable + string class_name = 7 [(gogoproto.moretags) = "yaml:\"class_name\""]; +} + +// RecordSpecification defines the specification for a Record including allowed/required inputs/outputs +message RecordSpecification { + option (gogoproto.goproto_stringer) = false; + + // unique identifier for this specification on chain + bytes specification_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + // Name of Record that will be created when this specification is used + string name = 2; + // A set of inputs that must be satisified to apply this RecordSpecification and create a Record + repeated InputSpecification inputs = 3; + // A type name for data associated with this record (typically a class or proto name) + string type_name = 4 [(gogoproto.moretags) = "yaml:\"type_name\""]; + // Type of result for this record specification (must be RECORD or RECORD_LIST) + DefinitionType result_type = 5 [(gogoproto.moretags) = "yaml:\"result_type\""]; + // Type of party responsible for this record + repeated PartyType responsible_parties = 6 [(gogoproto.moretags) = "yaml:\"responsible_parties\""]; +} + +// InputSpecification defines a name, type_name, and source reference (either on or off chain) to define an input +// parameter +message InputSpecification { + option (gogoproto.goproto_stringer) = false; + + // name for this input + string name = 1; + // a type_name (typically a proto name or class_name) + string type_name = 2 [(gogoproto.moretags) = "yaml:\"type_name\""]; + // source is either on chain (record_id) or off-chain (hash) + oneof source { + // the address of a record on chain (For Established Records) + bytes record_id = 3 [(gogoproto.customtype) = "MetadataAddress", (gogoproto.moretags) = "yaml:\"record_id\""]; + // the hash of an off-chain piece of information (For Proposed Records) + string hash = 4; + } +} + +// Description holds general information that is handy to associate with a structure. +message Description { + option (gogoproto.goproto_stringer) = false; + + // A Name for this thing. + string name = 1; + // A description of this thing. + string description = 3; + // URL to find even more info. + string website_url = 4 [(gogoproto.moretags) = "yaml:\"website_url\""]; + // URL of an icon. + string icon_url = 5 [(gogoproto.moretags) = "yaml:\"icon_url\""]; +} + +// DefinitionType indicates the required definition type for this value +enum DefinitionType { + // DEFINITION_TYPE_UNSPECIFIED indicates an unknown/invalid value + DEFINITION_TYPE_UNSPECIFIED = 0; + // DEFINITION_TYPE_PROPOSED indicates a proposed value is used here (a record that is not on-chain) + DEFINITION_TYPE_PROPOSED = 1; + // DEFINITION_TYPE_RECORD indicates the value must be a reference to a record on chain + DEFINITION_TYPE_RECORD = 2; + // DEFINITION_TYPE_RECORD_LIST indicates the value maybe a reference to a collection of values on chain having + // the same name + DEFINITION_TYPE_RECORD_LIST = 3; +} + +// PartyType are the different roles parties on a contract may use +enum PartyType { + // PARTY_TYPE_UNSPECIFIED is an error condition + PARTY_TYPE_UNSPECIFIED = 0; + // PARTY_TYPE_ORIGINATOR is an asset originator + PARTY_TYPE_ORIGINATOR = 1; + // PARTY_TYPE_SERVICER provides debt servicing functions + PARTY_TYPE_SERVICER = 2; + // PARTY_TYPE_INVESTOR is a generic investor + PARTY_TYPE_INVESTOR = 3; + // PARTY_TYPE_CUSTODIAN is an entity that provides custodian services for assets + PARTY_TYPE_CUSTODIAN = 4; + // PARTY_TYPE_OWNER indicates this party is an owner of the item + PARTY_TYPE_OWNER = 5; + // PARTY_TYPE_AFFILIATE is a party with an affiliate agreement + PARTY_TYPE_AFFILIATE = 6; + // PARTY_TYPE_OMNIBUS is a special type of party that controls an omnibus bank account + PARTY_TYPE_OMNIBUS = 7; + // PARTY_TYPE_PROVENANCE is used to indicate this party represents the blockchain or a smart contract action + PARTY_TYPE_PROVENANCE = 8; +} diff --git a/p8e-api/src/main/proto/provenance/metadata/v1/tx.proto b/p8e-api/src/main/proto/provenance/metadata/v1/tx.proto new file mode 100644 index 0000000..3301642 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/metadata/v1/tx.proto @@ -0,0 +1,332 @@ +syntax = "proto3"; +package provenance.metadata.v1; + +import "gogoproto/gogo.proto"; +import "provenance/metadata/v1/scope.proto"; +import "provenance/metadata/v1/specification.proto"; +import "provenance/metadata/v1/p8e/p8e.proto"; + +import "provenance/metadata/v1/objectstore.proto"; + +option go_package = "github.com/provenance-io/provenance/x/metadata/types"; + +option java_package = "io.provenance.metadata.v1"; +option java_multiple_files = true; + +// Msg defines the Metadata Msg service. +service Msg { + // AddScope adds a new scope + rpc AddScope(MsgAddScopeRequest) returns (MsgAddScopeResponse); + // DeleteScope deletes a scope and all associated Records, Sessions + rpc DeleteScope(MsgDeleteScopeRequest) returns (MsgDeleteScopeResponse); + + // AddSession adds a new session context to a scope + rpc AddSession(MsgAddSessionRequest) returns (MsgAddSessionResponse); + // AddRecord adds a set of records in a session within a scope + rpc AddRecord(MsgAddRecordRequest) returns (MsgAddRecordResponse); + // DeleteRecord deletes a record in a session + rpc DeleteRecord(MsgDeleteRecordRequest) returns (MsgDeleteRecordResponse); + + // AddScopeSpecification adds a scope specification + rpc AddScopeSpecification(MsgAddScopeSpecificationRequest) returns (MsgAddScopeSpecificationResponse); + // DeleteScopeSpecification deletes a scope specification + rpc DeleteScopeSpecification(MsgDeleteScopeSpecificationRequest) returns (MsgDeleteScopeSpecificationResponse); + + // AddContractSpecification adds a contract specification + rpc AddContractSpecification(MsgAddContractSpecificationRequest) returns (MsgAddContractSpecificationResponse); + // DeleteContractSpecification deletes a contract specification + rpc DeleteContractSpecification(MsgDeleteContractSpecificationRequest) + returns (MsgDeleteContractSpecificationResponse); + + // AddRecordSpecification adds a record specification + rpc AddRecordSpecification(MsgAddRecordSpecificationRequest) returns (MsgAddRecordSpecificationResponse); + // DeleteRecordSpecification deletes a record specification + rpc DeleteRecordSpecification(MsgDeleteRecordSpecificationRequest) returns (MsgDeleteRecordSpecificationResponse); + + // AddP8eContractSpec adds a P8e v39 contract spec as a v40 ContractSpecification + rpc AddP8eContractSpec(MsgAddP8eContractSpecRequest) returns (MsgAddP8eContractSpecResponse) { + option deprecated = true; + }; + // P8EMemorializeContract records the results of a P8e contract execution as a session and set of records in a scope + // It only exists to help facilitate the transition. The MemorializeContract is the one to use now. + rpc P8eMemorializeContract(MsgP8eMemorializeContractRequest) returns (MsgP8eMemorializeContractResponse) { + option deprecated = true; + }; + + // Os Locator + // BindOSLocator binds a owner address to a uri. + rpc BindOSLocator(MsgBindOSLocatorRequest) returns (MsgBindOSLocatorResponse); + // DeleteOSLocator defines a method to delete existing OSLocator record by the current owner. + rpc DeleteOSLocator(MsgDeleteOSLocatorRequest) returns (MsgDeleteOSLocatorResponse); + // Modify existing OSLocator record by the current owner + rpc ModifyOSLocator(MsgModifyOSLocatorRequest) returns (MsgModifyOSLocatorResponse); +} + +// MsgAddScopeRequest adds a new scope +message MsgAddScopeRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + Scope scope = 1 [(gogoproto.nullable) = false]; + repeated string signers = 2; +} + +// MsgAddScopeResponse from an add scope request +message MsgAddScopeResponse {} + +// MsgDeleteScopeRequest deletes a scope +message MsgDeleteScopeRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // Unique ID for the scope to delete + bytes scope_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"scope_id\"" + ]; + repeated string signers = 2; +} + +// MsgDeleteScopeResponse from a delete scope request +message MsgDeleteScopeResponse {} + +// MsgAddSessionRequest adds a new session +message MsgAddSessionRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + Session session = 1; + repeated string signers = 2; +} + +// MsgAddSessionResponse from an add session request +message MsgAddSessionResponse {} + +// MsgAddRecordRequest is a request to add a session of records to a scope +message MsgAddRecordRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + bytes session_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"session_id\"" + ]; + + Record record = 2; + repeated string signers = 3; +} + +// MsgAddRecordResponse from an add records request +message MsgAddRecordResponse {} + +// MsgDeleteRecordRequest is a request to add a session of records to a scope +message MsgDeleteRecordRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + bytes record_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"record_id\"" + ]; + + repeated string signers = 2; +} + +// MsgDeleteRecordResponse from a delete record request +message MsgDeleteRecordResponse {} + +// MsgAddScopeSpecificationRequest is a request to add a scope specification +message MsgAddScopeSpecificationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + ScopeSpecification specification = 1 [(gogoproto.nullable) = false]; + repeated string signers = 2; +} + +// MsgAddScopeSpecificationResponse from an add scope specification request +message MsgAddScopeSpecificationResponse {} + +// MsgDeleteScopeSpecificationRequest deletes a scope specification +message MsgDeleteScopeSpecificationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // MetadataAddress for the scope specification to delete. + bytes specification_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + repeated string signers = 2; +} + +// MsgDeleteScopeSpecificationResponse from a delete scope specification request +message MsgDeleteScopeSpecificationResponse {} + +// MsgAddContractSpecificationRequest is a request to add a contract specification +message MsgAddContractSpecificationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + ContractSpecification specification = 1 [(gogoproto.nullable) = false]; + repeated string signers = 2; +} + +// AddContractSpecificationResponse from an add contract specification request +message MsgAddContractSpecificationResponse {} + +// MsgDeleteContractSpecificationRequest deletes a contract specification +message MsgDeleteContractSpecificationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // MetadataAddress for the contract specification to delete. + bytes specification_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + repeated string signers = 2; +} + +// MsgDeleteContractSpecificationResponse from a delete contract specification request +message MsgDeleteContractSpecificationResponse {} + +// MsgAddRecordSpecificationRequest is a request to add a record specification +message MsgAddRecordSpecificationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + RecordSpecification specification = 1 [(gogoproto.nullable) = false]; + repeated string signers = 2; +} + +// MsgAddRecordSpecificationResponse from an add record specification request +message MsgAddRecordSpecificationResponse {} + +// MsgDeleteRecordSpecificationRequest deletes a record specification +message MsgDeleteRecordSpecificationRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // MetadataAddress for the record specification to delete. + bytes specification_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "MetadataAddress", + (gogoproto.moretags) = "yaml:\"specification_id\"" + ]; + repeated string signers = 2; +} + +// MsgDeleteRecordSpecificationResponse from a delete record specification request +message MsgDeleteRecordSpecificationResponse {} + +// MsgAddP8eContractSpecRequest records the result of a change ownership p8e contract execution +message MsgAddP8eContractSpecRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // ContractSpec v39 p8e ContractSpect to be converted into a v40 + p8e.ContractSpec contractspec = 1 [(gogoproto.nullable) = false]; + repeated string signers = 2; +} + +// MsgAddP8eContractSpecResponse returns a successful response +message MsgAddP8eContractSpecResponse {} + +// MsgP8eMemorializeContractRequest is the input for a P8eMemorializeContract call +message MsgP8eMemorializeContractRequest { + option deprecated = true; + option (gogoproto.equal) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + option (gogoproto.goproto_getters) = false; + + // The scope id of the object being add or modified on blockchain. + string scope_id = 1; + // The uuid of the contract execution. + string group_id = 2; + // The scope specification id. + string scope_specification_id = 3; + // The new recitals for the scope. Used in leu of Contract for direct ownership changes. + provenance.metadata.v1.p8e.Recitals recitals = 4; + // The executed contract. + provenance.metadata.v1.p8e.Contract contract = 5; + // The contract signatures + provenance.metadata.v1.p8e.SignatureSet signatures = 6; + // The bech32 address of the notary (ie the broadcaster of this message). + string invoker = 7; +} + +// MsgP8eMemorializeContractResponse is the output for a P8eMemorializeContract call +message MsgP8eMemorializeContractResponse { + option deprecated = true; +} + +// MsgBindOSLocatorRequest defines an sdk.Msg type that is used to add an address of an owner to a particular uri. +message MsgBindOSLocatorRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // The object locator to bind the address to bind to the URI. + ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; +} + +// MsgModifyOSLocatorRequest defines an sdk.Msg type that is used to modify a uri associated with an owner address. +message MsgModifyOSLocatorRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // The object locator to bind the address to bind to the URI. + ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; +} + +// MsgBindOSLocatorResponse defines the Msg/BindObjectLocator response type. +message MsgBindOSLocatorResponse { + ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; +} + +// MsgModifyOSLocatorResponse defines the Msg/ModifyObjectLocator response type +message MsgModifyOSLocatorResponse { + ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; +} + +// MsgDeleteOSLocatorRequest defines an sdk.Msg type that is used to remove an existing OSLocator record binding. +message MsgDeleteOSLocatorRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // The record being removed + ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; +} + +// MsgDeleteNameResponse defines the Msg/DeleteName response type. +message MsgDeleteOSLocatorResponse { + ObjectStoreLocator locator = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/provenance/name/v1/genesis.proto b/p8e-api/src/main/proto/provenance/name/v1/genesis.proto new file mode 100644 index 0000000..ce23e57 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/name/v1/genesis.proto @@ -0,0 +1,21 @@ +syntax = "proto3"; +package provenance.name.v1; + +import "gogoproto/gogo.proto"; +import "provenance/name/v1/name.proto"; + +option go_package = "github.com/provenance-io/provenance/x/name/types"; +option java_package = "io.provenance.name.v1"; +option java_multiple_files = true; + +// GenesisState defines the name module's genesis state. +message GenesisState { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // params defines all the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; + + // bindings defines all the name records present at genesis + repeated NameRecord bindings = 2 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/provenance/name/v1/name.proto b/p8e-api/src/main/proto/provenance/name/v1/name.proto new file mode 100644 index 0000000..f2e5347 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/name/v1/name.proto @@ -0,0 +1,48 @@ +syntax = "proto3"; +package provenance.name.v1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/provenance-io/provenance/x/name/types"; + +option java_package = "io.provenance.name.v1"; +option java_multiple_files = true; + +// Params defines the set of params for the name module. +message Params { + // maximum length of name segment to allow + uint32 max_segment_length = 1; + // minimum length of name segment to allow + uint32 min_segment_length = 2; + // maximum number of name segments to allow. Example: `foo.bar.baz` would be 3 + uint32 max_name_levels = 3; + // determines if unrestricted name keys are allowed or not + bool allow_unrestricted_names = 4; +} + +// NameRecord is a structure used to bind ownership of a name heirarchy to a collection of addresses +message NameRecord { + option (gogoproto.goproto_stringer) = false; + + // The bound name + string name = 1; + // The address the name resolved to. + string address = 2; + // Whether owner signature is required to add sub-names. + bool restricted = 3; +} + +// CreateRootNameProposal details a proposal to create a new root name +// that is controlled by a given owner and optionally restricted to the owner +// for the sole creation of sub names. +message CreateRootNameProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = false; + + string title = 1; + string description = 2; + string name = 3; + string owner = 4; + bool restricted = 5; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/name/v1/query.proto b/p8e-api/src/main/proto/provenance/name/v1/query.proto new file mode 100644 index 0000000..f27d411 --- /dev/null +++ b/p8e-api/src/main/proto/provenance/name/v1/query.proto @@ -0,0 +1,77 @@ +syntax = "proto3"; +package provenance.name.v1; + +option go_package = "github.com/provenance-io/provenance/x/name/types"; + +option java_package = "io.provenance.name.v1"; +option java_multiple_files = true; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "provenance/name/v1/name.proto"; + +// Query defines the gRPC querier service for distribution module. +service Query { + // Params queries params of the name module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/provenance/name/v1/params"; + } + + // Resolve queries for the address associated with a given name + rpc Resolve(QueryResolveRequest) returns (QueryResolveResponse) { + option (google.api.http).get = "/provenance/name/v1/resolve/{name}"; + } + + // ReverseLookup queries for all names bound against a given address + rpc ReverseLookup(QueryReverseLookupRequest) returns (QueryReverseLookupResponse) { + option (google.api.http).get = "/provenance/name/v1/lookup/{address}"; + } +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is the response type for the Query/Params RPC method. +message QueryParamsResponse { + // params defines the parameters of the module. + Params params = 1 [(gogoproto.nullable) = false]; +} + +// QueryResolveRequest is the request type for the Query/Resolve method. +message QueryResolveRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // name to resolve the address for + string name = 1; +} + +// QueryResolveResponse is the response type for the Query/Resolve method. +message QueryResolveResponse { + // a string containing the address the name resolves to + string address = 1; +} + +// QueryReverseLookupRequest is the request type for the Query/ReverseLookup method. +message QueryReverseLookupRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address to find name records for + string address = 1; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryReverseLookupResponse is the response type for the Query/Resolve method. +message QueryReverseLookupResponse { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // an array of names bound against a given address + repeated string name = 1; + + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} \ No newline at end of file diff --git a/p8e-api/src/main/proto/provenance/name/v1/tx.proto b/p8e-api/src/main/proto/provenance/name/v1/tx.proto new file mode 100644 index 0000000..bdd1eeb --- /dev/null +++ b/p8e-api/src/main/proto/provenance/name/v1/tx.proto @@ -0,0 +1,48 @@ +syntax = "proto3"; +package provenance.name.v1; + +import "gogoproto/gogo.proto"; +import "provenance/name/v1/name.proto"; + +option go_package = "github.com/provenance-io/provenance/x/name/types"; + +option java_package = "io.provenance.name.v1"; +option java_multiple_files = true; + +// Msg defines the bank Msg service. +service Msg { + // BindName binds a name to an address under a root name. + rpc BindName(MsgBindNameRequest) returns (MsgBindNameResponse); + + // DeleteName defines a method to verify a particular invariance. + rpc DeleteName(MsgDeleteNameRequest) returns (MsgDeleteNameResponse); +} + +// MsgBindNameRequest defines an sdk.Msg type that is used to add an address/name binding under an optional parent name. +// The record may optionally be restricted to prevent additional names from being added under this one without the +// owner signing the request. +message MsgBindNameRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // The parent record to bind this name under. + NameRecord parent = 1 [(gogoproto.nullable) = false]; + // The name record to bind under the parent + NameRecord record = 2 [(gogoproto.nullable) = false]; +} + +// MsgBindNameResponse defines the Msg/BindName response type. +message MsgBindNameResponse {} + +// MsgDeleteNameRequest defines an sdk.Msg type that is used to remove an existing address/name binding. The binding +// may not have any child names currently bound for this request to be successful. +message MsgDeleteNameRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // The record being removed + NameRecord record = 1 [(gogoproto.nullable) = false]; +} + +// MsgDeleteNameResponse defines the Msg/DeleteName response type. +message MsgDeleteNameResponse {} diff --git a/p8e-api/src/main/proto/tendermint/abci/types.proto b/p8e-api/src/main/proto/tendermint/abci/types.proto new file mode 100644 index 0000000..2cbcabb --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/abci/types.proto @@ -0,0 +1,407 @@ +syntax = "proto3"; +package tendermint.abci; + +option go_package = "github.com/tendermint/tendermint/abci/types"; + +// For more information on gogo.proto, see: +// https://github.com/gogo/protobuf/blob/master/extensions.md +import "tendermint/crypto/proof.proto"; +import "tendermint/types/types.proto"; +import "tendermint/crypto/keys.proto"; +import "tendermint/types/params.proto"; +import "google/protobuf/timestamp.proto"; +import "gogoproto/gogo.proto"; + +// This file is copied from http://github.com/tendermint/abci +// NOTE: When using custom types, mind the warnings. +// https://github.com/gogo/protobuf/blob/master/custom_types.md#warnings-and-issues + +//---------------------------------------- +// Request types + +message Request { + oneof value { + RequestEcho echo = 1; + RequestFlush flush = 2; + RequestInfo info = 3; + RequestSetOption set_option = 4; + RequestInitChain init_chain = 5; + RequestQuery query = 6; + RequestBeginBlock begin_block = 7; + RequestCheckTx check_tx = 8; + RequestDeliverTx deliver_tx = 9; + RequestEndBlock end_block = 10; + RequestCommit commit = 11; + RequestListSnapshots list_snapshots = 12; + RequestOfferSnapshot offer_snapshot = 13; + RequestLoadSnapshotChunk load_snapshot_chunk = 14; + RequestApplySnapshotChunk apply_snapshot_chunk = 15; + } +} + +message RequestEcho { + string message = 1; +} + +message RequestFlush {} + +message RequestInfo { + string version = 1; + uint64 block_version = 2; + uint64 p2p_version = 3; +} + +// nondeterministic +message RequestSetOption { + string key = 1; + string value = 2; +} + +message RequestInitChain { + google.protobuf.Timestamp time = 1 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + string chain_id = 2; + ConsensusParams consensus_params = 3; + repeated ValidatorUpdate validators = 4 [(gogoproto.nullable) = false]; + bytes app_state_bytes = 5; + int64 initial_height = 6; +} + +message RequestQuery { + bytes data = 1; + string path = 2; + int64 height = 3; + bool prove = 4; +} + +message RequestBeginBlock { + bytes hash = 1; + tendermint.types.Header header = 2 [(gogoproto.nullable) = false]; + LastCommitInfo last_commit_info = 3 [(gogoproto.nullable) = false]; + repeated Evidence byzantine_validators = 4 [(gogoproto.nullable) = false]; +} + +enum CheckTxType { + NEW = 0 [(gogoproto.enumvalue_customname) = "New"]; + RECHECK = 1 [(gogoproto.enumvalue_customname) = "Recheck"]; +} + +message RequestCheckTx { + bytes tx = 1; + CheckTxType type = 2; +} + +message RequestDeliverTx { + bytes tx = 1; +} + +message RequestEndBlock { + int64 height = 1; +} + +message RequestCommit {} + +// lists available snapshots +message RequestListSnapshots { +} + +// offers a snapshot to the application +message RequestOfferSnapshot { + Snapshot snapshot = 1; // snapshot offered by peers + bytes app_hash = 2; // light client-verified app hash for snapshot height +} + +// loads a snapshot chunk +message RequestLoadSnapshotChunk { + uint64 height = 1; + uint32 format = 2; + uint32 chunk = 3; +} + +// Applies a snapshot chunk +message RequestApplySnapshotChunk { + uint32 index = 1; + bytes chunk = 2; + string sender = 3; +} + +//---------------------------------------- +// Response types + +message Response { + oneof value { + ResponseException exception = 1; + ResponseEcho echo = 2; + ResponseFlush flush = 3; + ResponseInfo info = 4; + ResponseSetOption set_option = 5; + ResponseInitChain init_chain = 6; + ResponseQuery query = 7; + ResponseBeginBlock begin_block = 8; + ResponseCheckTx check_tx = 9; + ResponseDeliverTx deliver_tx = 10; + ResponseEndBlock end_block = 11; + ResponseCommit commit = 12; + ResponseListSnapshots list_snapshots = 13; + ResponseOfferSnapshot offer_snapshot = 14; + ResponseLoadSnapshotChunk load_snapshot_chunk = 15; + ResponseApplySnapshotChunk apply_snapshot_chunk = 16; + } +} + +// nondeterministic +message ResponseException { + string error = 1; +} + +message ResponseEcho { + string message = 1; +} + +message ResponseFlush {} + +message ResponseInfo { + string data = 1; + + string version = 2; + uint64 app_version = 3; + + int64 last_block_height = 4; + bytes last_block_app_hash = 5; +} + +// nondeterministic +message ResponseSetOption { + uint32 code = 1; + // bytes data = 2; + string log = 3; + string info = 4; +} + +message ResponseInitChain { + ConsensusParams consensus_params = 1; + repeated ValidatorUpdate validators = 2 [(gogoproto.nullable) = false]; + bytes app_hash = 3; +} + +message ResponseQuery { + uint32 code = 1; + // bytes data = 2; // use "value" instead. + string log = 3; // nondeterministic + string info = 4; // nondeterministic + int64 index = 5; + bytes key = 6; + bytes value = 7; + tendermint.crypto.ProofOps proof_ops = 8; + int64 height = 9; + string codespace = 10; +} + +message ResponseBeginBlock { + repeated Event events = 1 + [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; +} + +message ResponseCheckTx { + uint32 code = 1; + bytes data = 2; + string log = 3; // nondeterministic + string info = 4; // nondeterministic + int64 gas_wanted = 5 [json_name = "gas_wanted"]; + int64 gas_used = 6 [json_name = "gas_used"]; + repeated Event events = 7 + [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; + string codespace = 8; +} + +message ResponseDeliverTx { + uint32 code = 1; + bytes data = 2; + string log = 3; // nondeterministic + string info = 4; // nondeterministic + int64 gas_wanted = 5 [json_name = "gas_wanted"]; + int64 gas_used = 6 [json_name = "gas_used"]; + repeated Event events = 7 + [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; + string codespace = 8; +} + +message ResponseEndBlock { + repeated ValidatorUpdate validator_updates = 1 + [(gogoproto.nullable) = false]; + ConsensusParams consensus_param_updates = 2; + repeated Event events = 3 + [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; +} + +message ResponseCommit { + // reserve 1 + bytes data = 2; + int64 retain_height = 3; +} + +message ResponseListSnapshots { + repeated Snapshot snapshots = 1; +} + +message ResponseOfferSnapshot { + Result result = 1; + + enum Result { + UNKNOWN = 0; // Unknown result, abort all snapshot restoration + ACCEPT = 1; // Snapshot accepted, apply chunks + ABORT = 2; // Abort all snapshot restoration + REJECT = 3; // Reject this specific snapshot, try others + REJECT_FORMAT = 4; // Reject all snapshots of this format, try others + REJECT_SENDER = 5; // Reject all snapshots from the sender(s), try others + } +} + +message ResponseLoadSnapshotChunk { + bytes chunk = 1; +} + +message ResponseApplySnapshotChunk { + Result result = 1; + repeated uint32 refetch_chunks = 2; // Chunks to refetch and reapply + repeated string reject_senders = 3; // Chunk senders to reject and ban + + enum Result { + UNKNOWN = 0; // Unknown result, abort all snapshot restoration + ACCEPT = 1; // Chunk successfully accepted + ABORT = 2; // Abort all snapshot restoration + RETRY = 3; // Retry chunk (combine with refetch and reject) + RETRY_SNAPSHOT = 4; // Retry snapshot (combine with refetch and reject) + REJECT_SNAPSHOT = 5; // Reject this snapshot, try others + } +} + +//---------------------------------------- +// Misc. + +// ConsensusParams contains all consensus-relevant parameters +// that can be adjusted by the abci app +message ConsensusParams { + BlockParams block = 1; + tendermint.types.EvidenceParams evidence = 2; + tendermint.types.ValidatorParams validator = 3; + tendermint.types.VersionParams version = 4; +} + +// BlockParams contains limits on the block size. +message BlockParams { + // Note: must be greater than 0 + int64 max_bytes = 1; + // Note: must be greater or equal to -1 + int64 max_gas = 2; +} + +message LastCommitInfo { + int32 round = 1; + repeated VoteInfo votes = 2 [(gogoproto.nullable) = false]; +} + +// Event allows application developers to attach additional information to +// ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx. +// Later, transactions may be queried using these events. +message Event { + string type = 1; + repeated EventAttribute attributes = 2 [ + (gogoproto.nullable) = false, + (gogoproto.jsontag) = "attributes,omitempty" + ]; +} + +// EventAttribute is a single key-value pair, associated with an event. +message EventAttribute { + bytes key = 1; + bytes value = 2; + bool index = 3; // nondeterministic +} + +// TxResult contains results of executing the transaction. +// +// One usage is indexing transaction results. +message TxResult { + int64 height = 1; + uint32 index = 2; + bytes tx = 3; + ResponseDeliverTx result = 4 [(gogoproto.nullable) = false]; +} + +//---------------------------------------- +// Blockchain Types + +// Validator +message Validator { + bytes address = 1; // The first 20 bytes of SHA256(public key) + // PubKey pub_key = 2 [(gogoproto.nullable)=false]; + int64 power = 3; // The voting power +} + +// ValidatorUpdate +message ValidatorUpdate { + tendermint.crypto.PublicKey pub_key = 1 [(gogoproto.nullable) = false]; + int64 power = 2; +} + +// VoteInfo +message VoteInfo { + Validator validator = 1 [(gogoproto.nullable) = false]; + bool signed_last_block = 2; +} + +enum EvidenceType { + UNKNOWN = 0; + DUPLICATE_VOTE = 1; + LIGHT_CLIENT_ATTACK = 2; +} + +message Evidence { + EvidenceType type = 1; + // The offending validator + Validator validator = 2 [(gogoproto.nullable) = false]; + // The height when the offense occurred + int64 height = 3; + // The corresponding time where the offense occurred + google.protobuf.Timestamp time = 4 [ + (gogoproto.nullable) = false, + (gogoproto.stdtime) = true + ]; + // Total voting power of the validator set in case the ABCI application does + // not store historical validators. + // https://github.com/tendermint/tendermint/issues/4581 + int64 total_voting_power = 5; +} + +//---------------------------------------- +// State Sync Types + +message Snapshot { + uint64 height = 1; // The height at which the snapshot was taken + uint32 format = 2; // The application-specific snapshot format + uint32 chunks = 3; // Number of chunks in the snapshot + bytes hash = 4; // Arbitrary snapshot hash, equal only if identical + bytes metadata = 5; // Arbitrary application metadata +} + +//---------------------------------------- +// Service Definition + +service ABCIApplication { + rpc Echo(RequestEcho) returns (ResponseEcho); + rpc Flush(RequestFlush) returns (ResponseFlush); + rpc Info(RequestInfo) returns (ResponseInfo); + rpc SetOption(RequestSetOption) returns (ResponseSetOption); + rpc DeliverTx(RequestDeliverTx) returns (ResponseDeliverTx); + rpc CheckTx(RequestCheckTx) returns (ResponseCheckTx); + rpc Query(RequestQuery) returns (ResponseQuery); + rpc Commit(RequestCommit) returns (ResponseCommit); + rpc InitChain(RequestInitChain) returns (ResponseInitChain); + rpc BeginBlock(RequestBeginBlock) returns (ResponseBeginBlock); + rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock); + rpc ListSnapshots(RequestListSnapshots) returns (ResponseListSnapshots); + rpc OfferSnapshot(RequestOfferSnapshot) returns (ResponseOfferSnapshot); + rpc LoadSnapshotChunk(RequestLoadSnapshotChunk) returns (ResponseLoadSnapshotChunk); + rpc ApplySnapshotChunk(RequestApplySnapshotChunk) returns (ResponseApplySnapshotChunk); +} diff --git a/p8e-api/src/main/proto/tendermint/crypto/keys.proto b/p8e-api/src/main/proto/tendermint/crypto/keys.proto new file mode 100644 index 0000000..16fd7ad --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/crypto/keys.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; +package tendermint.crypto; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/crypto"; + +import "gogoproto/gogo.proto"; + +// PublicKey defines the keys available for use with Tendermint Validators +message PublicKey { + option (gogoproto.compare) = true; + option (gogoproto.equal) = true; + + oneof sum { + bytes ed25519 = 1; + bytes secp256k1 = 2; + } +} diff --git a/p8e-api/src/main/proto/tendermint/crypto/proof.proto b/p8e-api/src/main/proto/tendermint/crypto/proof.proto new file mode 100644 index 0000000..975df76 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/crypto/proof.proto @@ -0,0 +1,41 @@ +syntax = "proto3"; +package tendermint.crypto; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/crypto"; + +import "gogoproto/gogo.proto"; + +message Proof { + int64 total = 1; + int64 index = 2; + bytes leaf_hash = 3; + repeated bytes aunts = 4; +} + +message ValueOp { + // Encoded in ProofOp.Key. + bytes key = 1; + + // To encode in ProofOp.Data + Proof proof = 2; +} + +message DominoOp { + string key = 1; + string input = 2; + string output = 3; +} + +// ProofOp defines an operation used for calculating Merkle root +// The data could be arbitrary format, providing nessecary data +// for example neighbouring node hash +message ProofOp { + string type = 1; + bytes key = 2; + bytes data = 3; +} + +// ProofOps is Merkle proof defined by the list of ProofOps +message ProofOps { + repeated ProofOp ops = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/tendermint/libs/bits/types.proto b/p8e-api/src/main/proto/tendermint/libs/bits/types.proto new file mode 100644 index 0000000..3111d11 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/libs/bits/types.proto @@ -0,0 +1,9 @@ +syntax = "proto3"; +package tendermint.libs.bits; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/libs/bits"; + +message BitArray { + int64 bits = 1; + repeated uint64 elems = 2; +} diff --git a/p8e-api/src/main/proto/tendermint/p2p/types.proto b/p8e-api/src/main/proto/tendermint/p2p/types.proto new file mode 100644 index 0000000..0d42ea4 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/p2p/types.proto @@ -0,0 +1,34 @@ +syntax = "proto3"; +package tendermint.p2p; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/p2p"; + +import "gogoproto/gogo.proto"; + +message NetAddress { + string id = 1 [(gogoproto.customname) = "ID"]; + string ip = 2 [(gogoproto.customname) = "IP"]; + uint32 port = 3; +} + +message ProtocolVersion { + uint64 p2p = 1 [(gogoproto.customname) = "P2P"]; + uint64 block = 2; + uint64 app = 3; +} + +message DefaultNodeInfo { + ProtocolVersion protocol_version = 1 [(gogoproto.nullable) = false]; + string default_node_id = 2 [(gogoproto.customname) = "DefaultNodeID"]; + string listen_addr = 3; + string network = 4; + string version = 5; + bytes channels = 6; + string moniker = 7; + DefaultNodeInfoOther other = 8 [(gogoproto.nullable) = false]; +} + +message DefaultNodeInfoOther { + string tx_index = 1; + string rpc_address = 2 [(gogoproto.customname) = "RPCAddress"]; +} diff --git a/p8e-api/src/main/proto/tendermint/types/block.proto b/p8e-api/src/main/proto/tendermint/types/block.proto new file mode 100644 index 0000000..84e9bb1 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/types/block.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; +package tendermint.types; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/types"; + +import "gogoproto/gogo.proto"; +import "tendermint/types/types.proto"; +import "tendermint/types/evidence.proto"; + +message Block { + Header header = 1 [(gogoproto.nullable) = false]; + Data data = 2 [(gogoproto.nullable) = false]; + tendermint.types.EvidenceList evidence = 3 [(gogoproto.nullable) = false]; + Commit last_commit = 4; +} diff --git a/p8e-api/src/main/proto/tendermint/types/evidence.proto b/p8e-api/src/main/proto/tendermint/types/evidence.proto new file mode 100644 index 0000000..3b23457 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/types/evidence.proto @@ -0,0 +1,38 @@ +syntax = "proto3"; +package tendermint.types; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/types"; + +import "gogoproto/gogo.proto"; +import "google/protobuf/timestamp.proto"; +import "tendermint/types/types.proto"; +import "tendermint/types/validator.proto"; + +message Evidence { + oneof sum { + DuplicateVoteEvidence duplicate_vote_evidence = 1; + LightClientAttackEvidence light_client_attack_evidence = 2; + } +} + +// DuplicateVoteEvidence contains evidence of a validator signed two conflicting votes. +message DuplicateVoteEvidence { + tendermint.types.Vote vote_a = 1; + tendermint.types.Vote vote_b = 2; + int64 total_voting_power = 3; + int64 validator_power = 4; + google.protobuf.Timestamp timestamp = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; +} + +// LightClientAttackEvidence contains evidence of a set of validators attempting to mislead a light client. +message LightClientAttackEvidence { + tendermint.types.LightBlock conflicting_block = 1; + int64 common_height = 2; + repeated tendermint.types.Validator byzantine_validators = 3; + int64 total_voting_power = 4; + google.protobuf.Timestamp timestamp = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; +} + +message EvidenceList { + repeated Evidence evidence = 1 [(gogoproto.nullable) = false]; +} diff --git a/p8e-api/src/main/proto/tendermint/types/params.proto b/p8e-api/src/main/proto/tendermint/types/params.proto new file mode 100644 index 0000000..0de7d84 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/types/params.proto @@ -0,0 +1,80 @@ +syntax = "proto3"; +package tendermint.types; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/types"; + +import "gogoproto/gogo.proto"; +import "google/protobuf/duration.proto"; + +option (gogoproto.equal_all) = true; + +// ConsensusParams contains consensus critical parameters that determine the +// validity of blocks. +message ConsensusParams { + BlockParams block = 1 [(gogoproto.nullable) = false]; + EvidenceParams evidence = 2 [(gogoproto.nullable) = false]; + ValidatorParams validator = 3 [(gogoproto.nullable) = false]; + VersionParams version = 4 [(gogoproto.nullable) = false]; +} + +// BlockParams contains limits on the block size. +message BlockParams { + // Max block size, in bytes. + // Note: must be greater than 0 + int64 max_bytes = 1; + // Max gas per block. + // Note: must be greater or equal to -1 + int64 max_gas = 2; + // Minimum time increment between consecutive blocks (in milliseconds) If the + // block header timestamp is ahead of the system clock, decrease this value. + // + // Not exposed to the application. + int64 time_iota_ms = 3; +} + +// EvidenceParams determine how we handle evidence of malfeasance. +message EvidenceParams { + // Max age of evidence, in blocks. + // + // The basic formula for calculating this is: MaxAgeDuration / {average block + // time}. + int64 max_age_num_blocks = 1; + + // Max age of evidence, in time. + // + // It should correspond with an app's "unbonding period" or other similar + // mechanism for handling [Nothing-At-Stake + // attacks](https://github.com/ethereum/wiki/wiki/Proof-of-Stake-FAQ#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed). + google.protobuf.Duration max_age_duration = 2 + [(gogoproto.nullable) = false, (gogoproto.stdduration) = true]; + + // This sets the maximum size of total evidence in bytes that can be committed in a single block. + // and should fall comfortably under the max block bytes. + // Default is 1048576 or 1MB + int64 max_bytes = 3; +} + +// ValidatorParams restrict the public key types validators can use. +// NOTE: uses ABCI pubkey naming, not Amino names. +message ValidatorParams { + option (gogoproto.populate) = true; + option (gogoproto.equal) = true; + + repeated string pub_key_types = 1; +} + +// VersionParams contains the ABCI application version. +message VersionParams { + option (gogoproto.populate) = true; + option (gogoproto.equal) = true; + + uint64 app_version = 1; +} + +// HashedParams is a subset of ConsensusParams. +// +// It is hashed into the Header.ConsensusHash. +message HashedParams { + int64 block_max_bytes = 1; + int64 block_max_gas = 2; +} diff --git a/p8e-api/src/main/proto/tendermint/types/types.proto b/p8e-api/src/main/proto/tendermint/types/types.proto new file mode 100644 index 0000000..7f7ea74 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/types/types.proto @@ -0,0 +1,157 @@ +syntax = "proto3"; +package tendermint.types; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/types"; + +import "gogoproto/gogo.proto"; +import "google/protobuf/timestamp.proto"; +import "tendermint/crypto/proof.proto"; +import "tendermint/version/types.proto"; +import "tendermint/types/validator.proto"; + +// BlockIdFlag indicates which BlcokID the signature is for +enum BlockIDFlag { + option (gogoproto.goproto_enum_stringer) = true; + option (gogoproto.goproto_enum_prefix) = false; + + BLOCK_ID_FLAG_UNKNOWN = 0 [(gogoproto.enumvalue_customname) = "BlockIDFlagUnknown"]; + BLOCK_ID_FLAG_ABSENT = 1 [(gogoproto.enumvalue_customname) = "BlockIDFlagAbsent"]; + BLOCK_ID_FLAG_COMMIT = 2 [(gogoproto.enumvalue_customname) = "BlockIDFlagCommit"]; + BLOCK_ID_FLAG_NIL = 3 [(gogoproto.enumvalue_customname) = "BlockIDFlagNil"]; +} + +// SignedMsgType is a type of signed message in the consensus. +enum SignedMsgType { + option (gogoproto.goproto_enum_stringer) = true; + option (gogoproto.goproto_enum_prefix) = false; + + SIGNED_MSG_TYPE_UNKNOWN = 0 [(gogoproto.enumvalue_customname) = "UnknownType"]; + // Votes + SIGNED_MSG_TYPE_PREVOTE = 1 [(gogoproto.enumvalue_customname) = "PrevoteType"]; + SIGNED_MSG_TYPE_PRECOMMIT = 2 [(gogoproto.enumvalue_customname) = "PrecommitType"]; + + // Proposals + SIGNED_MSG_TYPE_PROPOSAL = 32 [(gogoproto.enumvalue_customname) = "ProposalType"]; +} + +// PartsetHeader +message PartSetHeader { + uint32 total = 1; + bytes hash = 2; +} + +message Part { + uint32 index = 1; + bytes bytes = 2; + tendermint.crypto.Proof proof = 3 [(gogoproto.nullable) = false]; +} + +// BlockID +message BlockID { + bytes hash = 1; + PartSetHeader part_set_header = 2 [(gogoproto.nullable) = false]; +} + +// -------------------------------- + +// Header defines the structure of a Tendermint block header. +message Header { + // basic block info + tendermint.version.Consensus version = 1 [(gogoproto.nullable) = false]; + string chain_id = 2 [(gogoproto.customname) = "ChainID"]; + int64 height = 3; + google.protobuf.Timestamp time = 4 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + + // prev block info + BlockID last_block_id = 5 [(gogoproto.nullable) = false]; + + // hashes of block data + bytes last_commit_hash = 6; // commit from validators from the last block + bytes data_hash = 7; // transactions + + // hashes from the app output from the prev block + bytes validators_hash = 8; // validators for the current block + bytes next_validators_hash = 9; // validators for the next block + bytes consensus_hash = 10; // consensus params for current block + bytes app_hash = 11; // state after txs from the previous block + bytes last_results_hash = 12; // root hash of all results from the txs from the previous block + + // consensus info + bytes evidence_hash = 13; // evidence included in the block + bytes proposer_address = 14; // original proposer of the block +} + +// Data contains the set of transactions included in the block +message Data { + // Txs that will be applied by state @ block.Height+1. + // NOTE: not all txs here are valid. We're just agreeing on the order first. + // This means that block.AppHash does not include these txs. + repeated bytes txs = 1; +} + +// Vote represents a prevote, precommit, or commit vote from validators for +// consensus. +message Vote { + SignedMsgType type = 1; + int64 height = 2; + int32 round = 3; + BlockID block_id = 4 + [(gogoproto.nullable) = false, (gogoproto.customname) = "BlockID"]; // zero if vote is nil. + google.protobuf.Timestamp timestamp = 5 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + bytes validator_address = 6; + int32 validator_index = 7; + bytes signature = 8; +} + +// Commit contains the evidence that a block was committed by a set of validators. +message Commit { + int64 height = 1; + int32 round = 2; + BlockID block_id = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "BlockID"]; + repeated CommitSig signatures = 4 [(gogoproto.nullable) = false]; +} + +// CommitSig is a part of the Vote included in a Commit. +message CommitSig { + BlockIDFlag block_id_flag = 1; + bytes validator_address = 2; + google.protobuf.Timestamp timestamp = 3 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + bytes signature = 4; +} + +message Proposal { + SignedMsgType type = 1; + int64 height = 2; + int32 round = 3; + int32 pol_round = 4; + BlockID block_id = 5 [(gogoproto.customname) = "BlockID", (gogoproto.nullable) = false]; + google.protobuf.Timestamp timestamp = 6 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + bytes signature = 7; +} + +message SignedHeader { + Header header = 1; + Commit commit = 2; +} + +message LightBlock { + SignedHeader signed_header = 1; + tendermint.types.ValidatorSet validator_set = 2; +} + +message BlockMeta { + BlockID block_id = 1 [(gogoproto.customname) = "BlockID", (gogoproto.nullable) = false]; + int64 block_size = 2; + Header header = 3 [(gogoproto.nullable) = false]; + int64 num_txs = 4; +} + +// TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree. +message TxProof { + bytes root_hash = 1; + bytes data = 2; + tendermint.crypto.Proof proof = 3; +} diff --git a/p8e-api/src/main/proto/tendermint/types/validator.proto b/p8e-api/src/main/proto/tendermint/types/validator.proto new file mode 100644 index 0000000..49860b9 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/types/validator.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; +package tendermint.types; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/types"; + +import "gogoproto/gogo.proto"; +import "tendermint/crypto/keys.proto"; + +message ValidatorSet { + repeated Validator validators = 1; + Validator proposer = 2; + int64 total_voting_power = 3; +} + +message Validator { + bytes address = 1; + tendermint.crypto.PublicKey pub_key = 2 [(gogoproto.nullable) = false]; + int64 voting_power = 3; + int64 proposer_priority = 4; +} + +message SimpleValidator { + tendermint.crypto.PublicKey pub_key = 1; + int64 voting_power = 2; +} diff --git a/p8e-api/src/main/proto/tendermint/version/types.proto b/p8e-api/src/main/proto/tendermint/version/types.proto new file mode 100644 index 0000000..6061868 --- /dev/null +++ b/p8e-api/src/main/proto/tendermint/version/types.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; +package tendermint.version; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/version"; + +import "gogoproto/gogo.proto"; + +// App includes the protocol and software version for the application. +// This information is included in ResponseInfo. The App.Protocol can be +// updated in ResponseEndBlock. +message App { + uint64 protocol = 1; + string software = 2; +} + +// Consensus captures the consensus rules for processing a block in the blockchain, +// including all blockchain data structures and the rules of the application's +// state transition machine. +message Consensus { + option (gogoproto.equal) = true; + + uint64 block = 1; + uint64 app = 2; +} diff --git a/p8e-api/src/main/resources/application-container.properties b/p8e-api/src/main/resources/application-container.properties index 21482df..60a80c8 100644 --- a/p8e-api/src/main/resources/application-container.properties +++ b/p8e-api/src/main/resources/application-container.properties @@ -17,7 +17,8 @@ jwt.consumer=${JWT_CONSUMER} # Event Stream event.stream.id=${EVENT_STREAM_ID} -event.stream.uri=${EVENT_STREAM_URI} +event.stream.websocketUri=${EVENT_STREAM_WEBSOCKET_URI} +event.stream.rpcUri=${EVENT_STREAM_RPC_URI} event.stream.epoch=${EVENT_STREAM_EPOCH:1288888} event.stream.key=${EVENT_STREAM_API_KEY} diff --git a/p8e-api/src/main/resources/application-development.properties b/p8e-api/src/main/resources/application-development.properties index 909cc2a..fcd3e7e 100644 --- a/p8e-api/src/main/resources/application-development.properties +++ b/p8e-api/src/main/resources/application-development.properties @@ -12,7 +12,8 @@ jwt.consumer=not-a-real-consumer # Event Stream event.stream.id=5440aa01-0e14-47a3-9e04-e72504484529 -event.stream.uri=grpc://localhost:9090 +event.stream.websocketUri=ws://localhost:26657 +event.stream.rpcUri=http://localhost:26657 event.stream.epoch=0 event.stream.key= diff --git a/p8e-api/src/main/resources/application-local.properties b/p8e-api/src/main/resources/application-local.properties index a7bc394..2d94fbc 100644 --- a/p8e-api/src/main/resources/application-local.properties +++ b/p8e-api/src/main/resources/application-local.properties @@ -12,7 +12,8 @@ jwt.consumer=not-a-real-consumer # Event Stream event.stream.id=5440aa01-0e14-47a3-9e04-e72504484529 -event.stream.uri=grpc://localhost:9090 +event.stream.websocketUri=ws://localhost:26657 +event.stream.rpcUri=http://localhost:26657 event.stream.epoch=0 event.stream.key= diff --git a/p8e-api/src/main/testutil/testdata/query.proto b/p8e-api/src/main/testutil/testdata/query.proto new file mode 100644 index 0000000..3a60aca --- /dev/null +++ b/p8e-api/src/main/testutil/testdata/query.proto @@ -0,0 +1,39 @@ +syntax = "proto3"; +package testdata; + +import "google/protobuf/any.proto"; +import "testdata.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/testutil/testdata"; + +// Query tests the protobuf Query service as defined in +// https://github.com/cosmos/cosmos-sdk/issues/5921. +service Query { + rpc Echo(EchoRequest) returns (EchoResponse); + rpc SayHello(SayHelloRequest) returns (SayHelloResponse); + rpc TestAny(TestAnyRequest) returns (TestAnyResponse); +} + +message EchoRequest { + string message = 1; +} + +message EchoResponse { + string message = 1; +} + +message SayHelloRequest { + string name = 1; +} + +message SayHelloResponse { + string greeting = 1; +} + +message TestAnyRequest { + google.protobuf.Any any_animal = 1; +} + +message TestAnyResponse { + testdata.HasAnimal has_animal = 1; +} diff --git a/p8e-api/src/main/testutil/testdata/testdata.proto b/p8e-api/src/main/testutil/testdata/testdata.proto new file mode 100644 index 0000000..585c230 --- /dev/null +++ b/p8e-api/src/main/testutil/testdata/testdata.proto @@ -0,0 +1,37 @@ +syntax = "proto3"; +package testdata; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/testutil/testdata"; + +message Dog { + string size = 1; + string name = 2; +} + +message Cat { + string moniker = 1; + int32 lives = 2; +} + +message HasAnimal { + google.protobuf.Any animal = 1; + int64 x = 2; +} + +message HasHasAnimal { + google.protobuf.Any has_animal = 1; +} + +message HasHasHasAnimal { + google.protobuf.Any has_has_animal = 1; +} + +// bad MultiSignature with extra fields +message BadMultiSignature { + option (gogoproto.goproto_unrecognized) = true; + repeated bytes signatures = 1; + bytes malicious_field = 5; +} diff --git a/p8e-api/src/main/testutil/testdata/tx.proto b/p8e-api/src/main/testutil/testdata/tx.proto new file mode 100644 index 0000000..eaeb958 --- /dev/null +++ b/p8e-api/src/main/testutil/testdata/tx.proto @@ -0,0 +1,28 @@ +syntax = "proto3"; +package testdata; + +import "gogoproto/gogo.proto"; +import "testdata.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/testutil/testdata"; + +// Msg tests the Protobuf message service as defined in +// https://github.com/cosmos/cosmos-sdk/issues/7500. +service Msg { + rpc CreateDog(MsgCreateDog) returns (MsgCreateDogResponse); +} + +message MsgCreateDog { + testdata.Dog dog = 1; +} + +message MsgCreateDogResponse { + string name = 1; +} + +// TestMsg is msg type for testing protobuf message using any, as defined in +// https://github.com/cosmos/cosmos-sdk/issues/6213. +message TestMsg { + option (gogoproto.goproto_getters) = false; + repeated string signers = 1; +} diff --git a/p8e-api/src/main/testutil/testdata/unknonwnproto.proto b/p8e-api/src/main/testutil/testdata/unknonwnproto.proto new file mode 100644 index 0000000..7bf1ce6 --- /dev/null +++ b/p8e-api/src/main/testutil/testdata/unknonwnproto.proto @@ -0,0 +1,308 @@ +syntax = "proto3"; +package testdata; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "cosmos/tx/v1beta1/tx.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/testutil/testdata"; + +message Customer1 { + int32 id = 1; + string name = 2; + float subscription_fee = 3; + + string payment = 7; +} + +message Customer2 { + int32 id = 1; + int32 industry = 2; + string name = 3; + float fewer = 4; + + int64 reserved = 1047; + + enum City { + Laos = 0; + LosAngeles = 1; + PaloAlto = 2; + Moscow = 3; + Nairobi = 4; + } + + City city = 6; + + google.protobuf.Any miscellaneous = 10; +} + +message Nested4A { + int32 id = 1; + string name = 2; +} + +message Nested3A { + int32 id = 1; + string name = 2; + repeated Nested4A a4 = 4; + map index = 5; +} + +message Nested2A { + int32 id = 1; + string name = 2; + Nested3A nested = 3; +} + +message Nested1A { + int32 id = 1; + Nested2A nested = 2; +} + +message Nested4B { + int32 id = 1; + int32 age = 2; + string name = 3; +} + +message Nested3B { + int32 id = 1; + int32 age = 2; + string name = 3; + repeated Nested4B b4 = 4; +} + +message Nested2B { + int32 id = 1; + double fee = 2; + Nested3B nested = 3; + string route = 4; +} + +message Nested1B { + int32 id = 1; + Nested2B nested = 2; + int32 age = 3; +} + +message Customer3 { + int32 id = 1; + string name = 2; + float sf = 3; + float surcharge = 4; + string destination = 5; + + oneof payment { + string credit_card_no = 7; + string cheque_no = 8; + } + + Customer1 original = 9; +} + +message TestVersion1 { + int64 x = 1; + TestVersion1 a = 2; + TestVersion1 b = 3; // [(gogoproto.nullable) = false] generates invalid recursive structs; + repeated TestVersion1 c = 4; + repeated TestVersion1 d = 5 [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + TestVersion1 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; +} +message TestVersion2 { + int64 x = 1; + TestVersion2 a = 2; + TestVersion2 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion2 c = 4; + repeated TestVersion2 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + TestVersion2 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + uint64 new_field = 25; +} +message TestVersion3 { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + TestVersion3 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; +} + +message TestVersion3LoneOneOfValue { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; +} + +message TestVersion3LoneNesting { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + TestVersion3LoneNesting f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; + + message Inner1 { + int64 id = 1; + string name = 2; + message InnerInner { + string id = 1; + string city = 2; + } + InnerInner inner = 3; + } + + Inner1 inner1 = 14; + + message Inner2 { + string id = 1; + string country = 2; + message InnerInner { + string id = 1; + string city = 2; + } + InnerInner inner = 3; + } + + Inner2 inner2 = 15; +} + +message TestVersion4LoneNesting { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + TestVersion3LoneNesting f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; + + message Inner1 { + int64 id = 1; + string name = 2; + message InnerInner { + int64 id = 1; + string city = 2; + } + InnerInner inner = 3; + } + + Inner1 inner1 = 14; + + message Inner2 { + string id = 1; + string country = 2; + message InnerInner { + string id = 1; + int64 value = 2; + } + InnerInner inner = 3; + } + + Inner2 inner2 = 15; +} + +message TestVersionFD1 { + int64 x = 1; + TestVersion1 a = 2; + oneof sum { + int32 e = 6; + TestVersion1 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; +} + +message TestVersionFD1WithExtraAny { + int64 x = 1; + TestVersion1 a = 2; + oneof sum { + int32 e = 6; + TestVersion1 f = 7; + } + AnyWithExtra g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; +} + +message AnyWithExtra { + google.protobuf.Any a = 1 [(gogoproto.embed) = true]; + int64 b = 3; + int64 c = 4; +} + +message TestUpdatedTxRaw { + bytes body_bytes = 1; + bytes auth_info_bytes = 2; + repeated bytes signatures = 3; + bytes new_field_5 = 5; + bytes new_field_1024 = 1024; +} + +message TestUpdatedTxBody { + repeated google.protobuf.Any messages = 1; + string memo = 2; + int64 timeout_height = 3; + uint64 some_new_field = 4; + string some_new_field_non_critical_field = 1050; + repeated google.protobuf.Any extension_options = 1023; + repeated google.protobuf.Any non_critical_extension_options = 2047; +} + +message TestUpdatedAuthInfo { + repeated cosmos.tx.v1beta1.SignerInfo signer_infos = 1; + cosmos.tx.v1beta1.Fee fee = 2; + bytes new_field_3 = 3; + bytes new_field_1024 = 1024; +} + +message TestRepeatedUints { + repeated uint64 nums = 1; +} diff --git a/p8e-api/src/test/kotlin/stream/EventStreamTest.kt b/p8e-api/src/test/kotlin/stream/EventStreamTest.kt new file mode 100644 index 0000000..3c9a0a4 --- /dev/null +++ b/p8e-api/src/test/kotlin/stream/EventStreamTest.kt @@ -0,0 +1,194 @@ +package stream + +import com.nhaarman.mockitokotlin2.* +import com.tinder.scarlet.Lifecycle +import com.tinder.scarlet.ShutdownReason +import com.tinder.scarlet.WebSocket +import com.tinder.scarlet.lifecycle.LifecycleRegistry +import io.p8e.util.base64decode +import io.p8e.util.base64encode +import io.provenance.engine.domain.* +import io.provenance.engine.service.TransactionQueryService +import io.provenance.engine.stream.EventStreamFactory +import io.provenance.engine.stream.domain.* +import io.reactivex.Flowable +import io.reactivex.rxkotlin.toFlowable +import org.junit.After +import org.junit.Before +import org.junit.Test + +class EventStreamTest { + val query = "tm.event='NewBlock'" + + lateinit var observer: EventStreamResponseObserver + + lateinit var transactionQueryService: TransactionQueryService + + lateinit var lifecycle: LifecycleRegistry + + lateinit var eventStreamService: EventStreamService + + var eventStream: EventStreamFactory.EventStream? = null + + @Before + fun setUp() { + observer = mock() + + transactionQueryService = mock() + + lifecycle = mock() + + eventStreamService = mock() + whenever(eventStreamService.observeWebSocketEvent()).thenReturn(listOf(mock>()).toFlowable()) + } + + @After + fun tearDown() { + eventStream?.shutdown() + } + + fun buildEventStream(eventTypes: List = listOf("scope_created", "scope_updated"), startHeight: Long = 100): EventStreamFactory.EventStream { + return EventStreamFactory.EventStream(eventTypes, startHeight, observer, lifecycle, eventStreamService, transactionQueryService).also { + eventStream = it + } + } + + @Test + fun `History is not streamed if startHeight is less than 0`() { + setLastBlockHeight(100) + queueEvents() + + buildEventStream(startHeight = -1).streamEvents() + + verify(transactionQueryService, times(0)).blocksWithTransactions(any(), any()) + } + + @Test + fun `History is not streamed if startHeight is greater than the last block height`() { + setLastBlockHeight(100) + queueEvents() + + buildEventStream(startHeight = 101).streamEvents() + + verify(transactionQueryService, times(0)).blocksWithTransactions(any(), any()) + } + + @Test + fun `History is streamed if startHeight is less than last block height`() { + setLastBlockHeight(100) + queueEvents() + whenever(transactionQueryService.blocksWithTransactions(90, 100)).thenReturn(listOf(95)) + setBlockResults(95, listOf(txResult(0, listOf("scope_created")))) + + buildEventStream(startHeight = 90).streamEvents() + + verify(observer, times(1)).onNext(argThat { height == 95L && events.count() == 1 && events[0].eventType == "scope_created" }) + } + + @Test + fun `History of non-requested events is not streamed`() { + setLastBlockHeight(100) + queueEvents() + whenever(transactionQueryService.blocksWithTransactions(90, 100)).thenReturn(listOf(95)) + setBlockResults(95, listOf(txResult(0, listOf("scope_destroyed")))) + + buildEventStream(startHeight = 90).streamEvents() + + verify(observer, times(0)).onNext(any()) + } + + @Test + fun `Requested events are emitted to the observer`() { + setLastBlockHeight(99) + queueEvents(event(100)) + val txResults = listOf(txResult(0, listOf("scope_created")), txResult(0, listOf("scope_updated"))) + setBlockResults(100, txResults) + + buildEventStream().streamEvents() + + verify(observer, times(1)).onNext(any()) + } + + @Test + fun `Non-requested events are not emitted to the observer`() { + setLastBlockHeight(99) + queueEvents(event(100)) + val txResults = listOf(txResult(0, listOf("scope_created")), txResult(0, listOf("scope_updated"))) + setBlockResults(100, txResults) + + buildEventStream(listOf("scope_destroyed")).streamEvents() + + verify(observer, times(0)).onNext(any()) + } + + @Test + fun `Any Event is emitted if no specific events are requested`() { + setLastBlockHeight(99) + queueEvents(event(100), event(101)) + setBlockResults(100, listOf(txResult(0, listOf("scope_created")), txResult(0, listOf("scope_updated")))) + setBlockResults(101, listOf(txResult(0, listOf("scope_destroyed")))) + + buildEventStream(listOf()).streamEvents() + + verify(observer, times(2)).onNext(any()) + } + + @Test + fun `Only events with requested attributes are emitted if specified`() { + setLastBlockHeight(99) + queueEvents(event(100), event(101)) + setBlockResults(100, listOf(txResult(0, listOf("scope_created")))) + setBlockResults(101, listOf(txResult(0, listOf("scope_created:my_favorite_attribute")))) + + buildEventStream(listOf("scope_created:my_favorite_attribute")).streamEvents() + + verify(observer, times(1)).onNext(any()) + } + + @Test + fun `Observer error and complete called when error thrown`() { + setLastBlockHeight(99) + val e = Throwable("Fail") + whenever(eventStreamService.streamEvents()).thenReturn(Flowable.error(e)) + + buildEventStream().streamEvents() + + verify(lifecycle, times(1)).onNext(Lifecycle.State.Stopped.WithReason(ShutdownReason.GRACEFUL)) + verify(observer, times(1)).onError(e) + verify(observer, times(1)).onCompleted() + } + + fun queueEvents(vararg events: Result) { + whenever(eventStreamService.streamEvents()).thenReturn(events.map { RPCResponse("2.0", "0", it) }.toFlowable()) + } + + fun event(height: Long) = Result(query, ResultData("tendermint/event/NewBlock", ResultValue(Block(BlockHeader(height), BlockData(null))))) + + fun setLastBlockHeight(height: Long) { + whenever(transactionQueryService.abciInfo()).thenReturn(ABCIInfo("provenance", height, "last_hash")) + } + + fun setBlockResults(height: Long, transactions: List) { + whenever(transactionQueryService.block(height)).thenReturn(BlockResponse( + BlockID("block_${height}_hash", PartSetHeader(1, "part_${height}_hash")), + Block(BlockHeader(height), BlockData(transactions.map { "txhash" })) + )) + whenever(transactionQueryService.blockResults(height)).thenReturn(BlockResults( + height, + transactions + )) + } + + fun txResult(code: Int, events: List): TxResult { + return TxResult(code, null, "bunch_of_json", "", 123, 123, events.map { + val (eventType, attributes) = if (it.contains(':')) it.split(':') else listOf(it, "scope_id,scope,group_id,execution_id,module,tx_hash") + val attributeTypes = attributes.split(',') + + Event(eventType, attributeTypes.map { attribute -> attribute(attribute, "${attribute}_value") }) + }) + } + + fun attribute(key: String, value: String): Attribute { + return Attribute(key.base64encode().base64decode(), value.base64encode().base64decode()) + } +} diff --git a/versions.gradle b/versions.gradle index 2a91342..e4b67b6 100644 --- a/versions.gradle +++ b/versions.gradle @@ -1,8 +1,5 @@ // Versions shared across subprojects ext { - provenance_gateway = 'master-5' - provenance_keystone = 'master-11' - arrow_version = '0.11.0' identity_version = 'master-184' elasticsearch_version = '7.4.1' @@ -17,6 +14,7 @@ ext { hikari_cp_version = '3.2.0' redisson_version = '3.11.0' grpc_version = '1.32.2' + scarlet_version = '0.1.11' protobuf_version = '3.6.1' kethereum_version = '0.83.4' khex_version = '1.0.0-RC6' @@ -24,7 +22,8 @@ ext { datadog_version = '2.11.0' logback_version = '1.2.3' - p8e_contract_version_prod = 'master-86' // prod cronjob - p8e_contract_version_test = 'develop-165' // develop cronjob + gradle_download = '4.1.1' + provenance_version = '0.3.0' + cosmos_version = '0.42.2' }