decl_module! {             }         } +        /// Assuming this is executed by the GC voting majority, adds a new cdd claim record.+        #[weight = 950_000_000]+        pub fn gc_add_cdd_claim(+            origin,+            target: IdentityId,+            expiry: Option<T::Moment>,+        ) -> DispatchResult {+            T::GCVotingMajorityOrigin::ensure_origin(origin)?;+            Self::base_add_cdd_claim(target, Claim::CustomerDueDiligence([0; 32].into()), GC_DID, expiry)

 pub struct PolymeshVotes<IdentityId, BlockNumber> {     pub nays: Vec<IdentityId>,     /// The hard end time of this vote.     pub end: BlockNumber,+    /// The time **at** which the proposal is expired.+    pub expiry: Option<BlockNumber>, } +// Fool `decl_storage!` below into not strip the `Option` in the genesis config.+use Option as Maybe;

 decl_module! {             let did = Context::current_identity_or::<Identity<T>>(&who)?;              let voting = Self::voting(&proposal).ok_or(Error::<T, I>::NoSuchProposal)?;++            // Ensure proposal hasn't expired. If it has, prune the proposal and bail.+            let now = system::Module::<T>::block_number();+            Self::ensure_not_expired(&proposal, voting.expiry, now)?;+             // POLYMESH-NOTE- Change specific to Polymesh             ensure!(T::MotionDuration::get() > Zero::zero(), Error::<T, I>::NotAllowed);             ensure!(voting.index == index, Error::<T, I>::MismatchedVotingIndex);-            ensure!(system::Module::<T>::block_number() >= voting.end, Error::<T, I>::TooEarly);+            ensure!(now >= voting.end, Error::<T, I>::TooEarly);

 decl_module! {             ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);             let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset); +            ensure!(tiers.len() > 0, Error::<T>::InvalidPriceTiers);+            ensure!(tiers.iter().all(|t| t.total > 0.into()), Error::<T>::InvalidPriceTiers);

 impl<T: Trait<I>, I: Instance> Module<T, I> {     /// Accepts or rejects the proposal if its threshold is satisfied.     fn check_proposal_threshold(proposal: T::Hash) {         if let Some(voting) = Self::voting(&proposal) {+            // Make sure we don't have an expired proposal at this point.+            if let Err(_) = Self::ensure_not_expired(+                &proposal,+                voting.expiry,+                system::Module::<T>::block_number(),+            ) {

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);++            ensure!(offering_portfolio.did == did, Error::<T>::InvalidPortfolio);+            ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);+            let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset);++            let offering_amount: T::Balance = tiers+                .iter()+                .map(|t| t.amount)+                .fold(0.into(), |x, total| total + x);

 decl_module! {             <RevokeOffChainAuthorization<T>>::insert((signer, auth), true);             Ok(())         }++        /// Add `Claim::InvestorUniqueness` claim for a given target identity.+        ///+        /// # <weight>+        ///  Weight of the this extrinsic is depend on the computation that used to validate+        ///  the proof of claim and that will be constant and not depend on the user inputs.+        /// # </weight>+        ///+        /// # Arguments+        /// * origin - Who provides the claim to the user, In this case user's account id as user provide+        /// this claim to itself.+        /// * target - IdentityId whom claim get assigned.+        /// * claim - `InvestorUniqueness` claim details.+        /// * proof - To validate the self attestation.+        /// * expiry - Expiry of claim.+        ///+        /// # Errors+        /// * `DidMustAlreadyExist` Target should already been a part of the ecosystem.+        /// * `ClaimVariantNotAllowed` When origin trying to pass claim variant other than `InvestorUniqueness`.+        /// * `ConfidentialScopeClaimNotAllowed` When issuer is different from target or CDD_ID is invalid for given user.+        /// * `InvalidScopeClaim1 When proof is invalid.+        #[weight = 7_500_000_000]+        pub fn add_investor_uniqueness_claim(origin, target: IdentityId, claim: Claim, proof: InvestorZKProofData, expiry: Option<T::Moment>) -> DispatchResult {+            // Validate whether the origin is signed or not. Also validate whether the given IdentityId (i.e target) has+            // already been in the system or not.+            let issuer = Self::ensure_signer_and_validate_claim_target(origin, target)?;++            // Validate proof and add claim only when the claim variant is `InvestorUniqueness` only+            // otherwise throw and error.+            match &claim {

 decl_module! {             claim: Claim,             expiry: Option<T::Moment>,         ) -> DispatchResult {-            let sender = ensure_signed(origin)?;-            let issuer = Context::current_identity_or::<Self>(&sender)?;-            ensure!(<DidRecords<T>>::contains_key(target), Error::<T>::DidMustAlreadyExist);+            // Validate whether the origin is signed or not. Also validate whether the given IdentityId (i.e target) has+            // already been in the system or not.

 impl<T: Trait> Module<T> {             Self::unlink_key_from_did(&signer, did)         }     }++    /// Validate whether the origin is signed or not. Also validate whether the given IdentityId (i.e target) has+    /// already been in the system or not.+    fn ensure_signer_and_validate_claim_target(

 impl<T: Trait> Module<T> {             Self::unlink_key_from_did(&signer, did)         }     }++    /// Validate whether the origin is signed or not. Also validate whether the given IdentityId (i.e target) has+    /// already been in the system or not.

 impl Claim { /// Claim type represent the claim without its data. /// /// # TODO-/// - Could we use `std::mem::Discriminat`?+/// - Could we use `std::mem::Discriminant`?

 pub enum Claim {     Exempted(#[migrate] Scope),     /// User is Blocked     Blocked(#[migrate] Scope),-    /// Confidential Scope claim-    InvestorZKProof(#[migrate] Scope, ScopeId, CddId, InvestorZKProofData),+    /// Confidential claim that will allow an investor to justify that it's identity can be+    /// a potential asset holder of given `scope`.+    ///+    /// This claim is mandatory to have for an investor. It will help issuer to apply compliance rules+    /// on the `ScopeId` instead of investor identityId as ScopeId is unique at investor entity level+    /// for a given scope (always be a Ticker).

 decl_module! {             <RevokeOffChainAuthorization<T>>::insert((signer, auth), true);             Ok(())         }++        /// Add `Claim::InvestorUniqueness` claim for a given target identity.+        ///+        /// # <weight>+        ///  Weight of the this extrinsic is depend on the computation that used to validate+        ///  the proof of claim and that will be constant and not depend on the user inputs.+        /// # </weight>+        ///+        /// # Arguments+        /// * origin - Who provides the claim to the user, In this case user's account id as user provide+        /// this claim to itself.+        /// * target - IdentityId whom claim get assigned.

 decl_module! {             <RevokeOffChainAuthorization<T>>::insert((signer, auth), true);             Ok(())         }++        /// Add `Claim::InvestorUniqueness` claim for a given target identity.+        ///+        /// # <weight>+        ///  Weight of the this extrinsic is depend on the computation that used to validate+        ///  the proof of claim and that will be constant and not depend on the user inputs.+        /// # </weight>+        ///+        /// # Arguments+        /// * origin - Who provides the claim to the user, In this case user's account id as user provide+        /// this claim to itself.+        /// * target - IdentityId whom claim get assigned.+        /// * claim - `InvestorUniqueness` claim details.+        /// * proof - To validate the self attestation.+        /// * expiry - Expiry of claim.+        ///+        /// # Errors+        /// * `DidMustAlreadyExist` Target should already been a part of the ecosystem.+        /// * `ClaimVariantNotAllowed` When origin trying to pass claim variant other than `InvestorUniqueness`.+        /// * `ConfidentialScopeClaimNotAllowed` When issuer is different from target or CDD_ID is invalid for given user.+        /// * `InvalidScopeClaim1 When proof is invalid.

 decl_module! {             <RevokeOffChainAuthorization<T>>::insert((signer, auth), true);             Ok(())         }++        /// Add `Claim::InvestorUniqueness` claim for a given target identity.+        ///+        /// # <weight>+        ///  Weight of the this extrinsic is depend on the computation that used to validate+        ///  the proof of claim and that will be constant and not depend on the user inputs.+        /// # </weight>+        ///+        /// # Arguments+        /// * origin - Who provides the claim to the user, In this case user's account id as user provide

 decl_module! {             <RevokeOffChainAuthorization<T>>::insert((signer, auth), true);             Ok(())         }++        /// Add `Claim::InvestorUniqueness` claim for a given target identity.+        ///+        /// # <weight>+        ///  Weight of the this extrinsic is depend on the computation that used to validate+        ///  the proof of claim and that will be constant and not depend on the user inputs.

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);++            ensure!(offering_portfolio.did == did, Error::<T>::InvalidPortfolio);+            ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);+            let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset);++            let offering_amount: T::Balance = tiers+                .iter()+                .map(|t| t.amount)+                .fold(0.into(), |x, total| total + x);++            ensure!(offering_amount >= asset_balance, Error::<T>::InsufficientTokensRemaining);++            // Sort by price+            tiers.sort_by(|a, b| a.price.cmp(&b.price));++            // TODO: Take custodial ownership of $sell_amount of $offering_token from primary issuance agent?+            let fundraiser_id = Self::fundraiser_count(offering_asset) + 1;+            // TODO revise the defaults+            let fundraiser = Fundraiser {+                    offering_portfolio,+                    offering_asset,+                    raising_asset,+                    tiers: tiers.into_iter().map(Into::into).collect(),+                    venue_id,+                    start: start.unwrap_or(Timestamp::<T>::get()),+                    end,+                    frozen: false,+                };+            <FundraiserCount>::insert(offering_asset, fundraiser_id);+            <Fundraisers<T>>::insert(+                offering_asset,+                fundraiser_id,+                fundraiser+            );+            Self::deposit_event(+                RawEvent::FundraiserCreated(did, fundraiser)+            );+            Ok(())+        }++        /// Purchase tokens from an ongoing offering.+        #[weight = 2_000_000_000]+        pub fn invest(origin, portfolio: PortfolioId, offering_asset: Ticker, fundraiser_id: u64, offering_token_amount: T::Balance, max_price: T::Balance) -> DispatchResult {+            let sender = ensure_signed(origin.clone())?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;++            ensure!(<Fundraisers<T>>::contains_key(offering_asset, fundraiser_id), Error::<T>::FundraiserNotFound);+            let fundraiser = <Fundraisers<T>>::get(offering_asset, fundraiser_id);

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);++            ensure!(offering_portfolio.did == did, Error::<T>::InvalidPortfolio);+            ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);+            let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset);++            let offering_amount: T::Balance = tiers+                .iter()+                .map(|t| t.amount)+                .fold(0.into(), |x, total| total + x);++            ensure!(offering_amount >= asset_balance, Error::<T>::InsufficientTokensRemaining);++            // Sort by price+            tiers.sort_by(|a, b| a.price.cmp(&b.price));++            // TODO: Take custodial ownership of $sell_amount of $offering_token from primary issuance agent?+            let fundraiser_id = Self::fundraiser_count(offering_asset) + 1;+            // TODO revise the defaults+            let fundraiser = Fundraiser {+                    offering_portfolio,+                    offering_asset,+                    raising_asset,+                    tiers: tiers.into_iter().map(Into::into).collect(),+                    venue_id,+                    start: start.unwrap_or(Timestamp::<T>::get()),+                    end,+                    frozen: false,+                };+            <FundraiserCount>::insert(offering_asset, fundraiser_id);+            <Fundraisers<T>>::insert(+                offering_asset,+                fundraiser_id,+                fundraiser+            );+            Self::deposit_event(+                RawEvent::FundraiserCreated(did, fundraiser)+            );+            Ok(())+        }++        /// Purchase tokens from an ongoing offering.

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);++            ensure!(offering_portfolio.did == did, Error::<T>::InvalidPortfolio);+            ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);+            let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset);++            let offering_amount: T::Balance = tiers+                .iter()+                .map(|t| t.amount)+                .fold(0.into(), |x, total| total + x);++            ensure!(offering_amount >= asset_balance, Error::<T>::InsufficientTokensRemaining);++            // Sort by price+            tiers.sort_by(|a, b| a.price.cmp(&b.price));++            // TODO: Take custodial ownership of $sell_amount of $offering_token from primary issuance agent?+            let fundraiser_id = Self::fundraiser_count(offering_asset) + 1;+            // TODO revise the defaults+            let fundraiser = Fundraiser {+                    offering_portfolio,+                    offering_asset,+                    raising_asset,+                    tiers: tiers.into_iter().map(Into::into).collect(),+                    venue_id,+                    start: start.unwrap_or(Timestamp::<T>::get()),+                    end,+                    frozen: false,+                };+            <FundraiserCount>::insert(offering_asset, fundraiser_id);

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);++            ensure!(offering_portfolio.did == did, Error::<T>::InvalidPortfolio);+            ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);+            let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset);++            let offering_amount: T::Balance = tiers+                .iter()+                .map(|t| t.amount)+                .fold(0.into(), |x, total| total + x);++            ensure!(offering_amount >= asset_balance, Error::<T>::InsufficientTokensRemaining);++            // Sort by price+            tiers.sort_by(|a, b| a.price.cmp(&b.price));

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);++            ensure!(offering_portfolio.did == did, Error::<T>::InvalidPortfolio);+            ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);+            let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset);

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {

 decl_error! { decl_storage! {     trait Store for Module<T: Trait> as StoCapped {         /// Info about a venue. venue_id -> venue_details-        VenueInfo get(fn venue_info): map hasher(twox_64_concat) u64 => Venue;+        pub VenueInfo get(fn venue_info): map hasher(twox_64_concat) u64 => Venue;

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,+}++impl<Balance: From<u8>> Into<FundraiserTier<Balance>> for PriceTier<Balance> {+    fn into(self) -> FundraiserTier<Balance> {+        FundraiserTier {+            inner: self,+            remaining: Balance::from(0),+        }+    }+}++pub trait Trait:+    frame_system::Trait+    + CommonTrait+    + IdentityTrait+    + SettlementTrait+    + TimestampTrait+    + PortfolioTrait+{+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;+}++decl_event!(+    pub enum Event<T>+    where+        Balance = <T as CommonTrait>::Balance,+        Moment = <T as TimestampTrait>::Moment,+    {+        /// A new fundraiser has been created+        /// (primary issuance agent, fundraiser)+        FundraiserCreated(IdentityId, Fundraiser<Balance, Moment>),+        /// An investor invested in the fundraiser+        /// (offering token, raise token, offering_token_amount, raise_token_amount, fundraiser_id)+        FundsRaised(IdentityId, Ticker, Ticker, Balance, Balance, u64),+    }+);++decl_error! {+    /// Errors for the Settlement module.+    pub enum Error for Module<T: Trait> {+        /// Sender does not have required permissions+        Unauthorized,+        /// An arithmetic operation overflowed+        Overflow,+        /// Not enough tokens left for sale+        InsufficientTokensRemaining,+        /// Fundraiser not found+        FundraiserNotFound,+        /// Fundraiser is frozen+        FundraiserFrozen,+        // Interacting with a fundraiser past the end `Moment`.+        FundraiserExpired,+        // Interacting with a fundraiser before the start `Moment`.+        FundraiserNotStated,+        // Using an invalid venue+        InvalidVenue,+        // Using an invalid portfolio+        InvalidPortfolio,+    }+}++decl_storage! {+    trait Store for Module<T: Trait> as StoCapped {+        /// All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser+        Fundraisers get(fn fundraisers): double_map hasher(blake2_128_concat) Ticker, hasher(twox_64_concat) u64 => Fundraiser<T::Balance, T::Moment>;+        /// Total fundraisers created for a token+        FundraiserCount get(fn fundraiser_count): map hasher(twox_64_concat) Ticker => u64;+    }+}++decl_module! {+    pub struct Module<T: Trait> for enum Call where origin: T::Origin {+        type Error = Error<T>;++        fn deposit_event() = default;++        /// Create a new offering. A fixed amount of pre-minted tokens are put up for sale at the specified tiered rate.+        #[weight = 800_000_000]+        pub fn create_fundraiser(+            origin,+            offering_portfolio: PortfolioId,+            offering_asset: Ticker,+            raising_asset: Ticker,+            tiers: Vec<PriceTier<T::Balance>>,+            venue_id: u64,+            start: Option<T::Moment>,+            end: Option<T::Moment>,+        ) -> DispatchResult {+            let sender = ensure_signed(origin)?;+            let did = Context::current_identity_or::<Identity<T>>(&sender)?;+            ensure!(T::Asset::primary_issuance_agent(&offering_asset) == did, Error::<T>::Unauthorized);++            ensure!(VenueInfo::contains_key(venue_id), Error::<T>::InvalidVenue);+            let venue = VenueInfo::get(venue_id);++            ensure!(venue.creator == did, Error::<T>::InvalidVenue);+            ensure!(venue.venue_type == VenueType::Sto, Error::<T>::InvalidVenue);++            ensure!(offering_portfolio.did == did, Error::<T>::InvalidPortfolio);+            ensure!(<PortfolioAssetBalances<T>>::contains_key(offering_portfolio, offering_asset), Error::<T>::InvalidPortfolio);+            let asset_balance = <PortfolioAssetBalances<T>>::get(offering_portfolio, offering_asset);++            let offering_amount: T::Balance = tiers+                .iter()+                .map(|t| t.amount)+                .fold(0.into(), |x, total| total + x);

+// Copyright (c) 2020 Polymath++//! # STO Module+//!+//! This is a proof of concept module. It is not meant to be used in the real world in its' current state.++#![cfg_attr(not(feature = "std"), no_std)]+#![recursion_limit = "256"]++use codec::{Decode, Encode};+use frame_support::{+    decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,+};+use frame_system::ensure_signed;+use pallet_identity as identity;+use pallet_portfolio::{self as portfolio, PortfolioAssetBalances, Trait as PortfolioTrait};+use pallet_settlement::{+    self as settlement, Leg, SettlementType, Trait as SettlementTrait, VenueInfo, VenueType,+};+use pallet_timestamp::{self as timestamp, Trait as TimestampTrait};+use polymesh_common_utilities::{+    constants::currency::*,+    traits::{asset::Trait as AssetTrait, identity::Trait as IdentityTrait, CommonTrait},+    Context,+};+use polymesh_primitives::{IdentityId, PortfolioId, Ticker};+use sp_runtime::traits::{CheckedAdd, CheckedMul, Saturating};+use sp_std::{collections::btree_set::BTreeSet, iter, prelude::*};++type Identity<T> = identity::Module<T>;+type Settlement<T> = settlement::Module<T>;+type Timestamp<T> = timestamp::Module<T>;++/// Details about the Fundraiser+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct Fundraiser<Balance, Moment> {+    /// Portfolio containing the asset being offered+    pub offering_portfolio: PortfolioId,+    /// Asset being offered+    pub offering_asset: Ticker,+    /// Asset to receive payment in+    pub raising_asset: Ticker,+    /// Tiers of the fundraiser.+    /// Each tier has a set amount of tokens available at a fixed price.+    /// The sum of the tiers is the total amount available in this fundraiser.+    pub tiers: Vec<FundraiserTier<Balance>>,+    /// Id of the venue to use for this fundraise+    pub venue_id: u64,+    /// Start of the fundraiser+    pub start: Moment,+    /// End of the fundraiser+    pub end: Option<Moment>,+    /// Fundraiser is frozen+    pub frozen: bool,+}++/// Single tier of a tiered pricing model+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct PriceTier<Balance> {+    amount: Balance,+    price: Balance,+}++/// Single price tier of a `Fundraiser`.+/// Similar to a `PriceTier` but with an extra field `remaining` for tracking the amount available in a tier.+#[cfg_attr(feature = "std", derive(Debug))]+#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]+pub struct FundraiserTier<Balance> {+    inner: PriceTier<Balance>,+    remaining: Balance,

 pub mod weight {     } } +pub trait WeightInfo {+    fn bond(u: u32) -> Weight;+    fn bond_extra(u: u32) -> Weight;+    fn unbond(u: u32) -> Weight;+    fn withdraw_unbonded_update(s: u32) -> Weight;+    fn withdraw_unbonded_kill(s: u32) -> Weight;+    fn validate(u: u32) -> Weight;+    fn nominate(n: u32) -> Weight;+    fn chill(u: u32) -> Weight;+    fn set_payee(u: u32) -> Weight;+    fn set_controller(u: u32) -> Weight;+    fn set_validator_count(c: u32) -> Weight;+    fn force_no_eras(i: u32) -> Weight;+    fn force_new_era(i: u32) -> Weight;+    fn force_new_era_always(i: u32) -> Weight;+    fn set_invulnerables(v: u32) -> Weight;+    fn force_unstake(s: u32) -> Weight;+    fn cancel_deferred_slash(s: u32) -> Weight;+    fn payout_stakers(n: u32) -> Weight;+    fn payout_stakers_alive_controller(n: u32) -> Weight;+    fn rebond(l: u32) -> Weight;+    fn set_history_depth(e: u32) -> Weight;+    fn reap_stash(s: u32) -> Weight;+    fn new_era(v: u32, n: u32) -> Weight;+    fn do_slash(l: u32) -> Weight;+    fn payout_all(v: u32, n: u32) -> Weight;+    fn submit_solution_initial(v: u32, n: u32, a: u32, w: u32) -> Weight;+    fn submit_solution_better(v: u32, n: u32, a: u32, w: u32) -> Weight;+    fn submit_solution_weaker(v: u32, n: u32) -> Weight;+}++impl WeightInfo for () {+    fn bond(_u: u32) -> Weight {+        1_000_000_000+    }+    fn bond_extra(_u: u32) -> Weight {+        1_000_000_000+    }+    fn unbond(_u: u32) -> Weight {+        1_000_000_000+    }+    fn withdraw_unbonded_update(_s: u32) -> Weight {+        1_000_000_000+    }+    fn withdraw_unbonded_kill(_s: u32) -> Weight {+        1_000_000_000+    }+    fn validate(_u: u32) -> Weight {+        1_000_000_000+    }+    fn nominate(_n: u32) -> Weight {+        1_000_000_000+    }+    fn chill(_u: u32) -> Weight {+        1_000_000_000+    }+    fn set_payee(_u: u32) -> Weight {+        1_000_000_000+    }+    fn set_controller(_u: u32) -> Weight {+        1_000_000_000+    }+    fn set_validator_count(_c: u32) -> Weight {+        1_000_000_000+    }+    fn force_no_eras(_i: u32) -> Weight {+        1_000_000_000+    }+    fn force_new_era(_i: u32) -> Weight {+        1_000_000_000+    }+    fn force_new_era_always(_i: u32) -> Weight {+        1_000_000_000+    }+    fn set_invulnerables(_v: u32) -> Weight {+        1_000_000_000+    }+    fn force_unstake(_s: u32) -> Weight {+        1_000_000_000+    }+    fn cancel_deferred_slash(_s: u32) -> Weight {+        1_000_000_000+    }+    fn payout_stakers(_n: u32) -> Weight {+        1_000_000_000+    }+    fn payout_stakers_alive_controller(_n: u32) -> Weight {+        1_000_000_000+    }+    fn rebond(_l: u32) -> Weight {+        1_000_000_000+    }+    fn set_history_depth(_e: u32) -> Weight {+        1_000_000_000+    }+    fn reap_stash(_s: u32) -> Weight {+        1_000_000_000+    }+    fn new_era(_v: u32, _n: u32) -> Weight {+        1_000_000_000+    }+    fn do_slash(_l: u32) -> Weight {+        1_000_000_000+    }+    fn payout_all(_v: u32, _n: u32) -> Weight {+        1_000_000_000+    }+    fn submit_solution_initial(_v: u32, _n: u32, _a: u32, _w: u32) -> Weight {+        1_000_000_000+    }+    fn submit_solution_better(_v: u32, _n: u32, _a: u32, _w: u32) -> Weight {+        1_000_000_000+    }+    fn submit_solution_weaker(_v: u32, _n: u32) -> Weight {+        1_000_000_000+    }+}+ pub trait Trait:     frame_system::Trait + SendTransactionTypes<Call<Self>> + pallet_babe::Trait + IdentityTrait {     /// The staking balance.-    type Currency: LockableCurrency<Self::AccountId, Moment = Self::BlockNumber>-        + BlockRewardsReserveCurrency<BalanceOf<Self>, NegativeImbalanceOf<Self>>;+    type Currency: LockableCurrency<Self::AccountId, Moment = Self::BlockNumber>;

 pub mod weight {     } } +pub trait WeightInfo {+    fn bond(u: u32) -> Weight;+    fn bond_extra(u: u32) -> Weight;+    fn unbond(u: u32) -> Weight;+    fn withdraw_unbonded_update(s: u32) -> Weight;+    fn withdraw_unbonded_kill(s: u32) -> Weight;+    fn validate(u: u32) -> Weight;+    fn nominate(n: u32) -> Weight;+    fn chill(u: u32) -> Weight;+    fn set_payee(u: u32) -> Weight;+    fn set_controller(u: u32) -> Weight;+    fn set_validator_count(c: u32) -> Weight;+    fn force_no_eras(i: u32) -> Weight;+    fn force_new_era(i: u32) -> Weight;+    fn force_new_era_always(i: u32) -> Weight;+    fn set_invulnerables(v: u32) -> Weight;+    fn force_unstake(s: u32) -> Weight;+    fn cancel_deferred_slash(s: u32) -> Weight;+    fn payout_stakers(n: u32) -> Weight;+    fn payout_stakers_alive_controller(n: u32) -> Weight;+    fn rebond(l: u32) -> Weight;+    fn set_history_depth(e: u32) -> Weight;+    fn reap_stash(s: u32) -> Weight;+    fn new_era(v: u32, n: u32) -> Weight;+    fn do_slash(l: u32) -> Weight;+    fn payout_all(v: u32, n: u32) -> Weight;+    fn submit_solution_initial(v: u32, n: u32, a: u32, w: u32) -> Weight;+    fn submit_solution_better(v: u32, n: u32, a: u32, w: u32) -> Weight;+    fn submit_solution_weaker(v: u32, n: u32) -> Weight;+}++impl WeightInfo for () {+    fn bond(_u: u32) -> Weight {+        1_000_000_000+    }+    fn bond_extra(_u: u32) -> Weight {+        1_000_000_000+    }+    fn unbond(_u: u32) -> Weight {+        1_000_000_000+    }+    fn withdraw_unbonded_update(_s: u32) -> Weight {+        1_000_000_000+    }+    fn withdraw_unbonded_kill(_s: u32) -> Weight {+        1_000_000_000+    }+    fn validate(_u: u32) -> Weight {+        1_000_000_000+    }+    fn nominate(_n: u32) -> Weight {+        1_000_000_000+    }+    fn chill(_u: u32) -> Weight {+        1_000_000_000+    }+    fn set_payee(_u: u32) -> Weight {+        1_000_000_000+    }+    fn set_controller(_u: u32) -> Weight {+        1_000_000_000+    }+    fn set_validator_count(_c: u32) -> Weight {+        1_000_000_000+    }+    fn force_no_eras(_i: u32) -> Weight {+        1_000_000_000+    }+    fn force_new_era(_i: u32) -> Weight {+        1_000_000_000+    }+    fn force_new_era_always(_i: u32) -> Weight {+        1_000_000_000+    }+    fn set_invulnerables(_v: u32) -> Weight {+        1_000_000_000+    }+    fn force_unstake(_s: u32) -> Weight {+        1_000_000_000+    }+    fn cancel_deferred_slash(_s: u32) -> Weight {+        1_000_000_000+    }+    fn payout_stakers(_n: u32) -> Weight {+        1_000_000_000+    }+    fn payout_stakers_alive_controller(_n: u32) -> Weight {+        1_000_000_000+    }+    fn rebond(_l: u32) -> Weight {+        1_000_000_000+    }+    fn set_history_depth(_e: u32) -> Weight {+        1_000_000_000+    }+    fn reap_stash(_s: u32) -> Weight {+        1_000_000_000+    }+    fn new_era(_v: u32, _n: u32) -> Weight {+        1_000_000_000+    }+    fn do_slash(_l: u32) -> Weight {+        1_000_000_000+    }+    fn payout_all(_v: u32, _n: u32) -> Weight {+        1_000_000_000+    }+    fn submit_solution_initial(_v: u32, _n: u32, _a: u32, _w: u32) -> Weight {+        1_000_000_000+    }+    fn submit_solution_better(_v: u32, _n: u32, _a: u32, _w: u32) -> Weight {+        1_000_000_000+    }+    fn submit_solution_weaker(_v: u32, _n: u32) -> Weight {+        1_000_000_000+    }+}+ pub trait Trait:     frame_system::Trait + SendTransactionTypes<Call<Self>> + pallet_babe::Trait + IdentityTrait {     /// The staking balance.-    type Currency: LockableCurrency<Self::AccountId, Moment = Self::BlockNumber>-        + BlockRewardsReserveCurrency<BalanceOf<Self>, NegativeImbalanceOf<Self>>;+    type Currency: LockableCurrency<Self::AccountId, Moment = Self::BlockNumber>;

 decl_module! {             ).expect(                 "An unsigned solution can only be submitted by validators; A validator should \                 always produce correct solutions, else this block should not be imported, thus \-                effectively depriving the validators from their authoring reward. Hence, this panic-                is expected."+				effectively depriving the validators from their authoring reward. Hence, this panic

 where         info: &DispatchInfoOf<T::Call>,         len: usize,     ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {-        let fee = Module::<T>::compute_fee(len as u32, info, 0u32.into());+        let tip = self.0;+        let fee = Module::<T>::compute_fee(len as u32, info, tip);          // Only mess with balances if fee is not zero.         if fee.is_zero() {             return Ok((fee, None));         }          if let Some(payer_key) = T::CddHandler::get_valid_payer(call, &who)? {-            let imbalance = T::Currency::withdraw(-                &payer_key,-                fee,-                WithdrawReason::TransactionPayment.into(),-                ExistenceRequirement::KeepAlive,-            )-            .map_err(|_| InvalidTransaction::Payment)?;+            let reason = if tip.is_zero() {+                WithdrawReason::TransactionPayment.into()+            } else {+                WithdrawReason::TransactionPayment | WithdrawReason::Tip

 use sp_runtime::{         InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,         ValidTransaction,     },-    FixedI128, FixedPointNumber, FixedPointOperand, Perquintill,+    FixedPointNumber, FixedPointOperand, FixedU128, Perquintill, }; use sp_std::prelude::*;  /// Fee multiplier.-pub type Multiplier = FixedI128;+pub type Multiplier = FixedU128;

 use crate::{-    scalar_blake2_from_bytes, CddId, Claim, Context, IdentityId, InvestorZKProofData, Proposition,-    Ticker,+    scalar_blake2_from_bytes, CddId, Claim, IdentityId, InvestorZKProofData, Scope, Ticker, }; use cryptography::claim_proofs::ProofPublicKey; use curve25519_dalek::{ristretto::CompressedRistretto, scalar::Scalar};  // ZKProofs claims // ========================================================= -/// Proposition that checks if any of its internal claims exists in context.+/// Data structure used to check if any of its internal claims exist in context. #[derive(Clone)] #[cfg_attr(feature = "std", derive(Debug))]-pub struct ValidProofOfInvestorProposition {-    /// The Investor proof should be associated to this ticker.-    pub ticker: Ticker,-}--impl Proposition for ValidProofOfInvestorProposition {-    /// Evaluate proposition against `context`.-    fn evaluate(&self, context: &Context) -> bool {-        context-            .claims-            .iter()-            .any(|claim| self.evaluate_claim(claim, context))-    }-}+pub struct ValidProofOfInvestor; -impl ValidProofOfInvestorProposition {+impl ValidProofOfInvestor {     /// Evaluates if the claim is a valid proof.-    fn evaluate_claim(&self, claim: &Claim, context: &Context) -> bool {+    pub fn evaluate_claim(claim: &Claim, id: &IdentityId) -> bool {         match claim {-            Claim::InvestorZKProof(ref _ticker_scope, ref scope_id, ref cdd_id, ref proof) => {-                let message = InvestorZKProofData::make_message(&context.id, &self.ticker);-                Self::verify_proof(cdd_id, &context.id, scope_id, &self.ticker, proof, &message)+            Claim::InvestorZKProof(ref scope, scope_id, cdd_id, proof) => {+                if let Scope::Ticker(ticker) = scope {+                    let message = InvestorZKProofData::make_message(id, ticker);+                    return Self::verify_proof(cdd_id, id, scope_id, ticker, proof, &message);+                }+                false

 where         info: &DispatchInfoOf<T::Call>,         len: usize,     ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {-        let fee = Module::<T>::compute_fee(len as u32, info, 0u32.into());+        let tip = self.0;

 use sp_runtime::{         InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,         ValidTransaction,     },-    FixedI128, FixedPointNumber, FixedPointOperand, Perquintill,+    FixedPointNumber, FixedPointOperand, FixedU128, Perquintill, }; use sp_std::prelude::*;  /// Fee multiplier.-pub type Multiplier = FixedI128;+pub type Multiplier = FixedU128;