diff --git a/ibcmail/client/0.3.0/execute_msg.json b/ibcmail/client/0.3.0/execute_msg.json new file mode 100644 index 0000000..c931c57 --- /dev/null +++ b/ibcmail/client/0.3.0/execute_msg.json @@ -0,0 +1,1426 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ExecuteMsg", + "description": "Wrapper around all possible messages that can be sent to the module.", + "oneOf": [ + { + "description": "A configuration message, defined by the base.", + "type": "object", + "required": [ + "base" + ], + "properties": { + "base": { + "$ref": "#/definitions/BaseExecuteMsg" + } + }, + "additionalProperties": false + }, + { + "description": "An app request defined by a base consumer.", + "type": "object", + "required": [ + "module" + ], + "properties": { + "module": { + "$ref": "#/definitions/ClientExecuteMsg" + } + }, + "additionalProperties": false + }, + { + "description": "IbcReceive to process IBC callbacks In order to trust this, the apps and adapters verify this comes from the ibc-client contract.", + "type": "object", + "required": [ + "ibc_callback" + ], + "properties": { + "ibc_callback": { + "$ref": "#/definitions/IbcResponseMsg" + } + }, + "additionalProperties": false + }, + { + "description": "ModuleIbc endpoint to receive messages from modules on other chains In order to trust this, the apps and adapters verify this comes from the ibc-host contract. They should also trust the sending chain", + "type": "object", + "required": [ + "module_ibc" + ], + "properties": { + "module_ibc": { + "$ref": "#/definitions/ModuleIbcMsg" + } + }, + "additionalProperties": false + }, + { + "description": "Receive endpoint for CW20 / external service integrations", + "type": "object", + "required": [ + "receive" + ], + "properties": { + "receive": { + "$ref": "#/definitions/Empty" + } + }, + "additionalProperties": false + } + ], + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "Attribute": { + "description": "An key value pair that is used in the context of event attributes in logs", + "type": "object", + "required": [ + "key", + "value" + ], + "properties": { + "key": { + "type": "string" + }, + "value": { + "type": "string" + } + } + }, + "BankQuery": { + "oneOf": [ + { + "description": "This calls into the native bank module for querying the total supply of one denomination. It does the same as the SupplyOf call in Cosmos SDK's RPC API. Return value is of type SupplyResponse.", + "type": "object", + "required": [ + "supply" + ], + "properties": { + "supply": { + "type": "object", + "required": [ + "denom" + ], + "properties": { + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "This calls into the native bank module for one denomination Return value is BalanceResponse", + "type": "object", + "required": [ + "balance" + ], + "properties": { + "balance": { + "type": "object", + "required": [ + "address", + "denom" + ], + "properties": { + "address": { + "type": "string" + }, + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "This calls into the native bank module for all denominations. Note that this may be much more expensive than Balance and should be avoided if possible. Return value is AllBalanceResponse.", + "type": "object", + "required": [ + "all_balances" + ], + "properties": { + "all_balances": { + "type": "object", + "required": [ + "address" + ], + "properties": { + "address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "This calls into the native bank module for querying metadata for a specific bank token. Return value is DenomMetadataResponse", + "type": "object", + "required": [ + "denom_metadata" + ], + "properties": { + "denom_metadata": { + "type": "object", + "required": [ + "denom" + ], + "properties": { + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "This calls into the native bank module for querying metadata for all bank tokens that have a metadata entry. Return value is AllDenomMetadataResponse", + "type": "object", + "required": [ + "all_denom_metadata" + ], + "properties": { + "all_denom_metadata": { + "type": "object", + "properties": { + "pagination": { + "anyOf": [ + { + "$ref": "#/definitions/PageRequest" + }, + { + "type": "null" + } + ] + } + } + } + }, + "additionalProperties": false + } + ] + }, + "BaseExecuteMsg": { + "oneOf": [ + { + "description": "Updates the base config", + "type": "object", + "required": [ + "update_config" + ], + "properties": { + "update_config": { + "type": "object", + "properties": { + "ans_host_address": { + "type": [ + "string", + "null" + ] + }, + "registry_address": { + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Binary": { + "description": "Binary is a wrapper around Vec to add base64 de/serialization with serde. It also adds some helper methods to help encode inline.\n\nThis is only needed as serde-json-{core,wasm} has a horrible encoding for Vec. See also .", + "type": "string" + }, + "Callback": { + "description": "Callback from modules, that is turned into an IbcResponseMsg by the ibc client A callback can only be sent to itself", + "type": "object", + "required": [ + "msg" + ], + "properties": { + "msg": { + "description": "Used to add information to the callback. This is usually used to provide information to the ibc callback function for context", + "allOf": [ + { + "$ref": "#/definitions/Binary" + } + ] + } + }, + "additionalProperties": false + }, + "ClientExecuteMsg": { + "description": "App execute messages", + "oneOf": [ + { + "description": "Receive a message from the server", + "type": "object", + "required": [ + "receive_message" + ], + "properties": { + "receive_message": { + "$ref": "#/definitions/IbcMailMessage" + } + }, + "additionalProperties": false + }, + { + "description": "Send a message", + "type": "object", + "required": [ + "send_message" + ], + "properties": { + "send_message": { + "type": "object", + "required": [ + "message" + ], + "properties": { + "message": { + "$ref": "#/definitions/Message" + }, + "route": { + "anyOf": [ + { + "$ref": "#/definitions/AccountTrace" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "DistributionQuery": { + "oneOf": [ + { + "description": "See ", + "type": "object", + "required": [ + "delegator_withdraw_address" + ], + "properties": { + "delegator_withdraw_address": { + "type": "object", + "required": [ + "delegator_address" + ], + "properties": { + "delegator_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "See ", + "type": "object", + "required": [ + "delegation_rewards" + ], + "properties": { + "delegation_rewards": { + "type": "object", + "required": [ + "delegator_address", + "validator_address" + ], + "properties": { + "delegator_address": { + "type": "string" + }, + "validator_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "See ", + "type": "object", + "required": [ + "delegation_total_rewards" + ], + "properties": { + "delegation_total_rewards": { + "type": "object", + "required": [ + "delegator_address" + ], + "properties": { + "delegator_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "See ", + "type": "object", + "required": [ + "delegator_validators" + ], + "properties": { + "delegator_validators": { + "type": "object", + "required": [ + "delegator_address" + ], + "properties": { + "delegator_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + } + ] + }, + "Empty": { + "description": "An empty struct that serves as a placeholder in different places, such as contracts that don't set a custom message.\n\nIt is designed to be expressable in correct JSON and JSON Schema but contains no meaningful data. Previously we used enums without cases, but those cannot represented as valid JSON Schema (https://github.com/CosmWasm/cosmwasm/issues/451)", + "type": "object" + }, + "ErrorResponse": { + "type": "object", + "required": [ + "error", + "message_index" + ], + "properties": { + "error": { + "description": "The error that occured executing the message.", + "type": "string" + }, + "message_index": { + "description": "The index of the first message who's execution failed.", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + } + }, + "additionalProperties": false + }, + "Event": { + "description": "A full [*Cosmos SDK* event].\n\nThis version uses string attributes (similar to [*Cosmos SDK* StringEvent]), which then get magically converted to bytes for Tendermint somewhere between the Rust-Go interface, JSON deserialization and the `NewEvent` call in Cosmos SDK.\n\n[*Cosmos SDK* event]: https://docs.cosmos.network/main/learn/advanced/events [*Cosmos SDK* StringEvent]: https://github.com/cosmos/cosmos-sdk/blob/v0.42.5/proto/cosmos/base/abci/v1beta1/abci.proto#L56-L70", + "type": "object", + "required": [ + "attributes", + "type" + ], + "properties": { + "attributes": { + "description": "The attributes to be included in the event.\n\nYou can learn more about these from [*Cosmos SDK* docs].\n\n[*Cosmos SDK* docs]: https://docs.cosmos.network/main/learn/advanced/events", + "type": "array", + "items": { + "$ref": "#/definitions/Attribute" + } + }, + "type": { + "description": "The event type. This is renamed to \"ty\" because \"type\" is reserved in Rust. This sucks, we know.", + "type": "string" + } + } + }, + "ExecutionResponse": { + "type": "object", + "required": [ + "executed_by", + "result" + ], + "properties": { + "executed_by": { + "description": "The address on the remote chain that executed the messages.", + "type": "string" + }, + "result": { + "description": "Index `i` corresponds to the result of executing the `i`th message.", + "type": "array", + "items": { + "$ref": "#/definitions/SubMsgResponse" + } + } + }, + "additionalProperties": false + }, + "IbcMailMessage": { + "type": "object", + "required": [ + "id", + "message", + "sender", + "timestamp", + "version" + ], + "properties": { + "id": { + "type": "string" + }, + "message": { + "$ref": "#/definitions/Message" + }, + "sender": { + "$ref": "#/definitions/Sender" + }, + "timestamp": { + "$ref": "#/definitions/Timestamp" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false + }, + "IbcQuery": { + "description": "These are queries to the various IBC modules to see the state of the contract's IBC connection. These will return errors if the contract is not \"ibc enabled\"", + "oneOf": [ + { + "description": "Gets the Port ID the current contract is bound to.\n\nReturns a `PortIdResponse`.", + "type": "object", + "required": [ + "port_id" + ], + "properties": { + "port_id": { + "type": "object" + } + }, + "additionalProperties": false + }, + { + "description": "Lists all channels that are bound to a given port. If `port_id` is omitted, this list all channels bound to the contract's port.\n\nReturns a `ListChannelsResponse`.", + "type": "object", + "required": [ + "list_channels" + ], + "properties": { + "list_channels": { + "type": "object", + "properties": { + "port_id": { + "type": [ + "string", + "null" + ] + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Lists all information for a (portID, channelID) pair. If port_id is omitted, it will default to the contract's own channel. (To save a PortId{} call)\n\nReturns a `ChannelResponse`.", + "type": "object", + "required": [ + "channel" + ], + "properties": { + "channel": { + "type": "object", + "required": [ + "channel_id" + ], + "properties": { + "channel_id": { + "type": "string" + }, + "port_id": { + "type": [ + "string", + "null" + ] + } + } + } + }, + "additionalProperties": false + } + ] + }, + "IbcResponseMsg": { + "description": "IbcResponseMsg should be de/serialized under `IbcCallback()` variant in a ExecuteMsg", + "type": "object", + "required": [ + "callback", + "result" + ], + "properties": { + "callback": { + "description": "The msg sent with the callback request.", + "allOf": [ + { + "$ref": "#/definitions/Callback" + } + ] + }, + "result": { + "$ref": "#/definitions/IbcResult" + } + }, + "additionalProperties": false + }, + "IbcResult": { + "oneOf": [ + { + "type": "object", + "required": [ + "query" + ], + "properties": { + "query": { + "type": "object", + "required": [ + "queries", + "results" + ], + "properties": { + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/QueryRequest_for_ModuleQuery" + } + }, + "results": { + "$ref": "#/definitions/Result_of_Array_of_Binary_or_ErrorResponse" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "execute" + ], + "properties": { + "execute": { + "type": "object", + "required": [ + "initiator_msg", + "result" + ], + "properties": { + "initiator_msg": { + "$ref": "#/definitions/Binary" + }, + "result": { + "$ref": "#/definitions/Result_of_ExecutionResponse_or_String" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "description": "An error occured that could not be recovered from. The only known way that this can occur is message handling running out of gas, in which case the error will be `codespace: sdk, code: 11`.\n\nThis error is not named becuase it could also occur due to a panic or unhandled error during message processing. We don't expect this to happen and have carefully written the code to avoid it.", + "type": "object", + "required": [ + "fatal_error" + ], + "properties": { + "fatal_error": { + "type": "string" + } + }, + "additionalProperties": false + } + ] + }, + "InstalledModuleIdentification": { + "description": "This is used for identifying calling modules For adapters, we don't need the account id because it's independent of an account For apps and standalone, the account id is used to identify the calling module", + "type": "object", + "required": [ + "module_info" + ], + "properties": { + "account_id": { + "anyOf": [ + { + "$ref": "#/definitions/AccountId" + }, + { + "type": "null" + } + ] + }, + "module_info": { + "$ref": "#/definitions/ModuleInfo" + } + }, + "additionalProperties": false + }, + "Message": { + "description": "Struct representing new message to send to another client", + "type": "object", + "required": [ + "body", + "recipient", + "subject" + ], + "properties": { + "body": { + "type": "string" + }, + "recipient": { + "$ref": "#/definitions/Recipient" + }, + "subject": { + "type": "string" + } + }, + "additionalProperties": false + }, + "ModuleIbcInfo": { + "type": "object", + "required": [ + "chain", + "module" + ], + "properties": { + "chain": { + "description": "Remote chain identification", + "allOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + } + ] + }, + "module": { + "description": "Information about the module that called ibc action on this module", + "allOf": [ + { + "$ref": "#/definitions/ModuleInfo" + } + ] + } + }, + "additionalProperties": false + }, + "ModuleIbcMsg": { + "type": "object", + "required": [ + "msg", + "src_module_info" + ], + "properties": { + "msg": { + "description": "The message sent by the module", + "allOf": [ + { + "$ref": "#/definitions/Binary" + } + ] + }, + "src_module_info": { + "description": "Sender Module Identification", + "allOf": [ + { + "$ref": "#/definitions/ModuleIbcInfo" + } + ] + } + }, + "additionalProperties": false + }, + "ModuleInfo": { + "description": "Stores the namespace, name, and version of an Abstract module.", + "type": "object", + "required": [ + "name", + "namespace", + "version" + ], + "properties": { + "name": { + "description": "Name of the contract", + "type": "string" + }, + "namespace": { + "description": "Namespace of the module", + "allOf": [ + { + "$ref": "#/definitions/Namespace" + } + ] + }, + "version": { + "description": "Version of the module", + "allOf": [ + { + "$ref": "#/definitions/ModuleVersion" + } + ] + } + }, + "additionalProperties": false + }, + "ModuleQuery": { + "type": "object", + "required": [ + "msg", + "target_module" + ], + "properties": { + "msg": { + "description": "The WasmQuery::Smart request to the module", + "allOf": [ + { + "$ref": "#/definitions/Binary" + } + ] + }, + "target_module": { + "description": "Information about the module that gets queried through ibc", + "allOf": [ + { + "$ref": "#/definitions/InstalledModuleIdentification" + } + ] + } + }, + "additionalProperties": false + }, + "ModuleVersion": { + "oneOf": [ + { + "type": "string", + "enum": [ + "latest" + ] + }, + { + "type": "object", + "required": [ + "version" + ], + "properties": { + "version": { + "type": "string" + } + }, + "additionalProperties": false + } + ] + }, + "Namespace": { + "description": "Represents an Abstract namespace for modules", + "type": "string" + }, + "PageRequest": { + "description": "Simplified version of the PageRequest type for pagination from the cosmos-sdk", + "type": "object", + "required": [ + "limit", + "reverse" + ], + "properties": { + "key": { + "anyOf": [ + { + "$ref": "#/definitions/Binary" + }, + { + "type": "null" + } + ] + }, + "limit": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "reverse": { + "type": "boolean" + } + } + }, + "QueryRequest_for_ModuleQuery": { + "oneOf": [ + { + "type": "object", + "required": [ + "bank" + ], + "properties": { + "bank": { + "$ref": "#/definitions/BankQuery" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "custom" + ], + "properties": { + "custom": { + "$ref": "#/definitions/ModuleQuery" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "staking" + ], + "properties": { + "staking": { + "$ref": "#/definitions/StakingQuery" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionQuery" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate query is encoded the same way as abci_query, with path and protobuf encoded request data. The format is defined in [ADR-21](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-021-protobuf-query-encoding.md). The response is protobuf encoded data directly without a JSON response wrapper. The caller is responsible for compiling the proper protobuf definitions for both requests and responses.", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "data", + "path" + ], + "properties": { + "data": { + "description": "this is the expected protobuf message type (not any), binary encoded", + "allOf": [ + { + "$ref": "#/definitions/Binary" + } + ] + }, + "path": { + "description": "this is the fully qualified service path used for routing, eg. custom/cosmos_sdk.x.bank.v1.Query/QueryBalance", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcQuery" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmQuery" + } + }, + "additionalProperties": false + } + ] + }, + "Recipient": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "namespace": { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "namespace": { + "$ref": "#/definitions/Namespace" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Result_of_Array_of_Binary_or_ErrorResponse": { + "oneOf": [ + { + "type": "object", + "required": [ + "Ok" + ], + "properties": { + "Ok": { + "type": "array", + "items": { + "$ref": "#/definitions/Binary" + } + } + } + }, + { + "type": "object", + "required": [ + "Err" + ], + "properties": { + "Err": { + "$ref": "#/definitions/ErrorResponse" + } + } + } + ] + }, + "Result_of_ExecutionResponse_or_String": { + "oneOf": [ + { + "type": "object", + "required": [ + "Ok" + ], + "properties": { + "Ok": { + "$ref": "#/definitions/ExecutionResponse" + } + } + }, + { + "type": "object", + "required": [ + "Err" + ], + "properties": { + "Err": { + "type": "string" + } + } + } + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "StakingQuery": { + "oneOf": [ + { + "description": "Returns the denomination that can be bonded (if there are multiple native tokens on the chain)", + "type": "object", + "required": [ + "bonded_denom" + ], + "properties": { + "bonded_denom": { + "type": "object" + } + }, + "additionalProperties": false + }, + { + "description": "AllDelegations will return all delegations by the delegator", + "type": "object", + "required": [ + "all_delegations" + ], + "properties": { + "all_delegations": { + "type": "object", + "required": [ + "delegator" + ], + "properties": { + "delegator": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Delegation will return more detailed info on a particular delegation, defined by delegator/validator pair", + "type": "object", + "required": [ + "delegation" + ], + "properties": { + "delegation": { + "type": "object", + "required": [ + "delegator", + "validator" + ], + "properties": { + "delegator": { + "type": "string" + }, + "validator": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Returns all validators in the currently active validator set.\n\nThe query response type is `AllValidatorsResponse`.", + "type": "object", + "required": [ + "all_validators" + ], + "properties": { + "all_validators": { + "type": "object" + } + }, + "additionalProperties": false + }, + { + "description": "Returns the validator at the given address. Returns None if the validator is not part of the currently active validator set.\n\nThe query response type is `ValidatorResponse`.", + "type": "object", + "required": [ + "validator" + ], + "properties": { + "validator": { + "type": "object", + "required": [ + "address" + ], + "properties": { + "address": { + "description": "The validator's address (e.g. (e.g. cosmosvaloper1...))", + "type": "string" + } + } + } + }, + "additionalProperties": false + } + ] + }, + "SubMsgResponse": { + "description": "The information we get back from a successful sub message execution, with full Cosmos SDK events.", + "type": "object", + "required": [ + "events" + ], + "properties": { + "data": { + "anyOf": [ + { + "$ref": "#/definitions/Binary" + }, + { + "type": "null" + } + ] + }, + "events": { + "type": "array", + "items": { + "$ref": "#/definitions/Event" + } + } + } + }, + "Timestamp": { + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + }, + "Uint64": { + "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```", + "type": "string" + }, + "WasmQuery": { + "oneOf": [ + { + "description": "this queries the public API of another contract at a known address (with known ABI) Return value is whatever the contract returns (caller should know), wrapped in a ContractResult that is JSON encoded.", + "type": "object", + "required": [ + "smart" + ], + "properties": { + "smart": { + "type": "object", + "required": [ + "contract_addr", + "msg" + ], + "properties": { + "contract_addr": { + "type": "string" + }, + "msg": { + "description": "msg is the json-encoded QueryMsg struct", + "allOf": [ + { + "$ref": "#/definitions/Binary" + } + ] + } + } + } + }, + "additionalProperties": false + }, + { + "description": "this queries the raw kv-store of the contract. returns the raw, unparsed data stored at that key, which may be an empty vector if not present", + "type": "object", + "required": [ + "raw" + ], + "properties": { + "raw": { + "type": "object", + "required": [ + "contract_addr", + "key" + ], + "properties": { + "contract_addr": { + "type": "string" + }, + "key": { + "description": "Key is the raw key used in the contracts Storage", + "allOf": [ + { + "$ref": "#/definitions/Binary" + } + ] + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Returns a [`ContractInfoResponse`] with metadata on the contract from the runtime", + "type": "object", + "required": [ + "contract_info" + ], + "properties": { + "contract_info": { + "type": "object", + "required": [ + "contract_addr" + ], + "properties": { + "contract_addr": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Returns a [`CodeInfoResponse`] with metadata of the code", + "type": "object", + "required": [ + "code_info" + ], + "properties": { + "code_info": { + "type": "object", + "required": [ + "code_id" + ], + "properties": { + "code_id": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + } + } + }, + "additionalProperties": false + } + ] + } + } +} diff --git a/ibcmail/client/0.3.0/instantiate_msg.json b/ibcmail/client/0.3.0/instantiate_msg.json new file mode 100644 index 0000000..28744d3 --- /dev/null +++ b/ibcmail/client/0.3.0/instantiate_msg.json @@ -0,0 +1,77 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "InstantiateMsg", + "type": "object", + "required": [ + "base", + "module" + ], + "properties": { + "base": { + "description": "base instantiate information", + "allOf": [ + { + "$ref": "#/definitions/BaseInstantiateMsg" + } + ] + }, + "module": { + "description": "custom instantiate msg", + "allOf": [ + { + "$ref": "#/definitions/ClientInstantiateMsg" + } + ] + } + }, + "additionalProperties": false, + "definitions": { + "AccountBase": { + "description": "Contains the minimal Abstract Account contract addresses.", + "type": "object", + "required": [ + "manager", + "proxy" + ], + "properties": { + "manager": { + "$ref": "#/definitions/Addr" + }, + "proxy": { + "$ref": "#/definitions/Addr" + } + }, + "additionalProperties": false + }, + "Addr": { + "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", + "type": "string" + }, + "BaseInstantiateMsg": { + "description": "Used by Module Factory to instantiate App", + "type": "object", + "required": [ + "account_base", + "ans_host_address", + "registry_address" + ], + "properties": { + "account_base": { + "$ref": "#/definitions/AccountBase" + }, + "ans_host_address": { + "type": "string" + }, + "registry_address": { + "type": "string" + } + }, + "additionalProperties": false + }, + "ClientInstantiateMsg": { + "description": "App instantiate message", + "type": "object", + "additionalProperties": false + } + } +} diff --git a/ibcmail/client/0.3.0/migrate_msg.json b/ibcmail/client/0.3.0/migrate_msg.json new file mode 100644 index 0000000..5ebb337 --- /dev/null +++ b/ibcmail/client/0.3.0/migrate_msg.json @@ -0,0 +1,38 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "MigrateMsg", + "type": "object", + "required": [ + "base", + "module" + ], + "properties": { + "base": { + "description": "base migrate information", + "allOf": [ + { + "$ref": "#/definitions/BaseMigrateMsg" + } + ] + }, + "module": { + "description": "custom migrate msg", + "allOf": [ + { + "$ref": "#/definitions/AppMigrateMsg" + } + ] + } + }, + "additionalProperties": false, + "definitions": { + "AppMigrateMsg": { + "type": "object", + "additionalProperties": false + }, + "BaseMigrateMsg": { + "type": "object", + "additionalProperties": false + } + } +} diff --git a/ibcmail/client/0.3.0/module-schema.json b/ibcmail/client/0.3.0/module-schema.json new file mode 100644 index 0000000..a2c1de0 --- /dev/null +++ b/ibcmail/client/0.3.0/module-schema.json @@ -0,0 +1,971 @@ +{ + "contract_name": "module-schema", + "contract_version": "0.23.0", + "idl_version": "1.0.0", + "instantiate": { + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "InstantiateMsg", + "description": "App instantiate message", + "type": "object", + "additionalProperties": false + }, + "execute": { + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ExecuteMsg", + "description": "App execute messages", + "oneOf": [ + { + "description": "Receive a message from the server", + "type": "object", + "required": [ + "receive_message" + ], + "properties": { + "receive_message": { + "$ref": "#/definitions/IbcMailMessage" + } + }, + "additionalProperties": false + }, + { + "description": "Send a message", + "type": "object", + "required": [ + "send_message" + ], + "properties": { + "send_message": { + "type": "object", + "required": [ + "message" + ], + "properties": { + "message": { + "$ref": "#/definitions/Message" + }, + "route": { + "anyOf": [ + { + "$ref": "#/definitions/AccountTrace" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ], + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "IbcMailMessage": { + "type": "object", + "required": [ + "id", + "message", + "sender", + "timestamp", + "version" + ], + "properties": { + "id": { + "type": "string" + }, + "message": { + "$ref": "#/definitions/Message" + }, + "sender": { + "$ref": "#/definitions/Sender" + }, + "timestamp": { + "$ref": "#/definitions/Timestamp" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Message": { + "description": "Struct representing new message to send to another client", + "type": "object", + "required": [ + "body", + "recipient", + "subject" + ], + "properties": { + "body": { + "type": "string" + }, + "recipient": { + "$ref": "#/definitions/Recipient" + }, + "subject": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Namespace": { + "description": "Represents an Abstract namespace for modules", + "type": "string" + }, + "Recipient": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "namespace": { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "namespace": { + "$ref": "#/definitions/Namespace" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Timestamp": { + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + }, + "Uint64": { + "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```", + "type": "string" + } + } + }, + "query": { + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "QueryMsg", + "description": "App query messages", + "oneOf": [ + { + "type": "object", + "required": [ + "list_messages" + ], + "properties": { + "list_messages": { + "type": "object", + "required": [ + "status" + ], + "properties": { + "filter": { + "anyOf": [ + { + "$ref": "#/definitions/MessageFilter" + }, + { + "type": "null" + } + ] + }, + "limit": { + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "start_after": { + "type": [ + "string", + "null" + ] + }, + "status": { + "$ref": "#/definitions/MessageStatus" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "messages" + ], + "properties": { + "messages": { + "type": "object", + "required": [ + "ids", + "status" + ], + "properties": { + "ids": { + "type": "array", + "items": { + "type": "string" + } + }, + "status": { + "$ref": "#/definitions/MessageStatus" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ], + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "MessageFilter": { + "type": "object", + "properties": { + "from": { + "anyOf": [ + { + "$ref": "#/definitions/Sender" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "MessageStatus": { + "type": "string", + "enum": [ + "sent", + "received" + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + } + } + }, + "migrate": { + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "MigrateMsg", + "type": "object", + "additionalProperties": false + }, + "sudo": null, + "responses": { + "list_messages": { + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "MessagesResponse", + "type": "object", + "required": [ + "messages" + ], + "properties": { + "messages": { + "type": "array", + "items": { + "$ref": "#/definitions/IbcMailMessage" + } + } + }, + "additionalProperties": false, + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "IbcMailMessage": { + "type": "object", + "required": [ + "id", + "message", + "sender", + "timestamp", + "version" + ], + "properties": { + "id": { + "type": "string" + }, + "message": { + "$ref": "#/definitions/Message" + }, + "sender": { + "$ref": "#/definitions/Sender" + }, + "timestamp": { + "$ref": "#/definitions/Timestamp" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Message": { + "description": "Struct representing new message to send to another client", + "type": "object", + "required": [ + "body", + "recipient", + "subject" + ], + "properties": { + "body": { + "type": "string" + }, + "recipient": { + "$ref": "#/definitions/Recipient" + }, + "subject": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Namespace": { + "description": "Represents an Abstract namespace for modules", + "type": "string" + }, + "Recipient": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "namespace": { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "namespace": { + "$ref": "#/definitions/Namespace" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Timestamp": { + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + }, + "Uint64": { + "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```", + "type": "string" + } + } + }, + "messages": { + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "MessagesResponse", + "type": "object", + "required": [ + "messages" + ], + "properties": { + "messages": { + "type": "array", + "items": { + "$ref": "#/definitions/IbcMailMessage" + } + } + }, + "additionalProperties": false, + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "IbcMailMessage": { + "type": "object", + "required": [ + "id", + "message", + "sender", + "timestamp", + "version" + ], + "properties": { + "id": { + "type": "string" + }, + "message": { + "$ref": "#/definitions/Message" + }, + "sender": { + "$ref": "#/definitions/Sender" + }, + "timestamp": { + "$ref": "#/definitions/Timestamp" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Message": { + "description": "Struct representing new message to send to another client", + "type": "object", + "required": [ + "body", + "recipient", + "subject" + ], + "properties": { + "body": { + "type": "string" + }, + "recipient": { + "$ref": "#/definitions/Recipient" + }, + "subject": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Namespace": { + "description": "Represents an Abstract namespace for modules", + "type": "string" + }, + "Recipient": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "namespace": { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "namespace": { + "$ref": "#/definitions/Namespace" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Timestamp": { + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + }, + "Uint64": { + "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```", + "type": "string" + } + } + } + } +} diff --git a/ibcmail/client/0.3.0/query_msg.json b/ibcmail/client/0.3.0/query_msg.json new file mode 100644 index 0000000..bdf634c --- /dev/null +++ b/ibcmail/client/0.3.0/query_msg.json @@ -0,0 +1,285 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "QueryMsg", + "oneOf": [ + { + "description": "A query to the base.", + "type": "object", + "required": [ + "base" + ], + "properties": { + "base": { + "$ref": "#/definitions/BaseQueryMsg" + } + }, + "additionalProperties": false + }, + { + "description": "Custom query", + "type": "object", + "required": [ + "module" + ], + "properties": { + "module": { + "$ref": "#/definitions/ClientQueryMsg" + } + }, + "additionalProperties": false + } + ], + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "BaseQueryMsg": { + "oneOf": [ + { + "description": "Returns [`AppConfigResponse`]", + "type": "object", + "required": [ + "base_config" + ], + "properties": { + "base_config": { + "type": "object", + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "description": "Returns the admin. Returns [`AdminResponse`]", + "type": "object", + "required": [ + "base_admin" + ], + "properties": { + "base_admin": { + "type": "object", + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "description": "Returns module data Returns [`ModuleDataResponse`]", + "type": "object", + "required": [ + "module_data" + ], + "properties": { + "module_data": { + "type": "object", + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "description": "Returns top level owner Returns [`TopLevelOwnerResponse`]", + "type": "object", + "required": [ + "top_level_owner" + ], + "properties": { + "top_level_owner": { + "type": "object", + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "ClientQueryMsg": { + "description": "App query messages", + "oneOf": [ + { + "type": "object", + "required": [ + "list_messages" + ], + "properties": { + "list_messages": { + "type": "object", + "required": [ + "status" + ], + "properties": { + "filter": { + "anyOf": [ + { + "$ref": "#/definitions/MessageFilter" + }, + { + "type": "null" + } + ] + }, + "limit": { + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "start_after": { + "type": [ + "string", + "null" + ] + }, + "status": { + "$ref": "#/definitions/MessageStatus" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "messages" + ], + "properties": { + "messages": { + "type": "object", + "required": [ + "ids", + "status" + ], + "properties": { + "ids": { + "type": "array", + "items": { + "type": "string" + } + }, + "status": { + "$ref": "#/definitions/MessageStatus" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "MessageFilter": { + "type": "object", + "properties": { + "from": { + "anyOf": [ + { + "$ref": "#/definitions/Sender" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "MessageStatus": { + "type": "string", + "enum": [ + "sent", + "received" + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + } + } +} diff --git a/ibcmail/client/0.3.0/raw/execute.json b/ibcmail/client/0.3.0/raw/execute.json new file mode 100644 index 0000000..04f5c1e --- /dev/null +++ b/ibcmail/client/0.3.0/raw/execute.json @@ -0,0 +1,275 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ExecuteMsg", + "description": "App execute messages", + "oneOf": [ + { + "description": "Receive a message from the server", + "type": "object", + "required": [ + "receive_message" + ], + "properties": { + "receive_message": { + "$ref": "#/definitions/IbcMailMessage" + } + }, + "additionalProperties": false + }, + { + "description": "Send a message", + "type": "object", + "required": [ + "send_message" + ], + "properties": { + "send_message": { + "type": "object", + "required": [ + "message" + ], + "properties": { + "message": { + "$ref": "#/definitions/Message" + }, + "route": { + "anyOf": [ + { + "$ref": "#/definitions/AccountTrace" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ], + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "IbcMailMessage": { + "type": "object", + "required": [ + "id", + "message", + "sender", + "timestamp", + "version" + ], + "properties": { + "id": { + "type": "string" + }, + "message": { + "$ref": "#/definitions/Message" + }, + "sender": { + "$ref": "#/definitions/Sender" + }, + "timestamp": { + "$ref": "#/definitions/Timestamp" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Message": { + "description": "Struct representing new message to send to another client", + "type": "object", + "required": [ + "body", + "recipient", + "subject" + ], + "properties": { + "body": { + "type": "string" + }, + "recipient": { + "$ref": "#/definitions/Recipient" + }, + "subject": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Namespace": { + "description": "Represents an Abstract namespace for modules", + "type": "string" + }, + "Recipient": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "namespace": { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "namespace": { + "$ref": "#/definitions/Namespace" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Timestamp": { + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + }, + "Uint64": { + "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```", + "type": "string" + } + } +} diff --git a/ibcmail/client/0.3.0/raw/instantiate.json b/ibcmail/client/0.3.0/raw/instantiate.json new file mode 100644 index 0000000..a093b88 --- /dev/null +++ b/ibcmail/client/0.3.0/raw/instantiate.json @@ -0,0 +1,7 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "InstantiateMsg", + "description": "App instantiate message", + "type": "object", + "additionalProperties": false +} diff --git a/ibcmail/client/0.3.0/raw/migrate.json b/ibcmail/client/0.3.0/raw/migrate.json new file mode 100644 index 0000000..7fbe8c5 --- /dev/null +++ b/ibcmail/client/0.3.0/raw/migrate.json @@ -0,0 +1,6 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "MigrateMsg", + "type": "object", + "additionalProperties": false +} diff --git a/ibcmail/client/0.3.0/raw/query.json b/ibcmail/client/0.3.0/raw/query.json new file mode 100644 index 0000000..25a8c7c --- /dev/null +++ b/ibcmail/client/0.3.0/raw/query.json @@ -0,0 +1,195 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "QueryMsg", + "description": "App query messages", + "oneOf": [ + { + "type": "object", + "required": [ + "list_messages" + ], + "properties": { + "list_messages": { + "type": "object", + "required": [ + "status" + ], + "properties": { + "filter": { + "anyOf": [ + { + "$ref": "#/definitions/MessageFilter" + }, + { + "type": "null" + } + ] + }, + "limit": { + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "start_after": { + "type": [ + "string", + "null" + ] + }, + "status": { + "$ref": "#/definitions/MessageStatus" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "messages" + ], + "properties": { + "messages": { + "type": "object", + "required": [ + "ids", + "status" + ], + "properties": { + "ids": { + "type": "array", + "items": { + "type": "string" + } + }, + "status": { + "$ref": "#/definitions/MessageStatus" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ], + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "MessageFilter": { + "type": "object", + "properties": { + "from": { + "anyOf": [ + { + "$ref": "#/definitions/Sender" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "MessageStatus": { + "type": "string", + "enum": [ + "sent", + "received" + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + } + } +} diff --git a/ibcmail/client/0.3.0/raw/response_to_base_admin.json b/ibcmail/client/0.3.0/raw/response_to_base_admin.json new file mode 100644 index 0000000..c73969a --- /dev/null +++ b/ibcmail/client/0.3.0/raw/response_to_base_admin.json @@ -0,0 +1,15 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "AdminResponse", + "description": "Returned from Admin.query_admin()", + "type": "object", + "properties": { + "admin": { + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false +} diff --git a/ibcmail/client/0.3.0/raw/response_to_base_config.json b/ibcmail/client/0.3.0/raw/response_to_base_config.json new file mode 100644 index 0000000..0f29e90 --- /dev/null +++ b/ibcmail/client/0.3.0/raw/response_to_base_config.json @@ -0,0 +1,28 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "AppConfigResponse", + "type": "object", + "required": [ + "ans_host_address", + "manager_address", + "proxy_address" + ], + "properties": { + "ans_host_address": { + "$ref": "#/definitions/Addr" + }, + "manager_address": { + "$ref": "#/definitions/Addr" + }, + "proxy_address": { + "$ref": "#/definitions/Addr" + } + }, + "additionalProperties": false, + "definitions": { + "Addr": { + "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", + "type": "string" + } + } +} diff --git a/ibcmail/client/0.3.0/raw/response_to_list_messages.json b/ibcmail/client/0.3.0/raw/response_to_list_messages.json new file mode 100644 index 0000000..f428498 --- /dev/null +++ b/ibcmail/client/0.3.0/raw/response_to_list_messages.json @@ -0,0 +1,240 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "MessagesResponse", + "type": "object", + "required": [ + "messages" + ], + "properties": { + "messages": { + "type": "array", + "items": { + "$ref": "#/definitions/IbcMailMessage" + } + } + }, + "additionalProperties": false, + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "IbcMailMessage": { + "type": "object", + "required": [ + "id", + "message", + "sender", + "timestamp", + "version" + ], + "properties": { + "id": { + "type": "string" + }, + "message": { + "$ref": "#/definitions/Message" + }, + "sender": { + "$ref": "#/definitions/Sender" + }, + "timestamp": { + "$ref": "#/definitions/Timestamp" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Message": { + "description": "Struct representing new message to send to another client", + "type": "object", + "required": [ + "body", + "recipient", + "subject" + ], + "properties": { + "body": { + "type": "string" + }, + "recipient": { + "$ref": "#/definitions/Recipient" + }, + "subject": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Namespace": { + "description": "Represents an Abstract namespace for modules", + "type": "string" + }, + "Recipient": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "namespace": { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "namespace": { + "$ref": "#/definitions/Namespace" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Timestamp": { + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + }, + "Uint64": { + "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```", + "type": "string" + } + } +} diff --git a/ibcmail/client/0.3.0/raw/response_to_messages.json b/ibcmail/client/0.3.0/raw/response_to_messages.json new file mode 100644 index 0000000..f428498 --- /dev/null +++ b/ibcmail/client/0.3.0/raw/response_to_messages.json @@ -0,0 +1,240 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "MessagesResponse", + "type": "object", + "required": [ + "messages" + ], + "properties": { + "messages": { + "type": "array", + "items": { + "$ref": "#/definitions/IbcMailMessage" + } + } + }, + "additionalProperties": false, + "definitions": { + "AccountId": { + "description": "Unique identifier for an account. On each chain this is unique.", + "type": "object", + "required": [ + "seq", + "trace" + ], + "properties": { + "seq": { + "description": "Unique identifier for the accounts create on a local chain. Is reused when creating an interchain account.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "trace": { + "description": "Sequence of the chain that triggered the IBC account creation `AccountTrace::Local` if the account was created locally Example: Account created on Juno which has an abstract interchain account on Osmosis, which in turn creates an interchain account on Terra -> `AccountTrace::Remote(vec![\"juno\", \"osmosis\"])`", + "allOf": [ + { + "$ref": "#/definitions/AccountTrace" + } + ] + } + }, + "additionalProperties": false + }, + "AccountTrace": { + "description": "The identifier of chain that triggered the account creation", + "oneOf": [ + { + "type": "string", + "enum": [ + "local" + ] + }, + { + "type": "object", + "required": [ + "remote" + ], + "properties": { + "remote": { + "type": "array", + "items": { + "$ref": "#/definitions/TruncatedChainId" + } + } + }, + "additionalProperties": false + } + ] + }, + "IbcMailMessage": { + "type": "object", + "required": [ + "id", + "message", + "sender", + "timestamp", + "version" + ], + "properties": { + "id": { + "type": "string" + }, + "message": { + "$ref": "#/definitions/Message" + }, + "sender": { + "$ref": "#/definitions/Sender" + }, + "timestamp": { + "$ref": "#/definitions/Timestamp" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Message": { + "description": "Struct representing new message to send to another client", + "type": "object", + "required": [ + "body", + "recipient", + "subject" + ], + "properties": { + "body": { + "type": "string" + }, + "recipient": { + "$ref": "#/definitions/Recipient" + }, + "subject": { + "type": "string" + } + }, + "additionalProperties": false + }, + "Namespace": { + "description": "Represents an Abstract namespace for modules", + "type": "string" + }, + "Recipient": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "namespace": { + "type": "object", + "required": [ + "namespace" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "namespace": { + "$ref": "#/definitions/Namespace" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Sender": { + "oneOf": [ + { + "type": "object", + "required": [ + "account" + ], + "properties": { + "account": { + "type": "object", + "required": [ + "id" + ], + "properties": { + "chain": { + "anyOf": [ + { + "$ref": "#/definitions/TruncatedChainId" + }, + { + "type": "null" + } + ] + }, + "id": { + "$ref": "#/definitions/AccountId" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + }, + "Timestamp": { + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", + "allOf": [ + { + "$ref": "#/definitions/Uint64" + } + ] + }, + "TruncatedChainId": { + "description": "The name of a chain, aka the chain-id without the post-fix number. ex. `cosmoshub-4` -> `cosmoshub`, `juno-1` -> `juno`", + "type": "string" + }, + "Uint64": { + "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```", + "type": "string" + } + } +} diff --git a/ibcmail/client/0.3.0/raw/response_to_module_data.json b/ibcmail/client/0.3.0/raw/response_to_module_data.json new file mode 100644 index 0000000..9932c0d --- /dev/null +++ b/ibcmail/client/0.3.0/raw/response_to_module_data.json @@ -0,0 +1,52 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ModuleDataResponse", + "type": "object", + "required": [ + "dependencies", + "module_id", + "version" + ], + "properties": { + "dependencies": { + "type": "array", + "items": { + "$ref": "#/definitions/DependencyResponse" + } + }, + "metadata": { + "type": [ + "string", + "null" + ] + }, + "module_id": { + "type": "string" + }, + "version": { + "type": "string" + } + }, + "additionalProperties": false, + "definitions": { + "DependencyResponse": { + "type": "object", + "required": [ + "id", + "version_req" + ], + "properties": { + "id": { + "type": "string" + }, + "version_req": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + } + } +} diff --git a/ibcmail/client/0.3.0/raw/response_to_top_level_owner.json b/ibcmail/client/0.3.0/raw/response_to_top_level_owner.json new file mode 100644 index 0000000..13fc072 --- /dev/null +++ b/ibcmail/client/0.3.0/raw/response_to_top_level_owner.json @@ -0,0 +1,20 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "TopLevelOwnerResponse", + "type": "object", + "required": [ + "address" + ], + "properties": { + "address": { + "$ref": "#/definitions/Addr" + } + }, + "additionalProperties": false, + "definitions": { + "Addr": { + "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", + "type": "string" + } + } +} diff --git a/ibcmail/client/metadata.json b/ibcmail/client/metadata.json index 71450c9..d12412e 100644 --- a/ibcmail/client/metadata.json +++ b/ibcmail/client/metadata.json @@ -1,9 +1,9 @@ { - "name": "IBC Mail Client", - "description": "Send and receive mail!", + "name": "IBC Mail Server", + "description": "IBC mail adapter.", "website": "", "docs": "", - "type": "app", - "icon": "FaMailBulk", + "type": "adapter", + "icon": "GiTrade", "enabled": true -} \ No newline at end of file +}