From 20d2ef7c30c0b60bd4b3692bd76936325093c310 Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:34:45 +0100 Subject: [PATCH 1/8] feat: init governace --- Cargo.toml | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a76dc89..4509b4f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,24 +1,25 @@ [workspace] resolver = "2" members = [ - "contracts/teachlink", + "contracts/governance", "contracts/insurance", + "contracts/teachlink", ] [workspace.package] edition = "2021" -license = "MIT" repository = "https://github.com/rinafcode/teachLink_contract" +license = "MIT" [workspace.dependencies] soroban-sdk = "25.0.0-rc.2" -[workspace.lints.rust] -unsafe_code = "deny" - [workspace.lints.clippy] all = { level = "warn", priority = -1 } -pedantic = { level = "warn", priority = -2 } -module_name_repetitions = "allow" missing_errors_doc = "allow" missing_panics_doc = "allow" +module_name_repetitions = "allow" +pedantic = { level = "warn", priority = -2 } + +[workspace.lints.rust] +unsafe_code = "deny" From 280a329372f879542b2cda71fc96389f69f1066f Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:35:58 +0100 Subject: [PATCH 2/8] feat: Add Proposal, Vote, ProposalType, ProposalStatus types --- contracts/governance/src/types.rs | 116 ++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 contracts/governance/src/types.rs diff --git a/contracts/governance/src/types.rs b/contracts/governance/src/types.rs new file mode 100644 index 0000000..4dedf04 --- /dev/null +++ b/contracts/governance/src/types.rs @@ -0,0 +1,116 @@ +use soroban_sdk::{contracttype, Address, Bytes}; + +/// Types of proposals that can be created in the governance system +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ProposalType { + /// Change platform fee parameters + FeeChange, + /// Update governance or platform parameters + ParameterUpdate, + /// Toggle platform features on/off + FeatureToggle, + /// Custom proposal with arbitrary execution data + Custom, +} + +/// Status of a proposal throughout its lifecycle +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ProposalStatus { + /// Proposal created, waiting for voting to start + Pending, + /// Voting is active + Active, + /// Voting ended with quorum met and majority for + Passed, + /// Voting ended with quorum not met or majority against + Failed, + /// Proposal has been executed + Executed, + /// Proposal was cancelled + Cancelled, +} + +/// Vote direction options +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum VoteDirection { + For, + Against, + Abstain, +} + +/// Individual vote record +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct Vote { + /// Voter address + pub voter: Address, + /// Proposal being voted on + pub proposal_id: u64, + /// Voting power at time of vote + pub power: i128, + /// Vote direction + pub direction: VoteDirection, + /// Timestamp of vote + pub timestamp: u64, +} + +/// Key for storing individual votes +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct VoteKey { + pub proposal_id: u64, + pub voter: Address, +} + +/// Complete proposal information +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct Proposal { + /// Unique proposal identifier + pub id: u64, + /// Address that created the proposal + pub proposer: Address, + /// Short title for the proposal + pub title: Bytes, + /// Detailed description of the proposal + pub description: Bytes, + /// Type of proposal + pub proposal_type: ProposalType, + /// Current status + pub status: ProposalStatus, + /// Creation timestamp + pub created_at: u64, + /// When voting begins + pub voting_start: u64, + /// When voting ends + pub voting_end: u64, + /// Total votes for + pub for_votes: i128, + /// Total votes against + pub against_votes: i128, + /// Total abstention votes + pub abstain_votes: i128, + /// Optional execution data for the proposal + pub execution_data: Option, +} + +/// Governance configuration parameters +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct GovernanceConfig { + /// Governance token address + pub token: Address, + /// Admin address + pub admin: Address, + /// Minimum tokens required to create a proposal + pub proposal_threshold: i128, + /// Minimum total votes required for quorum + pub quorum: i128, + /// Duration of voting period in seconds + pub voting_period: u64, + /// Delay before execution after passing (in seconds) + pub execution_delay: u64, +} From d301fc7eaf49ec40914feb305d931fed94593f2c Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:36:36 +0100 Subject: [PATCH 3/8] feat: Add storage keys and event definitions --- contracts/governance/Cargo.toml | 21 ++++++++++ contracts/governance/src/events.rs | 61 +++++++++++++++++++++++++++++ contracts/governance/src/storage.rs | 21 ++++++++++ 3 files changed, 103 insertions(+) create mode 100644 contracts/governance/Cargo.toml create mode 100644 contracts/governance/src/events.rs create mode 100644 contracts/governance/src/storage.rs diff --git a/contracts/governance/Cargo.toml b/contracts/governance/Cargo.toml new file mode 100644 index 0000000..93e1d4c --- /dev/null +++ b/contracts/governance/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "governance-contract" +version = "0.1.0" +edition.workspace = true +repository.workspace = true +license.workspace = true + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +soroban-sdk.workspace = true + +[dev-dependencies] +soroban-sdk = { workspace = true, features = ["testutils"] } + +[features] +testutils = ["soroban-sdk/testutils"] + +[lints] +workspace = true diff --git a/contracts/governance/src/events.rs b/contracts/governance/src/events.rs new file mode 100644 index 0000000..53b8d10 --- /dev/null +++ b/contracts/governance/src/events.rs @@ -0,0 +1,61 @@ +use soroban_sdk::{Address, Bytes, Env, Symbol}; + +use crate::types::{ProposalStatus, ProposalType, VoteDirection}; + +/// Emitted when a new proposal is created +pub fn proposal_created( + env: &Env, + proposal_id: u64, + proposer: &Address, + title: &Bytes, + proposal_type: &ProposalType, +) { + let topics = (Symbol::new(env, "proposal_created"), proposer); + env.events() + .publish(topics, (proposal_id, title.clone(), proposal_type.clone())); +} + +/// Emitted when a vote is cast +pub fn vote_cast( + env: &Env, + proposal_id: u64, + voter: &Address, + direction: &VoteDirection, + power: i128, +) { + let topics = (Symbol::new(env, "vote_cast"), voter); + env.events() + .publish(topics, (proposal_id, direction.clone(), power)); +} + +/// Emitted when a proposal status changes +pub fn proposal_status_changed( + env: &Env, + proposal_id: u64, + old_status: &ProposalStatus, + new_status: &ProposalStatus, +) { + let topics = (Symbol::new(env, "proposal_status"),); + env.events().publish( + topics, + (proposal_id, old_status.clone(), new_status.clone()), + ); +} + +/// Emitted when a proposal is executed +pub fn proposal_executed(env: &Env, proposal_id: u64, executor: &Address) { + let topics = (Symbol::new(env, "proposal_executed"), executor); + env.events().publish(topics, proposal_id); +} + +/// Emitted when a proposal is cancelled +pub fn proposal_cancelled(env: &Env, proposal_id: u64, cancelled_by: &Address) { + let topics = (Symbol::new(env, "proposal_cancelled"), cancelled_by); + env.events().publish(topics, proposal_id); +} + +/// Emitted when governance configuration is updated +pub fn config_updated(env: &Env, admin: &Address) { + let topics = (Symbol::new(env, "config_updated"), admin); + env.events().publish(topics, ()); +} diff --git a/contracts/governance/src/storage.rs b/contracts/governance/src/storage.rs new file mode 100644 index 0000000..ef01ae2 --- /dev/null +++ b/contracts/governance/src/storage.rs @@ -0,0 +1,21 @@ +use soroban_sdk::{symbol_short, Symbol}; + +// Storage keys for the governance contract + +/// Governance configuration +pub const CONFIG: Symbol = symbol_short!("config"); + +/// Proposal count (for generating IDs) +pub const PROPOSAL_COUNT: Symbol = symbol_short!("prop_cnt"); + +/// Proposals storage prefix +pub const PROPOSALS: Symbol = symbol_short!("proposal"); + +/// Votes storage prefix +pub const VOTES: Symbol = symbol_short!("votes"); + +/// Admin address +pub const ADMIN: Symbol = symbol_short!("admin"); + +/// Governance token address +pub const TOKEN: Symbol = symbol_short!("token"); From f92c57e6f3a00caadd6308055602a3cb365352cf Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:37:05 +0100 Subject: [PATCH 4/8] initialize, Set up governance t --- contracts/governance/src/governance.rs | 367 +++++++++++++++++++++++++ 1 file changed, 367 insertions(+) create mode 100644 contracts/governance/src/governance.rs diff --git a/contracts/governance/src/governance.rs b/contracts/governance/src/governance.rs new file mode 100644 index 0000000..c8cdef7 --- /dev/null +++ b/contracts/governance/src/governance.rs @@ -0,0 +1,367 @@ +//! Core governance logic for the TeachLink platform +//! +//! This module implements proposal management, voting, and execution. + +use soroban_sdk::{token, Address, Bytes, Env}; + +use crate::events; +use crate::storage::{CONFIG, PROPOSALS, PROPOSAL_COUNT, VOTES}; +use crate::types::{ + GovernanceConfig, Proposal, ProposalStatus, ProposalType, Vote, VoteDirection, VoteKey, +}; + +pub struct Governance; + +impl Governance { + /// Initialize the governance contract + pub fn initialize( + env: &Env, + token: Address, + admin: Address, + proposal_threshold: i128, + quorum: i128, + voting_period: u64, + execution_delay: u64, + ) { + if env.storage().instance().has(&CONFIG) { + panic!("Already initialized"); + } + + let config = GovernanceConfig { + token, + admin, + proposal_threshold, + quorum, + voting_period, + execution_delay, + }; + + env.storage().instance().set(&CONFIG, &config); + env.storage().instance().set(&PROPOSAL_COUNT, &0u64); + } + + /// Get the current governance configuration + pub fn get_config(env: &Env) -> GovernanceConfig { + env.storage() + .instance() + .get(&CONFIG) + .expect("Not initialized") + } + + /// Get the admin address + pub fn get_admin(env: &Env) -> Address { + Self::get_config(env).admin + } + + /// Get the governance token address + pub fn get_token(env: &Env) -> Address { + Self::get_config(env).token + } + + /// Create a new proposal + pub fn create_proposal( + env: &Env, + proposer: Address, + title: Bytes, + description: Bytes, + proposal_type: ProposalType, + execution_data: Option, + ) -> u64 { + proposer.require_auth(); + + let config = Self::get_config(env); + + // Check proposer has enough tokens + let token_client = token::Client::new(env, &config.token); + let balance = token_client.balance(&proposer); + if balance < config.proposal_threshold { + panic!("Insufficient token balance to create proposal"); + } + + // Generate proposal ID + let mut proposal_count: u64 = env.storage().instance().get(&PROPOSAL_COUNT).unwrap_or(0); + proposal_count += 1; + + let now = env.ledger().timestamp(); + let voting_start = now; // Voting starts immediately + let voting_end = voting_start + config.voting_period; + + let proposal = Proposal { + id: proposal_count, + proposer: proposer.clone(), + title: title.clone(), + description, + proposal_type: proposal_type.clone(), + status: ProposalStatus::Active, // Active immediately + created_at: now, + voting_start, + voting_end, + for_votes: 0, + against_votes: 0, + abstain_votes: 0, + execution_data, + }; + + // Store proposal + env.storage() + .persistent() + .set(&(PROPOSALS, proposal_count), &proposal); + env.storage() + .instance() + .set(&PROPOSAL_COUNT, &proposal_count); + + // Emit event + events::proposal_created(env, proposal_count, &proposer, &title, &proposal_type); + + proposal_count + } + + /// Cast a vote on a proposal + pub fn cast_vote( + env: &Env, + proposal_id: u64, + voter: Address, + direction: VoteDirection, + ) -> i128 { + voter.require_auth(); + + let config = Self::get_config(env); + + // Get proposal + let mut proposal: Proposal = env + .storage() + .persistent() + .get(&(PROPOSALS, proposal_id)) + .expect("Proposal not found"); + + // Check proposal is active + if proposal.status != ProposalStatus::Active { + panic!("Proposal is not active"); + } + + // Check voting period + let now = env.ledger().timestamp(); + if now < proposal.voting_start || now > proposal.voting_end { + panic!("Voting period not active"); + } + + // Check if already voted + let vote_key = VoteKey { + proposal_id, + voter: voter.clone(), + }; + if env.storage().persistent().has(&(VOTES, vote_key.clone())) { + panic!("Already voted on this proposal"); + } + + // Get voting power (token balance) + let token_client = token::Client::new(env, &config.token); + let power = token_client.balance(&voter); + if power <= 0 { + panic!("No voting power"); + } + + // Record vote + let vote = Vote { + voter: voter.clone(), + proposal_id, + power, + direction: direction.clone(), + timestamp: now, + }; + env.storage().persistent().set(&(VOTES, vote_key), &vote); + + // Update proposal vote counts + match direction { + VoteDirection::For => proposal.for_votes += power, + VoteDirection::Against => proposal.against_votes += power, + VoteDirection::Abstain => proposal.abstain_votes += power, + } + + env.storage() + .persistent() + .set(&(PROPOSALS, proposal_id), &proposal); + + // Emit event + events::vote_cast(env, proposal_id, &voter, &direction, power); + + power + } + + /// Finalize a proposal after voting ends + pub fn finalize_proposal(env: &Env, proposal_id: u64) { + let config = Self::get_config(env); + + let mut proposal: Proposal = env + .storage() + .persistent() + .get(&(PROPOSALS, proposal_id)) + .expect("Proposal not found"); + + // Check proposal is still active + if proposal.status != ProposalStatus::Active { + panic!("Proposal is not active"); + } + + // Check voting period has ended + let now = env.ledger().timestamp(); + if now <= proposal.voting_end { + panic!("Voting period not ended"); + } + + let old_status = proposal.status.clone(); + + // Calculate total votes + let total_votes = proposal.for_votes + proposal.against_votes + proposal.abstain_votes; + + // Check quorum and majority + if total_votes >= config.quorum && proposal.for_votes > proposal.against_votes { + proposal.status = ProposalStatus::Passed; + } else { + proposal.status = ProposalStatus::Failed; + } + + env.storage() + .persistent() + .set(&(PROPOSALS, proposal_id), &proposal); + + events::proposal_status_changed(env, proposal_id, &old_status, &proposal.status); + } + + /// Execute a passed proposal + pub fn execute_proposal(env: &Env, proposal_id: u64, executor: Address) { + executor.require_auth(); + + let config = Self::get_config(env); + + let mut proposal: Proposal = env + .storage() + .persistent() + .get(&(PROPOSALS, proposal_id)) + .expect("Proposal not found"); + + // Check proposal has passed + if proposal.status != ProposalStatus::Passed { + panic!("Proposal has not passed"); + } + + // Check execution delay has passed + let now = env.ledger().timestamp(); + if now < proposal.voting_end + config.execution_delay { + panic!("Execution delay not met"); + } + + let old_status = proposal.status.clone(); + proposal.status = ProposalStatus::Executed; + + env.storage() + .persistent() + .set(&(PROPOSALS, proposal_id), &proposal); + + events::proposal_status_changed(env, proposal_id, &old_status, &proposal.status); + events::proposal_executed(env, proposal_id, &executor); + } + + /// Cancel a proposal (by proposer before voting ends, or by admin anytime) + pub fn cancel_proposal(env: &Env, proposal_id: u64, caller: Address) { + caller.require_auth(); + + let config = Self::get_config(env); + + let mut proposal: Proposal = env + .storage() + .persistent() + .get(&(PROPOSALS, proposal_id)) + .expect("Proposal not found"); + + // Check if cancellable + let is_admin = caller == config.admin; + let is_proposer = caller == proposal.proposer; + let now = env.ledger().timestamp(); + let voting_ended = now > proposal.voting_end; + + if !is_admin && !is_proposer { + panic!("Only proposer or admin can cancel"); + } + + if !is_admin && voting_ended { + panic!("Proposer can only cancel during voting period"); + } + + // Cannot cancel executed proposals + if proposal.status == ProposalStatus::Executed { + panic!("Cannot cancel executed proposal"); + } + + let old_status = proposal.status.clone(); + proposal.status = ProposalStatus::Cancelled; + + env.storage() + .persistent() + .set(&(PROPOSALS, proposal_id), &proposal); + + events::proposal_status_changed(env, proposal_id, &old_status, &proposal.status); + events::proposal_cancelled(env, proposal_id, &caller); + } + + /// Update governance configuration (admin only) + pub fn update_config( + env: &Env, + new_proposal_threshold: Option, + new_quorum: Option, + new_voting_period: Option, + new_execution_delay: Option, + ) { + let mut config = Self::get_config(env); + config.admin.require_auth(); + + if let Some(threshold) = new_proposal_threshold { + config.proposal_threshold = threshold; + } + if let Some(quorum) = new_quorum { + config.quorum = quorum; + } + if let Some(period) = new_voting_period { + config.voting_period = period; + } + if let Some(delay) = new_execution_delay { + config.execution_delay = delay; + } + + env.storage().instance().set(&CONFIG, &config); + events::config_updated(env, &config.admin); + } + + /// Transfer admin role to a new address + pub fn transfer_admin(env: &Env, new_admin: Address) { + let mut config = Self::get_config(env); + config.admin.require_auth(); + + config.admin = new_admin; + env.storage().instance().set(&CONFIG, &config); + } + + // ========== View Functions ========== + + /// Get a proposal by ID + pub fn get_proposal(env: &Env, proposal_id: u64) -> Option { + env.storage().persistent().get(&(PROPOSALS, proposal_id)) + } + + /// Get a vote by proposal ID and voter + pub fn get_vote(env: &Env, proposal_id: u64, voter: Address) -> Option { + let vote_key = VoteKey { proposal_id, voter }; + env.storage().persistent().get(&(VOTES, vote_key)) + } + + /// Check if an address has voted on a proposal + pub fn has_voted(env: &Env, proposal_id: u64, voter: Address) -> bool { + let vote_key = VoteKey { proposal_id, voter }; + env.storage().persistent().has(&(VOTES, vote_key)) + } + + /// Get the current proposal count + pub fn get_proposal_count(env: &Env) -> u64 { + env.storage().instance().get(&PROPOSAL_COUNT).unwrap_or(0) + } +} From fd6a849b0594bff1ff0832eace3652a6a7348e32 Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:37:31 +0100 Subject: [PATCH 5/8] feat: expose governance fn --- contracts/governance/src/lib.rs | 171 ++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 contracts/governance/src/lib.rs diff --git a/contracts/governance/src/lib.rs b/contracts/governance/src/lib.rs new file mode 100644 index 0000000..0f9cdb0 --- /dev/null +++ b/contracts/governance/src/lib.rs @@ -0,0 +1,171 @@ +#![no_std] + +//! TeachLink Governance Contract +//! +//! A decentralized governance system allowing token holders to vote on +//! platform changes, fee structures, and new feature implementations. + +use soroban_sdk::{contract, contractimpl, Address, Bytes, Env}; + +mod events; +mod governance; +pub mod mock_token; +mod storage; +mod types; + +pub use mock_token::{MockToken, MockTokenClient}; +pub use types::{ + GovernanceConfig, Proposal, ProposalStatus, ProposalType, Vote, VoteDirection, VoteKey, +}; + +#[contract] +pub struct GovernanceContract; + +#[contractimpl] +impl GovernanceContract { + // ========== Initialization ========== + + /// Initialize the governance contract + /// + /// # Arguments + /// * `token` - Address of the governance token + /// * `admin` - Admin address for privileged operations + /// * `proposal_threshold` - Minimum tokens required to create a proposal + /// * `quorum` - Minimum total votes required for a proposal to pass + /// * `voting_period` - Duration of voting period in seconds (e.g., 604800 for 7 days) + /// * `execution_delay` - Delay before executing passed proposals in seconds + pub fn initialize( + env: Env, + token: Address, + admin: Address, + proposal_threshold: i128, + quorum: i128, + voting_period: u64, + execution_delay: u64, + ) { + governance::Governance::initialize( + &env, + token, + admin, + proposal_threshold, + quorum, + voting_period, + execution_delay, + ); + } + + // ========== Proposal Management ========== + + /// Create a new governance proposal + /// + /// Requires the proposer to hold at least `proposal_threshold` tokens. + /// Voting starts immediately upon proposal creation. + pub fn create_proposal( + env: Env, + proposer: Address, + title: Bytes, + description: Bytes, + proposal_type: ProposalType, + execution_data: Option, + ) -> u64 { + governance::Governance::create_proposal( + &env, + proposer, + title, + description, + proposal_type, + execution_data, + ) + } + + /// Cast a vote on an active proposal + /// + /// Voting power is equal to the voter's token balance at time of voting. + /// Each address can only vote once per proposal. + pub fn cast_vote(env: Env, proposal_id: u64, voter: Address, direction: VoteDirection) -> i128 { + governance::Governance::cast_vote(&env, proposal_id, voter, direction) + } + + /// Finalize a proposal after voting ends + /// + /// Updates the proposal status to Passed or Failed based on votes and quorum. + pub fn finalize_proposal(env: Env, proposal_id: u64) { + governance::Governance::finalize_proposal(&env, proposal_id); + } + + /// Execute a passed proposal + /// + /// Can be called by anyone after the execution delay has passed. + pub fn execute_proposal(env: Env, proposal_id: u64, executor: Address) { + governance::Governance::execute_proposal(&env, proposal_id, executor); + } + + /// Cancel a proposal + /// + /// - Proposer can cancel during voting period + /// - Admin can cancel anytime (except executed proposals) + pub fn cancel_proposal(env: Env, proposal_id: u64, caller: Address) { + governance::Governance::cancel_proposal(&env, proposal_id, caller); + } + + // ========== Admin Functions ========== + + /// Update governance configuration (admin only) + pub fn update_config( + env: Env, + new_proposal_threshold: Option, + new_quorum: Option, + new_voting_period: Option, + new_execution_delay: Option, + ) { + governance::Governance::update_config( + &env, + new_proposal_threshold, + new_quorum, + new_voting_period, + new_execution_delay, + ); + } + + /// Transfer admin role to a new address (admin only) + pub fn transfer_admin(env: Env, new_admin: Address) { + governance::Governance::transfer_admin(&env, new_admin); + } + + // ========== View Functions ========== + + /// Get the governance configuration + pub fn get_config(env: Env) -> GovernanceConfig { + governance::Governance::get_config(&env) + } + + /// Get a proposal by ID + pub fn get_proposal(env: Env, proposal_id: u64) -> Option { + governance::Governance::get_proposal(&env, proposal_id) + } + + /// Get a vote record + pub fn get_vote(env: Env, proposal_id: u64, voter: Address) -> Option { + governance::Governance::get_vote(&env, proposal_id, voter) + } + + /// Check if an address has voted on a proposal + pub fn has_voted(env: Env, proposal_id: u64, voter: Address) -> bool { + governance::Governance::has_voted(&env, proposal_id, voter) + } + + /// Get the current proposal count + pub fn get_proposal_count(env: Env) -> u64 { + governance::Governance::get_proposal_count(&env) + } + + /// Get the admin address + pub fn get_admin(env: Env) -> Address { + governance::Governance::get_admin(&env) + } + + /// Get the governance token address + pub fn get_token(env: Env) -> Address { + governance::Governance::get_token(&env) + } +} From a37a5cea67ed4290893aab742e2a3403a6418227 Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:37:45 +0100 Subject: [PATCH 6/8] Add MockToken contract for testing --- contracts/governance/src/mock_token.rs | 178 +++++++++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 contracts/governance/src/mock_token.rs diff --git a/contracts/governance/src/mock_token.rs b/contracts/governance/src/mock_token.rs new file mode 100644 index 0000000..57b8bee --- /dev/null +++ b/contracts/governance/src/mock_token.rs @@ -0,0 +1,178 @@ +//! Mock Token Contract for Testing +//! +//! A simple ERC20-like token for testing governance functionality. + +use soroban_sdk::{contract, contractimpl, contracttype, Address, Env, Map, String}; + +#[contracttype] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum TokenDataKey { + Admin, + Balances, + Allowances, + TotalSupply, + Name, + Symbol, + Decimals, +} + +#[contract] +pub struct MockToken; + +#[contractimpl] +impl MockToken { + /// Initialize the mock token + pub fn initialize(env: Env, admin: Address, name: String, symbol: String, decimals: u32) { + if env.storage().instance().has(&TokenDataKey::Admin) { + panic!("Already initialized"); + } + + env.storage().instance().set(&TokenDataKey::Admin, &admin); + env.storage().instance().set(&TokenDataKey::Name, &name); + env.storage().instance().set(&TokenDataKey::Symbol, &symbol); + env.storage() + .instance() + .set(&TokenDataKey::Decimals, &decimals); + env.storage() + .instance() + .set(&TokenDataKey::TotalSupply, &0i128); + + let balances: Map = Map::new(&env); + env.storage() + .instance() + .set(&TokenDataKey::Balances, &balances); + } + + /// Mint tokens to an address (admin only) + pub fn mint(env: Env, to: Address, amount: i128) { + if amount <= 0 { + panic!("Amount must be positive"); + } + + let admin: Address = env + .storage() + .instance() + .get(&TokenDataKey::Admin) + .expect("Not initialized"); + admin.require_auth(); + + let mut balances = Self::load_balances(&env); + let new_balance = balances.get(to.clone()).unwrap_or(0) + amount; + balances.set(to, new_balance); + env.storage() + .instance() + .set(&TokenDataKey::Balances, &balances); + + let total_supply: i128 = env + .storage() + .instance() + .get(&TokenDataKey::TotalSupply) + .unwrap_or(0); + env.storage() + .instance() + .set(&TokenDataKey::TotalSupply, &(total_supply + amount)); + } + + /// Burn tokens from an address + pub fn burn(env: Env, from: Address, amount: i128) { + if amount <= 0 { + panic!("Amount must be positive"); + } + from.require_auth(); + + let mut balances = Self::load_balances(&env); + let from_balance = balances.get(from.clone()).unwrap_or(0); + if from_balance < amount { + panic!("Insufficient balance"); + } + + balances.set(from, from_balance - amount); + env.storage() + .instance() + .set(&TokenDataKey::Balances, &balances); + + let total_supply: i128 = env + .storage() + .instance() + .get(&TokenDataKey::TotalSupply) + .unwrap_or(0); + env.storage() + .instance() + .set(&TokenDataKey::TotalSupply, &(total_supply - amount)); + } + + /// Transfer tokens from one address to another + pub fn transfer(env: Env, from: Address, to: Address, amount: i128) { + if amount <= 0 { + panic!("Amount must be positive"); + } + from.require_auth(); + + let mut balances = Self::load_balances(&env); + let from_balance = balances.get(from.clone()).unwrap_or(0); + if from_balance < amount { + panic!("Insufficient balance"); + } + + balances.set(from.clone(), from_balance - amount); + let to_balance = balances.get(to.clone()).unwrap_or(0); + balances.set(to, to_balance + amount); + env.storage() + .instance() + .set(&TokenDataKey::Balances, &balances); + } + + /// Get the balance of an address + pub fn balance(env: Env, owner: Address) -> i128 { + let balances = Self::load_balances(&env); + balances.get(owner).unwrap_or(0) + } + + /// Get total supply + pub fn total_supply(env: Env) -> i128 { + env.storage() + .instance() + .get(&TokenDataKey::TotalSupply) + .unwrap_or(0) + } + + /// Get token name + pub fn name(env: Env) -> String { + env.storage() + .instance() + .get(&TokenDataKey::Name) + .expect("Not initialized") + } + + /// Get token symbol + pub fn symbol(env: Env) -> String { + env.storage() + .instance() + .get(&TokenDataKey::Symbol) + .expect("Not initialized") + } + + /// Get token decimals + pub fn decimals(env: Env) -> u32 { + env.storage() + .instance() + .get(&TokenDataKey::Decimals) + .unwrap_or(18) + } + + /// Get admin address + pub fn admin(env: Env) -> Address { + env.storage() + .instance() + .get(&TokenDataKey::Admin) + .expect("Not initialized") + } + + // Internal helper to load balances + fn load_balances(env: &Env) -> Map { + env.storage() + .instance() + .get(&TokenDataKey::Balances) + .unwrap_or_else(|| Map::new(env)) + } +} From 0465bbe25e3653e59936eb961810dc6fed2337c9 Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:37:58 +0100 Subject: [PATCH 7/8] Add comprehensive test suite --- contracts/governance/tests/test_governance.rs | 321 ++++++++++++++++++ 1 file changed, 321 insertions(+) create mode 100644 contracts/governance/tests/test_governance.rs diff --git a/contracts/governance/tests/test_governance.rs b/contracts/governance/tests/test_governance.rs new file mode 100644 index 0000000..3293fad --- /dev/null +++ b/contracts/governance/tests/test_governance.rs @@ -0,0 +1,321 @@ +use soroban_sdk::{ + testutils::{Address as _, Ledger as _}, + Address, Bytes, Env, String, +}; + +use governance_contract::{ + GovernanceContract, GovernanceContractClient, MockToken, MockTokenClient, ProposalStatus, + ProposalType, VoteDirection, +}; + +// ========== Test Helper ========== + +fn setup_governance() -> ( + Env, + GovernanceContractClient<'static>, + MockTokenClient<'static>, + Address, + Address, + Address, +) { + let env = Env::default(); + env.mock_all_auths(); + + // Register contracts + let governance_id = env.register(GovernanceContract, ()); + let governance_client = GovernanceContractClient::new(&env, &governance_id); + + let token_id = env.register(MockToken, ()); + let token_client = MockTokenClient::new(&env, &token_id); + + // Set up addresses + let admin = Address::generate(&env); + let voter1 = Address::generate(&env); + let voter2 = Address::generate(&env); + + // Initialize token + let name = String::from_str(&env, "Governance Token"); + let symbol = String::from_str(&env, "GOV"); + token_client.initialize(&admin, &name, &symbol, &18); + + // Mint tokens + token_client.mint(&voter1, &1000); + token_client.mint(&voter2, &500); + token_client.mint(&admin, &2000); + + // Initialize governance + governance_client.initialize( + &token_id, &admin, &100, // proposal_threshold + &500, // quorum + &3600, // voting_period (1 hour) + &60, // execution_delay (1 minute) + ); + + (env, governance_client, token_client, admin, voter1, voter2) +} + +// ========== Tests ========== + +#[test] +fn test_initialize_governance() { + let (_env, governance_client, _token_client, admin, _voter1, _voter2) = setup_governance(); + + let config = governance_client.get_config(); + assert_eq!(config.admin, admin); + assert_eq!(config.proposal_threshold, 100); + assert_eq!(config.quorum, 500); + assert_eq!(config.voting_period, 3600); + assert_eq!(config.execution_delay, 60); +} + +#[test] +fn test_create_proposal() { + let (env, governance_client, _token_client, admin, _voter1, _voter2) = setup_governance(); + + let title = Bytes::from_slice(&env, b"Test Proposal"); + let description = Bytes::from_slice(&env, b"A test proposal for governance"); + + let proposal_id = governance_client.create_proposal( + &admin, + &title, + &description, + &ProposalType::ParameterUpdate, + &None, + ); + + assert_eq!(proposal_id, 1); + + let proposal = governance_client.get_proposal(&proposal_id).unwrap(); + assert_eq!(proposal.id, 1); + assert_eq!(proposal.proposer, admin); + assert_eq!(proposal.status, ProposalStatus::Active); + assert_eq!(proposal.for_votes, 0); + assert_eq!(proposal.against_votes, 0); +} + +#[test] +#[should_panic(expected = "Insufficient token balance to create proposal")] +fn test_create_proposal_insufficient_balance() { + let (env, governance_client, _token_client, _admin, _voter1, _voter2) = setup_governance(); + + // Create a new address with no tokens + let poor_user = Address::generate(&env); + + let title = Bytes::from_slice(&env, b"Test Proposal"); + let description = Bytes::from_slice(&env, b"Should fail"); + + governance_client.create_proposal( + &poor_user, + &title, + &description, + &ProposalType::ParameterUpdate, + &None, + ); +} + +#[test] +fn test_cast_vote() { + let (env, governance_client, _token_client, admin, voter1, voter2) = setup_governance(); + + // Create proposal + let title = Bytes::from_slice(&env, b"Test Proposal"); + let description = Bytes::from_slice(&env, b"Vote test"); + let proposal_id = governance_client.create_proposal( + &admin, + &title, + &description, + &ProposalType::FeeChange, + &None, + ); + + // Cast votes + let power1 = governance_client.cast_vote(&proposal_id, &voter1, &VoteDirection::For); + assert_eq!(power1, 1000); + + let power2 = governance_client.cast_vote(&proposal_id, &voter2, &VoteDirection::Against); + assert_eq!(power2, 500); + + // Check proposal vote counts + let proposal = governance_client.get_proposal(&proposal_id).unwrap(); + assert_eq!(proposal.for_votes, 1000); + assert_eq!(proposal.against_votes, 500); + + // Check has_voted + assert!(governance_client.has_voted(&proposal_id, &voter1)); + assert!(governance_client.has_voted(&proposal_id, &voter2)); +} + +#[test] +#[should_panic(expected = "Already voted on this proposal")] +fn test_double_vote() { + let (env, governance_client, _token_client, admin, voter1, _voter2) = setup_governance(); + + let title = Bytes::from_slice(&env, b"Test Proposal"); + let description = Bytes::from_slice(&env, b"Double vote test"); + let proposal_id = governance_client.create_proposal( + &admin, + &title, + &description, + &ProposalType::ParameterUpdate, + &None, + ); + + governance_client.cast_vote(&proposal_id, &voter1, &VoteDirection::For); + governance_client.cast_vote(&proposal_id, &voter1, &VoteDirection::Against); + // Should panic +} + +#[test] +fn test_finalize_and_execute_proposal() { + let (env, governance_client, _token_client, admin, _voter1, _voter2) = setup_governance(); + + let title = Bytes::from_slice(&env, b"Execute Test"); + let description = Bytes::from_slice(&env, b"Test execution"); + let proposal_id = governance_client.create_proposal( + &admin, + &title, + &description, + &ProposalType::FeatureToggle, + &None, + ); + + // Vote for with quorum (admin has 2000) + governance_client.cast_vote(&proposal_id, &admin, &VoteDirection::For); + + // Advance time past voting period + env.ledger().with_mut(|li| { + li.timestamp += 3700; // Past 1 hour voting period + }); + + // Finalize + governance_client.finalize_proposal(&proposal_id); + + let proposal = governance_client.get_proposal(&proposal_id).unwrap(); + assert_eq!(proposal.status, ProposalStatus::Passed); + + // Advance time past execution delay + env.ledger().with_mut(|li| { + li.timestamp += 100; // Past 1 minute execution delay + }); + + // Execute + governance_client.execute_proposal(&proposal_id, &admin); + + let proposal = governance_client.get_proposal(&proposal_id).unwrap(); + assert_eq!(proposal.status, ProposalStatus::Executed); +} + +#[test] +fn test_cancel_proposal() { + let (env, governance_client, _token_client, admin, _voter1, _voter2) = setup_governance(); + + let title = Bytes::from_slice(&env, b"Cancel Test"); + let description = Bytes::from_slice(&env, b"Test cancellation"); + let proposal_id = governance_client.create_proposal( + &admin, + &title, + &description, + &ProposalType::Custom, + &None, + ); + + governance_client.cancel_proposal(&proposal_id, &admin); + + let proposal = governance_client.get_proposal(&proposal_id).unwrap(); + assert_eq!(proposal.status, ProposalStatus::Cancelled); +} + +#[test] +fn test_update_config() { + let (_env, governance_client, _token_client, _admin, _voter1, _voter2) = setup_governance(); + + governance_client.update_config(&Some(200), &Some(1000), &Some(7200), &Some(120)); + + let config = governance_client.get_config(); + assert_eq!(config.proposal_threshold, 200); + assert_eq!(config.quorum, 1000); + assert_eq!(config.voting_period, 7200); + assert_eq!(config.execution_delay, 120); +} + +#[test] +fn test_proposal_passes_with_quorum() { + let (env, governance_client, _token_client, admin, _voter1, voter2) = setup_governance(); + + let title = Bytes::from_slice(&env, b"Quorum Test"); + let description = Bytes::from_slice(&env, b"Should pass with quorum"); + let proposal_id = governance_client.create_proposal( + &admin, + &title, + &description, + &ProposalType::ParameterUpdate, + &None, + ); + + // voter2 votes (500 tokens = quorum threshold) + governance_client.cast_vote(&proposal_id, &voter2, &VoteDirection::For); + + // Advance time past voting period + env.ledger().with_mut(|li| { + li.timestamp += 3700; + }); + + // Finalize - should pass since 500 >= 500 quorum and all for + governance_client.finalize_proposal(&proposal_id); + + let proposal = governance_client.get_proposal(&proposal_id).unwrap(); + assert_eq!(proposal.status, ProposalStatus::Passed); +} + +#[test] +fn test_proposal_fails_majority_against() { + let (env, governance_client, _token_client, admin, voter1, voter2) = setup_governance(); + + let title = Bytes::from_slice(&env, b"Rejected"); + let description = Bytes::from_slice(&env, b"Should be rejected"); + let proposal_id = governance_client.create_proposal( + &admin, + &title, + &description, + &ProposalType::ParameterUpdate, + &None, + ); + + // voter1 (1000) votes against, voter2 (500) votes for + governance_client.cast_vote(&proposal_id, &voter1, &VoteDirection::Against); + governance_client.cast_vote(&proposal_id, &voter2, &VoteDirection::For); + + // Advance time + env.ledger().with_mut(|li| { + li.timestamp += 3700; + }); + + governance_client.finalize_proposal(&proposal_id); + + let proposal = governance_client.get_proposal(&proposal_id).unwrap(); + assert_eq!(proposal.status, ProposalStatus::Failed); +} + +#[test] +fn test_mock_token_operations() { + let (env, _governance_client, token_client, admin, voter1, voter2) = setup_governance(); + + // Check initial balances + assert_eq!(token_client.balance(&admin), 2000); + assert_eq!(token_client.balance(&voter1), 1000); + assert_eq!(token_client.balance(&voter2), 500); + + // Test transfer + token_client.transfer(&voter1, &voter2, &200); + assert_eq!(token_client.balance(&voter1), 800); + assert_eq!(token_client.balance(&voter2), 700); + + // Test metadata + assert_eq!( + token_client.name(), + String::from_str(&env, "Governance Token") + ); + assert_eq!(token_client.symbol(), String::from_str(&env, "GOV")); + assert_eq!(token_client.decimals(), 18); + assert_eq!(token_client.total_supply(), 3500); +} From 56c6bd0ae4b3e05f0855c4f6de6c253701b8e3ba Mon Sep 17 00:00:00 2001 From: Ikem Peter Date: Sat, 24 Jan 2026 22:38:14 +0100 Subject: [PATCH 8/8] Test proposal lifecycle, voting, and edge casesIntegration:- Add governance contract to workspace members --- .../test_cancel_proposal.1.json | 610 +++++++++++++ .../test_snapshots/test_cast_vote.1.json | 846 ++++++++++++++++++ .../test_create_proposal.1.json | 568 ++++++++++++ ...reate_proposal_insufficient_balance.1.json | 377 ++++++++ .../test_snapshots/test_double_vote.1.json | 706 +++++++++++++++ .../test_finalize_and_execute_proposal.1.json | 750 ++++++++++++++++ .../test_initialize_governance.1.json | 377 ++++++++ .../test_mock_token_operations.1.json | 430 +++++++++ ...est_proposal_fails_majority_against.1.json | 845 +++++++++++++++++ .../test_proposal_passes_with_quorum.1.json | 707 +++++++++++++++ .../test_snapshots/test_update_config.1.json | 425 +++++++++ 11 files changed, 6641 insertions(+) create mode 100644 contracts/governance/test_snapshots/test_cancel_proposal.1.json create mode 100644 contracts/governance/test_snapshots/test_cast_vote.1.json create mode 100644 contracts/governance/test_snapshots/test_create_proposal.1.json create mode 100644 contracts/governance/test_snapshots/test_create_proposal_insufficient_balance.1.json create mode 100644 contracts/governance/test_snapshots/test_double_vote.1.json create mode 100644 contracts/governance/test_snapshots/test_finalize_and_execute_proposal.1.json create mode 100644 contracts/governance/test_snapshots/test_initialize_governance.1.json create mode 100644 contracts/governance/test_snapshots/test_mock_token_operations.1.json create mode 100644 contracts/governance/test_snapshots/test_proposal_fails_majority_against.1.json create mode 100644 contracts/governance/test_snapshots/test_proposal_passes_with_quorum.1.json create mode 100644 contracts/governance/test_snapshots/test_update_config.1.json diff --git a/contracts/governance/test_snapshots/test_cancel_proposal.1.json b/contracts/governance/test_snapshots/test_cancel_proposal.1.json new file mode 100644 index 0000000..aa8cdec --- /dev/null +++ b/contracts/governance/test_snapshots/test_cancel_proposal.1.json @@ -0,0 +1,610 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "create_proposal", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "bytes": "43616e63656c2054657374" + }, + { + "bytes": "546573742063616e63656c6c6174696f6e" + }, + { + "vec": [ + { + "symbol": "Custom" + } + ] + }, + "void" + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cancel_proposal", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "proposal" + }, + { + "u64": "1" + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "abstain_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "against_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "created_at" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "description" + }, + "val": { + "bytes": "546573742063616e63656c6c6174696f6e" + } + }, + { + "key": { + "symbol": "execution_data" + }, + "val": "void" + }, + { + "key": { + "symbol": "for_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "proposal_type" + }, + "val": { + "vec": [ + { + "symbol": "Custom" + } + ] + } + }, + { + "key": { + "symbol": "proposer" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "status" + }, + "val": { + "vec": [ + { + "symbol": "Cancelled" + } + ] + } + }, + { + "key": { + "symbol": "title" + }, + "val": { + "bytes": "43616e63656c2054657374" + } + }, + { + "key": { + "symbol": "voting_end" + }, + "val": { + "u64": "3600" + } + }, + { + "key": { + "symbol": "voting_start" + }, + "val": { + "u64": "0" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "1" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "2032731177588607455" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_cast_vote.1.json b/contracts/governance/test_snapshots/test_cast_vote.1.json new file mode 100644 index 0000000..80f0f87 --- /dev/null +++ b/contracts/governance/test_snapshots/test_cast_vote.1.json @@ -0,0 +1,846 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "create_proposal", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "bytes": "546573742050726f706f73616c" + }, + { + "bytes": "566f74652074657374" + }, + { + "vec": [ + { + "symbol": "FeeChange" + } + ] + }, + "void" + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cast_vote", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "vec": [ + { + "symbol": "For" + } + ] + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cast_vote", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "vec": [ + { + "symbol": "Against" + } + ] + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "proposal" + }, + { + "u64": "1" + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "abstain_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "against_votes" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "created_at" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "description" + }, + "val": { + "bytes": "566f74652074657374" + } + }, + { + "key": { + "symbol": "execution_data" + }, + "val": "void" + }, + { + "key": { + "symbol": "for_votes" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "symbol": "id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "proposal_type" + }, + "val": { + "vec": [ + { + "symbol": "FeeChange" + } + ] + } + }, + { + "key": { + "symbol": "proposer" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "status" + }, + "val": { + "vec": [ + { + "symbol": "Active" + } + ] + } + }, + { + "key": { + "symbol": "title" + }, + "val": { + "bytes": "546573742050726f706f73616c" + } + }, + { + "key": { + "symbol": "voting_end" + }, + "val": { + "u64": "3600" + } + }, + { + "key": { + "symbol": "voting_start" + }, + "val": { + "u64": "0" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "votes" + }, + { + "map": [ + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + } + } + ] + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "direction" + }, + "val": { + "vec": [ + { + "symbol": "For" + } + ] + } + }, + { + "key": { + "symbol": "power" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "timestamp" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "votes" + }, + { + "map": [ + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + } + } + ] + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "direction" + }, + "val": { + "vec": [ + { + "symbol": "Against" + } + ] + } + }, + { + "key": { + "symbol": "power" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "timestamp" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "1" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "2032731177588607455" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "key": { + "ledger_key_nonce": { + "nonce": "4270020994084947596" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_create_proposal.1.json b/contracts/governance/test_snapshots/test_create_proposal.1.json new file mode 100644 index 0000000..3b861c4 --- /dev/null +++ b/contracts/governance/test_snapshots/test_create_proposal.1.json @@ -0,0 +1,568 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "create_proposal", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "bytes": "546573742050726f706f73616c" + }, + { + "bytes": "4120746573742070726f706f73616c20666f7220676f7665726e616e6365" + }, + { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + }, + "void" + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "proposal" + }, + { + "u64": "1" + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "abstain_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "against_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "created_at" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "description" + }, + "val": { + "bytes": "4120746573742070726f706f73616c20666f7220676f7665726e616e6365" + } + }, + { + "key": { + "symbol": "execution_data" + }, + "val": "void" + }, + { + "key": { + "symbol": "for_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "proposal_type" + }, + "val": { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + } + }, + { + "key": { + "symbol": "proposer" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "status" + }, + "val": { + "vec": [ + { + "symbol": "Active" + } + ] + } + }, + { + "key": { + "symbol": "title" + }, + "val": { + "bytes": "546573742050726f706f73616c" + } + }, + { + "key": { + "symbol": "voting_end" + }, + "val": { + "u64": "3600" + } + }, + { + "key": { + "symbol": "voting_start" + }, + "val": { + "u64": "0" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "1" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_create_proposal_insufficient_balance.1.json b/contracts/governance/test_snapshots/test_create_proposal_insufficient_balance.1.json new file mode 100644 index 0000000..695abcc --- /dev/null +++ b/contracts/governance/test_snapshots/test_create_proposal_insufficient_balance.1.json @@ -0,0 +1,377 @@ +{ + "generators": { + "address": 6, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "0" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_double_vote.1.json b/contracts/governance/test_snapshots/test_double_vote.1.json new file mode 100644 index 0000000..f4078e9 --- /dev/null +++ b/contracts/governance/test_snapshots/test_double_vote.1.json @@ -0,0 +1,706 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "create_proposal", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "bytes": "546573742050726f706f73616c" + }, + { + "bytes": "446f75626c6520766f74652074657374" + }, + { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + }, + "void" + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cast_vote", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "vec": [ + { + "symbol": "For" + } + ] + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "proposal" + }, + { + "u64": "1" + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "abstain_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "against_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "created_at" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "description" + }, + "val": { + "bytes": "446f75626c6520766f74652074657374" + } + }, + { + "key": { + "symbol": "execution_data" + }, + "val": "void" + }, + { + "key": { + "symbol": "for_votes" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "symbol": "id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "proposal_type" + }, + "val": { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + } + }, + { + "key": { + "symbol": "proposer" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "status" + }, + "val": { + "vec": [ + { + "symbol": "Active" + } + ] + } + }, + { + "key": { + "symbol": "title" + }, + "val": { + "bytes": "546573742050726f706f73616c" + } + }, + { + "key": { + "symbol": "voting_end" + }, + "val": { + "u64": "3600" + } + }, + { + "key": { + "symbol": "voting_start" + }, + "val": { + "u64": "0" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "votes" + }, + { + "map": [ + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + } + } + ] + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "direction" + }, + "val": { + "vec": [ + { + "symbol": "For" + } + ] + } + }, + { + "key": { + "symbol": "power" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "timestamp" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "1" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "2032731177588607455" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_finalize_and_execute_proposal.1.json b/contracts/governance/test_snapshots/test_finalize_and_execute_proposal.1.json new file mode 100644 index 0000000..395fc88 --- /dev/null +++ b/contracts/governance/test_snapshots/test_finalize_and_execute_proposal.1.json @@ -0,0 +1,750 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "create_proposal", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "bytes": "457865637574652054657374" + }, + { + "bytes": "5465737420657865637574696f6e" + }, + { + "vec": [ + { + "symbol": "FeatureToggle" + } + ] + }, + "void" + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cast_vote", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "vec": [ + { + "symbol": "For" + } + ] + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "execute_proposal", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 3800, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "proposal" + }, + { + "u64": "1" + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "abstain_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "against_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "created_at" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "description" + }, + "val": { + "bytes": "5465737420657865637574696f6e" + } + }, + { + "key": { + "symbol": "execution_data" + }, + "val": "void" + }, + { + "key": { + "symbol": "for_votes" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "symbol": "id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "proposal_type" + }, + "val": { + "vec": [ + { + "symbol": "FeatureToggle" + } + ] + } + }, + { + "key": { + "symbol": "proposer" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "status" + }, + "val": { + "vec": [ + { + "symbol": "Executed" + } + ] + } + }, + { + "key": { + "symbol": "title" + }, + "val": { + "bytes": "457865637574652054657374" + } + }, + { + "key": { + "symbol": "voting_end" + }, + "val": { + "u64": "3600" + } + }, + { + "key": { + "symbol": "voting_start" + }, + "val": { + "u64": "0" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "votes" + }, + { + "map": [ + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + } + ] + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "direction" + }, + "val": { + "vec": [ + { + "symbol": "For" + } + ] + } + }, + { + "key": { + "symbol": "power" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "timestamp" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "1" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "2032731177588607455" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4270020994084947596" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_initialize_governance.1.json b/contracts/governance/test_snapshots/test_initialize_governance.1.json new file mode 100644 index 0000000..8e0704c --- /dev/null +++ b/contracts/governance/test_snapshots/test_initialize_governance.1.json @@ -0,0 +1,377 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "0" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_mock_token_operations.1.json b/contracts/governance/test_snapshots/test_mock_token_operations.1.json new file mode 100644 index 0000000..c0f27ef --- /dev/null +++ b/contracts/governance/test_snapshots/test_mock_token_operations.1.json @@ -0,0 +1,430 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "transfer", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "200" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [], + [], + [], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "0" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "800" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "700" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_proposal_fails_majority_against.1.json b/contracts/governance/test_snapshots/test_proposal_fails_majority_against.1.json new file mode 100644 index 0000000..e04cd6b --- /dev/null +++ b/contracts/governance/test_snapshots/test_proposal_fails_majority_against.1.json @@ -0,0 +1,845 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "create_proposal", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "bytes": "52656a6563746564" + }, + { + "bytes": "53686f756c642062652072656a6563746564" + }, + { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + }, + "void" + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cast_vote", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "vec": [ + { + "symbol": "Against" + } + ] + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cast_vote", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "vec": [ + { + "symbol": "For" + } + ] + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 3700, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "proposal" + }, + { + "u64": "1" + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "abstain_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "against_votes" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "symbol": "created_at" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "description" + }, + "val": { + "bytes": "53686f756c642062652072656a6563746564" + } + }, + { + "key": { + "symbol": "execution_data" + }, + "val": "void" + }, + { + "key": { + "symbol": "for_votes" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "proposal_type" + }, + "val": { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + } + }, + { + "key": { + "symbol": "proposer" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "status" + }, + "val": { + "vec": [ + { + "symbol": "Failed" + } + ] + } + }, + { + "key": { + "symbol": "title" + }, + "val": { + "bytes": "52656a6563746564" + } + }, + { + "key": { + "symbol": "voting_end" + }, + "val": { + "u64": "3600" + } + }, + { + "key": { + "symbol": "voting_start" + }, + "val": { + "u64": "0" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "votes" + }, + { + "map": [ + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + } + } + ] + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "direction" + }, + "val": { + "vec": [ + { + "symbol": "Against" + } + ] + } + }, + { + "key": { + "symbol": "power" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "timestamp" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "votes" + }, + { + "map": [ + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + } + } + ] + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "direction" + }, + "val": { + "vec": [ + { + "symbol": "For" + } + ] + } + }, + { + "key": { + "symbol": "power" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "timestamp" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "1" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "2032731177588607455" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "key": { + "ledger_key_nonce": { + "nonce": "4270020994084947596" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_proposal_passes_with_quorum.1.json b/contracts/governance/test_snapshots/test_proposal_passes_with_quorum.1.json new file mode 100644 index 0000000..b2b5bff --- /dev/null +++ b/contracts/governance/test_snapshots/test_proposal_passes_with_quorum.1.json @@ -0,0 +1,707 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "create_proposal", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "bytes": "51756f72756d2054657374" + }, + { + "bytes": "53686f756c64207061737320776974682071756f72756d" + }, + { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + }, + "void" + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "cast_vote", + "args": [ + { + "u64": "1" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "vec": [ + { + "symbol": "For" + } + ] + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 3700, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "proposal" + }, + { + "u64": "1" + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "abstain_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "against_votes" + }, + "val": { + "i128": "0" + } + }, + { + "key": { + "symbol": "created_at" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "description" + }, + "val": { + "bytes": "53686f756c64207061737320776974682071756f72756d" + } + }, + { + "key": { + "symbol": "execution_data" + }, + "val": "void" + }, + { + "key": { + "symbol": "for_votes" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "proposal_type" + }, + "val": { + "vec": [ + { + "symbol": "ParameterUpdate" + } + ] + } + }, + { + "key": { + "symbol": "proposer" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "status" + }, + "val": { + "vec": [ + { + "symbol": "Passed" + } + ] + } + }, + { + "key": { + "symbol": "title" + }, + "val": { + "bytes": "51756f72756d2054657374" + } + }, + { + "key": { + "symbol": "voting_end" + }, + "val": { + "u64": "3600" + } + }, + { + "key": { + "symbol": "voting_start" + }, + "val": { + "u64": "0" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "vec": [ + { + "symbol": "votes" + }, + { + "map": [ + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + } + } + ] + } + ] + }, + "durability": "persistent", + "val": { + "map": [ + { + "key": { + "symbol": "direction" + }, + "val": { + "vec": [ + { + "symbol": "For" + } + ] + } + }, + { + "key": { + "symbol": "power" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "proposal_id" + }, + "val": { + "u64": "1" + } + }, + { + "key": { + "symbol": "timestamp" + }, + "val": { + "u64": "0" + } + }, + { + "key": { + "symbol": "voter" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + } + } + ] + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "60" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "100" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "500" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "3600" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "1" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "key": { + "ledger_key_nonce": { + "nonce": "2032731177588607455" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/contracts/governance/test_snapshots/test_update_config.1.json b/contracts/governance/test_snapshots/test_update_config.1.json new file mode 100644 index 0000000..2663c7e --- /dev/null +++ b/contracts/governance/test_snapshots/test_update_config.1.json @@ -0,0 +1,425 @@ +{ + "generators": { + "address": 5, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + { + "i128": "1000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + { + "i128": "500" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "function_name": "mint", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + { + "i128": "2000" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "update_config", + "args": [ + { + "i128": "200" + }, + { + "i128": "1000" + }, + { + "u64": "7200" + }, + { + "u64": "120" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 25, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "config" + }, + "val": { + "map": [ + { + "key": { + "symbol": "admin" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "execution_delay" + }, + "val": { + "u64": "120" + } + }, + { + "key": { + "symbol": "proposal_threshold" + }, + "val": { + "i128": "200" + } + }, + { + "key": { + "symbol": "quorum" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "symbol": "token" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "voting_period" + }, + "val": { + "u64": "7200" + } + } + ] + } + }, + { + "key": { + "symbol": "prop_cnt" + }, + "val": { + "u64": "0" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Balances" + } + ] + }, + "val": { + "map": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + }, + "val": { + "i128": "2000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4" + }, + "val": { + "i128": "1000" + } + }, + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM" + }, + "val": { + "i128": "500" + } + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "Decimals" + } + ] + }, + "val": { + "u32": 18 + } + }, + { + "key": { + "vec": [ + { + "symbol": "Name" + } + ] + }, + "val": { + "string": "Governance Token" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Symbol" + } + ] + }, + "val": { + "string": "GOV" + } + }, + { + "key": { + "vec": [ + { + "symbol": "TotalSupply" + } + ] + }, + "val": { + "i128": "3500" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file