{
  "contract_name": "dexter-lp-token",
  "contract_version": "1.0.0",
  "idl_version": "1.0.0",
  "instantiate": {
    "$schema": "http://json-schema.org/draft-07/schema#",
    "title": "InstantiateMsg",
    "type": "object",
    "required": [
      "decimals",
      "initial_balances",
      "name",
      "symbol"
    ],
    "properties": {
      "decimals": {
        "type": "integer",
        "format": "uint8",
        "minimum": 0.0
      },
      "initial_balances": {
        "type": "array",
        "items": {
          "$ref": "#/definitions/Cw20Coin"
        }
      },
      "marketing": {
        "anyOf": [
          {
            "$ref": "#/definitions/InstantiateMarketingInfo"
          },
          {
            "type": "null"
          }
        ]
      },
      "mint": {
        "anyOf": [
          {
            "$ref": "#/definitions/MinterResponse"
          },
          {
            "type": "null"
          }
        ]
      },
      "name": {
        "type": "string"
      },
      "symbol": {
        "type": "string"
      }
    },
    "additionalProperties": false,
    "definitions": {
      "Binary": {
        "description": "Binary is a wrapper around Vec<u8> 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<u8>. See also <https://github.com/CosmWasm/cosmwasm/blob/main/docs/MESSAGE_TYPES.md>.",
        "type": "string"
      },
      "Cw20Coin": {
        "type": "object",
        "required": [
          "address",
          "amount"
        ],
        "properties": {
          "address": {
            "type": "string"
          },
          "amount": {
            "$ref": "#/definitions/Uint128"
          }
        },
        "additionalProperties": false
      },
      "EmbeddedLogo": {
        "description": "This is used to store the logo on the blockchain in an accepted format. Enforce maximum size of 5KB on all variants.",
        "oneOf": [
          {
            "description": "Store the Logo as an SVG file. The content must conform to the spec at https://en.wikipedia.org/wiki/Scalable_Vector_Graphics (The contract should do some light-weight sanity-check validation)",
            "type": "object",
            "required": [
              "svg"
            ],
            "properties": {
              "svg": {
                "$ref": "#/definitions/Binary"
              }
            },
            "additionalProperties": false
          },
          {
            "description": "Store the Logo as a PNG file. This will likely only support up to 64x64 or so within the 5KB limit.",
            "type": "object",
            "required": [
              "png"
            ],
            "properties": {
              "png": {
                "$ref": "#/definitions/Binary"
              }
            },
            "additionalProperties": false
          }
        ]
      },
      "InstantiateMarketingInfo": {
        "title": "Description -  This structure describes the marketing info settings such as project, description, and token logo.",
        "type": "object",
        "properties": {
          "description": {
            "description": "The project description",
            "type": [
              "string",
              "null"
            ]
          },
          "logo": {
            "description": "The token logo",
            "anyOf": [
              {
                "$ref": "#/definitions/Logo"
              },
              {
                "type": "null"
              }
            ]
          },
          "marketing": {
            "description": "The address of an admin who is able to update marketing info",
            "type": [
              "string",
              "null"
            ]
          },
          "project": {
            "description": "The project name",
            "type": [
              "string",
              "null"
            ]
          }
        },
        "additionalProperties": false
      },
      "Logo": {
        "description": "This is used for uploading logo data, or setting it in InstantiateData",
        "oneOf": [
          {
            "description": "A reference to an externally hosted logo. Must be a valid HTTP or HTTPS URL.",
            "type": "object",
            "required": [
              "url"
            ],
            "properties": {
              "url": {
                "type": "string"
              }
            },
            "additionalProperties": false
          },
          {
            "description": "Logo content stored on the blockchain. Enforce maximum size of 5KB on all variants",
            "type": "object",
            "required": [
              "embedded"
            ],
            "properties": {
              "embedded": {
                "$ref": "#/definitions/EmbeddedLogo"
              }
            },
            "additionalProperties": false
          }
        ]
      },
      "MinterResponse": {
        "type": "object",
        "required": [
          "minter"
        ],
        "properties": {
          "cap": {
            "description": "cap is a hard cap on total supply that can be achieved by minting. Note that this refers to total_supply. If None, there is unlimited cap.",
            "anyOf": [
              {
                "$ref": "#/definitions/Uint128"
              },
              {
                "type": "null"
              }
            ]
          },
          "minter": {
            "type": "string"
          }
        },
        "additionalProperties": false
      },
      "Uint128": {
        "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
        "type": "string"
      }
    }
  },
  "execute": {
    "$schema": "http://json-schema.org/draft-07/schema#",
    "title": "ExecuteMsg",
    "oneOf": [
      {
        "description": "Transfer is a base message to move tokens to another account without triggering actions",
        "type": "object",
        "required": [
          "transfer"
        ],
        "properties": {
          "transfer": {
            "type": "object",
            "required": [
              "amount",
              "recipient"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "recipient": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Burn is a base message to destroy tokens forever",
        "type": "object",
        "required": [
          "burn"
        ],
        "properties": {
          "burn": {
            "type": "object",
            "required": [
              "amount"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Send is a base message to transfer tokens to a contract and trigger an action on the receiving contract.",
        "type": "object",
        "required": [
          "send"
        ],
        "properties": {
          "send": {
            "type": "object",
            "required": [
              "amount",
              "contract",
              "msg"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "contract": {
                "type": "string"
              },
              "msg": {
                "$ref": "#/definitions/Binary"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"approval\" extension. Allows spender to access an additional amount tokens from the owner's (env.sender) account. If expires is Some(), overwrites current allowance expiration with this one.",
        "type": "object",
        "required": [
          "increase_allowance"
        ],
        "properties": {
          "increase_allowance": {
            "type": "object",
            "required": [
              "amount",
              "spender"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "expires": {
                "anyOf": [
                  {
                    "$ref": "#/definitions/Expiration"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "spender": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"approval\" extension. Lowers the spender's access of tokens from the owner's (env.sender) account by amount. If expires is Some(), overwrites current allowance expiration with this one.",
        "type": "object",
        "required": [
          "decrease_allowance"
        ],
        "properties": {
          "decrease_allowance": {
            "type": "object",
            "required": [
              "amount",
              "spender"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "expires": {
                "anyOf": [
                  {
                    "$ref": "#/definitions/Expiration"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "spender": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"approval\" extension. Transfers amount tokens from owner -> recipient if `env.sender` has sufficient pre-approval.",
        "type": "object",
        "required": [
          "transfer_from"
        ],
        "properties": {
          "transfer_from": {
            "type": "object",
            "required": [
              "amount",
              "owner",
              "recipient"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "owner": {
                "type": "string"
              },
              "recipient": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"approval\" extension. Sends amount tokens from owner -> contract if `env.sender` has sufficient pre-approval.",
        "type": "object",
        "required": [
          "send_from"
        ],
        "properties": {
          "send_from": {
            "type": "object",
            "required": [
              "amount",
              "contract",
              "msg",
              "owner"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "contract": {
                "type": "string"
              },
              "msg": {
                "$ref": "#/definitions/Binary"
              },
              "owner": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"approval\" extension. Destroys tokens forever",
        "type": "object",
        "required": [
          "burn_from"
        ],
        "properties": {
          "burn_from": {
            "type": "object",
            "required": [
              "amount",
              "owner"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "owner": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with the \"mintable\" extension. If authorized, creates amount new tokens and adds to the recipient balance.",
        "type": "object",
        "required": [
          "mint"
        ],
        "properties": {
          "mint": {
            "type": "object",
            "required": [
              "amount",
              "recipient"
            ],
            "properties": {
              "amount": {
                "$ref": "#/definitions/Uint128"
              },
              "recipient": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with the \"mintable\" extension. The current minter may set a new minter. Setting the minter to None will remove the token's minter forever.",
        "type": "object",
        "required": [
          "update_minter"
        ],
        "properties": {
          "update_minter": {
            "type": "object",
            "properties": {
              "new_minter": {
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with the \"marketing\" extension. If authorized, updates marketing metadata. Setting None/null for any of these will leave it unchanged. Setting Some(\"\") will clear this field on the contract storage",
        "type": "object",
        "required": [
          "update_marketing"
        ],
        "properties": {
          "update_marketing": {
            "type": "object",
            "properties": {
              "description": {
                "description": "A longer description of the token and it's utility. Designed for tooltips or such",
                "type": [
                  "string",
                  "null"
                ]
              },
              "marketing": {
                "description": "The address (if any) who can update this data structure",
                "type": [
                  "string",
                  "null"
                ]
              },
              "project": {
                "description": "A URL pointing to the project behind this token.",
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "If set as the \"marketing\" role on the contract, upload a new URL, SVG, or PNG for the token",
        "type": "object",
        "required": [
          "upload_logo"
        ],
        "properties": {
          "upload_logo": {
            "$ref": "#/definitions/Logo"
          }
        },
        "additionalProperties": false
      }
    ],
    "definitions": {
      "Binary": {
        "description": "Binary is a wrapper around Vec<u8> 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<u8>. See also <https://github.com/CosmWasm/cosmwasm/blob/main/docs/MESSAGE_TYPES.md>.",
        "type": "string"
      },
      "EmbeddedLogo": {
        "description": "This is used to store the logo on the blockchain in an accepted format. Enforce maximum size of 5KB on all variants.",
        "oneOf": [
          {
            "description": "Store the Logo as an SVG file. The content must conform to the spec at https://en.wikipedia.org/wiki/Scalable_Vector_Graphics (The contract should do some light-weight sanity-check validation)",
            "type": "object",
            "required": [
              "svg"
            ],
            "properties": {
              "svg": {
                "$ref": "#/definitions/Binary"
              }
            },
            "additionalProperties": false
          },
          {
            "description": "Store the Logo as a PNG file. This will likely only support up to 64x64 or so within the 5KB limit.",
            "type": "object",
            "required": [
              "png"
            ],
            "properties": {
              "png": {
                "$ref": "#/definitions/Binary"
              }
            },
            "additionalProperties": false
          }
        ]
      },
      "Expiration": {
        "description": "Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)",
        "oneOf": [
          {
            "description": "AtHeight will expire when `env.block.height` >= height",
            "type": "object",
            "required": [
              "at_height"
            ],
            "properties": {
              "at_height": {
                "type": "integer",
                "format": "uint64",
                "minimum": 0.0
              }
            },
            "additionalProperties": false
          },
          {
            "description": "AtTime will expire when `env.block.time` >= time",
            "type": "object",
            "required": [
              "at_time"
            ],
            "properties": {
              "at_time": {
                "$ref": "#/definitions/Timestamp"
              }
            },
            "additionalProperties": false
          },
          {
            "description": "Never will never expire. Used to express the empty variant",
            "type": "object",
            "required": [
              "never"
            ],
            "properties": {
              "never": {
                "type": "object",
                "additionalProperties": false
              }
            },
            "additionalProperties": false
          }
        ]
      },
      "Logo": {
        "description": "This is used for uploading logo data, or setting it in InstantiateData",
        "oneOf": [
          {
            "description": "A reference to an externally hosted logo. Must be a valid HTTP or HTTPS URL.",
            "type": "object",
            "required": [
              "url"
            ],
            "properties": {
              "url": {
                "type": "string"
              }
            },
            "additionalProperties": false
          },
          {
            "description": "Logo content stored on the blockchain. Enforce maximum size of 5KB on all variants",
            "type": "object",
            "required": [
              "embedded"
            ],
            "properties": {
              "embedded": {
                "$ref": "#/definitions/EmbeddedLogo"
              }
            },
            "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"
          }
        ]
      },
      "Uint128": {
        "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
        "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",
    "oneOf": [
      {
        "description": "Returns the current balance of the given address, 0 if unset.",
        "type": "object",
        "required": [
          "balance"
        ],
        "properties": {
          "balance": {
            "type": "object",
            "required": [
              "address"
            ],
            "properties": {
              "address": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Returns metadata on the contract - name, decimals, supply, etc.",
        "type": "object",
        "required": [
          "token_info"
        ],
        "properties": {
          "token_info": {
            "type": "object",
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"mintable\" extension. Returns who can mint and the hard cap on maximum tokens after minting.",
        "type": "object",
        "required": [
          "minter"
        ],
        "properties": {
          "minter": {
            "type": "object",
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"allowance\" extension. Returns how much spender can use from owner account, 0 if unset.",
        "type": "object",
        "required": [
          "allowance"
        ],
        "properties": {
          "allowance": {
            "type": "object",
            "required": [
              "owner",
              "spender"
            ],
            "properties": {
              "owner": {
                "type": "string"
              },
              "spender": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"enumerable\" extension (and \"allowances\") Returns all allowances this owner has approved. Supports pagination.",
        "type": "object",
        "required": [
          "all_allowances"
        ],
        "properties": {
          "all_allowances": {
            "type": "object",
            "required": [
              "owner"
            ],
            "properties": {
              "limit": {
                "type": [
                  "integer",
                  "null"
                ],
                "format": "uint32",
                "minimum": 0.0
              },
              "owner": {
                "type": "string"
              },
              "start_after": {
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"enumerable\" extension (and \"allowances\") Returns all allowances this spender has been granted. Supports pagination.",
        "type": "object",
        "required": [
          "all_spender_allowances"
        ],
        "properties": {
          "all_spender_allowances": {
            "type": "object",
            "required": [
              "spender"
            ],
            "properties": {
              "limit": {
                "type": [
                  "integer",
                  "null"
                ],
                "format": "uint32",
                "minimum": 0.0
              },
              "spender": {
                "type": "string"
              },
              "start_after": {
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"enumerable\" extension Returns all accounts that have balances. Supports pagination.",
        "type": "object",
        "required": [
          "all_accounts"
        ],
        "properties": {
          "all_accounts": {
            "type": "object",
            "properties": {
              "limit": {
                "type": [
                  "integer",
                  "null"
                ],
                "format": "uint32",
                "minimum": 0.0
              },
              "start_after": {
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"marketing\" extension Returns more metadata on the contract to display in the client: - description, logo, project url, etc.",
        "type": "object",
        "required": [
          "marketing_info"
        ],
        "properties": {
          "marketing_info": {
            "type": "object",
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      {
        "description": "Only with \"marketing\" extension Downloads the embedded logo data (if stored on chain). Errors if no logo data is stored for this contract.",
        "type": "object",
        "required": [
          "download_logo"
        ],
        "properties": {
          "download_logo": {
            "type": "object",
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      }
    ]
  },
  "migrate": {
    "$schema": "http://json-schema.org/draft-07/schema#",
    "title": "MigrateMsg",
    "type": "object",
    "additionalProperties": false
  },
  "sudo": null,
  "responses": {
    "all_accounts": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "AllAccountsResponse",
      "type": "object",
      "required": [
        "accounts"
      ],
      "properties": {
        "accounts": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "all_allowances": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "AllAllowancesResponse",
      "type": "object",
      "required": [
        "allowances"
      ],
      "properties": {
        "allowances": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/AllowanceInfo"
          }
        }
      },
      "definitions": {
        "AllowanceInfo": {
          "type": "object",
          "required": [
            "allowance",
            "expires",
            "spender"
          ],
          "properties": {
            "allowance": {
              "$ref": "#/definitions/Uint128"
            },
            "expires": {
              "$ref": "#/definitions/Expiration"
            },
            "spender": {
              "type": "string"
            }
          },
          "additionalProperties": false
        },
        "Expiration": {
          "description": "Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)",
          "oneOf": [
            {
              "description": "AtHeight will expire when `env.block.height` >= height",
              "type": "object",
              "required": [
                "at_height"
              ],
              "properties": {
                "at_height": {
                  "type": "integer",
                  "format": "uint64",
                  "minimum": 0.0
                }
              },
              "additionalProperties": false
            },
            {
              "description": "AtTime will expire when `env.block.time` >= time",
              "type": "object",
              "required": [
                "at_time"
              ],
              "properties": {
                "at_time": {
                  "$ref": "#/definitions/Timestamp"
                }
              },
              "additionalProperties": false
            },
            {
              "description": "Never will never expire. Used to express the empty variant",
              "type": "object",
              "required": [
                "never"
              ],
              "properties": {
                "never": {
                  "type": "object",
                  "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"
            }
          ]
        },
        "Uint128": {
          "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
          "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"
        }
      }
    },
    "all_spender_allowances": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "AllSpenderAllowancesResponse",
      "type": "object",
      "required": [
        "allowances"
      ],
      "properties": {
        "allowances": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/SpenderAllowanceInfo"
          }
        }
      },
      "definitions": {
        "Expiration": {
          "description": "Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)",
          "oneOf": [
            {
              "description": "AtHeight will expire when `env.block.height` >= height",
              "type": "object",
              "required": [
                "at_height"
              ],
              "properties": {
                "at_height": {
                  "type": "integer",
                  "format": "uint64",
                  "minimum": 0.0
                }
              },
              "additionalProperties": false
            },
            {
              "description": "AtTime will expire when `env.block.time` >= time",
              "type": "object",
              "required": [
                "at_time"
              ],
              "properties": {
                "at_time": {
                  "$ref": "#/definitions/Timestamp"
                }
              },
              "additionalProperties": false
            },
            {
              "description": "Never will never expire. Used to express the empty variant",
              "type": "object",
              "required": [
                "never"
              ],
              "properties": {
                "never": {
                  "type": "object",
                  "additionalProperties": false
                }
              },
              "additionalProperties": false
            }
          ]
        },
        "SpenderAllowanceInfo": {
          "type": "object",
          "required": [
            "allowance",
            "expires",
            "owner"
          ],
          "properties": {
            "allowance": {
              "$ref": "#/definitions/Uint128"
            },
            "expires": {
              "$ref": "#/definitions/Expiration"
            },
            "owner": {
              "type": "string"
            }
          },
          "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"
            }
          ]
        },
        "Uint128": {
          "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
          "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"
        }
      }
    },
    "allowance": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "AllowanceResponse",
      "type": "object",
      "required": [
        "allowance",
        "expires"
      ],
      "properties": {
        "allowance": {
          "$ref": "#/definitions/Uint128"
        },
        "expires": {
          "$ref": "#/definitions/Expiration"
        }
      },
      "definitions": {
        "Expiration": {
          "description": "Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)",
          "oneOf": [
            {
              "description": "AtHeight will expire when `env.block.height` >= height",
              "type": "object",
              "required": [
                "at_height"
              ],
              "properties": {
                "at_height": {
                  "type": "integer",
                  "format": "uint64",
                  "minimum": 0.0
                }
              },
              "additionalProperties": false
            },
            {
              "description": "AtTime will expire when `env.block.time` >= time",
              "type": "object",
              "required": [
                "at_time"
              ],
              "properties": {
                "at_time": {
                  "$ref": "#/definitions/Timestamp"
                }
              },
              "additionalProperties": false
            },
            {
              "description": "Never will never expire. Used to express the empty variant",
              "type": "object",
              "required": [
                "never"
              ],
              "properties": {
                "never": {
                  "type": "object",
                  "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"
            }
          ]
        },
        "Uint128": {
          "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
          "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"
        }
      }
    },
    "balance": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "BalanceResponse",
      "type": "object",
      "required": [
        "balance"
      ],
      "properties": {
        "balance": {
          "$ref": "#/definitions/Uint128"
        }
      },
      "additionalProperties": false,
      "definitions": {
        "Uint128": {
          "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
          "type": "string"
        }
      }
    },
    "download_logo": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "DownloadLogoResponse",
      "description": "When we download an embedded logo, we get this response type. We expect a SPA to be able to accept this info and display it.",
      "type": "object",
      "required": [
        "data",
        "mime_type"
      ],
      "properties": {
        "data": {
          "$ref": "#/definitions/Binary"
        },
        "mime_type": {
          "type": "string"
        }
      },
      "additionalProperties": false,
      "definitions": {
        "Binary": {
          "description": "Binary is a wrapper around Vec<u8> 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<u8>. See also <https://github.com/CosmWasm/cosmwasm/blob/main/docs/MESSAGE_TYPES.md>.",
          "type": "string"
        }
      }
    },
    "marketing_info": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "MarketingInfoResponse",
      "type": "object",
      "properties": {
        "description": {
          "description": "A longer description of the token and it's utility. Designed for tooltips or such",
          "type": [
            "string",
            "null"
          ]
        },
        "logo": {
          "description": "A link to the logo, or a comment there is an on-chain logo stored",
          "anyOf": [
            {
              "$ref": "#/definitions/LogoInfo"
            },
            {
              "type": "null"
            }
          ]
        },
        "marketing": {
          "description": "The address (if any) who can update this data structure",
          "anyOf": [
            {
              "$ref": "#/definitions/Addr"
            },
            {
              "type": "null"
            }
          ]
        },
        "project": {
          "description": "A URL pointing to the project behind this token.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "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"
        },
        "LogoInfo": {
          "description": "This is used to display logo info, provide a link or inform there is one that can be downloaded from the blockchain itself",
          "oneOf": [
            {
              "description": "A reference to an externally hosted logo. Must be a valid HTTP or HTTPS URL.",
              "type": "object",
              "required": [
                "url"
              ],
              "properties": {
                "url": {
                  "type": "string"
                }
              },
              "additionalProperties": false
            },
            {
              "description": "There is an embedded logo on the chain, make another call to download it.",
              "type": "string",
              "enum": [
                "embedded"
              ]
            }
          ]
        }
      }
    },
    "minter": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "MinterResponse",
      "type": "object",
      "required": [
        "minter"
      ],
      "properties": {
        "cap": {
          "description": "cap is a hard cap on total supply that can be achieved by minting. Note that this refers to total_supply. If None, there is unlimited cap.",
          "anyOf": [
            {
              "$ref": "#/definitions/Uint128"
            },
            {
              "type": "null"
            }
          ]
        },
        "minter": {
          "type": "string"
        }
      },
      "additionalProperties": false,
      "definitions": {
        "Uint128": {
          "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
          "type": "string"
        }
      }
    },
    "token_info": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "title": "TokenInfoResponse",
      "type": "object",
      "required": [
        "decimals",
        "name",
        "symbol",
        "total_supply"
      ],
      "properties": {
        "decimals": {
          "type": "integer",
          "format": "uint8",
          "minimum": 0.0
        },
        "name": {
          "type": "string"
        },
        "symbol": {
          "type": "string"
        },
        "total_supply": {
          "$ref": "#/definitions/Uint128"
        }
      },
      "additionalProperties": false,
      "definitions": {
        "Uint128": {
          "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 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 `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
          "type": "string"
        }
      }
    }
  }
}