candle_auction 0.1.0

CosmWasm implementing candle auction
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::state::{AuctionStatus, PaymentType};
use cosmwasm_schema::cw_serde;
use cosmwasm_std::{Addr, Binary};
use cw20::Cw20ReceiveMsg;
use cw721::Cw721ReceiveMsg;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
/// Auction init msg
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct InstantiateMsg {
    pub min_auction_duration: u64,
    pub max_auction_duration: u64,
    pub enable_auction: bool,
    pub fee_rate: u64,
    pub default_denom: String,
    pub support_contract: Vec<String>,
    pub oracle_contract: String,
}

/// Auction warrper message

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct Auction {
    pub id: u64,
    pub bidder: Option<String>,
}

#[cw_serde]
pub enum ExecuteMsg {
    // /// Post a new auction
    Auction {
        name: String,
        start_timestamp: u64,
        duration: u64,
        payment_type: PaymentType,
        payment: String,
        min_price: Option<u128>,
    },
    /// Winner claim the reward
    WinnerClaim {
        auction_id: u64,
        winner: Option<String>,
    },
    /// Update Config
    UpdateConfig {
        min_auction_duration: Option<u64>,
        max_auction_duration: Option<u64>,
        enable_auction: Option<bool>,
        fee_rate: Option<u64>,
        default_denom: Option<String>,
        support_contract: Option<Vec<String>>,
    },
    /// Candle blow
    BlowCandle { auction_id: u64 },
    /// Receive cw20 interface
    Receive(Cw20ReceiveMsg),
    /// auction flow refund
    FlowRefund { auction_id: u64 },
    /// Bid for denom payment
    BidForDenom {
        bidder: Option<String>,
        auction_id: u64,
    },
    /// cw721 recive
    ReceiveNft(Cw721ReceiveMsg),
}

#[cw_serde]
pub enum QueryMsg {
    /// Get auction static config
    Config {},
    /// Get Auction list
    AuctionList {
        status: Option<AuctionStatus>,
        page: u32,
        limit: u32,
    },
    /// Get auction by auction id
    Auction { id: u64 },
}

#[cw_serde]
pub enum RandQueryMsg {
    Get { round: u64 },
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct GetResponse {
    /// The randomness if available. When the beacon does not exist, this is an empty value.
    pub randomness: Binary,
}

pub mod response {
    use super::*;
    #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
    #[serde(rename_all = "snake_case")]
    pub struct Config {
        pub auction_num: u64,
        pub min_auction_duration: u64,
        pub max_auction_duration: u64,
        pub enable_auction: bool,
        pub fee_rate: u64,
        pub default_denom: String,
        pub support_contract: Vec<String>,
    }

    #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
    #[serde(rename_all = "snake_case")]
    pub struct Auction {
        pub name: String,
        pub start_timestamp: u64,
        pub auction_duration: u64,
        pub bidders: Vec<(String, u64, u128)>,
        pub curr_winner: Option<(String, u64, u128)>,
        pub tokens: Vec<(String, String)>,
        pub seller: Addr,
        pub payment_type: PaymentType,
        pub payment: String,
        pub min_price: Option<u128>,
        pub bid_num: u32,
    }
}

#[cw_serde]
pub struct MigrateMsg {}