polymesh-api 0.3.9

metaAsp_corecrypto,AccountId32
 [u8; 32] 0frame_system,AccountInfoIndex
,AccountData

nonce
Index
$consumers
 RefCount
$providers
 RefCount
,sufficients
 RefCount
data
,AccountDatadpolymesh_common_utilitiestraits balances,AccountData
free
Balance
 reserved
Balance
,misc_frozen
Balance
(fee_frozen
Balance4frame_supportweights@PerDispatchClassT
 
normal 
T
,operational 
T
$mandatory 
T $<primitive_typesH256
 [u8; 32](,(sp_runtimegenericdigestDigest
logs0
<Vec<DigestItem>044(sp_runtimegenericdigest(DigestItem
(PreRuntime8
DConsensusEngineId(
Vec<u8>$Consensus8
DConsensusEngineId(
Vec<u8>Seal8
DConsensusEngineId(
Vec<u8>Other(
Vec<u8>dRuntimeEnvironmentUpdated8<@@0frame_system,EventRecordE
DT
$
phase}
Phase
eventD
E
topics�
Vec<T>D`polymesh_runtime_developruntimeEvent
�SystemH
pframe_system::Event<Runtime>Indicesl
xpallet_indices::Event<Runtime> Balancesp
|pallet_balances::Event<Runtime> Identity�
|pallet_identity::Event<Runtime>LCddServiceProviders!

�pallet_group::Event<Runtime, pallet_group::Instance2>DPolymeshCommittee-

�pallet_committee::Event<Runtime, pallet_committee::Instance1>	LCommitteeMembershipA

�pallet_group::Event<Runtime, pallet_group::Instance1>
HTechnicalCommitteeI

�pallet_committee::Event<Runtime, pallet_committee::Instance3>pTechnicalCommitteeMembershipQ

�pallet_group::Event<Runtime, pallet_group::Instance3>@UpgradeCommitteeY

�pallet_committee::Event<Runtime, pallet_committee::Instance4>
hUpgradeCommitteeMembershipa

�pallet_group::Event<Runtime, pallet_group::Instance4> MultiSigi

|pallet_multisig::Event<Runtime>Bridgeu

tpallet_bridge::Event<Runtime>Staking�

xpallet_staking::Event<Runtime> Offences�

Xpallet_offences::EventSession�

Tpallet_session::EventGrandpa�

Tpallet_grandpa::Event ImOnline�

�pallet_im_online::Event<Runtime>Sudo�

lpallet_sudo::Event<Runtime>Asset�

ppallet_asset::Event<Runtime>LCapitalDistributionq
�pallet_capital_distribution::Event(Checkpoint�
`pallet_checkpoint::EventDComplianceManager�
�pallet_compliance_manager::Event<CorporateAction�
|pallet_corporate_actions::Event<CorporateBallot
xpallet_corporate_ballot::EventPipsI
lpallet_pips::Event<Runtime>!$Portfolio�
\pallet_portfolio::Event",ProtocolFee�
�pallet_protocol_fee::Event<Runtime>#$Scheduler�
�pallet_scheduler::Event<Runtime>$(Settlement�
�pallet_settlement::Event<Runtime>%(Statistics�
`pallet_statistics::Event&Sto%
hpallet_sto::Event<Runtime>' TreasuryA
|pallet_treasury::Event<Runtime>(UtilityE
Tpallet_utility::Event)BaseU
Hpallet_base::Event*8ExternalAgents]
tpallet_external_agents::Event+Relayera
xpallet_relayer::Event<Runtime>,Rewardse
xpallet_rewards::Event<Runtime>-$Contractsi
�pallet_contracts::Event<Runtime>.DPolymeshContractsm
dpolymesh_contracts::Event/ Preimageq
|pallet_preimage::Event<Runtime>0$TestUtilsu
�pallet_test_utils::Event<Runtime>2H0frame_systempalletEventT
@ExtrinsicSuccess
4dispatch_infoL
0DispatchInfo�An extrinsic completed successfully.<ExtrinsicFailed
8dispatch_errorX
4DispatchError
4dispatch_infoL
0DispatchInfo
PAn extrinsic failed.,CodeUpdatedP`:code` was updated.(NewAccount
account
0T::AccountIdhA new account was created.4KilledAccount
account
0T::AccountIdXAn account was reaped. Remarked
sender
0T::AccountId
hash$
T::HashpOn on-chain remark happened.pEvent for the System pallet.L4frame_supportweights0DispatchInfo
weight 
Weight
classP
4DispatchClass
 pays_feeT
PaysP4frame_supportweights4DispatchClass
Normal,Operational
$MandatoryT4frame_supportweightsPays
YesNo
X(sp_runtime4DispatchError
(Other0CannotLookup
$BadOriginModule\
,ModuleErrorDConsumerRemaining,NoProviders@TooManyConsumersToken`
(TokenError(Arithmeticd
<ArithmeticError4Transactionalh
HTransactionalError	\(sp_runtime,ModuleError
index
u8
error8
�[u8; MAX_MODULE_ERROR_ENCODED_SIZE]`(sp_runtime(TokenError
NoFunds WouldDie
0BelowMinimum0CannotCreate0UnknownAssetFrozen,Unsupportedd(sp_runtime<ArithmeticError
$Underflow Overflow
8DivisionByZeroh(sp_runtimeHTransactionalError
0LimitReachedNoLayer
l8pallet_indicespalletEventT
4IndexAssigned
who
0T::AccountId
index
<T::AccountIndextA account index was assigned.(IndexFreed
index
<T::AccountIndex
�A account index has been freed up (unassigned).,IndexFrozen
index
<T::AccountIndex
who
0T::AccountId�A account index has been frozen to its current account ID.�

			The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted
			by this pallet.
			pdpolymesh_common_utilitiestraits balances RawEvent$AccountId

Endowedt
HOption<IdentityId>
$AccountId
Balance1
An account was created with some free balance. \[did, account, free_balance] Transfert
HOption<IdentityId>
$AccountIdt
HOption<IdentityId>
$AccountId
Balance|
0Option<Memo>
�Transfer succeeded (from_did, from, to_did, to, value, memo).(BalanceSetx
(IdentityId
$AccountId
Balance
Balance�A balance was set by root (did, who, free, reserved).PAccountBalanceBurnedx
(IdentityId
$AccountId
Balance=
The account and the amount of unlocked balance of that account that was burned.�(caller Id, caller account, amount) Reserved
$AccountId
Balance
Some balance was reserved (moved from free to reserved). \[who, value](Unreserved
$AccountId
Balance!
Some balance was unreserved (moved from reserved to free). \[who, value]HReserveRepatriated
$AccountId
$AccountId
Balance�
StatusM
Some balance was moved from the reserve of the first account to the second account.�Final argument indicates the destination balance type.�\[from, to, balance, destination_status]\Events for this module.tOptionT
x
NoneSomex
xLpolymesh_primitives,identity_id(IdentityId
8[u8; UUID_LEN]|OptionT
�
NoneSome�
�dpolymesh_common_utilitiestraits balancesMemo
 [u8; 32]�4frame_supporttraitstokensmisc4BalanceStatus
Free Reserved
�dpolymesh_common_utilitiestraits identity RawEvent$AccountId
Moment
 
L(DidCreatedx
(IdentityId
$AccountId�
pVec<SecondaryKey<AccountId>>DIdentity created.�(DID, primary key, secondary keys)HSecondaryKeysAddedx
(IdentityId�
pVec<SecondaryKey<AccountId>>
�Secondary keys added to identity.<(DID, new keys)PSecondaryKeysRemovedx
(IdentityId�
8Vec<AccountId>�Secondary keys removed from identity.�(DID, the keys that got removed)`SecondaryKeyLeftIdentityx
(IdentityId
$AccountId�A secondary key left their identity.P(DID, secondary key)xSecondaryKeyPermissionsUpdatedx
(IdentityId
$AccountId�
,Permissions�
,Permissions�Secondary key permissions updated.

(DID, updated secondary key, previous permissions, new permissions)DPrimaryKeyUpdatedx
(IdentityId
$AccountId
$AccountId�Primary key of identity changed.�(DID, old primary key account ID, new ID)(ClaimAddedx
(IdentityId�
4IdentityClaim`Claim added to identity.0(DID, claim)0ClaimRevokedx
(IdentityId�
4IdentityClaimpClaim revoked from identity.0(DID, claim)HAssetDidRegisteredx
(IdentityId�
TickerpAsset's identity registered.L(Asset DID, ticker)HAuthorizationAddedx
(IdentityIdt
HOption<IdentityId>


DOption<AccountId> 
u64

pAuthorizationData<AccountId>�
8Option<Moment>	`New authorization added.1
(authorised_by, target_did, target_key, auth_id, authorization_data, expiry)PAuthorizationRevokedt
HOption<IdentityId>


DOption<AccountId> 
u64
�Authorization revoked by the authorizer.�(authorized_identity, authorized_key, auth_id)TAuthorizationRejectedt
HOption<IdentityId>


DOption<AccountId> 
u64�Authorization rejected by the user who was authorized.�(authorized_identity, authorized_key, auth_id)TAuthorizationConsumedt
HOption<IdentityId>


DOption<AccountId> 
u64\Authorization consumed.�(authorized_identity, authorized_key, auth_id)xAuthorizationRetryLimitReachedt
HOption<IdentityId>


DOption<AccountId> 
u64
�Accepting Authorization retry limit reached.�(authorized_identity, authorized_key, auth_id)�CddRequirementForPrimaryKeyUpdated

bool�CDD requirement for updating primary key changed.D(new_requirement)PCddClaimsInvalidatedx
(IdentityId 
MomentA
CDD claims generated by `IdentityId` (a CDD Provider) have been invalidated from$`Moment`.�(CDD provider DID, disable from date)LSecondaryKeysFrozenx
(IdentityId�All Secondary keys of the identity ID are frozen.(DID)TSecondaryKeysUnfrozenx
(IdentityId�All Secondary keys of the identity ID are unfrozen.(DID)PCustomClaimTypeAddedx
(IdentityId

DCustomClaimTypeId(
Vec<u8>�A new CustomClaimType was added.<(DID, id, Type)\Events for this module.���Lpolymesh_primitives4secondary_key0SecondaryKey$AccountId

key
$AccountId
,permissions�
,Permissions�Lpolymesh_primitives4secondary_key,Permissions
asset�
@AssetPermissions
$extrinsic�
PExtrinsicPermissions
$portfolio�
PPortfolioPermissions�Lpolymesh_primitivessubsetDSubsetRestrictionA
�
WholeThese�
,BTreeSet<A>
Except�
,BTreeSet<A>�Lpolymesh_primitivestickerTicker�
@[u8; TICKER_LEN]�� BTreeSetT
�����Lpolymesh_primitivessubsetDSubsetRestrictionA
�
WholeThese�
,BTreeSet<A>
Except�
,BTreeSet<A>�Lpolymesh_primitives4secondary_keyDPalletPermissions
,pallet_name�
(PalletName
Hdispatchable_names�
DDispatchableNames�Lpolymesh_primitives(PalletName(
Vec<u8>�Lpolymesh_primitivessubsetDSubsetRestrictionA
�
WholeThese�
,BTreeSet<A>
Except�
,BTreeSet<A>�Lpolymesh_primitives@DispatchableName(
Vec<u8>� BTreeSetT
����� BTreeSetT
�����Lpolymesh_primitivessubsetDSubsetRestrictionA
�
WholeThese�
,BTreeSet<A>
Except�
,BTreeSet<A>�Lpolymesh_primitives,identity_id,PortfolioId
didx
(IdentityId
kind�
4PortfolioKind�Lpolymesh_primitives,identity_id4PortfolioKind
DefaultUser�
<PortfolioNumber
�Lpolymesh_primitives,identity_id<PortfolioNumber 
u64� BTreeSetT
������Lpolymesh_primitives8identity_claim4IdentityClaim
0claim_issuerx
(IdentityId
4issuance_date 
Moment
@last_update_date 
Moment
expiry�
8Option<Moment>
claim�
Claim�OptionT
 
NoneSome 
�Lpolymesh_primitives8identity_claimClaim
4(Accredited�
Scope$Affiliate�
Scope
$BuyLockup�
Scope(SellLockup�
ScopePCustomerDueDiligence�
CddId@KnowYourCustomer�
Scope0Jurisdiction


,CountryCode�
Scope Exempted�
ScopeBlocked�
ScopeHInvestorUniqueness�
Scopex
ScopeId�
CddId	NoData
PInvestorUniquenessV2�
CddIdCustom

DCustomClaimTypeId	

4Option<Scope>�Lpolymesh_primitives8identity_claimScope
 Identityx
(IdentityIdTicker�
Ticker
Custom(
Vec<u8>�Lpolymesh_primitivescdd_idCddId
 [u8; 32]

Lpolymesh_primitives0jurisdiction,CountryCode
�AFAX
ALDZASADAOAIAQAG	AR
AMAWAU
ATAZBSBHBDBBBYBEBZBJBMBTBOBABWBVBRVGIO BN!BG"BF#BI$KH%CM&CA'CV(KY)CF*TD+CL,CN-HK.MO/CX0CC1CO2KM3CG4CD5CK6CR7CI8HR9CU:CY;CZ<DK=DJ>DM?DO@ECAEGBSVCGQDEREEEFETGFKHFOIFJJFIKFRLGFMPFNTFOGAPGMQGERDESGHTGIUGRVGLWGDXGPYGUZGT[GG\GN]GW^GY_HT`HMaVAbHNcHUdISeINfIDgIRhIQiIEjIMkILlITmJMnJPoJEpJOqKZrKEsKItKPuKRvKWwKGxLAyLVzLB{LS|LR}LY~LILT�LU�MK�MG�MW�MY�MV�ML�MT�MH�MQ�MR�MU�YT�MX�FM�MD�MC�MN�ME�MS�MA�MZ�MM�NA�NR�NP�NL�AN�NC�NZ�NI�NE�NG�NU�NF�MP�NO�OM�PK�PW�PS�PA�PG�PY�PE�PH�PN�PL�PT�PR�QA�RE�RO�RU�RW�BL�SH�KN�LC�MF�PM�VC�WS�SM�ST�SA�SN�RS�SC�SL�SG�SK�SI�SB�SO�ZA�GS�SS�ES�LK�SD�SR�SJ�SZ�SE�CH�SY�TW�TJ�TZ�TH�TL�TG�TK�TO�TT�TN�TR�TM�TC�TV�UG�UA�AE�GB�US�UM�UY�UZ�VU�VE�VN�VI�WF�EH�YE�ZM�ZW�BQ�CW�SX�
Lpolymesh_primitives8identity_claimDCustomClaimTypeId
u32	
OptionT
�
NoneSome�


OptionT

NoneSome

Lpolymesh_primitives4authorizationDAuthorizationData$AccountId

(`AttestPrimaryKeyRotationx
(IdentityId@RotatePrimaryKey
8TransferTicker�
TickerDAddMultiSigSigner
$AccountIdXTransferAssetOwnership�
Ticker0JoinIdentity�
,Permissions@PortfolioCustody�
,PortfolioId,BecomeAgent�
Ticker

(AgentGroupLAddRelayerPayingKey
$AccountId
$AccountId
BalancelRotatePrimaryKeyToSecondary�
,Permissions	
Lpolymesh_primitivesagent(AgentGroup
FullCustom

AGId
(ExceptMeta4PolymeshV1CAA4PolymeshV1PIA
Lpolymesh_primitivesagentAGId
u32
!
dpolymesh_common_utilitiestraitsgroup RawEvent$AccountId
Event
DI
%

,MemberAddedx
(IdentityIdx
(IdentityId�The given member was added; see the transaction for who.lcaller DID, New member DID.4MemberRemovedx
(IdentityIdx
(IdentityId
�The given member was removed; see the transaction for who.�caller DID, member DID that get removed.4MemberRevokedx
(IdentityIdx
(IdentityId�The given member has been revoked at specific time-stamp.�caller DID, member DID that get revoked.8MembersSwappedx
(IdentityIdx
(IdentityIdx
(IdentityId�Two members were swapped; see the transaction for who.�caller DID, Removed DID, New add DID.0MembersResetx
(IdentityId)

<Vec<IdentityId>
The membership was reset; see the transaction for who the new set is.�caller DID, List of new members.HActiveLimitChangedx
(IdentityId
,MemberCount
,MemberCount-
The limit of how many active members there can be concurrently was changed.DummylPhantom member, never used.\Events for this module.%
0pallet_group$Instance2)
x-
@pallet_committee RawEventHash
$,BlockNumber
I
1

( Proposedx
(IdentityId
4ProposalIndex$
Hash�
A motion (given hash) has been proposed (by given account) with a threshold (given `MemberCount`).�Parameters: caller DID, proposal index, proposal hash.Votedx
(IdentityId
4ProposalIndex$
Hash

bool
,MemberCount
,MemberCount
,MemberCount

A motion (given hash) has been voted on by given account, leavingI
a tally (yes votes, no votes and total seats given respectively as `MemberCount`).�
caller DID, Proposal index, Proposal hash, current vote, yay vote count, nay vote count, total seats.4VoteRetractedx
(IdentityId
4ProposalIndex$
Hash

bool�A vote on a motion (given hash) has been retracted.
caller DID, ProposalIndex, Proposal hash, vote that was retracted(FinalVotesx
(IdentityId
4ProposalIndex$
Hash)

<Vec<IdentityId>)

<Vec<IdentityId>�Final votes on a motion (given hash)�caller DID, ProposalIndex, Proposal hash, yes voters, no voter Approvedx
(IdentityId$
Hash
,MemberCount
,MemberCount
,MemberCount	
A motion was approved by the required threshold with the followingA
tally (yes votes, no votes and total seats given respectively as `MemberCount`).M
Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats. Rejectedx
(IdentityId$
Hash
,MemberCount
,MemberCount
,MemberCount	
A motion was rejected by the required threshold with the followingA
tally (yes votes, no votes and total seats given respectively as `MemberCount`).M
Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats. Executedx
(IdentityId$
Hash5

8DispatchResult9
A motion was executed; `DispatchResult` is `Ok(())` if returned without error.

Parameters: caller DID, proposal hash, result of proposal dispatch.dReleaseCoordinatorUpdatedx
(IdentityIdt
HOption<IdentityId>�Release coordinator has been updated.�Parameters: caller DID, DID of the release coordinator.LExpiresAfterUpdatedx
(IdentityId=

\MaybeBlock<BlockNumber>�Proposal expiry time has been updated.�Parameters: caller DID, new expiry time (if any).PVoteThresholdUpdatedx
(IdentityId
u32
u32	�Voting threshold has been updated�Parameters: caller DID, numerator, denominator\Events for this module.1
@pallet_committee$Instance15
ResultT
9
E
X
Ok9
ErrX
9
=
dpolymesh_common_utilities(MaybeBlock,BlockNumber

Some
,BlockNumberNone
A
dpolymesh_common_utilitiestraitsgroup RawEvent$AccountId
Event
DI
E

,MemberAddedx
(IdentityIdx
(IdentityId�The given member was added; see the transaction for who.lcaller DID, New member DID.4MemberRemovedx
(IdentityIdx
(IdentityId
�The given member was removed; see the transaction for who.�caller DID, member DID that get removed.4MemberRevokedx
(IdentityIdx
(IdentityId�The given member has been revoked at specific time-stamp.�caller DID, member DID that get revoked.8MembersSwappedx
(IdentityIdx
(IdentityIdx
(IdentityId�Two members were swapped; see the transaction for who.�caller DID, Removed DID, New add DID.0MembersResetx
(IdentityId)

<Vec<IdentityId>
The membership was reset; see the transaction for who the new set is.�caller DID, List of new members.HActiveLimitChangedx
(IdentityId
,MemberCount
,MemberCount-
The limit of how many active members there can be concurrently was changed.DummylPhantom member, never used.\Events for this module.E
0pallet_group$Instance1I
@pallet_committee RawEventHash
$,BlockNumber
I
M

( Proposedx
(IdentityId
4ProposalIndex$
Hash�
A motion (given hash) has been proposed (by given account) with a threshold (given `MemberCount`).�Parameters: caller DID, proposal index, proposal hash.Votedx
(IdentityId
4ProposalIndex$
Hash

bool
,MemberCount
,MemberCount
,MemberCount

A motion (given hash) has been voted on by given account, leavingI
a tally (yes votes, no votes and total seats given respectively as `MemberCount`).�
caller DID, Proposal index, Proposal hash, current vote, yay vote count, nay vote count, total seats.4VoteRetractedx
(IdentityId
4ProposalIndex$
Hash

bool�A vote on a motion (given hash) has been retracted.
caller DID, ProposalIndex, Proposal hash, vote that was retracted(FinalVotesx
(IdentityId
4ProposalIndex$
Hash)

<Vec<IdentityId>)

<Vec<IdentityId>�Final votes on a motion (given hash)�caller DID, ProposalIndex, Proposal hash, yes voters, no voter Approvedx
(IdentityId$
Hash
,MemberCount
,MemberCount
,MemberCount	
A motion was approved by the required threshold with the followingA
tally (yes votes, no votes and total seats given respectively as `MemberCount`).M
Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats. Rejectedx
(IdentityId$
Hash
,MemberCount
,MemberCount
,MemberCount	
A motion was rejected by the required threshold with the followingA
tally (yes votes, no votes and total seats given respectively as `MemberCount`).M
Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats. Executedx
(IdentityId$
Hash5

8DispatchResult9
A motion was executed; `DispatchResult` is `Ok(())` if returned without error.

Parameters: caller DID, proposal hash, result of proposal dispatch.dReleaseCoordinatorUpdatedx
(IdentityIdt
HOption<IdentityId>�Release coordinator has been updated.�Parameters: caller DID, DID of the release coordinator.LExpiresAfterUpdatedx
(IdentityId=

\MaybeBlock<BlockNumber>�Proposal expiry time has been updated.�Parameters: caller DID, new expiry time (if any).PVoteThresholdUpdatedx
(IdentityId
u32
u32	�Voting threshold has been updated�Parameters: caller DID, numerator, denominator\Events for this module.M
@pallet_committee$Instance3Q
dpolymesh_common_utilitiestraitsgroup RawEvent$AccountId
Event
DI
U

,MemberAddedx
(IdentityIdx
(IdentityId�The given member was added; see the transaction for who.lcaller DID, New member DID.4MemberRemovedx
(IdentityIdx
(IdentityId
�The given member was removed; see the transaction for who.�caller DID, member DID that get removed.4MemberRevokedx
(IdentityIdx
(IdentityId�The given member has been revoked at specific time-stamp.�caller DID, member DID that get revoked.8MembersSwappedx
(IdentityIdx
(IdentityIdx
(IdentityId�Two members were swapped; see the transaction for who.�caller DID, Removed DID, New add DID.0MembersResetx
(IdentityId)

<Vec<IdentityId>
The membership was reset; see the transaction for who the new set is.�caller DID, List of new members.HActiveLimitChangedx
(IdentityId
,MemberCount
,MemberCount-
The limit of how many active members there can be concurrently was changed.DummylPhantom member, never used.\Events for this module.U
0pallet_group$Instance3Y
@pallet_committee RawEventHash
$,BlockNumber
I
]

( Proposedx
(IdentityId
4ProposalIndex$
Hash�
A motion (given hash) has been proposed (by given account) with a threshold (given `MemberCount`).�Parameters: caller DID, proposal index, proposal hash.Votedx
(IdentityId
4ProposalIndex$
Hash

bool
,MemberCount
,MemberCount
,MemberCount

A motion (given hash) has been voted on by given account, leavingI
a tally (yes votes, no votes and total seats given respectively as `MemberCount`).�
caller DID, Proposal index, Proposal hash, current vote, yay vote count, nay vote count, total seats.4VoteRetractedx
(IdentityId
4ProposalIndex$
Hash

bool�A vote on a motion (given hash) has been retracted.
caller DID, ProposalIndex, Proposal hash, vote that was retracted(FinalVotesx
(IdentityId
4ProposalIndex$
Hash)

<Vec<IdentityId>)

<Vec<IdentityId>�Final votes on a motion (given hash)�caller DID, ProposalIndex, Proposal hash, yes voters, no voter Approvedx
(IdentityId$
Hash
,MemberCount
,MemberCount
,MemberCount	
A motion was approved by the required threshold with the followingA
tally (yes votes, no votes and total seats given respectively as `MemberCount`).M
Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats. Rejectedx
(IdentityId$
Hash
,MemberCount
,MemberCount
,MemberCount	
A motion was rejected by the required threshold with the followingA
tally (yes votes, no votes and total seats given respectively as `MemberCount`).M
Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats. Executedx
(IdentityId$
Hash5

8DispatchResult9
A motion was executed; `DispatchResult` is `Ok(())` if returned without error.

Parameters: caller DID, proposal hash, result of proposal dispatch.dReleaseCoordinatorUpdatedx
(IdentityIdt
HOption<IdentityId>�Release coordinator has been updated.�Parameters: caller DID, DID of the release coordinator.LExpiresAfterUpdatedx
(IdentityId=

\MaybeBlock<BlockNumber>�Proposal expiry time has been updated.�Parameters: caller DID, new expiry time (if any).PVoteThresholdUpdatedx
(IdentityId
u32
u32	�Voting threshold has been updated�Parameters: caller DID, numerator, denominator\Events for this module.]
@pallet_committee$Instance4a
dpolymesh_common_utilitiestraitsgroup RawEvent$AccountId
Event
DI
e

,MemberAddedx
(IdentityIdx
(IdentityId�The given member was added; see the transaction for who.lcaller DID, New member DID.4MemberRemovedx
(IdentityIdx
(IdentityId
�The given member was removed; see the transaction for who.�caller DID, member DID that get removed.4MemberRevokedx
(IdentityIdx
(IdentityId�The given member has been revoked at specific time-stamp.�caller DID, member DID that get revoked.8MembersSwappedx
(IdentityIdx
(IdentityIdx
(IdentityId�Two members were swapped; see the transaction for who.�caller DID, Removed DID, New add DID.0MembersResetx
(IdentityId)

<Vec<IdentityId>
The membership was reset; see the transaction for who the new set is.�caller DID, List of new members.HActiveLimitChangedx
(IdentityId
,MemberCount
,MemberCount-
The limit of how many active members there can be concurrently was changed.DummylPhantom member, never used.\Events for this module.e
0pallet_group$Instance4i
<pallet_multisig RawEvent$AccountId

0<MultiSigCreatedx
(IdentityId
$AccountId
$AccountIdm

dVec<Signatory<AccountId>> 
u64�Event emitted after creation of a multisig.e
Arguments: caller DID, multisig address, signers (pending approval), signatures required.4ProposalAddedx
(IdentityId
$AccountId 
u64
�Event emitted after adding a proposal.�Arguments: caller DID, multisig, proposal ID.@ProposalExecutedx
(IdentityId
$AccountId 
u64

bool�Event emitted when a proposal is executed.�Arguments: caller DID, multisig, proposal ID, result.LMultiSigSignerAddedx
(IdentityId
$AccountIdq

PSignatory<AccountId>�Event emitted when a signatory is added.�Arguments: caller DID, multisig, added signer.`MultiSigSignerAuthorizedx
(IdentityId
$AccountIdq

PSignatory<AccountId>	
Event emitted when a multisig signatory is authorized to be added.�Arguments: caller DID, multisig, authorized signer.TMultiSigSignerRemovedx
(IdentityId
$AccountIdq

PSignatory<AccountId>�Event emitted when a multisig signatory is removed.�Arguments: caller DID, multisig, removed signer.�MultiSigSignaturesRequiredChangedx
(IdentityId
$AccountId 
u64

Event emitted when the number of required signatures is changed.�Arguments: caller DID, multisig, new required signatures.@ProposalApprovedx
(IdentityId
$AccountIdq

PSignatory<AccountId> 
u64�Event emitted when the proposal get approved.

Arguments: caller DID, multisig, authorized signer, proposal id.TProposalRejectionVotex
(IdentityId
$AccountIdq

PSignatory<AccountId> 
u64

Event emitted when a vote is cast in favor of rejecting a proposal.

Arguments: caller DID, multisig, authorized signer, proposal id.@ProposalRejectedx
(IdentityId
$AccountId 
u64	�Event emitted when a proposal is rejected.�Arguments: caller DID, multisig, proposal ID.\ProposalExecutionFailedX
4DispatchError
�Event emitted when there's an error in proposal execution@SchedulingFailedX
4DispatchErrortScheduling of proposal fails.\Events for this module.m
q
q
Lpolymesh_primitives4secondary_key$Signatory$AccountId

 Identityx
(IdentityIdAccount
$AccountId
u
4pallet_bridge RawEvent$AccountId
,BlockNumber

DDControllerChangedx
(IdentityId
$AccountId�Confirmation of a signer set change.0AdminChangedx
(IdentityId
$AccountId
tConfirmation of Admin change.<TimelockChangedx
(IdentityId
,BlockNumber�Confirmation of default timelock change.Bridgedx
(IdentityIdy

LBridgeTx<AccountId>
Confirmation of POLYX upgrade on Polymesh from POLY tokens on Ethereum.Frozenx
(IdentityId�Notification of freezing the bridge. Unfrozenx
(IdentityId�Notification of unfreezing the bridge. FrozenTxx
(IdentityIdy

LBridgeTx<AccountId>�Notification of freezing a transaction.(UnfrozenTxx
(IdentityIdy

LBridgeTx<AccountId>�Notification of unfreezing a transaction.<ExemptedUpdatedx
(IdentityIdx
(IdentityId

bool�Exemption status of an identity has been updated.HBridgeLimitUpdatedx
(IdentityId
Balance
,BlockNumber	xBridge limit has been updated.(TxsHandled}

�Vec<(AccountId, u32, HandledTxStatus)>
a
An event emitted after a vector of transactions is handled. The parameter is a vector ofQ
tuples of recipient account, its nonce, and the status of the processed transaction.DBridgeTxScheduledx
(IdentityIdy

LBridgeTx<AccountId>
,BlockNumberPBridge Tx Scheduled.XBridgeTxScheduleFailedx
(IdentityIdy

LBridgeTx<AccountId>(
Vec<u8>tFailed to schedule Bridge Tx.@FreezeAdminAddedx
(IdentityId
$AccountId
�A new freeze admin has been added.HFreezeAdminRemovedx
(IdentityId
$AccountId�A freeze admin has been removed.$TxRemovedx
(IdentityIdy

LBridgeTx<AccountId>�Notification of removing a transaction.8BridgeTxFailedx
(IdentityIdy

LBridgeTx<AccountId>X
4DispatchError�Bridge Tx failed.  Recipient missing CDD or limit reached.\Events for this module.y
4pallet_bridge BridgeTxAccount

nonce
u32
$recipient
Account
amount
Balance
tx_hash$
H256}
�
�
�
�
4pallet_bridge<HandledTxStatus
SuccessError(
Vec<u8>
�
8pallet_staking RawEventBalance
$AccountId

D$EraPayout
 EraIndex
Balance
BalanceU
The era payout has been set; the first balance is the validator-payout; the second is�the remainder from the maximum amount of reward.�\[era_index, validator_payout, remainder\]Rewardx
(IdentityId
$AccountId
Balance
9
The staker has been rewarded by this amount. \[stash_identity, stash, amount\]Slash
$AccountId
Balance!
One validator (and its nominators) has been slashed by the given amount.T\[validator, amount\]hOldSlashingReportDiscarded
0SessionIndex
An old slashing report from a prior era was discarded because it could�not be processed. \[session_index\]<StakingElection�

<ElectionCompute�A new set of stakers was elected with the given \[compute\].8SolutionStored�

<ElectionCompute
A new solution for the upcoming election has been stored. \[compute\]Bondedx
(IdentityId
$AccountId
Balance�An account has bonded this amount. \[did, stash, amount\]M
NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,!
it will not be emitted for staking rewards when they are added to stake. Unbondedx
(IdentityId
$AccountId
Balance�An account has unbonded this amount. \[did, stash, amount\]$Nominatedx
(IdentityId
$AccountId�
8Vec<AccountId>�User has updated their nominations$Withdrawn
$AccountId
Balance	Y
An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`�from the unlocking queue. \[stash, amount\]dPermissionedIdentityAddedx
(IdentityIdx
(IdentityId
�An DID has issued a candidacy. See the transaction for who.�GC identity , Validator's identity.lPermissionedIdentityRemovedx
(IdentityIdx
(IdentityId�The given member was removed. See the transaction for who.�GC identity , Validator's identity.TInvalidatedNominatorsx
(IdentityId
$AccountId�
8Vec<AccountId>
Remove the nominators from the valid nominators when there CDD expired.�Caller, Stash accountId of nominatorsPCommissionCapUpdatedx
(IdentityId�

Perbill�

Perbill
�When commission cap get updated.X(old value, new value)lMinimumBondThresholdUpdatedt
HOption<IdentityId>
Balance�Min bond threshold was updated (new value).�RewardPaymentSchedulingInterrupted
$AccountId
 EraIndexX
4DispatchError�When scheduling of reward payments get interrupted.dSlashingAllowedForChanged�

8SlashingSwitch�Update for whom balance get slashed.\Events for this module.�
8pallet_staking<ElectionCompute
OnChainSigned
 Unsigned�
4sp_arithmetic(per_thingsPerbill
u32�
8pallet_staking8SlashingSwitch
$ValidatorTValidatorAndNominator
None�
<pallet_offencespalletEvent
Offence
kind�

Kind
 timeslot(
8OpaqueTimeSlotQ
There is an offence reported of the given `kind` happened at the `session_index` and5
(kind-specific) time slot. This event is not deposited for duplicate slashes.L\[kind, timeslot\].0Events type.�
�
8pallet_sessionpalletEvent
(NewSession
4session_index
0SessionIndex9
New session has happened. Note that the argument is the session index, not the�block number as the type might suggest.�

			The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted
			by this pallet.
			�
8pallet_grandpapalletEvent
8NewAuthorities
4authority_set�

4AuthorityList�New authority set has been applied.Paused
�Current authority set has been paused.Resumed�Current authority set has been resumed.�

			The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted
			by this pallet.
			�
�
�
�
 �
Lsp_finality_grandpaappPublic�

<ed25519::Public�
sp_coreed25519Public
 [u8; 32]�
@pallet_im_onlinepalletEventT
DHeartbeatReceived
0authority_id�

8T::AuthorityId�A new heartbeat was received from `AuthorityId`.AllGood
�At the end of the session, no offence was committed.,SomeOffline
offline�

lVec<IdentificationTuple<T>>)
At the end of the session, at least one validator was found to be offline.�

			The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted
			by this pallet.
			�
@pallet_im_onlinesr25519,app_sr25519Public�

<sr25519::Public�
sp_coresr25519Public
 [u8; 32]�
�
�
�
�
8pallet_staking Exposure$AccountId
Balance

total�

Balance
own�

Balance
others�

�Vec<IndividualExposure<AccountId, Balance>>�
�
�
�
8pallet_stakingHIndividualExposure$AccountId
Balance

who
$AccountId
value�

Balance�
,pallet_sudo RawEvent$AccountId

Sudid5

8DispatchResult�A sudo just took place. \[result\](KeyChanged
$AccountId
�The \[sudoer\] just switched identity; the old key is supplied.(SudoAsDone5

8DispatchResult�A sudo just took place. \[result\]\Events for this module.�
dpolymesh_common_utilitiestraitsasset RawEventMoment
 $AccountId

l Transferx
(IdentityId�
Ticker�
,PortfolioId�
,PortfolioId
BalancetEvent for transfer of tokens.�caller DID, ticker, from portfolio, to portfolio, valueIssuedx
(IdentityId�
Tickerx
(IdentityId
Balance�

@FundingRoundName
Balance
pEmit when tokens get issued.u
caller DID, ticker, beneficiary DID, value, funding round, total issued in this funding round Redeemedx
(IdentityId�
Tickerx
(IdentityId
BalancexEmit when tokens get redeemed.�caller DID, ticker,  from DID, value0AssetCreated$x
(IdentityId�
Ticker

bool�

$AssetTypex
(IdentityId

bool�

$AssetName�

PVec<AssetIdentifier>
`Option<FundingRoundName>�Event for creation of the asset.5caller DID/ owner DID, ticker, divisibility, asset type, beneficiary DID, disable investor uniqueness, asset name, identifiers, funding roundHIdentifiersUpdatedx
(IdentityId�
Ticker�

PVec<AssetIdentifier>�Event emitted when any token identifiers are updated.

caller DID, ticker, a vector of (identifier type, identifier value)LDivisibilityChangedx
(IdentityId�
Ticker

bool�Event for change in divisibility.�caller DID, ticker, divisibility@TransferWithDatax
(IdentityId�
Tickerx
(IdentityIdx
(IdentityId
Balance(
Vec<u8>5
An additional event to Transfer; emitted when `transfer_with_data` is called.�caller DID , ticker, from DID, to DID, value, data(IsIssuable�
Ticker

boolPis_issuable() output�ticker, return value (true if issuable)@TickerRegisteredx
(IdentityId�
Ticker�
8Option<Moment>|Emit when ticker is registered.�caller DID / ticker owner did, ticker, ticker owner, expiryDTickerTransferredx
(IdentityId�
Tickerx
(IdentityId	�Emit when ticker is transferred.�caller DID / ticker transferred to DID, ticker, fromdAssetOwnershipTransferredx
(IdentityId�
Tickerx
(IdentityId
�Emit when token ownership is transferred.�caller DID / token ownership transferred to DID, ticker, from,AssetFrozenx
(IdentityId�
Ticker�An event emitted when an asset is frozen.xParameter: caller DID, ticker.4AssetUnfrozenx
(IdentityId�
Ticker�An event emitted when an asset is unfrozen.xParameter: caller DID, ticker.0AssetRenamedx
(IdentityId�
Ticker�

$AssetName
�An event emitted when a token is renamed.�Parameters: caller DID, ticker, new token name.<FundingRoundSetx
(IdentityId�
Ticker�

@FundingRoundName
An event carrying the name of the current funding round of a ticker.�Parameters: caller DID, ticker, funding round name.4DocumentAddedx
(IdentityId�
Ticker	
(DocumentId

 Document�A new document attached to an asset<DocumentRemovedx
(IdentityId�
Ticker	
(DocumentId�A document removed from an asset@ExtensionRemovedx
(IdentityId�
Ticker
$AccountId`A extension got removed.tcaller DID, ticker, AccountIdPClassicTickerClaimedx
(IdentityId�
Ticker9
<EthereumAddress5
A Polymath Classic token was claimed and transferred to a non-systematic DID.HControllerTransferx
(IdentityId�
Ticker�
,PortfolioId
Balance�Event for when a forced transfer takes place.
caller DID/ controller DID, ticker, Portfolio of token holder, value.TCustomAssetTypeExistsx
(IdentityId�

DCustomAssetTypeId(
Vec<u8>�A custom asset type already exists on-chain.1
caller DID, the ID of the custom asset type, the string contents registered.dCustomAssetTypeRegisteredx
(IdentityId�

DCustomAssetTypeId(
Vec<u8>�A custom asset type was registered on-chain.1
caller DID, the ID of the custom asset type, the string contents registered.TSetAssetMetadataValuex
(IdentityId�
Ticker=
HAssetMetadataValueA
�Option<AssetMetadataValueDetail<Moment>>dSet asset metadata value.�(Caller DID, ticker, metadata value, optional value details)pSetAssetMetadataValueDetailsx
(IdentityId�
TickerE
�AssetMetadataValueDetail<Moment>�Set asset metadata value details (expire, lock status).�(Caller DID, ticker, value details)xRegisterAssetMetadataLocalTypex
(IdentityId�
TickerM
DAssetMetadataNameQ
TAssetMetadataLocalKeyU
DAssetMetadataSpec�Register asset metadata local type.
(Caller DID, ticker, Local type name, Local type key, type specs)|RegisterAssetMetadataGlobalTypeM
DAssetMetadataNamem
XAssetMetadataGlobalKeyU
DAssetMetadataSpec�Register asset metadata global type.�(Global type name, Global type key, type specs)@AssetTypeChangedx
(IdentityId�
Ticker�

$AssetType�An event emitted when the type of an asset changed.�Parameters: caller DID, ticker, new token type.\Events for this module.�
Lpolymesh_primitivesasset@FundingRoundName(
Vec<u8>�
Lpolymesh_primitivesasset$AssetType
,0EquityCommon<EquityPreferred
$Commodity,FixedIncomeREITFundTRevenueShareAgreementDStructuredProduct(DerivativeCustom�

DCustomAssetTypeId	(StableCoin
�
Lpolymesh_primitivesassetDCustomAssetTypeId
u32�
Lpolymesh_primitivesasset$AssetName(
Vec<u8>�
�
�
Lpolymesh_primitives@asset_identifier<AssetIdentifier
CUSIP�

[u8; 9]CINS�

[u8; 9]
ISIN�
 [u8; 12]LEI

 [u8; 20]FIGI�
 [u8; 12]�
	
OptionT
�

NoneSome�

	Lpolymesh_primitives document(DocumentId
u32
Lpolymesh_primitives document Document
uri
,DocumentUri
0content_hash
0DocumentHash
name-
0DocumentName
 doc_type1
POption<DocumentType>
,filing_date�
8Option<Moment>Lpolymesh_primitives document,DocumentUri(
Vec<u8>Lpolymesh_primitives4document_hash0DocumentHash
$NoneH512
 [u8; 64]
H384
 [u8; 48]H320!
 [u8; 40]H256
 [u8; 32]H224%
 [u8; 28]H192)
 [u8; 24]H160

 [u8; 20]H128�

 [u8; 16]@0!(%)-Lpolymesh_primitives document0DocumentName(
Vec<u8>1OptionT
5
NoneSome5
5Lpolymesh_primitives document0DocumentType(
Vec<u8>9Lpolymesh_primitives ethereum<EthereumAddress

 [u8; 20]=Lpolymesh_primitives8asset_metadataHAssetMetadataValue(
Vec<u8>AOptionT
E
NoneSomeE
ELpolymesh_primitives8asset_metadata`AssetMetadataValueDetailMoment
 
expire�
8Option<Moment>
,lock_statusI
|AssetMetadataLockStatus<Moment>ILpolymesh_primitives8asset_metadata\AssetMetadataLockStatusMoment
 
 UnlockedLocked
,LockedUntil 
MomentMLpolymesh_primitives8asset_metadataDAssetMetadataName(
Vec<u8>QLpolymesh_primitives8asset_metadataTAssetMetadataLocalKey 
u64ULpolymesh_primitives8asset_metadataDAssetMetadataSpec
urlY
,Option<Url>
,descriptiona
�Option<AssetMetadataDescription>
 type_defi
<Option<Vec<u8>>YOptionT
]
NoneSome]
]Lpolymesh_primitivesUrl(
Vec<u8>aOptionT
e
NoneSomee
eLpolymesh_primitives8asset_metadata`AssetMetadataDescription(
Vec<u8>iOptionT
(
NoneSome(
mLpolymesh_primitives8asset_metadataXAssetMetadataGlobalKey 
u64q`pallet_corporate_actions0distributionEvent
Createdu
 EventDidy
CAId�
0Distribution�A capital distribution, with details included,1
was created by the DID (permissioned agent) for the CA identified by `CAId`.�(Agent DID, CA's ID, distribution details)8BenefitClaimedu
 EventDidu
 EventDidy
CAId�
0Distribution
Balance�
Tax
Q
A token holder's benefit of a capital distribution for the given `CAId` was claimed.�
(Caller DID, Holder/Claimant DID, CA's ID, updated distribution details, DID's benefit, DID's tax %)$Reclaimedu
 EventDidy
CAId
Balance�Stats from `push_benefit` was emitted.
(Agent DID, CA's ID, max requested DIDs, processed DIDs, failed DIDs)Removedu
 EventDidy
CAId�A capital distribution was removed.P(Agent DID, CA's ID)\Events for this module.uLpolymesh_primitives(event_only$EventOnlyT
xx
Ty`pallet_corporate_actionsCAId
ticker�
Ticker
 local_id}
$LocalCAId}`pallet_corporate_actions$LocalCAId
u32�`pallet_corporate_actions0distribution0Distribution 
from�
,PortfolioId
 currency�
Ticker
$per_share
Balance
amount
Balance
$remaining
Balance
$reclaimed

bool
(payment_at 
Moment
(expires_at�
8Option<Moment>�4sp_arithmetic(per_thingsPermill
u32�dpolymesh_common_utilitiestraits(checkpointEvent
DCheckpointCreated�
@Option<EventDid>�
Ticker�
0CheckpointId
Balance 
MomentdA checkpoint was created.
(caller DID, ticker, checkpoint ID, total supply, checkpoint timestamp)�MaximumSchedulesComplexityChangedx
(IdentityId 
u64
)
The maximum complexity for an arbitrary ticker's schedule set was changed.d(GC DID, the new maximum)<ScheduleCreatedu
 EventDid�
Ticker�
8StoredSchedule�A checkpoint schedule was created.x(caller DID, ticker, schedule)<ScheduleRemovedx
(IdentityId�
Ticker�
8StoredSchedule�A checkpoint schedule was removed.x(caller DID, ticker, schedule)\Events for this module.�OptionT
u
NoneSomeu
�Lpolymesh_primitives calendar0CheckpointId 
u64�dpolymesh_common_utilitiestraits(checkpoint8StoredSchedule
 schedule�
HCheckpointSchedule
id�
(ScheduleId
at 
Moment
$remaining
u32�Lpolymesh_primitives calendarHCheckpointSchedule
start 
Moment
period�
8CalendarPeriod�Lpolymesh_primitives calendar8CalendarPeriod
unit�
0CalendarUnit
amount 
u64�Lpolymesh_primitives calendar0CalendarUnit
SecondMinute
HourDayWeekMonthYear�dpolymesh_common_utilitiestraits(checkpoint(ScheduleId 
u64�dpallet_compliance_managerEvent
$pComplianceRequirementCreatedx
(IdentityId�
Ticker�
TComplianceRequirement�Emitted when new compliance requirement is created.�(caller DID, Ticker, ComplianceRequirement).pComplianceRequirementRemovedx
(IdentityId�
Ticker
u32
�Emitted when a compliance requirement is removed.�(caller DID, Ticker, requirement_id).\AssetComplianceReplacedx
(IdentityId�
Ticker�
hVec<ComplianceRequirement>�Emitted when an asset compliance is replaced.�Parameters: caller DID, ticker, new asset compliance.PAssetComplianceResetx
(IdentityId�
Ticker�Emitted when an asset compliance of a ticker is reset.T(caller DID, Ticker).XAssetComplianceResumedx
(IdentityId�
Ticker

Emitted when an asset compliance for a given ticker gets resume.T(caller DID, Ticker).TAssetCompliancePausedx
(IdentityId�
Ticker

Emitted when an asset compliance for a given ticker gets paused.T(caller DID, Ticker).pComplianceRequirementChangedx
(IdentityId�
Ticker�
TComplianceRequirement�Emitted when compliance requirement get modified/change.�(caller DID, Ticker, ComplianceRequirement).xTrustedDefaultClaimIssuerAddedx
(IdentityId�
Ticker�
4TrustedIssuer
Emitted when default claim issuer list for a given ticker gets added.�(caller DID, Ticker, Added TrustedIssuer).�TrustedDefaultClaimIssuerRemovedx
(IdentityId�
Tickerx
(IdentityId
Emitted when default claim issuer list for a given ticker get removed.�(caller DID, Ticker, Removed TrustedIssuer).\Events for this module.�Lpolymesh_primitivesHcompliance_managerTComplianceRequirement
Dsender_conditions�
8Vec<Condition>
Lreceiver_conditions�
8Vec<Condition>
id
u32���Lpolymesh_primitives$condition$Condition
8condition_type�
4ConditionType
issuers�
HVec<TrustedIssuer>�Lpolymesh_primitives$condition4ConditionType
$IsPresent�
Claim IsAbsent�
Claim
IsAnyOf�
(Vec<Claim> IsNoneOf�
(Vec<Claim>(IsIdentity�
8TargetIdentity���Lpolymesh_primitives$condition8TargetIdentity
4ExternalAgent Specificx
(IdentityId
���Lpolymesh_primitives$condition4TrustedIssuer
issuerx
(IdentityId
,trusted_for�
(TrustedFor�Lpolymesh_primitives$condition(TrustedFor
Any Specific�
8Vec<ClaimType>
���Lpolymesh_primitives8identity_claim$ClaimType
4(Accredited$Affiliate
$BuyLockup(SellLockupPCustomerDueDiligence@KnowYourCustomer0Jurisdiction ExemptedBlockedHInvestorUniqueness	NoType
PInvestorUniquenessV2Custom

DCustomClaimTypeId���`pallet_corporate_actionsEvent
$\MaxDetailsLengthChangedx
(IdentityId
u32�The maximum length of `details` in bytes was changed.P(GC DID, new length)xDefaultTargetIdentitiesChangedx
(IdentityId�
Ticker�
@TargetIdentities
�The set of default `TargetIdentities` for a ticker changed.�(Agent DID, Ticker, New TargetIdentities)pDefaultWithholdingTaxChangedx
(IdentityId�
Ticker�
Tax�The default withholding tax for a ticker changed.t(Agent DID, Ticker, New Tax).`DidWithholdingTaxChangedx
(IdentityId�
Tickerx
(IdentityId�
,Option<Tax>�The withholding tax specific to a DID for a ticker changed.�(Agent DID, Ticker, Taxed DID, New Tax).8CAATransferredx
(IdentityId�
Tickerx
(IdentityIdlA new DID was made the CAA.�(New CAA DID, Ticker, New CAA DID).,CAInitiatedu
 EventDidy
CAId�
<CorporateAction	
$CADetailsLA CA was initiated.�(Agent DID, CA id, the CA, the CA details)4CALinkedToDocx
(IdentityIdy
CAId

<Vec<DocumentId>�A CA was linked to a set of docs.�(Agent DID, CA Id, List of doc identifiers)$CARemovedu
 EventDidy
CAIdDA CA was removed.H(Agent DID, CA Id)DRecordDateChangedu
 EventDidy
CAId�
<CorporateActionlA CA's record date changed.\Events for this module.�`pallet_corporate_actions@TargetIdentities
(identities)

<Vec<IdentityId>
$treatment�
<TargetTreatment�`pallet_corporate_actions<TargetTreatment
IncludeExclude
�OptionT
�
NoneSome�
�`pallet_corporate_actions<CorporateAction
kind�
CAKind
$decl_date 
Moment
,record_date�
HOption<RecordDate>
targets�
@TargetIdentities
\default_withholding_tax�
Tax
<withholding_tax

XVec<(IdentityId, Tax)>�`pallet_corporate_actionsCAKind
HPredictableBenefitPUnpredictableBenefit
0IssuerNotice8ReorganizationOther�OptionT
�
NoneSome�
�`pallet_corporate_actions(RecordDate
date 
Moment
(checkpoint�
0CACheckpoint�`pallet_corporate_actions0CACheckpoint
$Scheduled�
(ScheduleId 
u64 Existing�
0CheckpointId

x�	`pallet_corporate_actions$CADetails(
Vec<u8>
	`pallet_corporate_actionsballotEvent
Createdx
(IdentityIdy
CAId
<BallotTimeRange
(BallotMeta

bool|A corporate ballot was created.
(Agent DID, CA's ID, Voting start/end, Ballot metadata, RCV enabled?) VoteCastx
(IdentityIdy
CAId9
<Vec<BallotVote>
�A vote was cast in a corporate ballot.`(voter DID, CAId, Votes)0RangeChangedx
(IdentityIdy
CAId
<BallotTimeRange�A corporate ballot changed its start/end date range.�(Agent DID, CA's ID, Voting start/end),MetaChangedx
(IdentityIdy
CAId
(BallotMeta�A corporate ballot changed its metadata.�(Agent DID, CA's ID, New metadata)(RCVChangedx
(IdentityIdy
CAId

bool�A corporate ballot changed its RCV support.�(Agent DID, CA's ID, New support)Removedu
 EventDidy
CAId|A corporate ballot was removed.P(Agent DID, CA's ID)\Events for this module.`pallet_corporate_actionsballot<BallotTimeRange
start 
Moment
end 
Moment`pallet_corporate_actionsballot(BallotMeta
title
,BallotTitle
motions!
,Vec<Motion>`pallet_corporate_actionsballot,BallotTitle(
Vec<u8>!%%`pallet_corporate_actionsballotMotion
title)
,MotionTitle
$info_link-
8MotionInfoLink
choices1
@Vec<ChoiceTitle>)`pallet_corporate_actionsballot,MotionTitle(
Vec<u8>-`pallet_corporate_actionsballot8MotionInfoLink(
Vec<u8>155`pallet_corporate_actionsballot,ChoiceTitle(
Vec<u8>9==`pallet_corporate_actionsballot(BallotVote
power
Balance
 fallbackA
,Option<u16>AOptionT
E
NoneSomeE
EI,pallet_pips RawEvent$AccountId
,BlockNumber

PPHistoricalPipsPrunedx
(IdentityId

bool

boolE
Pruning Historical PIPs is enabled or disabled (caller DID, old value, new value)<ProposalCreated x
(IdentityIdM
LProposer<AccountId>U
PipId
BalanceY
,Option<Url>Y
XOption<PipDescription>=

\MaybeBlock<BlockNumber>a
0ProposalData
�A PIP was made with a `Balance` stake.4# Parameters:Q
Caller DID, Proposer, PIP ID, deposit, URL, description, expiry time, proposal data.PProposalStateUpdatedx
(IdentityIdU
PipIde
4ProposalState�Triggered each time the state of a proposal is amendedVotedx
(IdentityId
$AccountIdU
PipId

bool
Balance�`AccountId` voted `bool` on the proposal referenced by `PipId`$PipClosedx
(IdentityIdU
PipId

bool�Pip has been closed, bool indicates whether data is prunedHExecutionScheduledx
(IdentityIdU
PipId
,BlockNumber�Execution of a PIP has been scheduled at specific block.tDefaultEnactmentPeriodChangedx
(IdentityId
,BlockNumber
,BlockNumber�Default enactment period (in blocks) has been changed.�(caller DID, old period, new period)tMinimumProposalDepositChangedx
(IdentityId
Balance
Balance|Minimum deposit amount modified�(caller DID, old amount, new amount)\PendingPipExpiryChangedx
(IdentityId=

\MaybeBlock<BlockNumber>=

\MaybeBlock<BlockNumber>�Amount of blocks after which a pending PIP expires.�(caller DID, old expiry, new expiry)XMaxPipSkipCountChangedx
(IdentityId
0SkippedCount
0SkippedCount	�The maximum times a PIP can be skipped was changed.�(caller DID, old value, new value)TActivePipLimitChangedx
(IdentityId
u32
u32
�The maximum number of active PIPs was changed.�(caller DID, old value, new value)8ProposalRefundx
(IdentityIdU
PipId
Balance<Refund proposalH(id, total amount)<SnapshotClearedx
(IdentityIdi
(SnapshotIddThe snapshot was cleared.4SnapshotTakenx
(IdentityIdi
(SnapshotIdm
LVec<SnapshottedPip>
dA new snapshot was taken.(PipSkippedx
(IdentityIdU
PipId
0SkippedCount�A PIP in the snapshot queue was skipped.�(gc_did, pip_id, new_skip_count)XSnapshotResultsEnactedx
(IdentityIdy
HOption<SnapshotId>}
hVec<(PipId, SkippedCount)>�
(Vec<PipId>�
(Vec<PipId>1
Results (e.g., approved, rejected, and skipped), were enacted for some PIPs.Q
(gc_did, snapshot_id_opt, skipped_pips_with_new_count, rejected_pips, approved_pips)dExecutionSchedulingFailedx
(IdentityIdU
PipId
,BlockNumber

Scheduling of the PIP for execution failed in the scheduler pallet.<ExpiryScheduledx
(IdentityIdU
PipId
,BlockNumber�The PIP has been scheduled for expiry.XExpirySchedulingFailedx
(IdentityIdU
PipId
,BlockNumber

Scheduling of the PIP for expiry failed in the scheduler pallet.dExecutionCancellingFailedU
PipId�Cancelling the PIP execution failed in the scheduler pallet.\Events for this module.M,pallet_pips Proposer$AccountId

$Community
$AccountId$CommitteeQ
$Committee
Q,pallet_pips$Committee
$TechnicalUpgrade
U,pallet_pipsPipId
u32YOptionT
]
NoneSome]
],pallet_pips8PipDescription(
Vec<u8>a,pallet_pips0ProposalData
Hash$
H256 Proposal(
Vec<u8>
e,pallet_pips4ProposalState
Pending Rejected
$ScheduledFailed ExecutedExpiredi,pallet_pips(SnapshotId
u32mqq,pallet_pips8SnapshottedPip
idU
PipId
weightu
<(bool, Balance)u
yOptionT
i
NoneSomei
}��U�U�dpolymesh_common_utilitiestraits$portfolioEvent
@PortfolioCreatedx
(IdentityId�
<PortfolioNumber�
4PortfolioName�The portfolio has been successfully created.0# Parameters0* origin DIDH* portfolio number@* portfolio name@PortfolioDeletedx
(IdentityId�
<PortfolioNumber
�The portfolio has been successfully removed.0# Parameters0* origin DIDH* portfolio numberXMovedBetweenPortfoliosx
(IdentityId�
,PortfolioId�
,PortfolioId�
Ticker
Balance|
0Option<Memo> �A token amount has been moved from one portfolio to another.0# Parameters0* origin DIDH* source portfolio\* destination portfolio8* asset tickerx* asset balance that was moved@PortfolioRenamedx
(IdentityId�
<PortfolioNumber�
4PortfolioName�The portfolio identified with `num` has been renamed to `name`.0# Parameters0* origin DIDH* portfolio number@* portfolio name8UserPortfoliosx
(IdentityId�
�Vec<(PortfolioNumber, PortfolioName)>�All non-default portfolio numbers and names of a DID.0# Parameters0* origin DIDt* vector of number-name pairsdPortfolioCustodianChangedx
(IdentityId�
,PortfolioIdx
(IdentityId�Custody of a portfolio has been given to a different identity0# Parameters0* origin DID8* portfolio idd* portfolio custodian did\Events for this module.�Lpolymesh_primitives,identity_id4PortfolioName(
Vec<u8>���܍�Lpallet_protocol_fee RawEvent$AccountId

FeeSetx
(IdentityId
Balance�The protocol fee of an operation.8CoefficientSetx
(IdentityId�
 PosRatio
PThe fee coefficient.(FeeCharged
$AccountId
Balance0Fee charged.\Events for this module.�Lpolymesh_primitives PosRatio
u32
u32�@pallet_schedulerpalletEventT
$Scheduled
when
8T::BlockNumber
index
u32PScheduled some task. Canceled
when
8T::BlockNumber
index
u32
LCanceled some task.(Dispatched
task�
lTaskAddress<T::BlockNumber>
idi
<Option<Vec<u8>>
result5

8DispatchResultTDispatched some task.@CallLookupFailed
task�
lTaskAddress<T::BlockNumber>
idi
<Option<Vec<u8>>
error�
,LookupError)
The call for the provided hash was not found so the task has been aborted.0Events type.��4frame_supporttraits schedule,LookupError
Unknown$BadFormat
�Dpallet_settlement RawEventMoment
 ,BlockNumber
$AccountId

X0VenueCreatedx
(IdentityId�
VenueId�
0VenueDetails�
$VenueType�A new venue has been created (did, venue_id, details, type)LVenueDetailsUpdatedx
(IdentityId�
VenueId�
0VenueDetails

An existing venue's details has been updated (did, venue_id, details)@VenueTypeUpdatedx
(IdentityId�
VenueId�
$VenueType�An existing venue's type has been updated (did, venue_id, type)HInstructionCreated x
(IdentityId�
VenueId�
4InstructionId�
lSettlementType<BlockNumber>�
8Option<Moment>�
8Option<Moment>�
 Vec<Leg>�
\Option<InstructionMemo>�A new instruction has been createdQ
(did, venue_id, instruction_id, settlement_type, trade_date, value_date, legs, memo)LInstructionAffirmedx
(IdentityId�
,PortfolioId�
4InstructionId
An instruction has been affirmed (did, portfolio, instruction_id)PAffirmationWithdrawnx
(IdentityId�
,PortfolioId�
4InstructionId	
An affirmation has been withdrawn (did, portfolio, instruction_id)LInstructionRejectedx
(IdentityId�
4InstructionId�An instruction has been rejected (did, instruction_id)8ReceiptClaimedx
(IdentityId�
4InstructionId�
LegId 
u64
$AccountId�
<ReceiptMetadata}
A receipt has been claimed (did, instruction_id, leg_id, receipt_uid, signer, receipt metadata)XReceiptValidityChangedx
(IdentityId
$AccountId 
u64

bool

A receipt has been invalidated (did, signer, receipt_uid, validity)@ReceiptUnclaimedx
(IdentityId�
4InstructionId�
LegId 
u64
$AccountId	=
A receipt has been unclaimed (did, instruction_id, leg_id, receipt_uid, signer)8VenueFilteringx
(IdentityId�
Ticker

bool
i
Venue filtering has been enabled or disabled for a ticker (did, ticker, filtering_enabled)4VenuesAllowedx
(IdentityId�
Ticker�
0Vec<VenueId>�Venues added to allow list (did, ticker, vec<venue_id>)4VenuesBlockedx
(IdentityId�
Ticker�
0Vec<VenueId>�Venues added to block list (did, ticker, vec<venue_id>)HLegFailedExecutionx
(IdentityId�
4InstructionId�
LegId
�Execution of a leg failed (did, instruction_id, leg_id)DInstructionFailedx
(IdentityId�
4InstructionId�Instruction failed execution (did, instruction_id)LInstructionExecutedx
(IdentityId�
4InstructionId�Instruction executed successfully(did, instruction_id)DVenueUnauthorizedx
(IdentityId�
Ticker�
VenueId

Venue not part of the token's allow list (did, Ticker, venue_id)@SchedulingFailedX
4DispatchError�Scheduling of instruction fails.XInstructionRescheduledx
(IdentityId�
4InstructionIdlInstruction is rescheduled.p(caller DID, instruction_id)LVenueSignersUpdatedx
(IdentityId�
VenueId�
8Vec<AccountId>

boolI
An existing venue's signers has been updated (did, venue_id, signers, update_type)hSettlementManuallyExecutedx
(IdentityId�
4InstructionId�Settlement manually executed (did, id)hFailedToExecuteInstruction�
4InstructionIdX
4DispatchErrorxFailed to execute instruction.\Events for this module.�Dpallet_settlementVenueId 
u64�Dpallet_settlement0VenueDetails(
Vec<u8>�Dpallet_settlement$VenueType
Other0Distribution
Sto Exchange�Dpallet_settlement4InstructionId 
u64�Dpallet_settlement8SettlementType,BlockNumber

LSettleOnAffirmation4SettleOnBlock
,BlockNumber
0SettleManual
,BlockNumber���Dpallet_settlementLeg
from�
,PortfolioId
to�
,PortfolioId
asset�
Ticker
amount
Balance�OptionT
�
NoneSome�
�Dpallet_settlement<InstructionMemo
 [u8; 32]�Dpallet_settlementLegId 
u64�Dpallet_settlement<ReceiptMetadata(
Vec<u8>���dpolymesh_common_utilitiestraits(statisticsEvent
8StatTypesAddedx
(IdentityId�
(AssetScope�
4Vec<StatType>hStat types added to asset.|(Caller DID, Asset, Stat types)@StatTypesRemovedx
(IdentityId�
(AssetScope�
4Vec<StatType>
xStat types removed from asset.|(Caller DID, Asset, Stat types)DAssetStatsUpdatedx
(IdentityId�
(AssetScope�
 StatType�
<Vec<StatUpdate>PAsset stats updated.�(Caller DID, Asset, Stat type, Updates)hSetAssetTransferCompliancex
(IdentityId�
(AssetScope
XVec<TransferCondition>�Set Transfer compliance rules for asset.�(Caller DID, Asset, Transfer conditions)�TransferConditionExemptionsAddedx
(IdentityId
hTransferConditionExemptKey)

0Vec<ScopeId>	
Add `ScopeId`s exempt for transfer conditions matching exempt key.�(Caller DID, Exempt key, Entities)�TransferConditionExemptionsRemovedx
(IdentityId
hTransferConditionExemptKey)

0Vec<ScopeId>
Remove `ScopeId`s exempt for transfer conditions matching exempt key.�(Caller DID, Exempt key, Entities)\Events for this module.�Lpolymesh_primitives(statistics(AssetScope
Ticker�
Ticker���Lpolymesh_primitives(statistics StatType
op�
(StatOpType
0claim_issuer�
|Option<(ClaimType, IdentityId)>�Lpolymesh_primitives(statistics(StatOpType
CountBalance
�OptionT
�
NoneSome�
��x�

Lpolymesh_primitives(statistics(StatUpdate
key2
(Stat2ndKey
value
0Option<u128>Lpolymesh_primitives(statistics(Stat2ndKey
,NoClaimStatClaim	
$StatClaim
	Lpolymesh_primitives(statistics$StatClaim
(Accredited

bool$Affiliate

bool
0Jurisdiction

LOption<CountryCode>
OptionT



NoneSome


OptionT

NoneSome
Lpolymesh_primitivesLtransfer_complianceDTransferCondition
@MaxInvestorCount 
u64PMaxInvestorOwnership�
(Percentage
(ClaimCount	
$StatClaimx
(IdentityId 
u64�
,Option<u64>8ClaimOwnership	
$StatClaimx
(IdentityId�
(Percentage�
(PercentageLpolymesh_primitivesLtransfer_compliancehTransferConditionExemptKey
asset�
(AssetScope
op�
(StatOpType
(claim_type!
DOption<ClaimType>!OptionT
�
NoneSome�
%(pallet_sto RawEventMoment
 
DFundraiserCreatedx
(IdentityId)
0FundraiserId-
8FundraiserName1
HFundraiser<Moment>�A new fundraiser has been created.�(Agent DID, fundraiser id, fundraiser name, fundraiser details) Investedx
(IdentityId)
0FundraiserId�
Ticker�
Ticker
Balance
Balance
�An investor invested in the fundraiser.�
(Investor, fundraiser_id, offering token, raise token, offering_token_amount, raise_token_amount)@FundraiserFrozenx
(IdentityId)
0FundraiserIdtA fundraiser has been frozen.h(Agent DID, fundraiser id)HFundraiserUnfrozenx
(IdentityId)
0FundraiserId|A fundraiser has been unfrozen.h(Agent DID, fundraiser id)`FundraiserWindowModifiedu
 EventDid)
0FundraiserId 
Moment�
8Option<Moment> 
Moment�
8Option<Moment>�A fundraiser window has been modified.	
(Agent DID, fundraiser id, old_start, old_end, new_start, new_end)@FundraiserClosedx
(IdentityId)
0FundraiserIdxA fundraiser has been stopped.h(Agent DID, fundraiser id)\Events for this module.)(pallet_sto0FundraiserId 
u64-(pallet_sto8FundraiserName(
Vec<u8>1(pallet_sto(FundraiserMoment
 ,
creatorx
(IdentityId
Hoffering_portfolio�
,PortfolioId
8offering_asset�
Ticker
Draising_portfolio�
,PortfolioId
4raising_asset�
Ticker
tiers5
LVec<FundraiserTier>
 venue_id�
VenueId
start 
Moment
end�
8Option<Moment>
status=
@FundraiserStatus
Hminimum_investment
Balance599(pallet_sto8FundraiserTier
total
Balance
price
Balance
$remaining
Balance=(pallet_sto@FundraiserStatus
LiveFrozen
Closed,ClosedEarlyA<pallet_treasury RawEventBalance
$AccountId

PTreasuryDisbursementx
(IdentityIdx
(IdentityId
$AccountId
Balance�Disbursement to a target Identity.

(treasury identity, target identity, target primary key, amount)hTreasuryDisbursementFailedx
(IdentityIdx
(IdentityId
$AccountId
Balance
�Disbursement to a target Identity failed.

(treasury identity, target identity, target primary key, amount)TTreasuryReimbursementx
(IdentityId
Balance\Treasury reimbursement.d(source identity, amount)\Events for this module.E8pallet_utilityEvent
@BatchInterruptedI
,EventCountsM
ErrorAt�Batch of dispatches did not complete fully.�Includes a vector of event counts for each dispatch and�the index of the first failing dispatch as well as the error.TBatchOptimisticFailedI
,EventCountsQ
0Vec<ErrorAt>
�Batch of dispatches did not complete fully.�Includes a vector of event counts for each call and)
a vector of any failed dispatches with their indices and associated error.8BatchCompletedI
,EventCounts�Batch of dispatches completed fully with no error.�Includes a vector of event counts for each dispatch.\Events for this module.0Events type.IMXQMUdpolymesh_common_utilitiestraitsbaseEvent
<UnexpectedErrorY
TOption<DispatchError>�An unexpected error happened that should be investigated.\Events for this module.YOptionT
X
NoneSomeX
]dpolymesh_common_utilitiestraits<external_agentsEvent
0GroupCreatedu
 EventDid�
Ticker

AGId�
PExtrinsicPermissionslAn Agent Group was created.�(Caller DID, AG's ticker, AG's ID, AG's permissions)\GroupPermissionsUpdatedu
 EventDid�
Ticker

AGId�
PExtrinsicPermissions
�An Agent Group's permissions was updated.�(Caller DID, AG's ticker, AG's ID, AG's new permissions)(AgentAddedu
 EventDid�
Ticker

(AgentGroupLAn agent was added.�(Caller/Agent DID, Agent's ticker, Agent's group)0AgentRemovedu
 EventDid�
Tickerx
(IdentityIdTAn agent was removed.�(Caller DID, Agent's ticker, Agent's DID)0GroupChangedu
 EventDid�
Tickerx
(IdentityId

(AgentGrouptAn agent's group was changed.
(Caller DID, Agent's ticker, Agent's DID, The new group of the agent)\Events for this module.adpolymesh_common_utilitiestraitsrelayer RawEvent$AccountId

LAuthorizedPayingKeyu
 EventDid
$AccountId
$AccountId
Balance 
u64�Authorization given for `paying_key` to `user_key`.

(Caller DID, User Key, Paying Key, Initial POLYX limit, Auth ID)DAcceptedPayingKeyu
 EventDid
$AccountId
$AccountId
PAccepted paying key.�(Caller DID, User Key, Paying Key)@RemovedPayingKeyu
 EventDid
$AccountId
$AccountIdLRemoved paying key.�(Caller DID, User Key, Paying Key)DUpdatedPolyxLimitu
 EventDid
$AccountId
$AccountId
Balance
BalancePUpdated polyx limit.
(Caller DID, User Key, Paying Key, POLYX limit, old remaining POLYX)\Events for this module.e8pallet_rewards RawEvent$AccountId

@ItnRewardClaimed
$AccountId
Balance\Itn reward was claimed.\Events for this module.i@pallet_contractspalletEventT
0Instantiated
 deployer
0T::AccountId
 contract
0T::AccountId�Contract deployed by address at the specified address.(Terminated
 contract
0T::AccountId�The contract that was terminated.
,beneficiary
0T::AccountId�The account that received the contracts remaining balance
hContract has been removed.# Note=
The only way for a contract to be removed and emitting this event is by callingD`seal_terminate`.(CodeStored
$code_hash$
T::Hash�Code with the specified hash has been stored.<ContractEmitted
 contract
0T::AccountId�The contract that emitted the event.
data(
Vec<u8>5
Data supplied by the contract. Metadata generated during contract compilation\is needed to decode it.�A custom event emitted by the contract.,CodeRemoved
$code_hash$
T::Hash�A code with the specified hash was removed.LContractCodeUpdated
 contract
0T::AccountId�The contract that has been updated.
4new_code_hash$
T::Hash�New code hash that was set for the contract.
4old_code_hash$
T::Hash�Previous code hash of the contract.xA contract's code was updated.�

			The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted
			by this pallet.
			mHpolymesh_contractsEvent
\Events for this module.q<pallet_preimagepalletEventT
Noted
hash$
T::HashhA preimage has been noted.$Requested
hash$
T::Hash
xA preimage has been requested.Cleared
hash$
T::HashlA preimage has ben cleared.�

			The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted
			by this pallet.
			uDpallet_test_utils RawEvent$AccountId

XMockInvestorUIDCreatedx
(IdentityIdy
,InvestorUid

A new mocked `InvestorUid` has been created for the given Identity.t(Target DID, New InvestorUid)$DidStatusx
(IdentityId
$AccountId
�Emits the `IdentityId` and the `AccountId` of the caller.p(Caller DID, Caller account)$CddStatust
HOption<IdentityId>
$AccountId

boolU
Shows the `DID` associated to the `AccountId`, and a flag indicates if that DID has a@valid CDD claim.�(Target DID, Target Account, a valid CDD claim exists)\Events for this module.yLpolymesh_primitivescdd_id,InvestorUid�

 [u8; 16]}0frame_systemPhase
8ApplyExtrinsic
u320Finalization
8Initialization�$���0frame_systemXLastRuntimeUpgradeInfo
0spec_version�
Lcodec::Compact<u32>
$spec_name�
dsp_runtime::RuntimeString���0frame_systempalletCallT
$(fill_block
ratio�

Perbill
A dispatch that will fill the block weight up to the given ratio.remark
remark(
Vec<u8>
hMake some on-chain remark.(# <weight> - `O(1)`,# </weight>8set_heap_pages
pages 
u64�Set the number of pages in the WebAssembly environment's heap. set_code
code(
Vec<u8>0dSet the new runtime code.(# <weight>1
- `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`E
- 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is4  expensive).�- 1 storage write (codec `O(C)`).@- 1 digest item.(- 1 event.M
The weight of this function is dependent on the runtime, but generally this is very�expensive. We will treat this as a full block.,# </weight>\set_code_without_checks
code(
Vec<u8>$
Set the new runtime code without doing any checks of the given `code`.(# <weight>�- `O(C)` where `C` length of `code`�- 1 storage write (codec `O(C)`).@- 1 digest item.(- 1 event.U
The weight of this function is dependent on the runtime. We will treat this as a fullHblock. # </weight>,set_storage
items�
4Vec<KeyValue>hSet some items of storage.0kill_storage
keys�
 Vec<Key>tKill some items from storage.,kill_prefix
prefix(
Key
subkeys
u32
Kill all storage items with a key that starts with the given prefix.9
**NOTE:** We rely on the Root origin to provide us the number of subkeys under=
the prefix we are removing to accurately calculate the weight of this function.Dremark_with_event
remark(
Vec<u8>�Make some on-chain remark and emit event.%
Contains one variant per dispatchable that can be called by an extrinsic.���((�(�0frame_systemlimits0BlockWeights
(base_block 
Weight
$max_block 
Weight
$per_class�
�PerDispatchClass<WeightsPerClass>�4frame_supportweights@PerDispatchClassT
�
normal�
T
,operational�
T
$mandatory�
T�0frame_systemlimits<WeightsPerClass
8base_extrinsic 
Weight
4max_extrinsic�
8Option<Weight>
$max_total�
8Option<Weight>
 reserved�
8Option<Weight>�0frame_systemlimits,BlockLength
max�
TPerDispatchClass<u32>�4frame_supportweights@PerDispatchClassT

normal
T
,operational
T
$mandatory
T�4frame_supportweights<RuntimeDbWeight
read 
Weight
write 
Weight�(sp_version8RuntimeVersion 
$spec_name�
4RuntimeString
$impl_name�
4RuntimeString
Dauthoring_version
u32
0spec_version
u32
0impl_version
u32
apis�
ApisVec
Ltransaction_version
u32
4state_version
u8�CowT
��������0frame_systempalletErrorT
<InvalidSpecName
The name of specification does not match between the current runtimePand the new runtime.hSpecVersionNeedsToIncrease
A
The specification version is not allowed to decrease between the current runtimePand the new runtime.tFailedToExtractRuntimeVersion�Failed to extract the runtime version from the new runtime.	
Either calling `Core_version` or decoding `RuntimeVersion` failed.LNonDefaultComposite�Suicide called when the account has non-default composite data.<NonZeroRefCount5
There is a non-zero reference count preventing the account from being purged.0CallFiltered�The origin filter prevent the call to be dispatched.lError for the System pallet�4frame_supportstorage@weak_bounded_vec8WeakBoundedVecT
�S�
Vec<T>�� �Dsp_consensus_babeappPublic�

<sr25519::Public���Hsp_consensus_slotsSlot 
u64�Dsp_consensus_babedigestsPNextConfigDescriptor
V1
c�
((u64, u64)
4allowed_slots�
0AllowedSlots
�  �Dsp_consensus_babe0AllowedSlots
0PrimarySlotstPrimaryAndSecondaryPlainSlots
lPrimaryAndSecondaryVRFSlots�4frame_supportstorage,bounded_vec(BoundedVecT
S�
Vec<T>��OptionT

NoneSome

Dsp_consensus_babeXBabeEpochConfiguration
c�
((u64, u64)
4allowed_slots�
0AllowedSlots,pallet_babepalletCallT
Lreport_equivocation
Hequivocation_proof	
�Box<EquivocationProof<T::Header>>
<key_owner_proof
@T::KeyOwnerProof	
Report authority equivocation/misbehavior. This method will verify
the equivocation proof and validate the given key ownership proof

against the extracted offender. If both are valid, the offence will0be reported.preport_equivocation_unsigned
Hequivocation_proof	
�Box<EquivocationProof<T::Header>>
<key_owner_proof
@T::KeyOwnerProof
 	
Report authority equivocation/misbehavior. This method will verify
the equivocation proof and validate the given key ownership proof

against the extracted offender. If both are valid, the offence will0be reported.

This extrinsic must be called unsigned and it is expected that only
block authors will call it (validated in `ValidateUnsigned`), as such
if the block author is defined it will be defined as the equivocation$reporter.Hplan_config_change
config�
PNextConfigDescriptor]
Plan an epoch config change. The epoch config change is recorded and will be enacted onQ
the next call to `enact_epoch_change`. The config will be activated one epoch after.Y
Multiple calls to this method will replace any existing planned config change that hadTnot been enacted yet.%
Contains one variant per dispatchable that can be called by an extrinsic.	Hsp_consensus_slotsDEquivocationProofHeader

Id
�
 offender�
Id
slot�
Slot
0first_header

Header
4second_header

Header
(sp_runtimegenericheaderHeaderNumber
Hash

,parent_hash$
0Hash::Output
number�
Number
(state_root$
0Hash::Output
<extrinsics_root$
0Hash::Output
digest,
Digest(sp_runtimetraits,BlakeTwo256(sp_session<MembershipProof
session
0SessionIndex
(trie_nodes�
0Vec<Vec<u8>>
<validator_count
8ValidatorCount,pallet_babepalletErrorT
`InvalidEquivocationProof1
An equivocation proof provided as part of an equivocation report is invalid.`InvalidKeyOwnershipProof
1
A key ownership proof provided as part of an equivocation report is invalid.XDuplicateOffenceReport
A given equivocation report is valid but already previously reported.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
			@pallet_timestamppalletCallT
set
now!
$T::Moment@TSet the current time.U
This call should be invoked exactly once per block. It will panic at the finalization�phase, if this call hasn't been invoked by that time.A
The timestamp should be greater than the previous one by the amount specified by@`MinimumPeriod`.�The dispatch origin for this call must be `Inherent`.(# <weight>1
- `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)a
- 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in@  `on_finalize`)�- 1 event handler `on_timestamp_set`. Must be `O(1)`.,# </weight>%
Contains one variant per dispatchable that can be called by an extrinsic.! %
)8pallet_indicespalletCallT
claim
index
<T::AccountIndexH�Assign an previously unassigned index.�Payment: `Deposit` is reserved from the sender account.�The dispatch origin for this call must be _Signed_.�- `index`: the index to be claimed. This must not be in use.�Emits `IndexAssigned` if successful.(# <weight>$- `O(1)`.�- One storage mutation (codec `O(1)`).`- One reserve operation.0- One event.L-------------------�- DB Weight: 1 Read/Write (Accounts),# </weight> transfer
new
0T::AccountId
index
<T::AccountIndex
P]
Assign an index already owned by the sender to another account. The balance reservation�is effectively transferred to the new account.�The dispatch origin for this call must be _Signed_.%
- `index`: the index to be re-assigned. This must be owned by the sender.]
- `new`: the new owner of the index. This function is a no-op if it is equal to sender.�Emits `IndexAssigned` if successful.(# <weight>$- `O(1)`.�- One storage mutation (codec `O(1)`).d- One transfer operation.0- One event.L-------------------0- DB Weight:�   - Reads: Indices Accounts, System Account (recipient)�   - Writes: Indices Accounts, System Account (recipient),# </weight>free
index
<T::AccountIndexH�Free up an index owned by the sender.]
Payment: Any previous deposit placed for the index is unreserved in the sender account.U
The dispatch origin for this call must be _Signed_ and the sender must own the index.

- `index`: the index to be freed. This must be owned by the sender.�Emits `IndexFreed` if successful.(# <weight>$- `O(1)`.�- One storage mutation (codec `O(1)`).`- One reserve operation.0- One event.L-------------------�- DB Weight: 1 Read/Write (Accounts),# </weight>8force_transfer
new
0T::AccountId
index
<T::AccountIndex
freeze

boolTU
Force an index to an account. This doesn't require a deposit. If the index is already�held, then any deposit is reimbursed to its current owner.�The dispatch origin for this call must be _Root_.�- `index`: the index to be (re-)assigned.]
- `new`: the new owner of the index. This function is a no-op if it is equal to sender.A
- `freeze`: if set to `true`, will freeze the index so it cannot be transferred.�Emits `IndexAssigned` if successful.(# <weight>$- `O(1)`.�- One storage mutation (codec `O(1)`).x- Up to one reserve operation.0- One event.L-------------------0- DB Weight:�   - Reads: Indices Accounts, System Account (original owner)�   - Writes: Indices Accounts, System Account (original owner),# </weight>freeze
index
<T::AccountIndexHA
Freeze an index so it will always point to the sender account. This consumes the deposit.Y
The dispatch origin for this call must be _Signed_ and the signing account must have alnon-frozen account `index`.�- `index`: the index to be frozen in place.�Emits `IndexFrozen` if successful.(# <weight>$- `O(1)`.�- One storage mutation (codec `O(1)`).p- Up to one slash operation.0- One event.L-------------------�- DB Weight: 1 Read/Write (Accounts),# </weight>%
Contains one variant per dispatchable that can be called by an extrinsic.-8pallet_indicespalletErrorT
,NotAssigned�The index was not already assigned. NotOwner
�The index is assigned to another account.InUsepThe index was not available.,NotTransfer�The source and destination accounts are identical.$Permanent�The index is permanent and may not be freed/changed.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
			155Dpallet_authorship8UncleEntryItem,BlockNumber
Hash
$Author

<InclusionHeight
,BlockNumberUncle$
Hash


8Option<Author>
9Dpallet_authorshippalletCallT
(set_uncles
(new_uncles=
8Vec<T::Header>`Provide a set of uncles.%
Contains one variant per dispatchable that can be called by an extrinsic.=
ADpallet_authorshippalletErrorT
HInvalidUncleParent�The uncle parent not in the chain.@UnclesAlreadySet
�Uncles already set in the block.4TooManyUncles@Too many uncles.0GenesisUncleTThe uncle is genesis.0TooHighUncle|The uncle is too high in chain.PUncleAlreadyIncludedxThe uncle is already included. OldUncle�The uncle isn't recent enough to be included.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
			EII<pallet_balances,BalanceLockBalance

id�
8LockIdentifier
amount
Balance
reasonsM
ReasonsMdpolymesh_common_utilitiestraits balancesReasons
FeeMisc
AllQ<pallet_balancesCallT
 transfer
destU
�<T::Lookup as StaticLookup>::Source
value�

BalanceX�Transfer some liquid free balance to another account.
`transfer` will set the `FreeBalance` of the sender and receiver.
It will decrease the total issuance of the system by the `TransferFee`.
The dispatch origin for this call must be `Signed` by the transactor.(# <weight>-
- Dependent on arguments but not critical, given proper implementations for�  input config types. See related functions below.e
- It contains a limited number of reads and writes internally and no complex computation.HRelated functions:M
  - `ensure_can_withdraw` is always called internally but has a bounded complexity.)
  - Transferring balances to accounts that did not exist before will cause�     `T::OnNewAccount::on_new_account` to be called.�---------------------------------A
- Base Weight: 73.64 µs, worst case scenario (account created, account removed)�- DB Weight: 1 Read and 1 Write to destination account.
- Origin account is already in memory, so no DB operations for them.,# </weight>Htransfer_with_memo
destU
�<T::Lookup as StaticLookup>::Source
value�

Balance
memo|
0Option<Memo>
 �Transfer the native currency with the help of identifier string�this functionality can help to differentiate the transfers.(# <weight>A
- Base Weight: 73.64 µs, worst case scenario (account created, account removed)�- DB Weight: 1 Read and 1 Write to destination account.
- Origin account is already in memory, so no DB operations for them.,# </weight>�deposit_block_reward_reserve_balance
value�

Balance�Move some POLYX from balance of self to balance of BRR.,set_balance
whoU
�<T::Lookup as StaticLookup>::Source
 new_free�

Balance
0new_reserved�

Balance�Set the balances of a given account.
This will alter `FreeBalance` and `ReservedBalance` in storage. it will
also decrease the total issuance of the system (`TotalIssuance`).�The dispatch origin for this call is `root`.8force_transfer
sourceU
�<T::Lookup as StaticLookup>::Source
destU
�<T::Lookup as StaticLookup>::Source
value�

BalanceM
Exactly as `transfer`, except the origin must be root and the source account may be(specified.(# <weight>=
- Same as transfer, but additional read and write because the source account is�  not assumed to be in the overlay.,# </weight>Pburn_account_balance
amount
Balance)
Burns the given amount of tokens from the caller's free, unlocked balance.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.U(sp_runtime0multiaddress0MultiAddress$AccountId
0AccountIndex

Id
$AccountIdIndex�
0AccountIndex
Raw(
Vec<u8>$Address32
 [u8; 32]$Address20

 [u8; 20]Y<pallet_balancesErrorT
TLiquidityRestrictions�Account liquidity restrictions prevent withdrawal Overflow
pGot an overflow after addingLInsufficientBalancetBalance too low to send valueHExistentialDeposit�Value too low to create account due to existential depositHReceiverCddMissing�Receiver does not have a valid CDD]4sp_arithmetic,fixed_point$FixedU128
u128ahpallet_transaction_payment Releases
$V1AncientV2
eii4frame_supportweightsXWeightToFeeCoefficientBalance

4coeff_integer
Balance
(coeff_frac�

Perbill
 negative

bool
degree
u8mLpolymesh_primitives identity$DidRecord$AccountId

,primary_key


DOption<AccountId>quyu<pallet_identitytypes,Claim1stKey
targetx
(IdentityId
(claim_type�
$ClaimTypey<pallet_identitytypes,Claim2ndKey
issuerx
(IdentityId
scope	

4Option<Scope>}Lpolymesh_primitives4secondary_key$KeyRecord$AccountId

(PrimaryKeyx
(IdentityId0SecondaryKeyx
(IdentityId�
,Permissions
DMultiSigSignerKey
$AccountId�x�q
 �Lpolymesh_primitives4authorization4Authorization$AccountId
Moment
 
Hauthorization_data

pAuthorizationData<AccountId>
4authorized_byx
(IdentityId
expiry�
8Option<Moment>
auth_id 
u64
count
u32�x �<pallet_identityVersion
u8�<pallet_identityCallT
l@cdd_register_did
8target_account
0T::AccountId
8secondary_keys�
|Vec<SecondaryKey<T::AccountId>> �Register `target_account` with a new Identity.$# FailureE
- `origin` has to be a active CDD provider. Inactive CDD providers cannot add newclaims.]
- `target_account` (primary key of the new Identity) can be linked to just one and only4one identity.�- External secondary keys can be linked to just one identity.Tinvalidate_cdd_claims
cddx
(IdentityId
0disable_from 
$T::Moment
expiry�
DOption<T::Moment>
!
Invalidates any claim generated by `cdd` from `disable_from` timestamps.�You can also define an expiration time,m
which will invalidate all claims generated by that `cdd` and remove it as CDD member group.dremove_secondary_keys_old
8keys_to_removem

pVec<Signatory<T::AccountId>>�Deprecated. Use `remove_secondary_keys` instead.Haccept_primary_key
@rotation_auth_id 
u64
Poptional_cdd_auth_id�
,Option<u64>4e
Call this with the new primary key. By invoking this method, caller accepts authorizatione
to become the new primary key of the issuing identity. If a CDD service provider approved%
this change (or this is not required), primary key of the DID is updated.]
The caller (new primary key) must be either a secondary key of the issuing identity, ordunlinked to any identity.]
Differs from rotate_primary_key_to_secondary in that it will unlink the old primary key�instead of leaving it as a secondary key.,# Arguments
* `owner_auth_id` Authorization from the owner who initiated the change�* `cdd_auth_id` Authorization from a CDD service provider�change_cdd_requirement_for_mk_rotation
4auth_required

bool5
Set if CDD authorization is required for updating primary key of an identity.xCallable via root (governance),# Arguments�* `auth_required` CDD Authorization required or notPjoin_identity_as_key
auth_id 
u64�Join an identity as a secondary key.Tleave_identity_as_key�Leave the secondary key's identity.$add_claim
targetx
(IdentityId
claim�
Claim
expiry�
DOption<T::Moment>�Adds a new claim record or edits an existing one.�Only called by did_issuer's secondary key.0revoke_claim
targetx
(IdentityId
claim�
Claim�Marks the specified claim as revoked.`set_permission_to_signer
keyq

\Signatory<T::AccountId>
perms�
,Permissions	�Deprecated. Use `set_secondary_key_permissions` instead.�placeholder_legacy_set_permission_to_signer
�Placeholder for removed `legacy_set_permission_to_signer`.Tfreeze_secondary_keys�It disables all secondary keys at `did` identity. # Errors\unfreeze_secondary_keys�Re-enables all secondary keys of the caller's identity.Dadd_authorization
targetq

\Signatory<T::AccountId>
data

|AuthorizationData<T::AccountId>
expiry�
DOption<T::Moment>
XAdds an authorization.Premove_authorization
targetq

\Signatory<T::AccountId>
auth_id 
u64
D_auth_issuer_pays

booldRemoves an authorization.u
_auth_issuer_pays determines whether the issuer of the authorisation pays the transaction fee�add_secondary_keys_with_authorization_old
<additional_keys�
�Vec<SecondaryKeyWithAuthV1<T::AccountId>>
(expires_at 
$T::Moment

Deprecated. Use `add_secondary_keys_with_authorization` instead.tadd_investor_uniqueness_claim
targetx
(IdentityId
claim�
Claim
proof�
LInvestorZKProofData
expiry�
DOption<T::Moment>P	
Add `Claim::InvestorUniqueness` claim for a given target identity.(# <weight>A
 Weight of the this extrinsic is depend on the computation that used to validate%
 the proof of claim, which will be a constant independent of user inputs.,# </weight>,# Arguments�
* origin - Who provides the claim to the user? In this case, it's the user's account id as the user provides.�* target - `IdentityId` to which the claim gets assigned.�* claim - `InvestorUniqueness` claim details.�* proof - To validate the self attestation.l* 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.�* `InvalidScopeClaim When proof is invalid.�* `InvalidCDDId` when you are not the owner of that CDD_ID.@gc_add_cdd_claim
targetx
(IdentityIdE
Assuming this is executed by the GC voting majority, adds a new cdd claim record.Lgc_revoke_cdd_claim
targetx
(IdentityIdi
Assuming this is executed by the GC voting majority, removes an existing cdd claim record.�add_investor_uniqueness_claim_v2
targetx
(IdentityId
scope�
Scope
claim�
Claim
proof�
<ScopeClaimProof
expiry�
DOption<T::Moment>Trevoke_claim_by_index
targetx
(IdentityId
(claim_type�
$ClaimType
scope	

4Option<Scope> �
Revokes a specific claim using its [Claim Unique Index](/pallet_identity/index.html#claim-unique-index) composed by `target`,h`claim_type`, and `scope`.
Please note that `origin` must be the issuer of the target claim. # ErrorsM
- `TargetHasNonZeroBalanceAtScopeId` when you try to revoke a `InvestorUniqueness*`%
claim, and `target` identity still have any balance on the given `scope`.|rotate_primary_key_to_secondary
auth_id 
u64
Poptional_cdd_auth_id�
,Option<u64>8e
Call this with the new primary key. By invoking this method, caller accepts authorizatione
to become the new primary key of the issuing identity. If a CDD service provider approved)
this change, (or this is not required), primary key of the DID is updated.]
The caller (new primary key) must be either a secondary key of the issuing identity, ordunlinked to any identity.a
Differs from accept_primary_key in that it will leave the old primary key as a secondary�
key with the permissions specified in the corresponding RotatePrimaryKeyToSecondary authorization�instead of unlinking the old primary key.,# Arguments
* `owner_auth_id` Authorization from the owner who initiated the change�* `cdd_auth_id` Authorization from a CDD service provider�add_secondary_keys_with_authorization
<additional_keys�
�Vec<SecondaryKeyWithAuth<T::AccountId>>
(expires_at 
$T::Moment4�Adds secondary keys to target identity `id`.9
Keys are directly added to identity because each of them has an authorization.0# Arguments:	
    - `origin` which must be the primary key of the identity `id`.�    - `id` to which new secondary keys will be added.�    - `additional_keys` which includes secondary keys,	
       coupled with authorization data, to add to target identity. # Errors�    - Can only called by primary key owner.�    - Keys should be able to linked to any identity.tset_secondary_key_permissions
key
0T::AccountId
perms�
,Permissions�Sets permissions for an specific `target_key` key.5
Only the primary key of an identity is able to set secondary key permissions.Tremove_secondary_keys
8keys_to_remove�
DVec<T::AccountId>�Removes specified secondary keys of a DID if present. # Errors�The extrinsic can only called by primary key owner.hregister_custom_claim_type
ty(
Vec<u8>lRegister custom claim type. # ErrorsI
* `CustomClaimTypeAlreadyExists` The type that is being registered already exists.�* `CounterOverflow` CustomClaimTypeId has overflowed.�* `TooLong` The type being registered is too lang.dcdd_register_did_with_cdd
8target_account
0T::AccountId
8secondary_keys�
|Vec<SecondaryKey<T::AccountId>>
expiry�
DOption<T::Moment> Y
Register `target_account` with a new Identity and issue a CDD claim with a blank CddId$# FailureE
- `origin` has to be a active CDD provider. Inactive CDD providers cannot add newclaims.]
- `target_account` (primary key of the new Identity) can be linked to just one and only4one identity.�- External secondary keys can be linked to just one identity.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.���dpolymesh_common_utilitiestraits identityXSecondaryKeyWithAuthV1$AccountId

4secondary_key�
lv1::SecondaryKey<AccountId>
8auth_signature�
H512�Lpolymesh_primitives4secondary_keyv10SecondaryKey$AccountId

signerq

PSignatory<AccountId>
,permissions�
,Permissions�<primitive_typesH512
 [u8; 64]�@�`confidential_identity_v20claim_proofs<ScopeClaimProof
dproof_scope_id_wellformed�
$Signature
lproof_scope_id_cdd_id_match�
,ZkProofData
 scope_id
LCompressedRistretto�`confidential_identity_v2sign$Signature
r
LCompressedRistretto
s
Scalar�`confidential_identity_v20claim_proofs,ZkProofData
Lchallenge_responses�
�[Scalar; ZK_PROOF_DATA_CHG_RESPONSES]
`subtract_expressions_res
LCompressedRistretto
Xblinded_scope_did_hash
LCompressedRistretto����dpolymesh_common_utilitiestraits identityPSecondaryKeyWithAuth$AccountId

4secondary_key�
\SecondaryKey<AccountId>
8auth_signature�
H512�<pallet_identityErrorT
�4AlreadyLinked�One secondary or primary key can only belong to one DIDXMissingCurrentIdentity
�Missing current identity on the transaction0Unauthorized�Signatory is not pre authorized by the identityDInvalidAccountKey�Account Id cannot be extracted from signer\UnAuthorizedCddProvider�Only CDD service providers are allowed.tInvalidAuthorizationFromOwner�An invalid authorization from the owner.�InvalidAuthorizationFromCddProvider�An invalid authorization from the CDD provider.dNotCddProviderAttestation�Attestation was not by a CDD service provider.pAuthorizationsNotForSameDids�Authorizations are not for the same DID.LDidMustAlreadyExist	lThe DID must already exist.�CurrentIdentityCannotBeForwarded
M
Current identity cannot be forwarded, it is not a secondary key of target identity.PAuthorizationExpired�The offchain authorization has expired.8TargetHasNoCdd�The target DID has no valid CDD.lAuthorizationHasBeenRevoked
�Authorization has been explicitly revoked.tInvalidAuthorizationSignature�An invalid authorization signature.4KeyNotAllowed�This key is not allowed to execute a given operation.4NotPrimaryKeya
Only the primary key is allowed to revoke an Identity Signatory off-chain authorization.<DidDoesNotExist\The DID does not exist.@DidAlreadyExists\The DID already exists.xSecondaryKeysContainPrimaryKey�The secondary keys contain the primary key.DFailedToChargeFee�Couldn't charge fee for the transaction.(NotASigner�Signer is not a secondary key of the provided identitylCannotDecodeSignerAccountId
Cannot convert a `T::AccountId` to `AnySignature::Signer::AccountId`.HMultiSigHasBalance!
Multisig can not be unlinked from an identity while it still holds POLYX�ConfidentialScopeClaimNotAllowed
Confidential Scope claims can be added by an Identity to it-self.DInvalidScopeClaim�Addition of a new scope claim gets invalidated.XClaimVariantNotAllowed�Try to add a claim variant using un-designated extrinsic.�TargetHasNonZeroBalanceAtScopeIdQ
Try to delete the IU claim even when the user has non zero balance at given scopeId.dCDDIdNotUniqueForIdentity
CDDId should be unique & same within all cdd claims possessed by a DID.0InvalidCDDId	
Non systematic CDD providers can not create default cdd_id claims.|ClaimAndProofVersionsDoNotMatch�Claim and Proof versions are different.TAccountKeyIsBeingUsed�The account key is being used, it can't be unlinked.HCustomScopeTooLong lA custom scope is too long.�It can at most be `32` characters long.pCustomClaimTypeAlreadyExists!�The custom claim type trying to be registered already exists.lCustomClaimTypeDoesNotExist"�The custom claim type does not exist.DClaimDoesNotExist#TClaim does not exist.���dpolymesh_common_utilitiestraitsgroup8InactiveMemberMoment
 
idx
(IdentityId
8deactivated_at 
Moment
expiry�
8Option<Moment>�0pallet_groupCallTI
`set_active_members_limit
limit
,MemberCount5
Change this group's limit for how many concurrent active members they may be.,# Arguments

* `limit` - the number of active members there may be concurrently.8disable_member
whox
(IdentityId
expiry�
DOption<T::Moment>
at�
DOption<T::Moment>
@�Disables a member at specific moment.A
Please note that if member is already revoked (a "valid member"), its revocationltime-stamp will be updated.M
Any disabled member should NOT allow to act like an active member of the group. For]
instance, a disabled CDD member should NOT be able to generate a CDD claim. However any
generated claim issued before `at` would be considered as a valid one.Q
If you want to invalidate any generated claim, you should use `Self::remove_member`.,# Arguments|* `at` - Revocation time-stamp.�* `who` - Target member of the group.U
* `expiry` - Time-stamp when `who` is removed from CDD. As soon as it is expired, theQ
generated claims will be "invalid" as `who` is not considered a member of the group.(add_member
whox
(IdentityId9
Adds a member `who` to the group. May only be called from `AddOrigin` or root.,# Arguments�* `origin` - Origin representing `AddOrigin` or root�* `who` - IdentityId to be added to the group.4remove_member
whox
(IdentityId(Q
Removes a member `who` from the set. May only be called from `RemoveOrigin` or root.A
Any claim previously generated by this member is not valid as a group claim. ForY
instance, if a CDD member group generated a claim for a target identity and then it isa
removed, that claim will be invalid.  In case you want to keep the validity of generated�claims, you have to use `Self::disable_member` function,# Arguments�* `origin` - Origin representing `RemoveOrigin` or root�* `who` - IdentityId to be removed from the group.,swap_member
removex
(IdentityId
addx
(IdentityId �Swaps out one member `remove` for another member `add`.�May only be called from `SwapOrigin` or root.,# Arguments�* `origin` - Origin representing `SwapOrigin` or root�* `remove` - IdentityId to be removed from the group.�* `add` - IdentityId to be added in place of `remove`.4reset_members
members)

<Vec<IdentityId>)
Changes the membership to a new set, disregarding the existing membership.�May only be called from `ResetOrigin` or root.,# Arguments�* `origin` - Origin representing `ResetOrigin` or root�* `members` - New set of identitiesLabdicate_membership(M
Allows the calling member to *unilaterally quit* without this being subject to a GCvote.,# Arguments�* `origin` - Member of committee who wants to quit.# Error�* Only primary key can abdicate.�* Last member of a group cannot abdicate.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�0pallet_groupErrorTI
TOnlyPrimaryKeyAllowed�Only primary key of the identity is allowed.<DuplicateMember
|Group member was added already.0NoSuchMember�Can't remove a member that doesn't exist.PLastMemberCannotQuit�Last member of the committee can not quit.XMissingCurrentIdentityLMissing current DIDhActiveMembersLimitExceeded]
The limit for the number of concurrent active members for this group has been exceeded.hActiveMembersLimitOverflow
Active member limit was greater than maximum committee members limit.�`polymesh_runtime_developruntimeCall
�System�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<System, Runtime>Babe
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Babe, Runtime>
$Timestamp
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Timestamp, Runtime>Indices)
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Indices, Runtime>(Authorship9
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Authorship, Runtime> BalancesQ
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Balances, Runtime> Identity�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Identity, Runtime>LCddServiceProviders�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<CddServiceProviders, Runtime>DPolymeshCommittee�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<PolymeshCommittee, Runtime>	LCommitteeMembership�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<CommitteeMembership, Runtime>
HTechnicalCommittee�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<TechnicalCommittee, Runtime>pTechnicalCommitteeMembership�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<TechnicalCommitteeMembership, Runtime>@UpgradeCommittee�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<UpgradeCommittee, Runtime>
hUpgradeCommitteeMembership�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<UpgradeCommitteeMembership, Runtime> MultiSig�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<MultiSig, Runtime>Bridge�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Bridge, Runtime>Staking	
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Staking, Runtime>Session�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Session, Runtime>Grandpa	
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Grandpa, Runtime> ImOnline5
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ImOnline, Runtime>SudoU
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Sudo, Runtime>AssetY
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Asset, Runtime>LCapitalDistributionu
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<CapitalDistribution, Runtime>(Checkpoint}
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Checkpoint, Runtime>DComplianceManager�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ComplianceManager, Runtime><CorporateAction�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<CorporateAction, Runtime><CorporateBallot�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<CorporateBallot, Runtime>Pips�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Pips, Runtime>!$Portfolio�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Portfolio, Runtime>",ProtocolFee�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ProtocolFee, Runtime>#$Scheduler�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Scheduler, Runtime>$(Settlement�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Settlement, Runtime>%(Statistics�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Statistics, Runtime>&Sto

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Sto, Runtime>' Treasury
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Treasury, Runtime>(Utility
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Utility, Runtime>)Base)
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Base, Runtime>*8ExternalAgents-
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ExternalAgents, Runtime>+Relayer1
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Relayer, Runtime>,Rewards5
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Rewards, Runtime>-$Contracts=
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Contracts, Runtime>.DPolymeshContractsE
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<PolymeshContracts, Runtime>/ PreimageU
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Preimage, Runtime>0$TestUtilsY
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<TestUtils, Runtime>2�@pallet_committeeCallTI
Hset_vote_threshold
n
u32
d
u32�Change the vote threshold the determines the winning proposal.U
For e.g., for a simple majority use (1, 2) which represents the in-equation ">= 1/2".,# Arguments�* `n` - Numerator of the fraction representing vote threshold.

* `d` - Denominator of the fraction representing vote threshold.\set_release_coordinator
idx
(IdentityId
�Changes the release coordinator.,# Arguments�* `id` - The DID of the new release coordinator. # Errors%
* `NotAMember`, If the new coordinator `id` is not part of the committee.Dset_expires_after
expiry=

hMaybeBlock<T::BlockNumber>�Changes the time after which a proposal expires.,# Arguments�* `expiry` - The new expiry time.<vote_or_propose
approve

bool
call�
|Box<<T as Config<I>>::Proposal>D
Proposes to the committee that `call` should be executed in its name.]
Alternatively, if the hash of `call` has already been recorded, i.e., already proposed,
then this call counts as a vote, i.e., as if `vote_by_hash` was called. # Weight-
The weight of this dispatchable is that of `call` as well as the complexityxfor recording the vote itself.,# Arguments�* `approve` - is this an approving vote?a
  If the proposal doesn't exist, passing `false` will result in error `FirstVoteReject`.�* `call` - the call to propose for execution. # Errors-
* `FirstVoteReject`, if `call` hasn't been proposed and `approve == false`.	
* `NotAMember`, if the `origin` is not a member of this committee.vote
 proposal$
T::Hash
index
4ProposalIndex
approve

bool(�Votes `approve`ingly (or not, if `false`)�on an existing `proposal` given by its hash, `index`.,# Arguments�* `proposal` - A hash of the proposal to be voted on.|* `index` - The proposal index.-
* `approve` - If `true` than this is a `for` vote, and `against` otherwise. # Errors	
* `NotAMember`, if the `origin` is not a member of this committee.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�0pallet_groupCallTI
`set_active_members_limit
limit
,MemberCount5
Change this group's limit for how many concurrent active members they may be.,# Arguments

* `limit` - the number of active members there may be concurrently.8disable_member
whox
(IdentityId
expiry�
DOption<T::Moment>
at�
DOption<T::Moment>
@�Disables a member at specific moment.A
Please note that if member is already revoked (a "valid member"), its revocationltime-stamp will be updated.M
Any disabled member should NOT allow to act like an active member of the group. For]
instance, a disabled CDD member should NOT be able to generate a CDD claim. However any
generated claim issued before `at` would be considered as a valid one.Q
If you want to invalidate any generated claim, you should use `Self::remove_member`.,# Arguments|* `at` - Revocation time-stamp.�* `who` - Target member of the group.U
* `expiry` - Time-stamp when `who` is removed from CDD. As soon as it is expired, theQ
generated claims will be "invalid" as `who` is not considered a member of the group.(add_member
whox
(IdentityId9
Adds a member `who` to the group. May only be called from `AddOrigin` or root.,# Arguments�* `origin` - Origin representing `AddOrigin` or root�* `who` - IdentityId to be added to the group.4remove_member
whox
(IdentityId(Q
Removes a member `who` from the set. May only be called from `RemoveOrigin` or root.A
Any claim previously generated by this member is not valid as a group claim. ForY
instance, if a CDD member group generated a claim for a target identity and then it isa
removed, that claim will be invalid.  In case you want to keep the validity of generated�claims, you have to use `Self::disable_member` function,# Arguments�* `origin` - Origin representing `RemoveOrigin` or root�* `who` - IdentityId to be removed from the group.,swap_member
removex
(IdentityId
addx
(IdentityId �Swaps out one member `remove` for another member `add`.�May only be called from `SwapOrigin` or root.,# Arguments�* `origin` - Origin representing `SwapOrigin` or root�* `remove` - IdentityId to be removed from the group.�* `add` - IdentityId to be added in place of `remove`.4reset_members
members)

<Vec<IdentityId>)
Changes the membership to a new set, disregarding the existing membership.�May only be called from `ResetOrigin` or root.,# Arguments�* `origin` - Origin representing `ResetOrigin` or root�* `members` - New set of identitiesLabdicate_membership(M
Allows the calling member to *unilaterally quit* without this being subject to a GCvote.,# Arguments�* `origin` - Member of committee who wants to quit.# Error�* Only primary key can abdicate.�* Last member of a group cannot abdicate.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�@pallet_committeeCallTI
Hset_vote_threshold
n
u32
d
u32�Change the vote threshold the determines the winning proposal.U
For e.g., for a simple majority use (1, 2) which represents the in-equation ">= 1/2".,# Arguments�* `n` - Numerator of the fraction representing vote threshold.

* `d` - Denominator of the fraction representing vote threshold.\set_release_coordinator
idx
(IdentityId
�Changes the release coordinator.,# Arguments�* `id` - The DID of the new release coordinator. # Errors%
* `NotAMember`, If the new coordinator `id` is not part of the committee.Dset_expires_after
expiry=

hMaybeBlock<T::BlockNumber>�Changes the time after which a proposal expires.,# Arguments�* `expiry` - The new expiry time.<vote_or_propose
approve

bool
call�
|Box<<T as Config<I>>::Proposal>D
Proposes to the committee that `call` should be executed in its name.]
Alternatively, if the hash of `call` has already been recorded, i.e., already proposed,
then this call counts as a vote, i.e., as if `vote_by_hash` was called. # Weight-
The weight of this dispatchable is that of `call` as well as the complexityxfor recording the vote itself.,# Arguments�* `approve` - is this an approving vote?a
  If the proposal doesn't exist, passing `false` will result in error `FirstVoteReject`.�* `call` - the call to propose for execution. # Errors-
* `FirstVoteReject`, if `call` hasn't been proposed and `approve == false`.	
* `NotAMember`, if the `origin` is not a member of this committee.vote
 proposal$
T::Hash
index
4ProposalIndex
approve

bool(�Votes `approve`ingly (or not, if `false`)�on an existing `proposal` given by its hash, `index`.,# Arguments�* `proposal` - A hash of the proposal to be voted on.|* `index` - The proposal index.-
* `approve` - If `true` than this is a `for` vote, and `against` otherwise. # Errors	
* `NotAMember`, if the `origin` is not a member of this committee.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�0pallet_groupCallTI
`set_active_members_limit
limit
,MemberCount5
Change this group's limit for how many concurrent active members they may be.,# Arguments

* `limit` - the number of active members there may be concurrently.8disable_member
whox
(IdentityId
expiry�
DOption<T::Moment>
at�
DOption<T::Moment>
@�Disables a member at specific moment.A
Please note that if member is already revoked (a "valid member"), its revocationltime-stamp will be updated.M
Any disabled member should NOT allow to act like an active member of the group. For]
instance, a disabled CDD member should NOT be able to generate a CDD claim. However any
generated claim issued before `at` would be considered as a valid one.Q
If you want to invalidate any generated claim, you should use `Self::remove_member`.,# Arguments|* `at` - Revocation time-stamp.�* `who` - Target member of the group.U
* `expiry` - Time-stamp when `who` is removed from CDD. As soon as it is expired, theQ
generated claims will be "invalid" as `who` is not considered a member of the group.(add_member
whox
(IdentityId9
Adds a member `who` to the group. May only be called from `AddOrigin` or root.,# Arguments�* `origin` - Origin representing `AddOrigin` or root�* `who` - IdentityId to be added to the group.4remove_member
whox
(IdentityId(Q
Removes a member `who` from the set. May only be called from `RemoveOrigin` or root.A
Any claim previously generated by this member is not valid as a group claim. ForY
instance, if a CDD member group generated a claim for a target identity and then it isa
removed, that claim will be invalid.  In case you want to keep the validity of generated�claims, you have to use `Self::disable_member` function,# Arguments�* `origin` - Origin representing `RemoveOrigin` or root�* `who` - IdentityId to be removed from the group.,swap_member
removex
(IdentityId
addx
(IdentityId �Swaps out one member `remove` for another member `add`.�May only be called from `SwapOrigin` or root.,# Arguments�* `origin` - Origin representing `SwapOrigin` or root�* `remove` - IdentityId to be removed from the group.�* `add` - IdentityId to be added in place of `remove`.4reset_members
members)

<Vec<IdentityId>)
Changes the membership to a new set, disregarding the existing membership.�May only be called from `ResetOrigin` or root.,# Arguments�* `origin` - Origin representing `ResetOrigin` or root�* `members` - New set of identitiesLabdicate_membership(M
Allows the calling member to *unilaterally quit* without this being subject to a GCvote.,# Arguments�* `origin` - Member of committee who wants to quit.# Error�* Only primary key can abdicate.�* Last member of a group cannot abdicate.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�@pallet_committeeCallTI
Hset_vote_threshold
n
u32
d
u32�Change the vote threshold the determines the winning proposal.U
For e.g., for a simple majority use (1, 2) which represents the in-equation ">= 1/2".,# Arguments�* `n` - Numerator of the fraction representing vote threshold.

* `d` - Denominator of the fraction representing vote threshold.\set_release_coordinator
idx
(IdentityId
�Changes the release coordinator.,# Arguments�* `id` - The DID of the new release coordinator. # Errors%
* `NotAMember`, If the new coordinator `id` is not part of the committee.Dset_expires_after
expiry=

hMaybeBlock<T::BlockNumber>�Changes the time after which a proposal expires.,# Arguments�* `expiry` - The new expiry time.<vote_or_propose
approve

bool
call�
|Box<<T as Config<I>>::Proposal>D
Proposes to the committee that `call` should be executed in its name.]
Alternatively, if the hash of `call` has already been recorded, i.e., already proposed,
then this call counts as a vote, i.e., as if `vote_by_hash` was called. # Weight-
The weight of this dispatchable is that of `call` as well as the complexityxfor recording the vote itself.,# Arguments�* `approve` - is this an approving vote?a
  If the proposal doesn't exist, passing `false` will result in error `FirstVoteReject`.�* `call` - the call to propose for execution. # Errors-
* `FirstVoteReject`, if `call` hasn't been proposed and `approve == false`.	
* `NotAMember`, if the `origin` is not a member of this committee.vote
 proposal$
T::Hash
index
4ProposalIndex
approve

bool(�Votes `approve`ingly (or not, if `false`)�on an existing `proposal` given by its hash, `index`.,# Arguments�* `proposal` - A hash of the proposal to be voted on.|* `index` - The proposal index.-
* `approve` - If `true` than this is a `for` vote, and `against` otherwise. # Errors	
* `NotAMember`, if the `origin` is not a member of this committee.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�0pallet_groupCallTI
`set_active_members_limit
limit
,MemberCount5
Change this group's limit for how many concurrent active members they may be.,# Arguments

* `limit` - the number of active members there may be concurrently.8disable_member
whox
(IdentityId
expiry�
DOption<T::Moment>
at�
DOption<T::Moment>
@�Disables a member at specific moment.A
Please note that if member is already revoked (a "valid member"), its revocationltime-stamp will be updated.M
Any disabled member should NOT allow to act like an active member of the group. For]
instance, a disabled CDD member should NOT be able to generate a CDD claim. However any
generated claim issued before `at` would be considered as a valid one.Q
If you want to invalidate any generated claim, you should use `Self::remove_member`.,# Arguments|* `at` - Revocation time-stamp.�* `who` - Target member of the group.U
* `expiry` - Time-stamp when `who` is removed from CDD. As soon as it is expired, theQ
generated claims will be "invalid" as `who` is not considered a member of the group.(add_member
whox
(IdentityId9
Adds a member `who` to the group. May only be called from `AddOrigin` or root.,# Arguments�* `origin` - Origin representing `AddOrigin` or root�* `who` - IdentityId to be added to the group.4remove_member
whox
(IdentityId(Q
Removes a member `who` from the set. May only be called from `RemoveOrigin` or root.A
Any claim previously generated by this member is not valid as a group claim. ForY
instance, if a CDD member group generated a claim for a target identity and then it isa
removed, that claim will be invalid.  In case you want to keep the validity of generated�claims, you have to use `Self::disable_member` function,# Arguments�* `origin` - Origin representing `RemoveOrigin` or root�* `who` - IdentityId to be removed from the group.,swap_member
removex
(IdentityId
addx
(IdentityId �Swaps out one member `remove` for another member `add`.�May only be called from `SwapOrigin` or root.,# Arguments�* `origin` - Origin representing `SwapOrigin` or root�* `remove` - IdentityId to be removed from the group.�* `add` - IdentityId to be added in place of `remove`.4reset_members
members)

<Vec<IdentityId>)
Changes the membership to a new set, disregarding the existing membership.�May only be called from `ResetOrigin` or root.,# Arguments�* `origin` - Origin representing `ResetOrigin` or root�* `members` - New set of identitiesLabdicate_membership(M
Allows the calling member to *unilaterally quit* without this being subject to a GCvote.,# Arguments�* `origin` - Member of committee who wants to quit.# Error�* Only primary key can abdicate.�* Last member of a group cannot abdicate.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�<pallet_multisigCallT
L<create_multisig
signersm

pVec<Signatory<T::AccountId>>
4sigs_required 
u64HCreates a multisig,# Arguments�
* `signers` - Signers of the multisig (They need to accept authorization before they are actually added).
* `sigs_required` - Number of sigs required to process a multi-sig tx.�create_or_approve_proposal_as_identity
 multisig
0T::AccountId
 proposal�
@Box<T::Proposal>
expiry�
DOption<T::Moment>
(auto_close

bool
 =
Creates a multisig proposal if it hasn't been created or approves it if it has.,# Arguments�* `multisig` - MultiSig address.�* `proposal` - Proposal to be voted on.�* `expiry` - Optional proposal expiry time.
* `auto_close` - Close proposal on receiving enough reject votes.1
If this is 1 out of `m` multisig, the proposal will be immediately executed.�create_or_approve_proposal_as_key
 multisig
0T::AccountId
 proposal�
@Box<T::Proposal>
expiry�
DOption<T::Moment>
(auto_close

bool =
Creates a multisig proposal if it hasn't been created or approves it if it has.,# Arguments�* `multisig` - MultiSig address.�* `proposal` - Proposal to be voted on.�* `expiry` - Optional proposal expiry time.
* `auto_close` - Close proposal on receiving enough reject votes.1
If this is 1 out of `m` multisig, the proposal will be immediately executed.lcreate_proposal_as_identity
 multisig
0T::AccountId
 proposal�
@Box<T::Proposal>
expiry�
DOption<T::Moment>
(auto_close

bool lCreates a multisig proposal,# Arguments�* `multisig` - MultiSig address.�* `proposal` - Proposal to be voted on.�* `expiry` - Optional proposal expiry time.
* `auto_close` - Close proposal on receiving enough reject votes.1
If this is 1 out of `m` multisig, the proposal will be immediately executed.Xcreate_proposal_as_key
 multisig
0T::AccountId
 proposal�
@Box<T::Proposal>
expiry�
DOption<T::Moment>
(auto_close

bool lCreates a multisig proposal,# Arguments�* `multisig` - MultiSig address.�* `proposal` - Proposal to be voted on.�* `expiry` - Optional proposal expiry time.
* `auto_close` - Close proposal on receiving enough reject votes.1
If this is 1 out of `m` multisig, the proposal will be immediately executed.Lapprove_as_identity
 multisig
0T::AccountId
,proposal_id 
u64�Approves a multisig proposal using the caller's identity.,# Arguments�* `multisig` - MultiSig address.�* `proposal_id` - Proposal id to approve.

If quorum is reached, the proposal will be immediately executed.8approve_as_key
 multisig
0T::AccountId
,proposal_id 
u641
Approves a multisig proposal using the caller's secondary key (`AccountId`).,# Arguments�* `multisig` - MultiSig address.�* `proposal_id` - Proposal id to approve.

If quorum is reached, the proposal will be immediately executed.Hreject_as_identity
 multisig
0T::AccountId
,proposal_id 
u64�Rejects a multisig proposal using the caller's identity.,# Arguments�* `multisig` - MultiSig address.�* `proposal_id` - Proposal id to reject.

If quorum is reached, the proposal will be immediately executed.4reject_as_key
 multisig
0T::AccountId
,proposal_id 
u64-
Rejects a multisig proposal using the caller's secondary key (`AccountId`).,# Arguments�* `multisig` - MultiSig address.�* `proposal_id` - Proposal id to reject.

If quorum is reached, the proposal will be immediately executed.�accept_multisig_signer_as_identity
auth_id 
u64	

Accepts a multisig signer authorization given to signer's identity.,# Arguments�* `auth_id` - Auth id of the authorization.taccept_multisig_signer_as_key
auth_id 
u64
)
Accepts a multisig signer authorization given to signer's key (AccountId).,# Arguments�* `auth_id` - Auth id of the authorization.Ladd_multisig_signer
signerq

\Signatory<T::AccountId>)
Adds a signer to the multisig. This must be called by the multisig itself.,# Argumentsx* `signer` - Signatory to add.Xremove_multisig_signer
signerq

\Signatory<T::AccountId>=
Removes a signer from the multisig. This must be called by the multisig itself.,# Arguments�* `signer` - Signatory to remove.�add_multisig_signers_via_creator
 multisig
0T::AccountId
signersm

pVec<Signatory<T::AccountId>>
$E
Adds a signer to the multisig. This must be called by the creator identity of the$multisig.,# Arguments�* `multisig` - Address of the multi sig�* `signers` - Signatories to add. # Weight�`900_000_000 + 3_000_000 * signers.len()`�remove_multisig_signers_via_creator
 multisig
0T::AccountId
signersm

pVec<Signatory<T::AccountId>>$�Removes a signer from the multisig.�This must be called by the creator identity of the multisig.,# Arguments�* `multisig` - Address of the multisig.�* `signers` - Signatories to remove. # Weight�`900_000_000 + 3_000_000 * signers.len()`Pchange_sigs_required
4sigs_required 
u64M
Changes the number of signatures required by a multisig. This must be called by the@multisig itself.,# Arguments�* `sigs_required` - New number of required signatures.\make_multisig_secondary
 multisig
0T::AccountIdi
Adds a multisig as a secondary key of current did if the current did is the creator of the$multisig.,# Arguments�* `multisig` - multi sig addressTmake_multisig_primary
 multisig
0T::AccountId
Poptional_cdd_auth_id�
,Option<u64>]
Adds a multisig as the primary key of the current did if the current DID is the creator@of the multisig.,# Arguments�* `multi_sig` - multi sig addresshexecute_scheduled_proposal
 multisig
0T::AccountId
,proposal_id 
u64
0multisig_didx
(IdentityId
@_proposal_weight 
Weightq
Root callable extrinsic, used as an internal call for executing scheduled multisig proposal.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�4pallet_bridgeCallT
DDchange_controller
(controller
0T::AccountId�Changes the controller account as admin.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.0change_admin
admin
0T::AccountId
tChanges the bridge admin key.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.<change_timelock
 timelock
8T::BlockNumberpChanges the timelock period.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.freeze]
Freezes transaction handling in the bridge module if it is not already frozen. When theI
bridge is frozen, attempted transactions get postponed instead of getting handled.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account. unfreeze
Unfreezes transaction handling in the bridge module if it is frozen.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.Lchange_bridge_limit
amount
Balance
 duration
8T::BlockNumberhChanges the bridge limits.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.�- `DivisionByZero` if `duration` is zero.Xchange_bridge_exempted
 exempted�
\Vec<(IdentityId, bool)>�Changes the bridge limit exempted list.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.Xforce_handle_bridge_tx
$bridge_txy

XBridgeTx<T::AccountId>%
Forces handling a transaction by bypassing the bridge limit and timelock.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.!
- `NoValidCdd` if `bridge_tx.recipient` does not have a valid CDD claim.\batch_propose_bridge_tx
(bridge_txs
lVec<BridgeTx<T::AccountId>>$E
Proposes a vector of bridge transactions. The vector is processed until the firstM
proposal which causes an error, in which case the error is returned and the rest ofpproposals are not processed.$## Errors�- `ControllerNotSet` if `Controllers` was not set. # Weight�`500_000_000 + 7_000_000 * bridge_txs.len()`Dpropose_bridge_tx
$bridge_txy

XBridgeTx<T::AccountId>	I
Proposes a bridge transaction, which amounts to making a multisig proposal for theU
bridge transaction if the transaction is new or approving an existing proposal if the�transaction has already been proposed.$## Errors�- `ControllerNotSet` if `Controllers` was not set.@handle_bridge_tx
$bridge_txy

XBridgeTx<T::AccountId>
�Handles an approved bridge transaction proposal.$## Errors
- `BadCaller` if `origin` is not `Self::controller` or  `Self::admin`.�- `TimelockedTx` if the transaction status is `Timelocked`.	
- `ProposalAlreadyHandled` if the transaction status is `Handled`.(freeze_txs
(bridge_txs
lVec<BridgeTx<T::AccountId>> �Freezes given bridge transactions.�
If any bridge txn is already handled then this function will just ignore it and process next one.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account. # Weight�`400_000_000 + 2_000_000 * bridge_txs.len()`0unfreeze_txs
(bridge_txs
lVec<BridgeTx<T::AccountId>> �Unfreezes given bridge transactions.�
If any bridge txn is already handled then this function will just ignore it and process next one.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account. # Weight�`400_000_000 + 7_000_000 * bridge_txs.len()`hhandle_scheduled_bridge_tx
$bridge_txy

XBridgeTx<T::AccountId>
�
Root callable extrinsic, used as an internal call to handle a scheduled timelocked bridge transaction. # Errors�- `BadOrigin` if `origin` is not root.�- `ProposalAlreadyHandled` if transaction status is `Handled`.�- `FrozenTx` if transaction status is `Frozen`.@add_freeze_admin
0freeze_admin
0T::AccountIdLAdd a freeze admin.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.Lremove_freeze_admin
0freeze_admin
0T::AccountIdXRemove a freeze admin.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.(remove_txs
(bridge_txs
lVec<BridgeTx<T::AccountId>>�Remove given bridge transactions.$## Errors�- `BadAdmin` if `origin` is not `Self::admin()` account.�- `NotFrozen` if a tx in `bridge_txs` is not frozen.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�

x
y
	8pallet_stakingCallT
�bond
(controllerU
�<T::Lookup as StaticLookup>::Source
value�

0BalanceOf<T>
payee

|RewardDestination<T::AccountId>Xa
Take the origin account as a stash and lock up `value` of its balance. `controller` will�be the account that controls it.-
`value` must be more than the `minimum_balance` specified by `T::Currency`.!
The dispatch origin for this call must be _Signed_ by the stash account.<Emits `Bonded`.(# <weight>�- Independent of the arguments. Moderate complexity.- O(1).d- Three extra DB entries.M
NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned=
unless the `origin` falls below _existential deposit_ and gets removed as dust.H------------------0Weight: O(1)(DB Weight:-
- Read: Bonded, Ledger, [Origin Account], Current Era, History Depth, Locks�- Write: Bonded, Payee, [Origin Account], Locks, Ledger,# </weight>(bond_extra
8max_additional�

0BalanceOf<T>
Ta
Add some extra amount that have appeared in the stash `free_balance` into the balance up0for staking.M
Use this if there are additional funds in your stash account that you wish to bond.a
Unlike [`bond`] or [`unbond`] this function does not impose any limitation on the amountHthat can be added.]
The dispatch origin for this call must be _Signed_ by the stash, not the controller and�it can be only called when [`EraElectionStatus`] is `Closed`.<Emits `Bonded`.(# <weight>�- Independent of the arguments. Insignificant complexity.- O(1).<- One DB entry.0------------(DB Weight:
- Read: Era Election Status, Bonded, Ledger, [Origin Account], Locks�- Write: [Origin Account], Locks, Ledger,# </weight>unbond
value�

0BalanceOf<T>�Q
Schedule a portion of the stash to be unlocked ready for transfer out after the bond�period ends. If this leaves an amount actively bonded less than!
T::Currency::minimum_balance(), then it is increased to the full amount.E
Once the unlock period is done, you can call `withdraw_unbonded` to actually move�the funds out of management ready for transfer.9
No more than a limited number of unlocking chunks (see `MAX_UNLOCKING_CHUNKS`)9
can co-exists at the same time. In that case, [`Call::withdraw_unbonded`] need�to be called first to remove some of the chunks (if possible).Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.	
And, it can be only called when [`EraElectionStatus`] is `Closed`.DEmits `Unbonded`.�See also [`Call::withdraw_unbonded`].(# <weight>=
- Independent of the arguments. Limited but potentially exploitable complexity.�- Contains a limited number of reads.a
- Each call (requires the remainder of the bonded balance to be above `minimum_balance`)m
  will cause a new entry to be inserted into a vector (`Ledger.unlocking`) kept in storage.M
  The only way to clean the aforementioned storage item is also user-controlled viaX  `withdraw_unbonded`.<- One DB entry.(----------0Weight: O(1)(DB Weight:!
- Read: EraElectionStatus, Ledger, CurrentEra, Locks, \[Origin Account\]�- Write: Locks, Ledger, \[Origin Account\]$</weight>Dwithdraw_unbonded
Hnum_slashing_spans
u32|)
Remove any unlocked chunks from the `unlocking` queue from our management.1
This essentially frees up that balance to be used by the stash account to doHwhatever it wants.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.	
And, it can be only called when [`EraElectionStatus`] is `Closed`.HEmits `Withdrawn`.hSee also [`Call::unbond`].(# <weight>Q
- Could be dependent on the `origin` argument and how much `unlocking` chunks exist.A
 It implies `consolidate_unlocked` which loops over `Ledger.unlocking`, which is� indirectly user-controlled. See [`unbond`] for more detail.u
- Contains a limited number of reads, yet the size of which could be large based on `ledger`.�- Writes are limited to the `origin` account key.<---------------
Complexity O(S) where S is the number of slashing spans to removeUpdate:!
- Reads: EraElectionStatus, Ledger, Current Era, Locks, [Origin Account]�- Writes: [Origin Account], Locks, LedgerKill:A
- Reads: EraElectionStatus, Ledger, Current Era, Bonded, Slashing Spans, [OriginD  Account], LocksM
- Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators,d  [Origin Account], Locksp- Writes Each: SpanSlash * S	
NOTE: Weight annotation is the kill scenario, we refund otherwise.,# </weight> validate
prefs
8ValidatorPrefsD�Declare the desire to validate for the origin controller.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.	
And, it can be only called when [`EraElectionStatus`] is `Closed`.(# <weight>�- Independent of the arguments. Insignificant complexity.�- Contains a limited number of reads.�- Writes are limited to the `origin` account key.,-----------0Weight: O(1)(DB Weight:�- Read: Era Election Status, Ledger|- Write: Nominators, Validators,# </weight> nominate
targets
�Vec<<T::Lookup as StaticLookup>::Source>L

Declare the desire to nominate `targets` for the origin controller.M
Effects will be felt at the beginning of the next era. This can only be called when�[`EraElectionStatus`] is `Closed`.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.	
And, it can be only called when [`EraElectionStatus`] is `Closed`.(# <weight>-
- The transaction's complexity is proportional to the size of `targets` (N)�which is capped at CompactAssignments::LIMIT (MAX_NOMINATIONS).�- Both the reads and writes follow a similar pattern.$---------0Weight: O(N)�where N is the number of targets(DB Weight:�- Reads: Era Election Status, Ledger, Current Era�- Writes: Validators, Nominators,# </weight>chillD�Declare no desire to either validate or nominate.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.	
And, it can be only called when [`EraElectionStatus`] is `Closed`.(# <weight>�- Independent of the arguments. Insignificant complexity.P- Contains one read.�- Writes are limited to the `origin` account key. --------0Weight: O(1)(DB Weight:�- Read: EraElectionStatus, Ledger|- Write: Validators, Nominators,# </weight>$set_payee
payee

|RewardDestination<T::AccountId>@�(Re-)set the payment target for a controller.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.(# <weight>�- Independent of the arguments. Insignificant complexity.�- Contains a limited number of reads.�- Writes are limited to the `origin` account key.$---------8- Weight: O(1)0- DB Weight:H    - Read: LedgerH    - Write: Payee,# </weight>8set_controller
(controllerU
�<T::Lookup as StaticLookup>::Source@�(Re-)set the controller of a stash.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the stash, not the controller.(# <weight>�- Independent of the arguments. Insignificant complexity.�- Contains a limited number of reads.�- Writes are limited to the `origin` account key.(----------0Weight: O(1)(DB Weight:�- Read: Bonded, Ledger New Controller, Ledger Old Controller�- Write: Bonded, Ledger New Controller, Ledger Old Controller,# </weight>Lset_validator_count
new�
u32	 �Sets the ideal number of validators.�The dispatch origin must be Root.(# <weight>0Weight: O(1)XWrite: Validator Count,# </weight>`increase_validator_count
(additional�
u32
�Increments the ideal number of validators.�The dispatch origin must be Root.(# <weight>�Same as [`set_validator_count`].,# </weight>Tscale_validator_count
factor
Percent�Scale up the ideal number of validators by a factor.�The dispatch origin must be Root.(# <weight>�Same as [`set_validator_count`].,# </weight>hadd_permissioned_validator
 identityx
(IdentityId
8intended_count!
,Option<u32> =
Governance committee on 2/3 rds majority can introduce a new potential identity�
to the pool of permissioned entities who can run validators. Staking module uses `PermissionedIdentity`U
to ensure validators have completed KYB compliance and considers them for validation.,# Arguments�* origin Required origin for adding a potential validator.�* identity Validator's IdentityId.
* intended_count No. of validators given identity intends to run.tremove_permissioned_validator
 identityx
(IdentityId
�
Remove an identity from the pool of (wannabe) validator identities. Effects are known in the next session.
Staking module checks `PermissionedIdentity` to ensure validators have`completed KYB compliance,# Arguments�* origin Required origin for removing a potential validator.�* identity Validator's IdentityId.xvalidate_cdd_expiry_nominators
targets�
DVec<T::AccountId>(�Validate the nominators CDD expiry time.�If an account from a given set of address is nominating then�check the CDD expiry time of it and if it is expired1
then the account should be unbonded and removed from the nominating process.$#<weight>�- Depends on passed list of AccountId.)
- Depends on the no. of claim issuers an accountId has for the CDD expiry.(#</weight>Hset_commission_cap
new_cap�

Perbill!
Changes commission rate which applies to all validators. Only Governance�committee is allowed to change this value.,# Arguments�* `new_cap` the new commission cap.Xset_min_bond_threshold
$new_value
0BalanceOf<T>

Changes min bond value to be used in validate(). Only Governance�committee is allowed to change this value.,# Argumentst* `new_value` the new minimum4force_no_eras$�Force there to be no new eras indefinitely.�The dispatch origin must be Root.(# <weight><- No arguments.8- Weight: O(1)D- Write: ForceEra,# </weight>4force_new_era(I
Force there to be a new era at the end of the next session. After this, it will be�reset to normal (non-forced) behaviour.�The dispatch origin must be Root.(# <weight><- No arguments.8- Weight: O(1)@- Write ForceEra,# </weight>Dset_invulnerables
4invulnerables�
DVec<T::AccountId> �Set the validators who cannot be slashed (if any).�The dispatch origin must be Root.(# <weight>- O(V)X- Write: Invulnerables,# </weight>4force_unstake
stash
0T::AccountId
Hnum_slashing_spans
u32(	
Force a current staker to become completely unstaked, immediately.�The dispatch origin must be Root.(# <weight>�O(S) where S is the number of slashing spans to be removed�Reads: Bonded, Slashing Spans, Account, Locks�
Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators, Account, LockshWrites Each: SpanSlash * S,# </weight>Pforce_new_era_always 

Force there to be a new era at the end of sessions indefinitely.�The dispatch origin must be Root.(# <weight>8- Weight: O(1)D- Write: ForceEra,# </weight>Tcancel_deferred_slash
era
 EraIndex
4slash_indicesI
 Vec<u32>4�Cancel enactment of a deferred slash.�Can be called by the `T::SlashCancelOrigin`.

Parameters: era and indices of the slashes for that era to kill.(# <weight>PComplexity: O(U + S)�with U unapplied slashes weighted with U=1000�and S is the number of slash indices to be canceled.d- Read: Unapplied Slashesh- Write: Unapplied Slashes,# </weight>8payout_stakers
<validator_stash
0T::AccountId
era
 EraIndexd

Pay out all the stakers behind a single validator for a single era.I
- `validator_stash` is the stash account of the validator. Their nominators, up to%
  `T::MaxNominatorRewardedPerValidator`, will also receive their rewards.1
- `era` may be any era between `[current_era - history_depth; current_era]`.U
The origin of this call must be _Signed_. Any account can call this function, even iftit is not one of the stakers.�This can only be called when [`EraElectionStatus`] is `Closed`.(# <weight>�- Time complexity: at most O(MaxNominatorRewardedPerValidator).�- Contains a limited number of reads and writes.,-----------
N is the Number of payouts for the validator (including the validator)Weight:�- Reward Destination Staked: O(N)�- Reward Destination Controller (Creating): O(N)(DB Weight:%
- Read: EraElectionStatus, CurrentEra, HistoryDepth, ErasValidatorReward,)
        ErasStakersClipped, ErasRewardPoints, ErasValidatorPrefs (8 items)

- Read Each: Bonded, Ledger, Payee, Locks, System Account (5 items)�- Write Each: System Account, Locks, Ledger (3 items),# </weight>rebond
value�

0BalanceOf<T>8�Rebond a portion of the stash scheduled to be unlocked.Q
The dispatch origin must be signed by the controller, and it can be only called when�[`EraElectionStatus`] is `Closed`.(# <weight>�- Time complexity: O(L), where L is unlocking chunks�- Bounded by `MAX_UNLOCKING_CHUNKS`.�- Storage changes: Can't increase storage, only decrease it.<---------------0- DB Weight:�    - Reads: EraElectionStatus, Ledger, Locks, [Origin Account]�    - Writes: [Origin Account], Locks, Ledger,# </weight>Dset_history_depth
Dnew_history_depth�
 EraIndex
H_era_items_deleted�
u32T-
Set `HistoryDepth` value. This function will delete any history information|when `HistoryDepth` is reduced.,Parameters:

- `new_history_depth`: The new history depth you would like to set.E
- `era_items_deleted`: The number of items that will be deleted by this dispatch.A
   This should report all the storage items that will be deleted by clearing oldA
   era history. Needed to report an accurate weight for the dispatch. Trusted by�   `Root` to report an accurate number.POrigin must be root.(# <weight>�- E: Number of history depths removed, i.e. 10 -> 7 = 38- Weight: O(E)0- DB Weight:�    - Reads: Current Era, History Depthl    - Writes: History Depth-
    - Clear Prefix Each: Era Stakers, EraStakersClipped, ErasValidatorPrefs}
    - Writes Each: ErasValidatorReward, ErasRewardPoints, ErasTotalStake, ErasStartSessionIndex,# </weight>(reap_stash
stash
0T::AccountId
Hnum_slashing_spans
u32<]
Remove all data structure concerning a staker/stash once its balance is at the minimum.]
This is essentially equivalent to `withdraw_unbonded` except it can be called by anyone�and the target `stash` must have no funds left beyond the ED.�This can be called from any origin.�- `stash`: The stash account to reap. Its balance must be zero.(# <weight>!
Complexity: O(S) where S is the number of slashing spans on the account.(DB Weight:�- Reads: Stash Account, Bonded, Slashing Spans, Locks�
- Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators, Stash Account, Locksp- Writes Each: SpanSlash * S,# </weight>`submit_election_solution
winners%
LVec<ValidatorIndex>
compact)
HCompactAssignments
score�
4ElectionScore
era
 EraIndex
size�
0ElectionSize��Submit an election result to the chain. If the solution:01. is valid.
2. has a better score than a potentially existing solution on chain.�then, it will be _put_ on chain.�A solution consists of two pieces of data:�1. `winners`: a flat vector of all the winners of the round.M
2. `assignments`: the compact version of an assignment vector that encodes the edge,   weights.
Both of which may be computed using _phragmen_, or any other algorithm.�Additionally, the submitter must provide:�- The `score` that they claim their solution has.I
Both validators and nominators will be represented by indices in the solution. The
indices should respect the corresponding types ([`ValidatorIndex`] and-
[`NominatorIndex`]). Moreover, they should be valid when used to index intoM
[`SnapshotValidators`] and [`SnapshotNominators`]. Any invalid index will cause the]
solution to be rejected. These two storage items are set during the election window and�may be used to determine the indices.\A solution is valid if:�0. It is submitted when [`EraElectionStatus`] is `Open`.�1. Its claimed score is equal to the score computed on-chain.�2. Presents the correct number of winners.Q
3. All indexes must be value according to the snapshot vectors. All edge values mustY
   also be correct and should not overflow the granularity of the ratio type (i.e. 256<   or billion).	
4. For each edge, all targets are actually nominated by the voter.h5. Has correct self-votes.�A solutions score is consisted of 3 parameters:a
1. `min { support.total }` for each support of a winner. This value should be maximized.a
2. `sum { support.total }` for each support of a winner. This value should be minimized.=
3. `sum { support.total^2 }` for each support of a winner. This value should be�   minimized (to ensure less variance)(# <weight>
The transaction is assumed to be the longest path, a better solution.�  - Initial solution is almost the same.A
  - Worse solution is retraced in pre-dispatch-checks which sets its own weight.,# </weight>�submit_election_solution_unsigned
winners%
LVec<ValidatorIndex>
compact)
HCompactAssignments
score�
4ElectionScore
era
 EraIndex
size�
0ElectionSize$�Unsigned version of `submit_election_solution`.Y
Note that this must pass the [`ValidateUnsigned`] check which only allows transactions]
from the local node to be included. In other words, only the block author can include adtransaction in the block.(# <weight>�See [`submit_election_solution`].,# </weight>`payout_stakers_by_system
<validator_stash
0T::AccountId
era
 EraIndex!
System version of `payout_stakers()`. Only be called by the root origin.lchange_slashing_allowed_for
<slashing_switch�

8SlashingSwitchi
Switch slashing status on the basis of given `SlashingSwitch`. Can only be called by root.,# Argumentst* origin - AccountId of root.

* slashing_switch - Switch used to set the targets for slashing.�update_permissioned_validator_intended_count
 identityx
(IdentityId
Hnew_intended_count
u32�Update the intended validator count for a given DID.,# Arguments1
* origin which must be the required origin for adding a potential validator.�* identity to add as a validator.�* new_intended_count New value of intended count.Tchill_from_governance
 identityx
(IdentityId
(stash_keys�
DVec<T::AccountId> 8�GC forcefully chills a validator.�Effects will be felt at the beginning of the next era.	
And, it can be only called when [`EraElectionStatus`] is `Closed`.,# Argumentsp* origin which must be a GC.

* identity must be permissioned to run operator/validator nodes.
* stash_keys contains the secondary keys of the permissioned identity # Errors�* `BadOrigin` The origin was not a GC member.�
* `CallNotAllowed` The call is not allowed at the given time due to restrictions of election period.�* `NotExists` Permissioned validator doesn't exist.�* `NotStash` Not a stash account for the permissioned identity.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.
8pallet_stakingDRewardDestination$AccountId

StakedStash
(ControllerAccount
$AccountId8pallet_staking8ValidatorPrefs
(commission
Perbill
blocked

bool�
U4sp_arithmetic(per_thingsPercent
u8!OptionT

NoneSome
%E)8pallet_stakingHCompactAssignments@
votes1-
votes29
votes3M
votes4Y
votes5e
votes6q
votes7}
votes8�
votes9�
votes10�
votes11�
votes12�
votes13�
votes14�
votes15�
votes16�-11�55E9==�A5A5EEII4sp_arithmetic(per_thingsPerU16E
u16MQQ�U5UAY]]�a5aAeii�m5mAquu�y5yA}����5�A�����5�A�����5�A�����5�	A�����5�
A�����5�A�����5�A�����5�
A�����5�A�����5�A�Dsp_npos_elections4ElectionScore
4minimal_stake
<ExtendedBalance
$sum_stake
<ExtendedBalance
Dsum_stake_squared
<ExtendedBalance�8pallet_staking0ElectionSize
(validators5
8ValidatorIndex
(nominators�
8NominatorIndex�8pallet_sessionpalletCallT
 set_keys
keys

T::Keys
proof(
Vec<u8>8�Sets the session key(s) of the function caller to `keys`.
Allows an account to set its session key prior to becoming a validator.�This doesn't take effect until the next session.�The dispatch origin of this function must be signed.(# <weight>
- Complexity: `O(1)`. Actual cost depends on the number of length of�  `T::Keys::key_ids()` which is fixed.�- DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`�- DbWrites: `origin account`, `NextKeys`�- DbReads per key id: `KeyOwner`�- DbWrites per key id: `KeyOwner`,# </weight>(purge_keys
@�Removes any session key(s) of the function caller.�This doesn't take effect until the next session.U
The dispatch origin of this function must be Signed and the account must be either be]
convertible to a validator ID using the chain's typical addressing system (this usuallyQ
means being a controller account) or directly convertible into a validator ID (which�usually means being a stash account).(# <weight>a
- Complexity: `O(1)` in number of key types. Actual cost depends on the number of length�  of `T::Keys::key_ids()` which is fixed.�- DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`�- DbWrites: `NextKeys`, `origin account`�- DbWrites per key id: `KeyOwner`,# </weight>%
Contains one variant per dispatchable that can be called by an extrinsic.
`polymesh_runtime_developruntime,SessionKeys
grandpa�

�<Grandpa as $crate::BoundToRuntimeAppPublic>::Public
babe�
�<Babe as $crate::BoundToRuntimeAppPublic>::Public
$im_online�

�<ImOnline as $crate::BoundToRuntimeAppPublic>::Public
Lauthority_discovery
�<AuthorityDiscovery as $crate::BoundToRuntimeAppPublic>::PublicXsp_authority_discoveryappPublic�

<sr25519::Public	8pallet_grandpapalletCallT
Lreport_equivocation
Hequivocation_proof

�Box<EquivocationProof<T::Hash, T::BlockNumber>>
<key_owner_proof
@T::KeyOwnerProof	
Report voter equivocation/misbehavior. This method will verify the�equivocation proof and validate the given key ownership proof�against the extracted offender. If both are valid, the offenceDwill be reported.preport_equivocation_unsigned
Hequivocation_proof

�Box<EquivocationProof<T::Hash, T::BlockNumber>>
<key_owner_proof
@T::KeyOwnerProof
$	
Report voter equivocation/misbehavior. This method will verify the�equivocation proof and validate the given key ownership proof�against the extracted offender. If both are valid, the offenceDwill be reported.

This extrinsic must be called unsigned and it is expected that only
block authors will call it (validated in `ValidateUnsigned`), as such
if the block author is defined it will be defined as the equivocation$reporter.0note_stalled
delay
8T::BlockNumber
lbest_finalized_block_number
8T::BlockNumber
Note that the current authority set of the GRANDPA finality gadget has%
stalled. This will trigger a forced authority set change at the beginning
of the next session, to be enacted `delay` blocks after that. The delay
should be high enough to safely assume that the block signalling the%
forced change will not be re-orged (e.g. 1000 blocks). The GRANDPA voters%
will start the new authority set using the given finalized block as base.XOnly callable by root.%
Contains one variant per dispatchable that can be called by an extrinsic.
Lsp_finality_grandpaDEquivocationProofH
$N

set_id 
SetId
0equivocation
HEquivocation<H, N>Lsp_finality_grandpa0EquivocationH
$N

Prevote
9
grandpa::Equivocation<AuthorityId, grandpa::Prevote<H, N>,
AuthoritySignature>$Precommit)
A
grandpa::Equivocation<AuthorityId, grandpa::Precommit<H, N>,
AuthoritySignature>
@finality_grandpa0EquivocationId
�
V
S

0round_number 
u64
 identity�

Id
first%
(V, S)
second%
(V, S)@finality_grandpaPrevoteH
$N

,target_hash$
H
4target_number
NLsp_finality_grandpaapp$Signature!
Hed25519::Signature!sp_coreed25519$Signature
 [u8; 64]%)@finality_grandpa0EquivocationId
�
V
-S

0round_number 
u64
 identity�

Id
first1
(V, S)
second1
(V, S)-@finality_grandpa$PrecommitH
$N

,target_hash$
H
4target_number
N1-5@pallet_im_onlinepalletCallT
$heartbeat
$heartbeat9
dHeartbeat<T::BlockNumber>
$signatureM
�<T::AuthorityId as RuntimeAppPublic>::Signature$(# <weight>a
- Complexity: `O(K + E)` where K is length of `Keys` (heartbeat.validators_len) and E is�  length of `heartbeat.network_state.external_address`�  - `O(K)`: decoding of length `K`�  - `O(E)`: decoding/encoding of length `E`9
- DbReads: pallet_session `Validators`, pallet_session `CurrentIndex`, `Keys`,X  `ReceivedHeartbeats`�- DbWrites: `ReceivedHeartbeats`,# </weight>%
Contains one variant per dispatchable that can be called by an extrinsic.9@pallet_im_online$Heartbeat,BlockNumber

0block_number
,BlockNumber
4network_state=
HOpaqueNetworkState
4session_index
0SessionIndex
<authority_index
$AuthIndex
8validators_len
u32=sp_core offchainHOpaqueNetworkState
peer_idA
0OpaquePeerId
Hexternal_addressesE
PVec<OpaqueMultiaddr>Asp_core0OpaquePeerId(
Vec<u8>EIIsp_core offchain<OpaqueMultiaddr(
Vec<u8>M@pallet_im_onlinesr25519,app_sr25519$SignatureQ
Hsr25519::SignatureQsp_coresr25519$Signature
 [u8; 64]U,pallet_sudoCallT
sudo
call�
`Box<<T as Config>::Call>(5
Authenticates the sudo key and dispatches a function call with `Root` origin.�The dispatch origin for this call must be _Signed_.(# <weight>- O(1).`- Limited storage reads.\- One DB write (event).�- Weight of derivative `call` execution + 10,000.,# </weight>Tsudo_unchecked_weight
call�
`Box<<T as Config>::Call>
_weight 
Weight
(5
Authenticates the sudo key and dispatches a function call with `Root` origin.-
This function does not check the weight of the call, and instead allows the�Sudo user to specify the weight of the call.�The dispatch origin for this call must be _Signed_.(# <weight>- O(1).�- The weight of this call is defined by the caller.,# </weight>set_key
newU
�<T::Lookup as StaticLookup>::Source$q
Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo key.�The dispatch origin for this call must be _Signed_.(# <weight>- O(1).`- Limited storage reads.@- One DB change.,# </weight>sudo_as
whoU
�<T::Lookup as StaticLookup>::Source
call�
`Box<<T as Config>::Call>,M
Authenticates the sudo key and dispatches a function call with `Signed` origin from@a given account.�The dispatch origin for this call must be _Signed_.(# <weight>- O(1).`- Limited storage reads.\- One DB write (event).�- Weight of derivative `call` execution + 10,000.,# </weight>LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.Y0pallet_assetCallT
h<register_ticker
ticker�
Ticker$
Registers a new ticker or extends validity of an existing ticker.
NB: Ticker validity does not get carry forward when renewing ticker.,# Arguments�
* `origin` It contains the secondary key of the caller (i.e. who signed the transaction to execute this function).x* `ticker` ticker to register.4# Permissions* AssetXaccept_ticker_transfer
auth_id 
u64
0hAccepts a ticker transfer.-
Consumes the authorization `auth_id` (see `pallet_identity::consume_auth`).%
NB: To reject the transfer, call remove auth function in identity module.,# Arguments�
* `origin` It contains the secondary key of the caller (i.e. who signed the transaction to execute this function).�* `auth_id` Authorization ID of ticker transfer authorization.$## Errorsi
- `AuthorizationError::BadType` if `auth_id` is not a valid ticket transfer authorization.|accept_asset_ownership_transfer
auth_id 
u64�This function is used to accept a token ownership transfer.%
NB: To reject the transfer, call remove auth function in identity module.,# Arguments�
* `origin` It contains the secondary key of the caller (i.e. who signed the transaction to execute this function).-
* `auth_id` Authorization ID of the token ownership transfer authorization.0create_asset
name�

$AssetName
ticker�
Ticker
$divisible

bool
(asset_type�

$AssetType
,identifiers�

PVec<AssetIdentifier>
4funding_round
`Option<FundingRoundName>
(disable_iu

boolh-
Initializes a new security token, with the initiating account as its owner.
The total supply will initially be zero. To mint tokens, use `issue`.,# Arguments�
* `origin` - contains the secondary key of the caller (i.e. who signed the transaction to execute this function).�* `name` - the name of the token.�* `ticker` - the ticker symbol of the token.-
* `divisible` - a boolean to identify the divisibility status of the token.�* `asset_type` - the asset type.�* `identifiers` - a vector of asset identifiers.�* `funding_round` - name of the funding round.M
* `disable_iu` - whether or not investor uniqueness enforcement should be disabled.�  This cannot be changed after creating the asset.$## Errors�- `InvalidAssetIdentifier` if any of `identifiers` are invalid.Q
- `MaxLengthOfAssetNameExceeded` if `name`'s length exceeds `T::AssetNameMaxLength`.U
- `FundingRoundNameMaxLengthExceeded` if the name of the funding round is longer that|`T::FundingRoundNameMaxLength`.�- `AssetAlreadyCreated` if asset was already created.]
- `TickerTooLong` if `ticker`'s length is greater than `config.max_ticker_length` chain(parameter.�- `TickerNotAscii` if `ticker` is not yet registered, and contains non-ascii printable characters (from code 32 to 126) or any character after first occurrence of `\0`.8## Permissions,* Portfoliofreeze
ticker�
Ticker,�Freezes transfers and minting of a given token.,# Arguments�* `origin` - the secondary key of the sender.�* `ticker` - the ticker of the token.$## Errors�- `AlreadyFrozen` if `ticker` is already frozen.4# Permissions* Asset unfreeze
ticker�
Ticker,�Unfreezes transfers and minting of a given token.,# Arguments�* `origin` - the secondary key of the sender.�* `ticker` - the ticker of the frozen token.$## Errors�- `NotFrozen` if `ticker` is not frozen yet.4# Permissions* Asset0rename_asset
ticker�
Ticker
name�

$AssetName4XRenames a given token.,# Arguments�* `origin` - the secondary key of the sender.�* `ticker` - the ticker of the token.�* `name` - the new name of the token.$## Errors
- `MaxLengthOfAssetNameExceeded` if length of `name` is greater than``T::AssetNameMaxLength`.4# Permissions* Assetissue
ticker�
Ticker
amount
Balance,�Issue, or mint, new tokens to the caller,�which must be an authorized external agent.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.`* `ticker` of the token.�* `amount` of tokens that get issued.4# Permissions* Asset,* Portfolioredeem
ticker�
Ticker
value
Balance<�
Redeems existing tokens by reducing the balance of the caller's default portfolio and the total supply of the token,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.�* `value` Amount of tokens to redeem. # Errorsa
- `Unauthorized` If called by someone without the appropriate external agent permissionsY
- `InvalidGranularity` If the amount is not divisible by 10^6 for non-divisible tokens�
- `InsufficientPortfolioBalance` If the caller's default portfolio doesn't have enough free balance4# Permissions* Asset,* Portfolio8make_divisible
ticker�
Ticker	,�Makes an indivisible token divisible.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.$## Errors�- `AssetAlreadyDivisible` if `ticker` is already divisible.4# Permissions* Asset4add_documents
docs]
4Vec<Document>
ticker�
Ticker
$�Add documents for a given token.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.�* `docs` Documents to be attached to `ticker`.4# Permissions* Asset@remove_documents
ids

<Vec<DocumentId>
ticker�
Ticker$�Remove documents for a given token.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.�* `ids` Documents ids to be removed from `ticker`.4# Permissions* AssetDset_funding_round
ticker�
Ticker
name�

@FundingRoundName4�Sets the name of the current funding round.,# Arguments)
* `origin` - a signer that has permissions to act as an agent of `ticker`.�* `ticker` - the ticker of the token.�* `name` - the desired name of the current funding round.$## Errors%
- `FundingRoundNameMaxLengthExceeded` if length of `name` is greater than|`T::FundingRoundNameMaxLength`.4# Permissions* AssetHupdate_identifiers
ticker�
Ticker
,identifiers�

PVec<AssetIdentifier>
4xUpdates the asset identifiers.,# Arguments)
* `origin` - a signer that has permissions to act as an agent of `ticker`.�* `ticker` - the ticker of the token.Y
* `identifiers` - the asset identifiers to be updated in the form of a vector of pairs�   of `IdentifierType` and `AssetIdentifier` value.$## Errors1
- `InvalidAssetIdentifier` if `identifiers` contains any invalid identifier.4# Permissions* AssetPclaim_classic_ticker
ticker�
Ticker
Hethereum_signaturea
8EcdsaSignature8�Claim a systematically reserved Polymath Classic (PMC) `ticker`�and transfer it to the `origin`'s identity.=
To verify that the `origin` is in control of the Ethereum account on the books,
an `ethereum_signature` containing the `origin`'s DID as the message�must be provided by that Ethereum account. # Errors1
- `NoSuchClassicTicker` if this is not a systematically reserved PMC ticker.Q
- `TickerAlreadyRegistered` if the ticker was already registered, e.g., by `origin`.
- `TickerRegistrationExpired` if the ticker's registration has expired.p- `BadOrigin` if not signed.
- `InvalidEthereumSignature` if the `ethereum_signature` is not valid.)
- `NotAnOwner` if the ethereum account is not the owner of the PMC ticker.Xreserve_classic_ticker
Tclassic_ticker_importi
LClassicTickerImport
0contract_didx
(IdentityId
configm
�TickerRegistrationConfig<T::Moment>4�Reserve a Polymath Classic (PMC) ticker.

Must be called by root, and assigns the ticker to a systematic DID.,# Argumentsx* `origin` which must be root.�* `classic_ticker_import` specification for the PMC ticker.]
* `contract_did` to reserve the ticker to if `classic_ticker_import.is_contract` holds.�* `config` to use for expiry and ticker length. # ErrorsI
* `AssetAlreadyCreated` if `classic_ticker_import.ticker` was created as an asset.a
* `TickerTooLong` if the `config` considers the `classic_ticker_import.ticker` too long.U
* `TickerAlreadyRegistered` if `classic_ticker_import.ticker` was already registered.Lcontroller_transfer
ticker�
Ticker
value
Balance
8from_portfolio�
,PortfolioIdM
Forces a transfer of token from `from_portfolio` to the caller's default portfolio.,# ArgumentsU
* `origin` Must be an external agent with appropriate permissions for a given ticker.�* `ticker` Ticker symbol of the asset.�* `value`  Amount of tokens need to force transfer.�* `from_portfolio` From whom portfolio tokens gets transferred.hregister_custom_asset_type
ty(
Vec<u8>$xRegisters a custom asset type.�The provided `ty` will be bound to an ID in storage.�The ID can then be used in `AssetType::Custom`.%
Should the `ty` already exist in storage, no second ID is assigned to it.,# Arguments�* `origin` who called the extrinsic.�* `ty` contains the string representation of the asset type.tcreate_asset_with_custom_type
name�

$AssetName
ticker�
Ticker
$divisible

bool
Dcustom_asset_type(
Vec<u8>
,identifiers�

PVec<AssetIdentifier>
4funding_round
`Option<FundingRoundName>
(disable_iu

bool-
Utility extrinsic to batch `create_asset` and `register_custom_asset_type`.Hset_asset_metadata
ticker�
Ticker
keyq
@AssetMetadataKey
value=
HAssetMetadataValue
detailA
�Option<AssetMetadataValueDetail<T::Moment>>DdSet asset metadata value.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.T* `key` Metadata key.d* `value` Metadata value.	
* `details` Optional Metadata value details (expire, lock status). # Errors
* `AssetMetadataKeyIsMissing` if the metadata type key doesn't exist.%
* `AssetMetadataValueIsLocked` if the metadata value for `key` is locked.e
* `AssetMetadataValueMaxLengthExceeded` if the metadata value exceeds the maximum length.4# Permissions* Agent* Assethset_asset_metadata_details
ticker�
Ticker
keyq
@AssetMetadataKey
detailE
�AssetMetadataValueDetail<T::Moment><�Set asset metadata value details (expire, lock status).,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.T* `key` Metadata key.�* `details` Metadata value details (expire, lock status). # Errors
* `AssetMetadataKeyIsMissing` if the metadata type key doesn't exist.%
* `AssetMetadataValueIsLocked` if the metadata value for `key` is locked.4# Permissions* Agent* Asset�register_and_set_local_asset_metadata
ticker�
Ticker
nameM
DAssetMetadataName
specU
DAssetMetadataSpec
value=
HAssetMetadataValue
detailA
�Option<AssetMetadataValueDetail<T::Moment>>L�Registers and set local asset metadata.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.\* `name` Metadata name.�* `spec` Metadata type definition.d* `value` Metadata value.	
* `details` Optional Metadata value details (expire, lock status). # Errors�
* `AssetMetadataLocalKeyAlreadyExists` if a local metadata type with `name` already exists for `ticker`.e
* `AssetMetadataNameMaxLengthExceeded` if the metadata `name` exceeds the maximum length.�
* `AssetMetadataTypeDefMaxLengthExceeded` if the metadata `spec` type definition exceeds the maximum length.e
* `AssetMetadataValueMaxLengthExceeded` if the metadata value exceeds the maximum length.4# Permissions* Agent* Asset�register_asset_metadata_local_type
ticker�
Ticker
nameM
DAssetMetadataName
specU
DAssetMetadataSpec@�Registers asset metadata local type.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.\* `name` Metadata name.�* `spec` Metadata type definition. # Errors�
* `AssetMetadataLocalKeyAlreadyExists` if a local metadata type with `name` already exists for `ticker`.e
* `AssetMetadataNameMaxLengthExceeded` if the metadata `name` exceeds the maximum length.�
* `AssetMetadataTypeDefMaxLengthExceeded` if the metadata `spec` type definition exceeds the maximum length.4# Permissions* Agent* Asset�register_asset_metadata_global_type
nameM
DAssetMetadataName
specU
DAssetMetadataSpec,�Registers asset metadata global type.,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.\* `name` Metadata name.�* `spec` Metadata type definition. # Errorsq
* `AssetMetadataGlobalKeyAlreadyExists` if a globa metadata type with `name` already exists.e
* `AssetMetadataNameMaxLengthExceeded` if the metadata `name` exceeds the maximum length.�
* `AssetMetadataTypeDefMaxLengthExceeded` if the metadata `spec` type definition exceeds the maximum length.Tredeem_from_portfolio
ticker�
Ticker
value
Balance
$portfolio�
4PortfolioKindD�
Redeems existing tokens by reducing the balance of the caller's portfolio and the total supply of the token,# Arguments-
* `origin` is a signer that has permissions to act as an agent of `ticker`.|* `ticker` Ticker of the token.�* `value` Amount of tokens to redeem.�* `portfolio` From whom portfolio tokens gets transferred. # Errorsa
- `Unauthorized` If called by someone without the appropriate external agent permissionsY
- `InvalidGranularity` If the amount is not divisible by 10^6 for non-divisible tokensu
- `InsufficientPortfolioBalance` If the caller's `portfolio` doesn't have enough free balance�- `PortfolioDoesNotExist` If the portfolio doesn't exist.4# Permissions* Asset,* PortfolioDupdate_asset_type
ticker�
Ticker
(asset_type�

$AssetType0tUpdates the type of an asset.,# Arguments�* `origin` - the secondary key of the sender.�* `ticker` - the ticker of the token.�* `asset_type` - the new type of the token.$## Errorsi
- `InvalidCustomAssetTypeId` if `asset_type` is of type custom and has an invalid type id.4# Permissions* AssetLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.]
aLpolymesh_primitives ethereum8EcdsaSignaturee
 [u8; 65]eAi0pallet_assetLClassicTickerImport
$eth_owner9
<EthereumAddress
ticker�
Ticker
,is_contract

bool
(is_created

boolm0pallet_asset`TickerRegistrationConfigU
 
Dmax_ticker_length
u8
Lregistration_length�
$Option<U>qLpolymesh_primitives8asset_metadata@AssetMetadataKey
Globalm
XAssetMetadataGlobalKeyLocalQ
TAssetMetadataLocalKey
u`pallet_corporate_actions0distributionCallT
(distribute
ca_idy
CAId
$portfolioy
\Option<PortfolioNumber>
 currency�
Ticker
$per_share
Balance
amount
Balance
(payment_at 
Moment
(expires_at�
8Option<Moment>�%
Start and attach a capital distribution, to the CA identified by `ca_id`,e
with `amount` funds in `currency` withdrawn from `portfolio` belonging to `origin`'s DID.)
The distribution will commence at `payment_at` and expire at `expires_at`,�if provided, or if `None`, then there's no expiry.%
The funds will be locked in `portfolio` from when `distribute` is called.5
When there's no expiry, some funds may be locked indefinitely in `portfolio`,
due to claimants not withdrawing or no benefits being pushed to them.)
For indivisible currencies, unlocked amounts, of less than one whole unit,�will not be transferable from `portfolio`.M
However, if we imagine that users `Alice` and `Bob` both are entitled to 1.5 units,Q
and only receive `1` units each, then `0.5 + 0.5 = 1` units are left in `portfolio`,lwhich is now transferrable.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.

- `ca_id` identifies the CA to start a capital distribution for.Y
- `portfolio` specifies the portfolio number of the agent to distribute `amount` from.�- `currency` to withdraw and distribute from the `portfolio`.�- `per_share` amount of `currency` to withdraw and distribute.%
   Specified as a per-million, i.e. `1 / 10^6`th of one `currency` token.�- `amount` of `currency` to withdraw and distribute at most.
- `payment_at` specifies when benefits may first be pushed or claimed.)
- `expires_at` specifies, if provided, when remaining benefits are forfeit�   and may be reclaimed by `origin`. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `ExpiryBeforePayment` if `expires_at.unwrap() <= payment_at`.�- `NoSuchCA` if `ca_id` does not identify an existing CA.�- `NoRecordDate` if CA has no record date.�- `RecordDateAfterStart` if CA's record date > payment_at.1
- `UnauthorizedCustodian` if the caller is not the custodian of `portfolio`.U
- `InsufficientPortfolioBalance` if `portfolio` has less than `amount` of `currency`.

- `InsufficientBalance` if the protocol fee couldn't be charged.E
- `CANotBenefit` if the CA is not of kind PredictableBenefit/UnpredictableBenefit�- `DistributionAmountIsZero` if the `amount` is zero.�- `DistributionPerShareIsZero` if the `per_share` is zero.4# Permissions* Asset,* Portfolioclaim
ca_idy
CAId
\

Claim a benefit of the capital distribution attached to `ca_id`.�Taxes are withheld as specified by the CA.Y
Post-tax earnings are then transferred to the default portfolio of the `origin`'s DID.
All benefits are rounded by truncation, down to first integer below.9
Moreover, before post-tax earnings, in indivisible currencies are transferred,�they are rounded down to a whole unit.0## ArgumentsE
- `origin` which must be a holder of the asset and eligible for the distribution.

- `ca_id` identifies the CA to start a capital distribution for. # Errors%
- `HolderAlreadyPaid` if `origin`'s DID has already received its benefit.
- `NoSuchDistribution` if there's no capital distribution for `ca_id`.�- `CannotClaimBeforeStart` if `now < payment_at`.�- `CannotClaimAfterExpiry` if `now > expiry_at.unwrap()`.�- `NoSuchCA` if `ca_id` does not identify an existing CA.�- `NotTargetedByCA` if the CA does not target `origin`'s DID.5
- `BalanceAmountProductOverflowed` if `ba = balance * amount` would overflow.5
- `BalanceAmountProductSupplyDivisionFailed` if `ba * supply` would overflow.!
- Other errors can occur if the compliance manager rejects the transfer.0push_benefit
ca_idy
CAId
holderx
(IdentityId`�Push benefit of an ongoing distribution to the given `holder`.�Taxes are withheld as specified by the CA.Y
Post-tax earnings are then transferred to the default portfolio of the `origin`'s DID.
All benefits are rounded by truncation, down to first integer below.9
Moreover, before post-tax earnings, in indivisible currencies are transferred,�they are rounded down to a whole unit.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.9
- `ca_id` identifies the CA with a capital distributions to push benefits for.|- `holder` to push benefits to. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.
- `NoSuchDistribution` if there's no capital distribution for `ca_id`.�- `CannotClaimBeforeStart` if `now < payment_at`.�- `CannotClaimAfterExpiry` if `now > expiry_at.unwrap()`.�- `NoSuchCA` if `ca_id` does not identify an existing CA.�- `NotTargetedByCA` if the CA does not target `holder`.5
- `BalanceAmountProductOverflowed` if `ba = balance * amount` would overflow.5
- `BalanceAmountProductSupplyDivisionFailed` if `ba * supply` would overflow.!
- Other errors can occur if the compliance manager rejects the transfer.reclaim
ca_idy
CAId,�Assuming a distribution has expired,�unlock the remaining amount in the distributor portfolio.0## ArgumentsE
- `origin` which must be the creator of the capital distribution tied to `ca_id`.
- `ca_id` identifies the CA with a capital distribution to reclaim for. # Errors
- `NoSuchDistribution` if there's no capital distribution for `ca_id`.-
- `AlreadyReclaimed` if this function has already been called successfully.�- `NotExpired` if `now < expiry`.Lremove_distribution
ca_idy
CAId,�Removes a distribution that hasn't started yet,�unlocking the full amount in the distributor portfolio.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.I
- `ca_id` identifies the CA with a not-yet-started capital distribution to remove. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.
- `NoSuchDistribution` if there's no capital distribution for `ca_id`.�- `DistributionStarted` if `payment_at <= now`.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.yOptionT
�
NoneSome�
}0pallet_asset(checkpointCallT
Dcreate_checkpoint
ticker�
Ticker$�Creates a single checkpoint at the current time.,# Arguments-
- `origin` is a signer that has permissions to act as an agent of `ticker`.�- `ticker` to create the checkpoint for. # ErrorsU
- `UnauthorizedAgent` if the DID of `origin` isn't a permissioned agent for `ticker`.

- `CounterOverflow` if the total checkpoint counter would overflow.pset_schedules_max_complexity
8max_complexity 
u64
$Y
Sets the max complexity of a schedule set for an arbitrary ticker to `max_complexity`.�The new maximum is not enforced retroactively,�and only applies once new schedules are made.�Must be called as a PIP (requires "root").,# Argumentsx- `origin` is the root origin.	
- `max_complexity` allowed for an arbitrary ticker's schedule set.<create_schedule
ticker�
Ticker
 schedule�
0ScheduleSpecL�Creates a schedule generating checkpoints�in the future at either a fixed time or at intervals.	
The schedule starts out with `strong_ref_count(schedule_id) <- 0`.,# Arguments!
- `origin` is a signer that has permissions to act as owner of `ticker`.�- `ticker` to create the schedule for.�- `schedule` that will generate checkpoints. # ErrorsU
- `UnauthorizedAgent` if the DID of `origin` isn't a permissioned agent for `ticker`.

- `ScheduleDurationTooShort` if the schedule duration is too short.!
- `InsufficientAccountBalance` if the protocol fee could not be charged.M
- `CounterOverflow` if the schedule ID or total checkpoint counters would overflow.]
- `FailedToComputeNextCheckpoint` if the next checkpoint for `schedule` is in the past.4# Permissions* Asset<remove_schedule
ticker�
Ticker
id�
(ScheduleId8�Removes the checkpoint schedule of an asset identified by `id`.,# Arguments!
- `origin` is a signer that has permissions to act as owner of `ticker`.�- `ticker` to remove the schedule from.	
- `id` of the schedule, when it was created by `created_schedule`. # ErrorsU
- `UnauthorizedAgent` if the DID of `origin` isn't a permissioned agent for `ticker`.A
- `NoCheckpointSchedule` if `id` does not identify a schedule for this `ticker`.�- `ScheduleNotRemovable` if `id` exists but is not removable.4# Permissions* AssetLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�0pallet_asset(checkpoint0ScheduleSpec
start�
8Option<Moment>
period�
8CalendarPeriod
$remaining
u32�dpallet_compliance_managerCallT
$hadd_compliance_requirement
ticker�
Ticker
Dsender_conditions�
8Vec<Condition>
Lreceiver_conditions�
8Vec<Condition>,
Adds a compliance requirement to an asset's compliance by ticker.i
If there are duplicate ClaimTypes for a particular trusted issuer, duplicates are removed.,# Arguments-
* origin - Signer of the dispatchable. It should be the owner of the tickerx* ticker - Symbol of the asset�* sender_conditions - Sender transfer conditions.�* receiver_conditions - Receiver transfer conditions.4# Permissions* Assettremove_compliance_requirement
ticker�
Ticker
id
u32
$�Removes a compliance requirement from an asset's compliance.,# Arguments-
* origin - Signer of the dispatchable. It should be the owner of the tickerx* ticker - Symbol of the asset�* id - Compliance requirement id which is need to be removed4# Permissions* Asset`replace_asset_compliance
ticker�
Ticker
@asset_compliance�
hVec<ComplianceRequirement><�Replaces an asset's compliance by ticker with a new compliance.�Compliance requirements will be sorted (ascending by id) before�replacing the current requirements.,# Argumentsx* `ticker` - the asset ticker,�* `asset_compliance - the new asset compliance. # Errors�* `Unauthorized` if `origin` is not the owner of the ticker.�
* `DuplicateAssetCompliance` if `asset_compliance` contains multiple entries with the same `requirement_id`.4# Permissions* AssetXreset_asset_compliance
ticker�
Ticker tRemoves an asset's compliance,# Arguments-
* origin - Signer of the dispatchable. It should be the owner of the tickerx* ticker - Symbol of the asset4# Permissions* AssetXpause_asset_compliance
ticker�
Ticker 
Pauses the verification of conditions for `ticker` during transfers.,# Arguments-
* origin - Signer of the dispatchable. It should be the owner of the tickerx* ticker - Symbol of the asset4# Permissions* Asset\resume_asset_compliance
ticker�
Ticker 
Resumes the verification of conditions for `ticker` during transfers.,# Arguments-
* origin - Signer of the dispatchable. It should be the owner of the tickerx* ticker - Symbol of the asset4# Permissions* Asset�add_default_trusted_claim_issuer
ticker�
Ticker
issuer�
4TrustedIssuer$�Adds another default trusted claim issuer at the ticker level.,# Arguments1
* origin - Signer of the dispatchable. It should be the owner of the ticker.|* ticker - Symbol of the asset.�* issuer - IdentityId of the trusted claim issuer.4# Permissions* Asset�remove_default_trusted_claim_issuer
ticker�
Ticker
issuerx
(IdentityId$u
Removes the given `issuer` from the set of default trusted claim issuers at the ticker level.,# Arguments1
* origin - Signer of the dispatchable. It should be the owner of the ticker.|* ticker - Symbol of the asset.�* issuer - IdentityId of the trusted claim issuer.4# Permissions* Assettchange_compliance_requirement
ticker�
Ticker
new_req�
TComplianceRequirement$�Modify an existing compliance requirement of a given ticker.,# Arguments1
* origin - Signer of the dispatchable. It should be the owner of the ticker.|* ticker - Symbol of the asset.�* new_req - Compliance requirement.4# Permissions* AssetLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�`pallet_corporate_actionsCallT
$Xset_max_details_length
length
u32�Set the max `length` of `details` in terms of bytes.tMay only be called via a PIP.Lset_default_targets
ticker�
Ticker
targets�
@TargetIdentities
4�Set the default CA `TargetIdentities` to `targets`.0## ArgumentsE
- `origin` which must be an external agent of `ticker` with relevant permissions.�- `ticker` for which the default identities are changing.�- `targets` the default target identities for a CA.$## Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.1
- `TooManyTargetIds` if `targets.identities.len() > T::MaxTargetIds::get()`.4# Permissions* Assetlset_default_withholding_tax
ticker�
Ticker
tax�
Tax0=
Set the default withholding tax for all DIDs and CAs relevant to this `ticker`.0## ArgumentsE
- `origin` which must be an external agent of `ticker` with relevant permissions.�- `ticker` that the withholding tax will apply to.
- `tax` that should be withheld when distributing dividends, etc.$## Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.4# Permissions* Asset\set_did_withholding_tax
ticker�
Ticker
$taxed_didx
(IdentityId
tax�
,Option<Tax>@�Set the withholding tax of `ticker` for `taxed_did` to `tax`.�
If `Some(tax)`, this overrides the default withholding tax of `ticker` to `tax` for `taxed_did`.�Otherwise, if `None`, the default withholding tax will be used.0## ArgumentsE
- `origin` which must be an external agent of `ticker` with relevant permissions.�- `ticker` that the withholding tax will apply to.�- `taxed_did` that will have its withholding tax updated.
- `tax` that should be withheld when distributing dividends, etc.$## Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�
- `TooManyDidTaxes` if `Some(tax)` and adding the override would go over the limit `MaxDidWhts`.4# Permissions* Assetdinitiate_corporate_action 
ticker�
Ticker
kind�
CAKind
$decl_date 
Moment
,record_date�
XOption<RecordDateSpec>
details	
$CADetails
targets�
`Option<TargetIdentities>
\default_withholding_tax�
,Option<Tax>
<withholding_tax�
xOption<Vec<(IdentityId, Tax)>>xI
Initiates a CA for `ticker` of `kind` with `details` and other provided arguments.0## ArgumentsE
- `origin` which must be an external agent of `ticker` with relevant permissions.�- `ticker` that the CA is made for.|- `kind` of CA being initiated.�- `decl_date` of CA bring initialized.�- `record_date`, if any, to calculate the impact of this CA.a
   If provided, this results in a scheduled balance snapshot ("checkpoint") at the date.M
- `details` of the CA in free-text form, up to a certain number of bytes in length.�- `targets`, if any, which this CA is relevant/irrelevant to.I
   Overrides, if provided, the default at the asset level (`set_default_targets`).]
- `default_withholding_tax`, if any, is the default withholding tax to use for this CA.i
   Overrides, if provided, the default at the asset level (`set_default_withholding_tax`).!
- `withholding_tax`, if any, provides per-DID withholding tax overrides.Y
   Overrides, if provided, the default at the asset level (`set_did_withholding_tax`). # Errors
- `DetailsTooLong` if `details.len()` goes beyond `max_details_length`.%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.i
- `CounterOverflow` in the unlikely event that so many CAs were created for this `ticker`,�  that integer overflow would have occured if instead allowed.u
- `TooManyDidTaxes` if `withholding_tax.unwrap().len()` would go over the limit `MaxDidWhts`.

- `DuplicateDidTax` if a DID is included more than once in `wt`.U
- `TooManyTargetIds` if `targets.unwrap().identities.len() > T::MaxTargetIds::get()`.

- `DeclDateInFuture` if the declaration date is not in the past.Q
- When `record_date.is_some()`, other errors due to checkpoint scheduling may occur.4# Permissions* Asset,link_ca_doc
idy
CAId
docs

<Vec<DocumentId>H�Link the given CA `id` to the given `docs`.�Any previous links for the CA are removed in favor of `docs`.U
The workflow here is to add the documents and initiating the CA in any order desired.�Once both exist, they can now be linked together.0## ArgumentsQ
- `origin` which must be an external agent of `id.ticker` with relevant permissions.�- `id` of the CA to associate with `docs`.�- `docs` to associate with the CA with `id`. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchCA` if `id` does not identify an existing CA.
- `NoSuchDoc` if any of `docs` does not identify an existing document.4# Permissions* Asset$remove_ca
ca_idy
CAIdH�Removes the CA identified by `ca_id`.�Associated data, such as document links, ballots,�and capital distributions are also removed.�Any schedule associated with the record date will see�`strong_ref_count(schedule_id)` decremented.0## Arguments]
- `origin` which must be an external agent of `ca_id.ticker` with relevant permissions.x- `ca_id` of the CA to remove. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchCA` if `id` does not identify an existing CA.4# Permissions* AssetHchange_record_date
ca_idy
CAId
,record_date�
XOption<RecordDateSpec><�Changes the record date of the CA identified by `ca_id`.0## Arguments]
- `origin` which must be an external agent of `ca_id.ticker` with relevant permissions.t- `ca_id` of the CA to alter.�- `record_date`, if any, to calculate the impact of the CA.a
   If provided, this results in a scheduled balance snapshot ("checkpoint") at the date. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchCA` if `id` does not identify an existing CA.Q
- When `record_date.is_some()`, other errors due to checkpoint scheduling may occur.4# Permissions* Asset�initiate_corporate_action_and_distribute
ca_args�
lInitiateCorporateActionArgs
$portfolioy
\Option<PortfolioNumber>
 currency�
Ticker
$per_share
Balance
amount
Balance
(payment_at 
Moment
(expires_at�
8Option<Moment>
Utility extrinsic to batch `initiate_corporate_action` and `distribute`LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�OptionT
�
NoneSome�
�`pallet_corporate_actions8RecordDateSpec
$Scheduled 
Moment@ExistingSchedule�
(ScheduleId
 Existing�
0CheckpointId�OptionT
�
NoneSome�
�OptionT


NoneSome

�`pallet_corporate_actionslInitiateCorporateActionArgs 
ticker�
Ticker
kind�
CAKind
$decl_date 
Moment
,record_date�
XOption<RecordDateSpec>
details	
$CADetails
targets�
`Option<TargetIdentities>
\default_withholding_tax�
,Option<Tax>
<withholding_tax�
xOption<Vec<(IdentityId, Tax)>>�`pallet_corporate_actionsballotCallT
4attach_ballot
ca_idy
CAId
range
<BallotTimeRange
meta
(BallotMeta
rcv

boolh�Attach a corporate ballot to the CA identified by `ca_id`.�The ballot will admit votes within `range`.�The ballot's metadata is provided by `meta`,
which includes the ballot title, the motions, their choices, etc.xSee the `BallotMeta` for more.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.�- `ca_id` identifies the CA to attach the ballot to.�- `range` specifies when voting starts and ends.�- `meta` specifies the ballot's metadata as aforementioned.�- `rcv` specifies whether RCV is enabled for this ballot. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchCA` if `ca_id` does not identify an existing CA.�- `CANotNotice` if the CA is not of the `IssuerNotice` kind.�- `StartAfterEnd` if `range.start > range.end`.)
- `NowAfterEnd` if `now > range.end` where `now` is the current timestamp.�- `NoRecordDate` if CA has no record date.Y
- `RecordDateAfterStart` if `date > range.start` where `date` is the CA's record date.�- `AlreadyExists` if there's a ballot already.1
- `NumberOfChoicesOverflow` if the total choice in `meta` overflows `usize`.	
- `TooLong` if any of the embedded strings in `meta` are too long.

- `InsufficientBalance` if the protocol fee couldn't be charged.vote
ca_idy
CAId
votes9
<Vec<BallotVote>
D
Cast `votes` in the ballot attached to the CA identified by `ca_id`.0## Arguments	
- `origin` which must be a permissioned signer targeted by the CA.�- `ca_id` identifies the attached ballot's CA.!
- `votes` specifies the balances to assign to each choice in the ballot.U
   The full voting power of `origin`'s DID may be used for each motion in the ballot. # Errors�- `NoSuchBallot` if `ca_id` does not identify a ballot.�- `VotingNotStarted` if the voting period hasn't commenced yet.�- `VotingAlreadyEnded` if the voting period has ended.]
- `WrongVoteCount` if the number of choices in the ballot does not match `votes.len()`.�- `NoSuchCA` if `ca_id` does not identify an existing CA.�- `NotTargetedByCA` if the CA does not target `origin`'s DID.!
- `InsufficientVotes` if the voting power used for any motion in `votes`�   exceeds `origin`'s DID's voting power.(change_end
ca_idy
CAId
end 
Moment0
Amend the end date of the ballot of the CA identified by `ca_id`.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.�- `ca_id` identifies the attached ballot's CA.�- `end` specifies the new end date of the ballot. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchBallot` if `ca_id` does not identify a ballot.1
- `VotingAlreadyStarted` if `start >= now`, where `now` is the current time.�- `StartAfterEnd` if `start > end`.,change_meta
ca_idy
CAId
meta
(BallotMeta4a
Amend the metadata (title, motions, etc.) of the ballot of the CA identified by `ca_id`.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.�- `ca_id` identifies the attached ballot's CA.�- `meta` specifies the new metadata. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchBallot` if `ca_id` does not identify a ballot.1
- `VotingAlreadyStarted` if `start >= now`, where `now` is the current time.1
- `NumberOfChoicesOverflow` if the total choice in `meta` overflows `usize`.	
- `TooLong` if any of the embedded strings in `meta` are too long.(change_rcv
ca_idy
CAId
rcv

bool,
Amend RCV support for the ballot of the CA identified by `ca_id`.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.�- `ca_id` identifies the attached ballot's CA.�- `rcv` specifies if RCV is to be supported or not. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchBallot` if `ca_id` does not identify a ballot.1
- `VotingAlreadyStarted` if `start >= now`, where `now` is the current time.4remove_ballot
ca_idy
CAId(�Remove the ballot of the CA identified by `ca_id`.0## ArgumentsE
- `origin` is a signer that has permissions to act as an agent of `ca_id.ticker`.�- `ca_id` identifies the attached ballot's CA. # Errors%
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `ticker`.�- `NoSuchBallot` if `ca_id` does not identify a ballot.1
- `VotingAlreadyStarted` if `start >= now`, where `now` is the current time.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�,pallet_pipsCallT
Ddset_prune_historical_pips
prune

bool�Change whether completed PIPs are pruned.lCan only be called by root.,# Arguments�* `prune` specifies whether completed PIPs should be pruned.`set_min_proposal_deposit
deposit
Balance
!
Change the minimum proposal deposit amount required to start a proposal.lCan only be called by root.,# Arguments�* `deposit` the new min deposit required to start a proposalpset_default_enactment_period
 duration
8T::BlockNumber�Change the default enactment period.lCan only be called by root.,# Argumentsi
* `duration` the new default enactment period it takes for a scheduled PIP to be executed.Xset_pending_pip_expiry
expiry=

hMaybeBlock<T::BlockNumber>
Change the amount of blocks after which a pending PIP is expired.�If `expiry` is `None` then PIPs never expire.lCan only be called by root.,# Arguments
* `expiry` the block-time it takes for a still-`Pending` PIP to expire.Xset_max_pip_skip_count
max
0SkippedCount�Change the maximum skip count (`max_pip_skip_count`).lCan only be called by root.,# Arguments�* `max` skips before a PIP cannot be skipped by GC anymore.Pset_active_pip_limit
limit
u32i
Change the maximum number of active PIPs before community members cannot propose anything.lCan only be called by root.,# Arguments�* `limit` of concurrent active PIPs.propose
 proposal�
@Box<T::Proposal>
deposit
Balance
urlY
,Option<Url>
,descriptionY
XOption<PipDescription>$
A network member creates a PIP by submitting a dispatchable whichU
changes the network in someway. A minimum deposit is required to open a new proposal.,# Arguments�* `proposer` is either a signing key or committee.e
   Used to understand whether this is a committee proposal and verified against `origin`.�* `proposal` a dispatchable callE
* `deposit` minimum deposit value, which is ignored if `proposer` is a committee.�* `url` a link to a website for proposal discussionvote
idU
PipId
(aye_or_nay

bool
deposit
BalanceH
Vote either in favor (`aye_or_nay` == true) or against a PIP with `id`.M
The "convinction" or strength of the vote is given by `deposit`, which is reserved.�Note that `vote` is *not* additive.�That is, `vote(id, true, 50)` followed by `vote(id, true, 40)`I
will first reserve `50` and then refund `50 - 10`, ending up with `40` in deposit.%
To add atop of existing votes, you'll need `existing_deposit + addition`.,# ArgumentsL* `id`, proposal id�* `aye_or_nay`, a bool representing for or against vote�* `deposit`, the "conviction" with which the vote is made. # Errors�* `NoSuchProposal` if `id` doesn't reference a valid PIP.�* `NotFromCommunity` if proposal was made by a committee.�* `IncorrectProposalState` if PIP isn't pending.-
* `InsufficientDeposit` if `origin` cannot reserve `deposit - old_deposit`.happrove_committee_proposal
idU
PipId�Approves the pending committee PIP given by the `id`. # Errors
* `BadOrigin` unless a GC voting majority executes this function.�* `NoSuchProposal` if the PIP with `id` doesn't exist.�* `IncorrectProposalState` if the proposal isn't pending.�* `NotByCommittee` if the proposal isn't by a committee.<reject_proposal
idU
PipId	 �Rejects the PIP given by the `id`, refunding any bonded funds,�assuming it hasn't been cancelled or executed.
Note that proposals scheduled-for-execution can also be rejected. # Errors
* `BadOrigin` unless a GC voting majority executes this function.�* `NoSuchProposal` if the PIP with `id` doesn't exist.
* `IncorrectProposalState` if the proposal was cancelled or executed.8prune_proposal
idU
PipId
$)
Prune the PIP given by the `id`, refunding any funds not already refunded.dThe PIP may not be active	
This function is intended for storage garbage collection purposes. # Errors
* `BadOrigin` unless a GC voting majority executes this function.�* `NoSuchProposal` if the PIP with `id` doesn't exist.�* `IncorrectProposalState` if the proposal is active.Preschedule_execution
idU
PipId
until!
XOption<T::BlockNumber>$�Updates the execution schedule of the PIP given by `id`.,# Arguments1
* `until` defines the future block where the enactment period will finished.E
   `None` value means that enactment period is going to finish in the next block. # Errors9
* `RescheduleNotByReleaseCoordinator` unless triggered by release coordinator.!
* `IncorrectProposalState` unless the proposal was in a scheduled state.8clear_snapshot�Clears the snapshot and emits the event `SnapshotCleared`. # Errors=
* `NotACommitteeMember` - triggered when a non-GC-member executes the function. snapshot


Takes a new snapshot of the current list of active && pending PIPs.)
The PIPs are then sorted into a priority queue based on each PIP's weight. # Errors=
* `NotACommitteeMember` - triggered when a non-GC-member executes the function.Xenact_snapshot_results
results�
pVec<(PipId, SnapshotResult)>D�Enacts `results` for the PIPs in the snapshot queue.)
The snapshot will be available for further enactments until it is cleared.U
The `results` are encoded a list of `(id, result)` where `result` is applied to `id`.I
Note that the snapshot priority queue is encoded with the *lowest priority first*.U
so `results = [(id, Approve)]` will approve `SnapshotQueue[SnapshotQueue.len() - 1]`. # Errors

* `BadOrigin` - unless a GC voting majority executes this function.!
* `CannotSkipPip` - a given PIP has already been skipped too many times.

* `SnapshotResultTooLarge` - on len(results) > len(snapshot_queue).p* `SnapshotIdMismatch` - if:$  ```text�   ∃ (i ∈ 0..SnapshotQueue.len()).�     results[i].0 ≠ SnapshotQueue[SnapshotQueue.len() - i].id  ```�   This is protects against clearing queue while GC is voting.Texecute_scheduled_pip
idU
PipId�Internal dispatchable that handles execution of a PIP.Pexpire_scheduled_pip
didx
(IdentityId
idU
PipId�Internal dispatchable that handles expiration of a PIP.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.���U��,pallet_pips8SnapshotResult
ApproveReject
Skip�@pallet_portfolioCallT
@create_portfolio
name�
4PortfolioName�Creates a portfolio with the given `name`.@delete_portfolio
num�
<PortfolioNumber
 5
Deletes a user portfolio. A portfolio can be deleted only if it has no funds. # Errors
* `PortfolioDoesNotExist` if `num` doesn't reference a valid portfolio.�* `PortfolioNotEmpty` if the portfolio still holds any asset4# Permissions,* PortfolioPmove_portfolio_funds
from�
,PortfolioId
to�
,PortfolioId
items�
XVec<MovePortfolioItem><]
Moves a token amount from one portfolio of an identity to another portfolio of the same�identity. Must be called by the custodian of the sender.
Funds from deleted portfolios can also be recovered via this method.�A short memo can be added to to each token amount moved. # Errorsi
* `PortfolioDoesNotExist` if one or both of the portfolios reference an invalid portfolio.Q
* `destination_is_same_portfolio` if both sender and receiver portfolio are the same�
* `DifferentIdentityPortfolios` if the sender and receiver portfolios belong to different identitiesI
* `UnauthorizedCustodian` if the caller is not the custodian of the from portfolioA
* `InsufficientPortfolioBalance` if the sender does not have enough free balance4# Permissions,* Portfolio@rename_portfolio
num�
<PortfolioNumber
to_name�
4PortfolioName�Renames a non-default portfolio. # Errors
* `PortfolioDoesNotExist` if `num` doesn't reference a valid portfolio.4# Permissions,* PortfolioXquit_portfolio_custody
pid�
,PortfolioId �When called by the custodian of `portfolio_id`,I
allows returning the custody of the portfolio to the portfolio owner unilaterally. # Errors]
* `UnauthorizedCustodian` if the caller is not the current custodian of `portfolio_id`.4# Permissions,* Portfolio`accept_portfolio_custody
auth_id 
u64LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.���@pallet_portfolioDMovePortfolioItem
ticker�
Ticker
amount
Balance
memo|
0Option<Memo>�Lpallet_protocol_feeCallT
Hchange_coefficient
,coefficient�
 PosRatio�Changes the fee coefficient for the root origin. # Errors�* `BadOrigin` - Only root allowed.<change_base_fee
op�
(ProtocolOp
 base_fee
Balance
�Changes the a base fee for the root origin. # Errors�* `BadOrigin` - Only root allowed.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.�dpolymesh_common_utilities0protocol_fee(ProtocolOp
4LAssetRegisterTicker(AssetIssue
DAssetAddDocuments@AssetCreateAsset`CheckpointCreateSchedule�ComplianceManagerAddComplianceRequirementXIdentityCddRegisterDid@IdentityAddClaim�IdentityAddSecondaryKeysWithAuthorization,PipsPropose	@ContractsPutCode
lCorporateBallotAttachBallottCapitalDistributionDistribute�@pallet_schedulerpalletCallT
 schedule
when
8T::BlockNumber
8maybe_periodic�
�Option<schedule::Period<T::BlockNumber>>
 priority
Hschedule::Priority
call�
PBox<CallOrHashOf<T>>pAnonymously schedule a task.cancel
when
8T::BlockNumber
index
u32
�Cancel an anonymously scheduled task.8schedule_named
id(
Vec<u8>
when
8T::BlockNumber
8maybe_periodic�
�Option<schedule::Period<T::BlockNumber>>
 priority
Hschedule::Priority
call�
PBox<CallOrHashOf<T>>XSchedule a named task.0cancel_named
id(
Vec<u8>xCancel a named scheduled task.8schedule_after
after
8T::BlockNumber
8maybe_periodic�
�Option<schedule::Period<T::BlockNumber>>
 priority
Hschedule::Priority
call�
PBox<CallOrHashOf<T>>�Anonymously schedule a task after a delay.(# <weight>TSame as [`schedule`].,# </weight>Pschedule_named_after
id(
Vec<u8>
after
8T::BlockNumber
8maybe_periodic�
�Option<schedule::Period<T::BlockNumber>>
 priority
Hschedule::Priority
call�
PBox<CallOrHashOf<T>>�Schedule a named task after a delay.(# <weight>�Same as [`schedule_named`](Self::schedule_named).,# </weight>%
Contains one variant per dispatchable that can be called by an extrinsic.�OptionT
�
NoneSome�
�4frame_supporttraits schedule,MaybeHashedT
�Hash
$
Value�
THash$
Hash
�Dpallet_settlementCallT
T0create_venue
details�
0VenueDetails
signers�
DVec<T::AccountId>
typ�
$VenueTypeXRegisters a new venue.�* `details` - Extra details about a venue=
* `signers` - Array of signers that are allowed to sign receipts for this venue�* `typ` - Type of venue being createdPupdate_venue_details
id�
VenueId
details�
0VenueDetails
\Edit a venue's details.�* `id` specifies the ID of the venue to edit.�* `details` specifies the updated venue details.Dupdate_venue_type
id�
VenueId
typ�
$VenueTypePEdit a venue's type.�* `id` specifies the ID of the venue to edit.�* `type` specifies the new type of the venue.<add_instruction
 venue_id�
VenueId
<settlement_type�
xSettlementType<T::BlockNumber>
(trade_date�
DOption<T::Moment>
(value_date�
DOption<T::Moment>
legs�
 Vec<Leg>4�Deprecated. Use `add_instruction_with_memo` instead.\Adds a new instruction.,# Arguments�* `venue_id` - ID of the venue this instruction belongs to.	
* `settlement_type` - Defines if the instruction should be settled]
   in the next block after receiving all affirmations or waiting till a specific block.Q
* `trade_date` - Optional date from which people can interact with this instruction.m
* `value_date` - Optional date after which the instruction should be settled (not enforced)�* `legs` - Legs included in this instruction. # Weight�`950_000_000 + 1_000_000 * legs.len()`hadd_and_affirm_instruction
 venue_id�
VenueId
<settlement_type�
xSettlementType<T::BlockNumber>
(trade_date�
DOption<T::Moment>
(value_date�
DOption<T::Moment>
legs�
 Vec<Leg>
(portfolios�
@Vec<PortfolioId>8�Deprecated. Use `add_and_affirm_instruction_with_memo` instead.�Adds and affirms a new instruction.,# Arguments�* `venue_id` - ID of the venue this instruction belongs to.	
* `settlement_type` - Defines if the instruction should be settled]
   in the next block after receiving all affirmations or waiting till a specific block.Q
* `trade_date` - Optional date from which people can interact with this instruction.m
* `value_date` - Optional date after which the instruction should be settled (not enforced)�* `legs` - Legs included in this instruction.m
* `portfolios` - Portfolios that the sender controls and wants to use in this affirmations.4# Permissions,* PortfolioHaffirm_instruction
id�
4InstructionId
(portfolios�
@Vec<PortfolioId>
8max_legs_count
u32$�Provide affirmation to an existing instruction.,# Arguments�* `id` - Instruction id to affirm.i
* `portfolios` - Portfolios that the sender controls and wants to affirm this instruction.�* `max_legs_count` - Number of legs that need to be  affirmed.4# Permissions,* PortfolioPwithdraw_affirmation
id�
4InstructionId
(portfolios�
@Vec<PortfolioId>
8max_legs_count
u32$�Withdraw an affirmation for a given instruction.,# Arguments�* `id` - Instruction id for that affirmation get withdrawn.]
* `portfolios` - Portfolios that the sender controls and wants to withdraw affirmation.

* `max_legs_count` - Number of legs that need to be un-affirmed.4# Permissions,* PortfolioHreject_instruction
id�
4InstructionId
$portfolio�
,PortfolioId
,num_of_legs
u32$�Rejects an existing instruction.,# Arguments�* `id` - Instruction id to reject.�* `portfolio` - Portfolio to reject the instruction.�* `num_of_legs` - Number of legs in the instruction.4# Permissions,* PortfolioPaffirm_with_receipts
id�
4InstructionId
<receipt_details�
�Vec<ReceiptDetails<T::AccountId, T::OffChainSignature>>
(portfolios�
@Vec<PortfolioId>
8max_legs_count
u320�Accepts an instruction and claims a signed receipt.,# Arguments|* `id` - Target instruction id.�* `leg_id` - Target leg id for the receipt�* `receipt_uid` - Receipt ID generated by the signer.�* `signer` - Signer of the receipt.�* `signed_data` - Signed receipt.y
* `portfolios` - Portfolios that the sender controls and wants to accept this instruction with4# Permissions,* Portfolio4claim_receipt
id�
4InstructionId
<receipt_details�
�ReceiptDetails<T::AccountId, T::OffChainSignature>	,`Claims a signed receipt.,# Arguments�* `id` - Target instruction id for the receipt.�* `leg_id` - Target leg id for the receipt�* `receipt_uid` - Receipt ID generated by the signer.�* `signer` - Signer of the receipt.�* `signed_data` - Signed receipt.4# Permissions,* Portfolio<unclaim_receipt
8instruction_id�
4InstructionId
leg_id�
LegId
 �Unclaims a previously claimed receipt.,# Arguments�* `instruction_id` - Target instruction id for the receipt.�* `leg_id` - Target leg id for the receipt4# Permissions,* PortfolioLset_venue_filtering
ticker�
Ticker
enabled

bool �Enables or disabled venue filtering for a token.,# Arguments�* `ticker` - Ticker of the token in question.
* `enabled` - Boolean that decides if the filtering should be enabled.4# Permissions* Asset0allow_venues
ticker�
Ticker
venues�
0Vec<VenueId>

Allows additional venues to create instructions involving an asset.�* `ticker` - Ticker of the token in question.}
* `venues` - Array of venues that are allowed to create instructions for the token in question.4# Permissions* Asset<disallow_venues
ticker�
Ticker
venues�
0Vec<VenueId>
i
Revokes permission given to venues for creating instructions involving a particular asset.�* `ticker` - Ticker of the token in question.�
* `venues` - Array of venues that are no longer allowed to create instructions for the token in question.4# Permissions* Asset\change_receipt_validity
,receipt_uid 
u64
 validity

bool�Marks a receipt issued by the caller as claimed or not claimed.�
This allows the receipt issuer to invalidate an already issued receipt or revalidate an already claimed receipt.�* `receipt_uid` - Unique ID of the receipt.�* `validity` - New validity of the receipt.texecute_scheduled_instruction
id�
4InstructionId
,_legs_count
u32�
Root callable extrinsic, used as an internal call to execute a scheduled settlement instruction.Xreschedule_instruction
id�
4InstructionId(�Reschedules a failed instruction.,# Arguments�* `id` - Target instruction id to reschedule.4# Permissions,* Portfolio # Errors=
* `InstructionNotFailed` - Instruction not in a failed state or does not exist.Pupdate_venue_signers
id�
VenueId
signers�
DVec<T::AccountId>
,add_signers

bool\Edit a venue's signers.�* `id` specifies the ID of the venue to edit.�* `signers` specifies the signers to add/remove.�
* `add_signers` specifies the update type add/remove of venue where add is true and remove is false.dadd_instruction_with_memo
 venue_id�
VenueId
<settlement_type�
xSettlementType<T::BlockNumber>
(trade_date�
DOption<T::Moment>
(value_date�
DOption<T::Moment>
legs�
 Vec<Leg>
@instruction_memo�
\Option<InstructionMemo>4�Adds a new instruction with memo.,# Arguments�* `venue_id` - ID of the venue this instruction belongs to.	
* `settlement_type` - Defines if the instruction should be settled]
   in the next block after receiving all affirmations or waiting till a specific block.Q
* `trade_date` - Optional date from which people can interact with this instruction.m
* `value_date` - Optional date after which the instruction should be settled (not enforced)�* `legs` - Legs included in this instruction.�* `memo` - Memo field for this instruction. # Weight�`950_000_000 + 1_000_000 * legs.len()`�add_and_affirm_instruction_with_memo
 venue_id�
VenueId
<settlement_type�
xSettlementType<T::BlockNumber>
(trade_date�
DOption<T::Moment>
(value_date�
DOption<T::Moment>
legs�
 Vec<Leg>
(portfolios�
@Vec<PortfolioId>
@instruction_memo�
\Option<InstructionMemo>8�Adds and affirms a new instruction.,# Arguments�* `venue_id` - ID of the venue this instruction belongs to.	
* `settlement_type` - Defines if the instruction should be settled]
   in the next block after receiving all affirmations or waiting till a specific block.Q
* `trade_date` - Optional date from which people can interact with this instruction.m
* `value_date` - Optional date after which the instruction should be settled (not enforced)�* `legs` - Legs included in this instruction.m
* `portfolios` - Portfolios that the sender controls and wants to use in this affirmations.�* `memo` - Memo field for this instruction.4# Permissions,* Portfoliohexecute_manual_instruction
id�
4InstructionId
(legs_count
u32
$portfolio�
LOption<PortfolioId> lManually execute settlement,# Arguments�* `id` - Target instruction id to reschedule.�* `_legs_count` - Legs included in this instruction. # Errors=
* `InstructionNotFailed` - Instruction not in a failed state or does not exist.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.���Dpallet_settlement8ReceiptDetails$AccountId
DOffChainSignature
�
,receipt_uid 
u64
leg_id�
LegId
signer
$AccountId
$signature�
DOffChainSignature
 metadata�
<ReceiptMetadata�(sp_runtime8MultiSignature
Ed25519!
Hed25519::SignatureSr25519Q
Hsr25519::Signature
Ecdsa�
@ecdsa::Signature�sp_coreecdsa$Signaturee
 [u8; 65]�OptionT
�
NoneSome�
�Dpallet_statisticsCallT
Xset_active_asset_stats
asset�
(AssetScope
(stat_types�
HBTreeSet<StatType><�Set the active asset stat_types.,# Arguments%
- `origin` - a signer that has permissions to act as an agent of `asset`.�- `asset` - the asset to change the active stats on.	
- `stat_types` - the new stat types to replace any existing types. # Errors
- `StatTypeLimitReached` - too many stat types enabled for the `asset`.�
- `CannotRemoveStatTypeInUse` - can not remove a stat type that is in use by transfer conditions.!
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `asset`.4# Permissions- Agent- Asset`batch_update_asset_stats
asset�
(AssetScope
$stat_type�
 StatType
values�
PBTreeSet<StatUpdate>
<�Allow a trusted issuer to init/resync ticker/company stats.,# Arguments%
- `origin` - a signer that has permissions to act as an agent of `asset`.�- `asset` - the asset to change the active stats on.�- `stat_type` - stat type to update.�- `values` - Updated values for `stat_type`. # Errors
- `StatTypeMissing` - `stat_type` is not enabled for the `asset`.!
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `asset`.4# Permissions- Agent- Assettset_asset_transfer_compliance
asset�
(AssetScope
Ltransfer_conditions�
lBTreeSet<TransferCondition><�Set asset transfer compliance rules.,# Arguments%
- `origin` - a signer that has permissions to act as an agent of `asset`.�- `asset` - the asset to change the active stats on.a
- `transfer_conditions` - the new transfer condition to replace any existing conditions. # ErrorsU
- `TransferConditionLimitReached` - too many transfer condititon enabled for `asset`.�
- `StatTypeMissing` - a transfer condition requires a stat type that is not enabled for the `asset`.!
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `asset`.4# Permissions- Agent- AssetLset_entities_exempt
$is_exempt

bool
(exempt_key
hTransferConditionExemptKey
 entities�
DBTreeSet<ScopeId>8
Set/unset entities exempt from an asset's transfer compliance rules.,# ArgumentsQ
- `origin` - a signer that has permissions to act as an agent of `exempt_key.asset`.�- `is_exempt` - enable/disable exemption for `entities`.
- `exempt_key` - the asset and stat type to exempt the `entities` from.�- `entities` - the entities to set/unset the exemption for. # Errors!
- `UnauthorizedAgent` if `origin` is not agent-permissioned for `asset`.4# Permissions- Agent- AssetLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.� BTreeSetT
��� BTreeSetT

�� BTreeSetT
� BTreeSetT
x)

(pallet_stoCallT
Dcreate_fundraiser(
Hoffering_portfolio�
,PortfolioId
8offering_asset�
Ticker
Draising_portfolio�
,PortfolioId
4raising_asset�
Ticker
tiers
8Vec<PriceTier>
 venue_id�
VenueId
start�
DOption<T::Moment>
end�
DOption<T::Moment>
Hminimum_investment
Balance
<fundraiser_name-
8FundraiserName@`Create a new fundraiser.

* `offering_portfolio` - Portfolio containing the `offering_asset`.�* `offering_asset` - Asset being offered.
* `raising_portfolio` - Portfolio containing the `raising_asset`.5
* `raising_asset` - Asset being exchanged for `offering_asset` on investment.�* `tiers` - Price tiers to charge investors on investment.�* `venue_id` - Venue to handle settlement.M
* `start` - Fundraiser start time, if `None` the fundraiser will start immediately.)
* `end` - Fundraiser end time, if `None` the fundraiser will never expire.�
* `minimum_investment` - Minimum amount of `raising_asset` that an investor needs to spend to invest in this raise.�* `fundraiser_name` - Fundraiser name, only used in the UIs.4# Permissions* Asset,* Portfolioinvest
Pinvestment_portfolio�
,PortfolioId
Dfunding_portfolio�
,PortfolioId
8offering_asset�
Ticker
id)
0FundraiserId
<purchase_amount
Balance
$max_price
<Option<Balance>
receipt

�Option<ReceiptDetails<T::AccountId, T::OffChainSignature>>
0\Invest in a fundraiser.A
* `investment_portfolio` - Portfolio that `offering_asset` will be deposited in.

* `funding_portfolio` - Portfolio that will fund the investment.�* `offering_asset` - Asset to invest in.�* `id` - ID of the fundraiser to invest in.�* `purchase_amount` - Amount of `offering_asset` to purchase.�
* `max_price` - Maximum price to pay per unit of `offering_asset`, If `None`there are no constraints on price.i
* `receipt` - Off-chain receipt to use instead of on-chain balance in `funding_portfolio`.4# Permissions,* PortfolioDfreeze_fundraiser
8offering_asset�
Ticker
id)
0FundraiserIdPFreeze a fundraiser.�* `offering_asset` - Asset to freeze.�* `id` - ID of the fundraiser to freeze.4# Permissions* AssetLunfreeze_fundraiser
8offering_asset�
Ticker
id)
0FundraiserIdXUnfreeze a fundraiser.�* `offering_asset` - Asset to unfreeze.�* `id` - ID of the fundraiser to unfreeze.4# Permissions* Asset`modify_fundraiser_window
8offering_asset�
Ticker
id)
0FundraiserId
start 
$T::Moment
end�
DOption<T::Moment>$�Modify the time window a fundraiser is active�* `offering_asset` - Asset to modify.�* `id` - ID of the fundraiser to modify.�* `start` - New start of the fundraiser.�* `end` - New end of the fundraiser to modify.4# Permissions* Assetstop
8offering_asset�
Ticker
id)
0FundraiserIdHStop a fundraiser.�* `offering_asset` - Asset to stop.�* `id` - ID of the fundraiser to stop.4# Permissions* AssetLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.		(pallet_sto$PriceTier
total
Balance
price
Balance
OptionT
�
NoneSome�
<pallet_treasuryCallT
0disbursement
4beneficiaries
xVec<Beneficiary<BalanceOf<T>>>Q
It transfers balances from treasury to each of beneficiaries and the specific amountDfor each of them.# Error�* `BadOrigin`: Only root can execute transaction.]
* `InsufficientBalance`: If treasury balances is not enough to cover all beneficiaries.%
* `InvalidIdentity`: If one of the beneficiaries has an invalid identity.4reimbursement
amount
0BalanceOf<T>

It transfers the specific `amount` from `origin` account into treasury.I
Only accounts which are associated to an identity can make a donation to treasury.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.Lpolymesh_primitives,BeneficiaryBalance

idx
(IdentityId
amount
Balance8pallet_utilityCallT
batch
calls!
`Vec<<T as Config>::Call>H�Dispatch multiple calls from the sender's origin.�This will execute until the first one fails and then stop.�May be called from root or a signed origin.0# Parameters�- `calls`: The calls to be dispatched from the same origin. # Weight�- The sum of the weights of the `calls`.0- One event.�
This will return `Ok` in all circumstances except an unsigned origin. To determine the success of the batch, an1
event is deposited. If a call failed and the batch was interrupted, then theU
`BatchInterrupted` event is deposited, along with the number of successful calls madeM
and the error of the failed call. If all were successful, then the `BatchCompleted`Levent is deposited.0batch_atomic
calls!
`Vec<<T as Config>::Call>
L�Dispatch multiple calls from the sender's origin.
This will execute all calls, in order, stopping at the first failure,�in which case the state changes are rolled back.%
On failure, an event `BatchInterrupted(failure_idx, error)` is deposited.�May be called from root or a signed origin.0# Parameters�- `calls`: The calls to be dispatched from the same origin. # Weight�- The sum of the weights of the `calls`.0- One event.
This will return `Ok` in all circumstances except an unsigned origin.�To determine the success of the batch, an event is deposited.�If any call failed, then `BatchInterrupted` is deposited.
If all were successful, then the `BatchCompleted` event is deposited.@batch_optimistic
calls!
`Vec<<T as Config>::Call>T�Dispatch multiple calls from the sender's origin.

This will execute all calls, in order, irrespective of failures.	
Any failures will be available in a `BatchOptimisticFailed` event.�May be called from root or a signed origin.0# Parameters�- `calls`: The calls to be dispatched from the same origin. # Weight�- The sum of the weights of the `calls`.0- One event.
This will return `Ok` in all circumstances except an unsigned origin.�To determine the success of the batch, an event is deposited.�If any call failed, then `BatchOptimisticFailed` is deposited,�with a vector of event counts for each call as well as a vector(of errors.
If all were successful, then the `BatchCompleted` event is deposited. relay_tx
target
0T::AccountId
$signature�
PT::OffChainSignature
call%
|UniqueCall<<T as Config>::Call>0�Relay a call for a target from an originQ
Relaying in this context refers to the ability of origin to make a call on behalf oftarget.hFees are charged to origin0# Parameters�- `target`: Account to be relayed�- `signature`: Signature from target authorizing the relay�- `call`: Call to be relayed on behalf of targetLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.!�%8pallet_utility(UniqueCallC
�
nonce 
HAuthorizationNonce
call�
Box<C>),pallet_baseCallT
LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.-Xpallet_external_agentsCallT
 0create_group
ticker�
Ticker
perms�
PExtrinsicPermissionsH�Creates a custom agent group (AG) for the given `ticker`.�The AG will have the permissions as given by `perms`.)
This new AG is then assigned `id = AGIdSequence::get() + 1` as its `AGId`,9
which you can use as `AgentGroup::Custom(id)` when adding agents for `ticker`.,# Arguments�- `ticker` to add the custom group for.�- `perms` that the new AG will have. # Errors9
- `UnauthorizedAgent` if `origin` was not authorized as an agent to call this.!
- `TooLong` if `perms` had some string or list length that was too long.%
- `CounterOverflow` if `AGIdSequence::get() + 1` would exceed `u32::MAX`.4# Permissions* Asset* AgentTset_group_permissions
ticker�
Ticker
id

AGId
perms�
PExtrinsicPermissions
<Q
Updates the permissions of the custom AG identified by `id`, for the given `ticker`.,# Arguments�- `ticker` the custom AG belongs to.�- `id` for the custom AG within `ticker`.�- `perms` to update the custom AG to. # Errors9
- `UnauthorizedAgent` if `origin` was not authorized as an agent to call this.!
- `TooLong` if `perms` had some string or list length that was too long.�- `NoSuchAG` if `id` does not identify a custom AG.4# Permissions* Asset* Agent0remove_agent
ticker�
Ticker
agentx
(IdentityId8�Remove the given `agent` from `ticker`.,# Arguments�- `ticker` that has the `agent` to remove.�- `agent` of `ticker` to remove. # Errors9
- `UnauthorizedAgent` if `origin` was not authorized as an agent to call this.�- `NotAnAgent` if `agent` is not an agent of `ticker`.�- `RemovingLastFullAgent` if `agent` is the last full one.4# Permissions* Asset* Agent abdicate
ticker�
Ticker,�Abdicate agentship for `ticker`.,# Arguments�- `ticker` of which the caller is an agent. # Errors�- `NotAnAgent` if the caller is not an agent of `ticker`.�- `RemovingLastFullAgent` if the caller is the last full agent.4# Permissions* Asset0change_group
ticker�
Ticker
agentx
(IdentityId
group

(AgentGroup@�Change the agent group that `agent` belongs to in `ticker`.,# Arguments�- `ticker` that has the `agent`.�- `agent` of `ticker` to change the group for.�- `group` that `agent` will belong to in `ticker`. # Errors9
- `UnauthorizedAgent` if `origin` was not authorized as an agent to call this.�- `NoSuchAG` if `id` does not identify a custom AG.�- `NotAnAgent` if `agent` is not an agent of `ticker`.-
- `RemovingLastFullAgent` if `agent` was a `Full` one and is being demoted.4# Permissions* Asset* AgentLaccept_become_agent
auth_id 
u64@

Accept an authorization by an agent "Alice" who issued `auth_id`�to also become an agent of the ticker Alice specified.,# Arguments�- `auth_id` identifying the authorization to accept. # ErrorsE
- `AuthorizationError::Invalid` if `auth_id` does not exist for the given caller.5
- `AuthorizationError::Expired` if `auth_id` is for an auth that has expired.M
- `AuthorizationError::BadType` if `auth_id` was not for a `BecomeAgent` auth type.%
- `UnauthorizedAgent` if "Alice" is not permissioned to provide the auth.

- `NoSuchAG` if the group referred to a custom that does not exist.

- `AlreadyAnAgent` if the caller is already an agent of the ticker.4# Permissions* Agentdcreate_group_and_add_auth
ticker�
Ticker
perms�
PExtrinsicPermissions
targetx
(IdentityId
expiry�
DOption<T::Moment>�Utility extrinsic to batch `create_group` and  `add_auth`.4# Permissions* Asset* Agentxcreate_and_change_custom_group
ticker�
Ticker
perms�
PExtrinsicPermissions
agentx
(IdentityIdU
Utility extrinsic to batch `create_group` and  `change_group` for custom groups only.4# Permissions* Asset* AgentLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.18pallet_relayerCallT
8set_paying_key
 user_key
0T::AccountId
,polyx_limit
Balance �
Creates an authorization to allow `user_key` to accept the caller (`origin == paying_key`) as their subsidiser.,# Arguments�- `user_key` the user key to subsidise.�- `polyx_limit` the initial POLYX limit for this subsidy. # Errors1
- `UnauthorizedCaller` if `origin` is not authorized to call this extrinsic.Daccept_paying_key
auth_id 
u64
8�Accepts a `paying_key` authorization.,# Arguments�- `auth_id` the authorization id to accept a `paying_key`. # ErrorsE
- `AuthorizationError::Invalid` if `auth_id` does not exist for the given caller.-
- `AuthorizationError::Expired` if `auth_id` the authorization has expired.m
- `AuthorizationError::BadType` if `auth_id` was not a `AddRelayerPayingKey` authorization.�
- `NotAuthorizedForUserKey` if `origin` is not authorized to accept the authorization for the `user_key`.�
- `NotAuthorizedForPayingKey` if the authorization was created an identity different from the `paying_key`'s identity.1
- `UserKeyCddMissing` if the `user_key` is not attached to a CDD'd identity.A
- `PayingKeyCddMissing` if the `paying_key` is not attached to a CDD'd identity.1
- `UnauthorizedCaller` if `origin` is not authorized to call this extrinsic.Dremove_paying_key
 user_key
0T::AccountId
(paying_key
0T::AccountId,�Removes the `paying_key` from a `user_key`.,# Arguments�- `user_key` the user key to remove the subsidy from.	
- `paying_key` the paying key that was subsidising the `user_key`. # Errors�
- `NotAuthorizedForUserKey` if `origin` is not authorized to remove the subsidy for the `user_key`.�- `NoPayingKey` if the `user_key` doesn't have a `paying_key`.1
- `NotPayingKey` if the `paying_key` doesn't match the current `paying_key`.1
- `UnauthorizedCaller` if `origin` is not authorized to call this extrinsic.Hupdate_polyx_limit
 user_key
0T::AccountId
,polyx_limit
Balance(�Updates the available POLYX for a `user_key`.,# Arguments
- `user_key` the user key of the subsidy to update the available POLYX.5
- `polyx_limit` the amount of POLYX available for subsidising the `user_key`. # Errors�- `NoPayingKey` if the `user_key` doesn't have a `paying_key`.
- `NotPayingKey` if `origin` doesn't match the current `paying_key`.1
- `UnauthorizedCaller` if `origin` is not authorized to call this extrinsic.Pincrease_polyx_limit
 user_key
0T::AccountId
amount
Balance,�Increase the available POLYX for a `user_key`.,# Arguments
- `user_key` the user key of the subsidy to update the available POLYX.

- `amount` the amount of POLYX to add to the subsidy of `user_key`. # Errors�- `NoPayingKey` if the `user_key` doesn't have a `paying_key`.
- `NotPayingKey` if `origin` doesn't match the current `paying_key`.1
- `UnauthorizedCaller` if `origin` is not authorized to call this extrinsic.=
- `Overlow` if the subsidy's remaining POLYX would have overflowed `u128::MAX`.Pdecrease_polyx_limit
 user_key
0T::AccountId
amount
Balance,�Decrease the available POLYX for a `user_key`.,# Arguments
- `user_key` the user key of the subsidy to update the available POLYX.!
- `amount` the amount of POLYX to remove from the subsidy of `user_key`. # Errors�- `NoPayingKey` if the `user_key` doesn't have a `paying_key`.
- `NotPayingKey` if `origin` doesn't match the current `paying_key`.1
- `UnauthorizedCaller` if `origin` is not authorized to call this extrinsic.	
- `Overlow` if the subsidy has less then `amount` POLYX remaining.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.58pallet_rewardsCallT
@claim_itn_reward
<_reward_address
0T::AccountId
0_itn_address
0T::AccountId
(_signature�
PT::OffChainSignature4PClaim an ITN reward.0## Arguments�* `itn_address` specifying the awarded address on ITN.�* `signature` authenticating the claim to the reward.u
   The signature should contain `reward_address` followed by the suffix `"claim_itn_reward"`,�   and must have been signed by `itn_address`. # ErrorsE
* `InsufficientBalance` - Itn rewards has insufficient funds to issue the reward.1
* `InvalidSignature` - `signature` had an invalid signer or invalid message.i
* `ItnRewardAlreadyClaimed` - Reward issued to the `itn_address` has already been claimed.�
* `UnknownItnAddress` - `itn_address` is not in the rewards table and has no reward to be claimed.Tset_itn_reward_status
0_itn_address
0T::AccountId
_status9
<ItnRewardStatus
LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.98pallet_rewards<ItnRewardStatus
$Unclaimed
BalanceClaimed
=@pallet_contractspalletCallT
call
destU
�<T::Lookup as StaticLookup>::Source
value�

0BalanceOf<T>
$gas_limit!
Weight
Tstorage_deposit_limitA
�Option<<BalanceOf<T> as codec::HasCompact>::Type>
data(
Vec<u8>@
Makes a call to an account, optionally transferring some balance.0# Parameters�* `dest`: Address of the contract to call.�* `value`: The balance to transfer from the `origin` to `dest`.
* `gas_limit`: The gas limit enforced when executing the constructor.U
* `storage_deposit_limit`: The maximum amount of balance that can be charged from the�  caller to pay for the storage consumed.�* `data`: The input data to pass to the contract.%
* If the account is a smart-contract account, the associated code will be�executed and any value will be transferred.
* If the account is a regular account, any value will be transferred.E
* If no account exists and the call value is not less than `existential_deposit`,
a regular account will be created and any value will be transferred.Tinstantiate_with_code
value�

0BalanceOf<T>
$gas_limit!
Weight
Tstorage_deposit_limitA
�Option<<BalanceOf<T> as codec::HasCompact>::Type>
code(
Vec<u8>
data(
Vec<u8>
salt(
Vec<u8>
h1
Instantiates a new contract from the supplied `code` optionally transferring4some balance.!
This dispatchable has the same effect as calling [`Self::upload_code`] +=
[`Self::instantiate`]. Bundling them together provides efficiency gains. Please�also check the documentation of [`Self::upload_code`].0# ParametersM
* `value`: The balance to transfer from the `origin` to the newly created contract.
* `gas_limit`: The gas limit enforced when executing the constructor.U
* `storage_deposit_limit`: The maximum amount of balance that can be charged/reserved�  from the caller to pay for the storage consumed.�* `code`: The contract code to deploy in raw bytes.�* `data`: The input data to pass to the contract constructor.1
* `salt`: Used for the address derivation. See [`Pallet::contract_address`].�Instantiation is executed as follows:Y
- The supplied `code` is instrumented, deployed, and a `code_hash` is created for that  code.Y
- If the `code_hash` already exists on the chain the underlying `code` will be shared.I
- The destination address is computed based on the sender, code_hash and the salt.

- The smart-contract account is created at the computed address.�- The `value` is transferred to the new account.A
- The `deploy` function is executed in the context of the newly-created account.,instantiate
value�

0BalanceOf<T>
$gas_limit!
Weight
Tstorage_deposit_limitA
�Option<<BalanceOf<T> as codec::HasCompact>::Type>
$code_hash$
,CodeHash<T>
data(
Vec<u8>
salt(
Vec<u8>�Instantiates a contract from a previously deployed wasm binary.5
This function is identical to [`Self::instantiate_with_code`] but without theI
code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binaryDmust be supplied.,upload_code
code(
Vec<u8>
Tstorage_deposit_limitA
�Option<<BalanceOf<T> as codec::HasCompact>::Type>@�Upload new `code` without instantiating a contract from it.!
If the code does not already exist a deposit is reserved from the callerE
and unreserved only when [`Self::remove_code`] is called. The size of the reserve�depends on the instrumented size of the the supplied `code`.1
If the code already exists in storage it will still return `Ok` and upgrades�the in storage version to the current�[`InstructionWeights::version`](InstructionWeights).# NoteY
Anyone can instantiate a contract from any uploaded code and thus prevent its removal.A
To avoid this situation a constructor could employ access control so that it can9
only be instantiated by permissioned entities. The same is true when uploading�through [`Self::instantiate_with_code`].,remove_code
$code_hash$
,CodeHash<T>5
Remove the code stored under `code_hash` and refund the deposit to its owner.E
A code can only be removed by its original uploader (its owner) and only if it isdnot used by any contract.%
Contains one variant per dispatchable that can be called by an extrinsic.AOptionT
�

NoneSome�

EHpolymesh_contractsCallT
linstantiate_with_code_perms
$endowment
Balance
$gas_limit 
Weight
Tstorage_deposit_limit
<Option<Balance>
code(
Vec<u8>
data(
Vec<u8>
salt(
Vec<u8>
perms�
,Permissions`-
Instantiates a smart contract defining it with the given `code` and `salt`.�The contract will be attached as a secondary key,�with `perms` as its permissions, to `origin`'s identity.�The contract is transferred `endowment` amount of POLYX.�This is distinct from the `gas_limit`,
which controls how much gas the deployment code may at most consume.,# Arguments�- `endowment` amount of POLYX to transfer to the contract.U
- `gas_limit` for how much gas the `deploy` code in the contract may at most consume.Q
- `storage_deposit_limit` The maximum amount of balance that can be charged/reserved�  from the caller to pay for the storage consumed.�- `code` with the WASM binary defining the smart contract.�- `data` The input data to pass to the contract constructor.�- `salt` used for contract address derivation.!
   By varying this, the same `code` can be used under the same identity.�- `perms` that the new secondary key will have. # Errorse
- All the errors in `pallet_contracts::Call::instantiate_with_code` can also happen here.�- CDD/Permissions are checked, unlike in `pallet_contracts`.!
- Errors that arise when adding a new secondary key can also occur here.linstantiate_with_hash_perms
$endowment
Balance
$gas_limit 
Weight
Tstorage_deposit_limit
<Option<Balance>
$code_hash$
,CodeHash<T>
data(
Vec<u8>
salt(
Vec<u8>
perms�
,Permissions
l9
Instantiates a smart contract defining using the given `code_hash` and `salt`.|Unlike `instantiate_with_code`,i
this assumes that at least one contract with the same WASM code has already been uploaded.�The contract will be attached as a secondary key,�with `perms` as its permissions, to `origin`'s identity.�The contract is transferred `endowment` amount of POLYX.�This is distinct from the `gas_limit`,
which controls how much gas the deployment code may at most consume.,# Arguments�- `endowment` amount of POLYX to transfer to the contract.U
- `gas_limit` for how much gas the `deploy` code in the contract may at most consume.Q
- `storage_deposit_limit` The maximum amount of balance that can be charged/reserved�  from the caller to pay for the storage consumed.�- `code_hash` of an already uploaded WASM binary.�- `data` The input data to pass to the contract constructor.�- `salt` used for contract address derivation.!
   By varying this, the same `code` can be used under the same identity.�- `perms` that the new secondary key will have. # Errors=
- All the errors in `pallet_contracts::Call::instantiate` can also happen here.�- CDD/Permissions are checked, unlike in `pallet_contracts`.!
- Errors that arise when adding a new secondary key can also occur here.tupdate_call_runtime_whitelist
updatesI
`Vec<(ExtrinsicId, bool)>tUpdate CallRuntime whitelist.,# Arguments # ErrorsLDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.IMMQ
QHpolymesh_contracts<chain_extension,ExtrinsicId
u8
u8U<pallet_preimagepalletCallT
4note_preimage
bytes(
Vec<u8>tRegister a preimage on-chain.U
If the preimage was previously requested, no fees or deposits are taken for providingU
the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.<unnote_preimage
hash$
T::Hash
�Clear an unrequested preimage from the runtime storage.@request_preimage
hash$
T::HashA
Request a preimage be uploaded to the chain without paying any fees or deposits.U
If the preimage requests has already been provided on-chain, we unreserve any deposit9
a user may have paid, and take the control of the preimage out of their hands.Hunrequest_preimage
hash$
T::Hash�Clear a previously made request for a preimage.-
NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.%
Contains one variant per dispatchable that can be called by an extrinsic.YDpallet_test_utilsCallT
0register_did
uidy
,InvestorUid
8secondary_keys�
|Vec<SecondaryKey<T::AccountId>>(M
Generates a new `IdentityID` for the caller, and issues a self-generated CDD claim.�The caller account will be the primary key of that identity.]
For each account of `secondary_keys`, a new `JoinIdentity` authorization is created, soA
each of them will need to accept it before become part of this new `IdentityID`. # Errors�
- `AlreadyLinked` if the caller account or if any of the given `secondary_keys` has already linked to an `IdentityID`M
- `SecondaryKeysContainPrimaryKey` if `secondary_keys` contains the caller account.�- `DidAlreadyExists` if auto-generated DID already exists.Tmock_cdd_register_did
8target_account
0T::AccountId
0=
Registers a new Identity for the `target_account` and issues a CDD claim to it.Q
The Investor UID is generated deterministically by the hash of the generated DID and�then we fix it to be compliant with UUID v4.# See�- [RFC 4122: UUID](https://tools.ietf.org/html/rfc4122)$# FailureI
- `origin` has to be an active CDD provider. Inactive CDD providers cannot add newclaims.]
- `target_account` (primary key of the new Identity) can be linked to just one and only4one identity.(get_my_did�Emits an event with caller's identity.(get_cdd_of
of
0T::AccountId�Emits an event with caller's identity and CDD status.LDispatchable calls.U
Each variant of this enum maps to a dispatchable function from the associated module.]@pallet_committee4PolymeshVotes,BlockNumber

index
4ProposalIndex
ayes)

<Vec<IdentityId>
nays)

<Vec<IdentityId>
expiry=

\MaybeBlock<BlockNumber>a@pallet_committeeVersion
u8e@pallet_committeeErrorTI
$4DuplicateVote�Duplicate votes are not allowed.(NotAMember
�A DID isn't part of the committee.�The DID may either be a caller or some other context.8NoSuchProposalDNo such proposal.<ProposalExpired�Proposal exists, but it has expired.DDuplicateProposalLDuplicate proposal.TMismatchedVotingIndex`Mismatched voting index.DInvalidProportion�Proportion must be a rational number.<FirstVoteReject�First vote on a proposal creates it, so it must be an approval.

All proposals are motions to execute something as "GC majority".�To reject e.g., a PIP, a motion to reject should be *approved*.TProposalsLimitReached�Maximum number of proposals has been reached.i0pallet_groupErrorTI
TOnlyPrimaryKeyAllowed�Only primary key of the identity is allowed.<DuplicateMember
|Group member was added already.0NoSuchMember�Can't remove a member that doesn't exist.PLastMemberCannotQuit�Last member of the committee can not quit.XMissingCurrentIdentityLMissing current DIDhActiveMembersLimitExceeded]
The limit for the number of concurrent active members for this group has been exceeded.hActiveMembersLimitOverflow
Active member limit was greater than maximum committee members limit.m@pallet_committeeErrorTI
$4DuplicateVote�Duplicate votes are not allowed.(NotAMember
�A DID isn't part of the committee.�The DID may either be a caller or some other context.8NoSuchProposalDNo such proposal.<ProposalExpired�Proposal exists, but it has expired.DDuplicateProposalLDuplicate proposal.TMismatchedVotingIndex`Mismatched voting index.DInvalidProportion�Proportion must be a rational number.<FirstVoteReject�First vote on a proposal creates it, so it must be an approval.

All proposals are motions to execute something as "GC majority".�To reject e.g., a PIP, a motion to reject should be *approved*.TProposalsLimitReached�Maximum number of proposals has been reached.q0pallet_groupErrorTI
TOnlyPrimaryKeyAllowed�Only primary key of the identity is allowed.<DuplicateMember
|Group member was added already.0NoSuchMember�Can't remove a member that doesn't exist.PLastMemberCannotQuit�Last member of the committee can not quit.XMissingCurrentIdentityLMissing current DIDhActiveMembersLimitExceeded]
The limit for the number of concurrent active members for this group has been exceeded.hActiveMembersLimitOverflow
Active member limit was greater than maximum committee members limit.u@pallet_committeeErrorTI
$4DuplicateVote�Duplicate votes are not allowed.(NotAMember
�A DID isn't part of the committee.�The DID may either be a caller or some other context.8NoSuchProposalDNo such proposal.<ProposalExpired�Proposal exists, but it has expired.DDuplicateProposalLDuplicate proposal.TMismatchedVotingIndex`Mismatched voting index.DInvalidProportion�Proportion must be a rational number.<FirstVoteReject�First vote on a proposal creates it, so it must be an approval.

All proposals are motions to execute something as "GC majority".�To reject e.g., a PIP, a motion to reject should be *approved*.TProposalsLimitReached�Maximum number of proposals has been reached.y0pallet_groupErrorTI
TOnlyPrimaryKeyAllowed�Only primary key of the identity is allowed.<DuplicateMember
|Group member was added already.0NoSuchMember�Can't remove a member that doesn't exist.PLastMemberCannotQuit�Last member of the committee can not quit.XMissingCurrentIdentityLMissing current DIDhActiveMembersLimitExceeded]
The limit for the number of concurrent active members for this group has been exceeded.hActiveMembersLimitOverflow
Active member limit was greater than maximum committee members limit.}q
� ���q
 �<pallet_multisig<ProposalDetailsT
 
$approvals 
u64
(rejections 
u64
status�
8ProposalStatus
expiry�
$Option<T>
(auto_close

bool�<pallet_multisig8ProposalStatus
Invalid<ActiveOrExpired
LExecutionSuccessful<ExecutionFailed Rejected�<pallet_multisigVersion
u8�<pallet_multisigErrorT
d(CddMissing�The multisig is not attached to a CDD'd identity.<ProposalMissing
pThe proposal does not exist.4DecodingErrorDMultisig address.$NoSigners,No signers.tRequiredSignaturesOutOfBounds�Too few or too many required signatures.(NotASigner4Not a signer.8NoSuchMultisigDNo such multisig.@NotEnoughSignersLNot enough signers.4NonceOverflowDA nonce overflow.0AlreadyVoted	8Already voted.8AlreadyASigner
DAlready a signer.DFailedToChargeFee�Couldn't charge fee for the transaction.HIdentityNotCreator�Identity provided is not the multisig's creator.@ChangeNotAllowed
%
Changing multisig parameters not allowed since multisig is a primary key.tSignerAlreadyLinkedToMultisig
Signer is an account key that is already associated with a multisig.tSignerAlreadyLinkedToIdentity
Signer is an account key that is already associated with an identity.�MultisigNotAllowedToLinkToItself�Multisig not allowed to add itself as a signer.XMissingCurrentIdentityXCurrent DID is missing4NotPrimaryKey�The function can only be called by the primary key of the did\ProposalAlreadyRejectedtProposal was rejected earlier<ProposalExpiredPProposal has expired\ProposalAlreadyExecutedtProposal was executed earlier\MultisigMissingIdentity�Multisig is not attached to an identity@FailedToSchedulexScheduling of a proposal fails8TooManySignerslMore signers than required.\Multisig module errors.��4pallet_bridge8BridgeTxDetail,BlockNumber

amount
Balance
status�
8BridgeTxStatus
<execution_block
,BlockNumber
tx_hash$
H256�4pallet_bridge8BridgeTxStatus
AbsentPending
u8
Frozen(TimelockedHandled��4pallet_bridgeVersion
u8�4pallet_bridgeErrorT
4@ControllerNotSet�The bridge controller address is not set.$BadCaller
�The origin is not the controller or the admin address. BadAdmin�The origin is not the admin address.(NoValidCdd�The recipient DID has no valid CDD.XProposalAlreadyHandled9
The bridge transaction proposal has already been handled and the funds minted.0Unauthorized�Unauthorized to perform an operation.FrozentThe bridge is already frozen.$NotFrozendThe bridge is not frozen. FrozenTxhThe transaction is frozen.HBridgeLimitReached	�The identity's minted total has reached the bridge limit. Overflow
�The identity's minted total has overflowed.8DivisionByZero�The block interval duration is zero. Cannot divide.0TimelockedTxxThe transaction is timelocked.�8pallet_staking4StakingLedger$AccountId
Balance

stash
$AccountId
total�

Balance
active�

Balance
$unlocking�
dVec<UnlockChunk<Balance>>
<claimed_rewardsI
4Vec<EraIndex>���8pallet_staking,UnlockChunkBalance

value�

Balance
era�
 EraIndex�8pallet_staking,Nominations$AccountId

targets�
8Vec<AccountId>
0submitted_in
 EraIndex
(suppressed

bool�8pallet_staking4ActiveEraInfo
index
 EraIndex
start�
,Option<u64>��8pallet_staking<EraRewardPoints$AccountId

total
,RewardPoint
(individual�
�BTreeMap<AccountId, RewardPoint>� BTreeMapK
V
����8pallet_stakingForcing
(NotForcing ForceNew
$ForceNone,ForceAlways���8pallet_staking8UnappliedSlash$AccountId
Balance

$validator
$AccountId
own
Balance
others�
dVec<(AccountId, Balance)>
$reporters�
8Vec<AccountId>
payout
Balance�����
�8pallet_staking slashing4SlashingSpans
(span_index
$SpanIndex
(last_start
 EraIndex
Hlast_nonzero_slash
 EraIndex
priorI
4Vec<EraIndex>�8pallet_staking slashing(SpanRecordBalance

slashed
Balance
 paid_out
Balance���

	8pallet_staking8ElectionResult$AccountId
Balance

<elected_stashes�
8Vec<AccountId>
$exposures�

�Vec<(AccountId, Exposure<AccountId, Balance>)>
compute�

<ElectionCompute	8pallet_staking8ElectionStatus,BlockNumber

ClosedOpen
,BlockNumber
		8pallet_stakingdPermissionedIdentityPrefs
8intended_count
u32
4running_count
u32
	8pallet_staking Releases
 4V1_0_0AncientV2_0_0
V3_0_0V4_0_0V5_0_0V6_0_0V6_0_1V7_0_0	8pallet_stakingVersion
u8	8pallet_stakingErrorT
�4NotControllerdNot a controller account. NotStash
PNot a stash account.4AlreadyBonded`Stash is already bonded.4AlreadyPairedtController is already paired.0EmptyTargets`Targets cannot be empty.DInvalidSlashIndex�Slash record index out of bounds.DInsufficientValue�Can not bond with value less than minimum balance.0NoMoreChunks�Can not schedule more unlock chunks.4NoUnlockChunk�Can not rebond without unlocking chunks.0FundedTarget	�Attempting to target a stash that still has funds.HInvalidEraToReward
XInvalid era to reward.HNotSortedAndUnique�Items are not sorted and unique.8AlreadyClaimed	
Rewards for this era have already been claimed for this validator.|OffchainElectionEarlySubmission
�The submitted result is received out of the open window.xOffchainElectionWeakSubmission�The submitted result is not as good as the one stored on chain.LSnapshotUnavailable�The snapshot data of the current window is missing.�OffchainElectionBogusWinnerCount�Incorrect number of winners were presented.lOffchainElectionBogusWinner]
One of the submitted winners is not an active candidate on chain (index is out of range4in snapshot).pOffchainElectionBogusCompactY
Error while building the assignment type from the compact. This can happen if an index�is invalid, or if the weights _overflow_.xOffchainElectionBogusNominator
One of the submitted nominators is not an active nominator on chain.|OffchainElectionBogusNominationI
One of the submitted nominators has an edge to which they have not voted on chain.�OffchainElectionSlashedNomination]
One of the submitted nominators has an edge which is submitted before the last non-zeroPslash of the target.tOffchainElectionBogusSelfVote!
A self vote must only be originated from a validator to ONLY themselves.dOffchainElectionBogusEdgeA
The submitted result has unknown edges that are not among the presented winners.hOffchainElectionBogusScore
The claimed score does not match with the one computed from the data.�OffchainElectionBogusElectionSizetThe election size is invalid.8CallNotAllowedE
The call is not allowed at the given time due to restrictions of election period.XIncorrectSlashingSpans�Incorrect number of slashing spans provided.4AlreadyExists�Permissioned validator already exists.$NotExists�Permissioned validator not exists. NoChange`Updates with same value.`InvalidValidatorIdentity�Given potential validator identity is invalid.hInvalidValidatorCommission �Validator prefs are not in valid range.dStashIdentityDoesNotExist!�Validator or nominator stash identity does not exist.pStashIdentityNotPermissioned"�Validator stash identity was not permissioned.TStashIdentityNotCDDed#xNominator stash was not CDDed.dHitIntendedValidatorCount$�Running validator count hit the intended count.�IntendedCountIsExceedingConsensusLimit%5
When the intended number of validators to run is >= 2/3 of `validator_count`.0BondTooSmall&�When the amount to be bonded is less than `MinimumBond` BadState'9
Internal state has become somehow corrupted and the operation cannot continue.8TooManyTargets(�Too many nomination targets supplied.$BadTarget)=
A nomination target was supplied that was blocked or otherwise not a validator.pInvalidValidatorUnbondAmount*�Validator should have minimum 50k POLYX bonded.tError for the staking module.	(sp_stakingoffence8OffenceDetails Reporter
 Offender
�

 offender�

 Offender
$reporters�
4Vec<Reporter>	�
(!	%	%	
)	-	(-	sp_corecrypto$KeyTypeId8
[u8; 4]1	8pallet_sessionpalletErrorT
0InvalidProof`Invalid ownership proof.\NoAssociatedValidatorId
�No associated validator ID for account.4DuplicatedKeydRegistered duplicate key.NoKeys�No keys are associated with this account.$NoAccount
Key setting account is not live, so it's impossible to associate keys.tError for the session pallet.5	8pallet_grandpa,StoredStateN

Live0PendingPause
0scheduled_at
N
delay
N
Paused4PendingResume
0scheduled_at
N
delay
N9	8pallet_grandpaLStoredPendingChangeN
Limit
0scheduled_at
N
delay
N
@next_authorities=	
lBoundedAuthorityList<Limit>
forced!
$Option<N>=	4frame_supportstorage@weak_bounded_vec8WeakBoundedVecT
�
S�

Vec<T>A	8pallet_grandpapalletErrorT
,PauseFailed
Attempt to signal GRANDPA pause when the authority set isn't live�(either paused or already pending pause).0ResumeFailed

Attempt to signal GRANDPA resume when the authority set isn't paused�(either live or already pending resume).4ChangePending�Attempt to signal GRANDPA change with one already pending.TooSoon�Cannot signal forced change so soon after last.`InvalidKeyOwnershipProof1
A key ownership proof provided as part of an equivocation report is invalid.`InvalidEquivocationProof1
An equivocation proof provided as part of an equivocation report is invalid.XDuplicateOffenceReport
A given equivocation report is valid but already previously reported.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
			E	4frame_supportstorage@weak_bounded_vec8WeakBoundedVecT
�
SI	
Vec<T>I	�
M	4frame_supporttraitsmisc4WrapperOpaqueT
Q	�Q	
TQ	@pallet_im_onlinedBoundedOpaqueNetworkStateLPeerIdEncodingLimitXMultiAddrEncodingLimit8AddressesLimit
peer_idU	
�WeakBoundedVec<u8, PeerIdEncodingLimit>
Hexternal_addressesY	
-
WeakBoundedVec<WeakBoundedVec<u8, MultiAddrEncodingLimit>, AddressesLimit
>U	4frame_supportstorage@weak_bounded_vec8WeakBoundedVecT
S(
Vec<T>Y	4frame_supportstorage@weak_bounded_vec8WeakBoundedVecT
U	S]	
Vec<T>]	U	a	@pallet_im_onlinepalletErrorT
(InvalidKey`Non existent public key.LDuplicatedHeartbeat
TDuplicated heartbeat.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
			e	4frame_supportstorage,bounded_vec(BoundedVecT
$S�
Vec<T>i	,pallet_sudoErrorT
,RequireSudo|Sender must be the Sudo accountdError for the Sudo modulem	0pallet_assetHTickerRegistrationU
 
ownerx
(IdentityId
expiry�
$Option<U>q	0pallet_asset4SecurityToken
0total_supply
Balance
$owner_didx
(IdentityId
$divisible

bool
(asset_type�

$AssetTypeu	�xy	��
}	x��	0pallet_assetXAssetOwnershipRelation
 NotOwned,TickerOwned
(AssetOwned�	�	�	0pallet_assetdClassicTickerRegistration
$eth_owner9
<EthereumAddress
(is_created

bool�	xx�	�q�	�M�	�Q�	0pallet_assetVersion
u8�	0pallet_assetErrorT
�0UnauthorizedlThe user is not authorized.LAssetAlreadyCreated
�The token has already been created.4TickerTooLong�The ticker length is over the limit.8TickerNotAscii�The ticker has non-ascii-encoded parts.\TickerAlreadyRegistered�The ticker is already registered to someone else.TTotalSupplyAboveLimit�The total supply is above the limit.,NoSuchAsset8No such token.4AlreadyFrozenpThe token is already frozen.(NotAnOwner�Not an owner of the token on Ethereum.<BalanceOverflow	�An overflow while calculating the balance.LTotalSupplyOverflow
�An overflow while calculating the total supply.HInvalidGranularity\An invalid granularity.$NotFrozendThe asset must be frozen.<InvalidTransfer
�Transfer validation check failed.LInsufficientBalance�The sender balance is not sufficient.TAssetAlreadyDivisible|The token is already divisible.`InvalidEthereumSignature�An invalid Ethereum `EcdsaSignature`.LNoSuchClassicTicker�The given ticker is not a classic one.dTickerRegistrationExpired�Registration of ticker has expired.PSenderSameAsReceiver�Transfers to self are not allowed$NoSuchDoc�The given Document does not exist.pMaxLengthOfAssetNameExceeded�Maximum length of asset name has been exceeded.�FundingRoundNameMaxLengthExceeded�Maximum length of the funding round name has been exceeded.XInvalidAssetIdentifier�Some `AssetIdentifier` was invalid.�InvestorUniquenessClaimNotAllowed�Investor Uniqueness claims are not allowed for this asset.`InvalidCustomAssetTypeIdpInvalid `CustomAssetTypeId`.�AssetMetadataNameMaxLengthExceeded
Maximum length of the asset metadata type name has been exceeded.�AssetMetadataValueMaxLengthExceeded�Maximum length of the asset metadata value has been exceeded.�AssetMetadataTypeDefMaxLengthExceeded
Maximum length of the asset metadata type definition has been exceeded.dAssetMetadataKeyIsMissingxAsset Metadata key is missing.hAssetMetadataValueIsLocked|Asset Metadata value is locked.�AssetMetadataLocalKeyAlreadyExists�Asset Metadata Local type already exists for asset.�AssetMetadataGlobalKeyAlreadyExists �Asset Metadata Global type already exists.\TickerFirstByteNotValid!�Tickers should start with at least one valid byte.�	yx�	`pallet_corporate_actions0distributionVersion
u8�	`pallet_corporate_actions0distributionErrorT
<0CANotBenefit�A capital distribution was made for a non-benefit CA.4AlreadyExists
�A distribution already exists for this CA.LExpiryBeforePayment)
A distributions provided expiry date was strictly before its payment date.!
In other words, everything to distribute would immediately be forfeited.DHolderAlreadyPaid�The token holder has already been paid their benefit.HNoSuchDistribution�A capital distribution doesn't exist for this CA.XCannotClaimBeforeStarta
Distribution allotment cannot be claimed as the current time is before start-of-payment.XCannotClaimAfterExpiryi
Distribution's expiry has passed. DID cannot claim anymore and has forfeited the benefits.�BalancePerShareProductOverflowed)
Multiplication of the balance with the per share payout amount overflowed.XNotDistributionCreator�DID is not the one who created the distribution.@AlreadyReclaimed	�DID who created the distribution already did reclaim.(NotExpired
�Distribution had not expired yet, or there's no expiry date.LDistributionStarted

A distribution has been activated, as `payment_at <= now` holds.lInsufficientRemainingAmount-
A distribution has insufficient remaining amount of currency to distribute.`DistributionAmountIsZero
�Distribution `amount` cannot be zero.hDistributionPerShareIsZero�Distribution `per_share` cannot be zero.�	���	�	x�	��	��	���	0pallet_asset(checkpointVersion
u8�	0pallet_asset(checkpointErrorT
8NoSuchSchedule�A checkpoint schedule does not exist for the asset.PScheduleNotRemovable

A checkpoint schedule is not removable as `ref_count(schedule_id) > 0`.tFailedToComputeNextCheckpoint�Failed to compute the next checkpoint.�The schedule does not have any upcoming checkpoints.`ScheduleDurationTooShort�The duration of a schedule period is too short.LSchedulesTooComplex�The set of schedules taken together are too complex.�For example, they are too many, or they occurs too frequently.�	Lpolymesh_primitivesHcompliance_manager<AssetCompliance
paused

bool
0requirements�
hVec<ComplianceRequirement>�	dpallet_compliance_managerVersion
u8�	dpallet_compliance_managerErrorT
0Unauthorized\User is not authorized.,DidNotExist
4Did not existxInvalidComplianceRequirementId�Compliance requirement id doesn't exist�IncorrectOperationOnTrustedIssuer�Issuer exist but trying to add it again|DuplicateComplianceRequirements�There are duplicate compliance requirements.|ComplianceRequirementTooComplex
The worst case scenario of the compliance requirement is too complex�	�}�	`pallet_corporate_actionsVersion
u8�	`pallet_corporate_actionsErrorT
0HAuthNotCAATransfer
The authorization type is not to transfer the CAA to another DID.8DetailsTooLong
�The `details` of a CA exceeded the max allowed length.<DuplicateDidTax!
A withholding tax override for a given DID was specified more than once.
The chain refused to make a choice, and hence there was an error.<TooManyDidTaxes�Too many withholding tax overrides were specified.@TooManyTargetIds�Too many identities in `TargetIdentities` were specified.HNoSuchCheckpointId
On CA creation, a checkpoint ID was provided which doesn't exist. NoSuchCA�A CA with the given `CAId` did not exist.0NoRecordDate�The CA did not have a record date.PRecordDateAfterStart�A CA's record date was strictly after the "start" time,�where "start" is context dependent.�
For example, it could be the start of a ballot, or the start-of-payment in capital distribution.\DeclDateAfterRecordDate	�A CA's declaration date was strictly after its record date.@DeclDateInFuture
�A CA's declaration date occurs in the future.<NotTargetedByCAlCA does not target the DID.�	�	`pallet_corporate_actionsballotErrorT
8,CANotNotice�A corporate ballot was made for a non `IssuerNotice` CA.4AlreadyExists
�A corporate ballot already exists for this CA.0NoSuchBallot�A corporate ballot doesn't exist for this CA.4StartAfterEnd
A corporate ballot's start time was strictly after the ballot's end.,NowAfterEnd

A corporate ballot's end time was strictly before the current time.\NumberOfChoicesOverflow9
If some motion in a corporate ballot has more choices than would fit in `u16`.PVotingAlreadyStarted

Voting started already. Amending a ballot is no longer possible.@VotingNotStartedhVoting hasn't started yet.HVotingAlreadyEndedTVoting ended already.8WrongVoteCount	
Provided list of balances does not match the total number of choices.DInsufficientVotes
=
Voting power used by a DID on a motion exceeds that which is available to them.DNoSuchRCVFallback�The RCV fallback of some choice does not exist.0RCVSelfCycle�The RCV fallback points to the origin choice.4RCVNotAllowed
�RCV is not allowed for this ballot.�	Hpallet_permissionsErrorT
HUnauthorizedCaller�The caller is not authorized to call the current extrinsic.�	,pallet_pips0PipsMetadata,BlockNumber

idU
PipId
urlY
,Option<Url>
,descriptionY
XOption<PipDescription>
(created_at
,BlockNumber
Ltransaction_version
u32
expiry=

\MaybeBlock<BlockNumber>�	U�	,pallet_pips,DepositInfo$AccountId

owner
$AccountId
amount
Balance�	,pallet_pipsPip Proposal
�$AccountId

idU
PipId
 proposal�
 Proposal
 proposerM
LProposer<AccountId>

,pallet_pips0VotingResult
(ayes_count
u32
(ayes_stake
Balance
(nays_count
u32
(nays_stake
Balance
,pallet_pipsVote

bool
Balance	
,pallet_pips@SnapshotMetadata,BlockNumber
$AccountId

(created_at
,BlockNumber
made_by
$AccountId
idi
(SnapshotId
,pallet_pipsVersion
u8
,pallet_pipsErrorT
H�RescheduleNotByReleaseCoordinator1
Only the GC release coordinator is allowed to reschedule proposal execution.@NotFromCommunity
�The given dispatchable call is not valid for this proposal.�The proposal must be from the community, but isn't.8NotByCommittee�The given dispatchable call is not valid for this proposal.�The proposal must be by community, but isn't.DTooManyActivePips)
The current number of active (pending | scheduled) PIPs exceed the maximum�and the proposal is not by a committee.@IncorrectDeposit�Proposer specifies an incorrect depositLInsufficientDeposit�Proposer can't afford to lock minimum deposit8NoSuchProposalpThe proposal does not exist.LNotACommitteeMember�Not part of governance committee.`InvalidFutureBlockNumber�When a block number is less than current block number.TNumberOfVotesExceeded	|When number of votes overflows.hStakeAmountOfVotesExceeded
�When stake amount of a vote overflows.XMissingCurrentIdentityLMissing current DIDXIncorrectProposalState�Proposal is not in the correct state4CannotSkipPip
�When enacting snapshot results, an unskippable PIP was skipped.XSnapshotResultTooLarge
Tried to enact results for the snapshot queue overflowing its length.HSnapshotIdMismatch]
Tried to enact result for PIP with id different from that at the position in the queue.pScheduledProposalDoesntExist�Execution of a scheduled proposal failed because it is missing.lProposalNotInScheduledState�A proposal that is not in a scheduled state cannot be executed.
x�
x�
Ԝ!
x�%
@pallet_portfolioVersion
u8)
@pallet_portfolioErrorT
(TPortfolioDoesNotExistpThe portfolio doesn't exist.pInsufficientPortfolioBalance
�Insufficient balance for a transaction.hDestinationIsSamePortfolio�The source and destination portfolios should be different.dPortfolioNameAlreadyInUse1
The portfolio couldn't be renamed because the chosen name is already in use.�SecondaryKeyNotAuthorizedForPortfolio�The secondary key is not authorized to access the portfolio(s).TUnauthorizedCustodian�The porfolio's custody is with someone other than the caller.`InsufficientTokensLocked�Can not unlock more tokens than what are lockedDPortfolioNotEmpty�The portfolio still has some asset balance leftlDifferentIdentityPortfolios�The portfolios belong to different identities`NoDuplicateAssetsAllowed	�Duplicate asset among the items.-
Lpallet_protocol_feeErrorT
hInsufficientAccountBalance�Insufficient account balance to pay the fee.LUnHandledImbalances
�Not able to handled the imbalanceshInsufficientSubsidyBalance�Insufficient subsidy balance to pay the fee.1
5
5
OptionT
9

NoneSome9

9
@pallet_scheduler,ScheduledV3Call
�,BlockNumber
4PalletsOrigin
=
$AccountId

 maybe_idi
<Option<Vec<u8>>
 priority
Hschedule::Priority
call�
Call
8maybe_periodic�
�Option<schedule::Period<BlockNumber>>
origin=

4PalletsOrigin=
`polymesh_runtime_developruntime0OriginCaller
systemA

tframe_system::Origin<Runtime>DPolymeshCommitteeE

�pallet_committee::Origin<Runtime, pallet_committee::Instance1>	HTechnicalCommitteeI

�pallet_committee::Origin<Runtime, pallet_committee::Instance3>@UpgradeCommitteeM

�pallet_committee::Origin<Runtime, pallet_committee::Instance4>
VoidQ


self::sp_api_hidden_includes_construct_runtime::hidden_include::VoidA
4frame_support dispatch$RawOrigin$AccountId

RootSigned
$AccountId
NoneE
@pallet_committee$RawOrigin$AccountId
I
1

 EndorsedI
@pallet_committee$RawOrigin$AccountId
I
M

 EndorsedM
@pallet_committee$RawOrigin$AccountId
I
]

 EndorsedQ
sp_coreVoid
U
@pallet_schedulerpalletErrorT
@FailedToScheduledFailed to schedule a call NotFound
|Cannot find the scheduled call.\TargetBlockNumberInPast�Given target block number is in the past.HRescheduleNoChange�Reschedule failed because it does not change scheduled time.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
			Y
Dpallet_settlementVenue
creatorx
(IdentityId
(venue_type�
$VenueType]
��a
�e
Dpallet_settlement,InstructionMoment
 ,BlockNumber

8instruction_id�
4InstructionId
 venue_id�
VenueId
statusi

DInstructionStatus
<settlement_type�
lSettlementType<BlockNumber>
(created_at�
8Option<Moment>
(trade_date�
8Option<Moment>
(value_date�
8Option<Moment>i
Dpallet_settlementDInstructionStatus
UnknownPending
Failedm
��q
Dpallet_settlement$LegStatus$AccountId

@PendingTokenLock@ExecutionPending
PExecutionToBeSkipped
$AccountId 
u64u
��y
Dpallet_settlementDAffirmationStatus
UnknownPending
 Affirmed}
Խ�
���
Dpallet_settlementVersion
u8�
Dpallet_settlementErrorT
x0InvalidVenueTVenue does not exist.0Unauthorized
�Sender does not have required permissions.<NoPendingAffirm�No pending affirmation for the provided instruction.XInstructionNotAffirmed�Instruction has not been affirmed.TInstructionNotPending�Provided instruction is not pending execution.PInstructionNotFailed�Provided instruction is not failing execution.4LegNotPending�Provided leg is not pending execution.HUnauthorizedSigner�Signer is not authorized by the venue.TReceiptAlreadyClaimedTReceipt already used.DReceiptNotClaimed	TReceipt not used yet.DUnauthorizedVenue
�Venue does not have required permissions.HFailedToLockTokens!
While affirming the transfer, system failed to lock the assets involved.DInstructionFailedxInstruction failed to execute.\InstructionDatesInvalid
tInstruction has invalid datespInstructionSettleBlockPassed�Instruction's target settle block reached.@InvalidSignaturexOffchain signature is invalid.HSameSenderReceiver�Sender and receiver are the same.DPortfolioMismatch%
Portfolio in receipt does not match with portfolios provided by the user.DSettleOnPastBlocka
The provided settlement block number is in the past and cannot be used by the scheduler.LNoPortfolioProvided=
Portfolio based actions require at least one portfolio to be provided as input.lUnexpectedAffirmationStatusE
The current instruction affirmation status does not support the requested action.@FailedToSchedule�Scheduling of an instruction fails.@LegCountTooSmall�
Legs count should matches with the total number of legs in which given portfolio act as `from_portfolio`.HUnknownInstructiontInstruction status is unknowndInstructionHasTooManyLegs�Maximum legs that can be in a single instruction.LSignerAlreadyExists�Signer is already added to venue.HSignerDoesNotExisttSigner is not added to venue.(ZeroAmount�Instruction leg amount can't be zero�InstructionSettleBlockNotReached�Instruction settlement block has not yet been reached.DCallerIsNotAParty�The caller is not a party of this instruction.�Errors for the Settlement module.�
�
�
Lpolymesh_primitives(statistics(Stat1stKey
asset�
(AssetScope
$stat_type�
 StatType�
Lpolymesh_primitivesLtransfer_compliance\AssetTransferCompliance
paused

bool
0requirements�
lBTreeSet<TransferCondition>�
x�
Dpallet_statisticsVersion
u8�
Dpallet_statisticsErrorT
<InvalidTransferTTransfer not allowed.<StatTypeMissing
`StatType is not enabled.�StatTypeNeededByTransferCondition�StatType is needed by TransferCondition.dCannotRemoveStatTypeInUse�A Stattype is in use and can't be removed.PStatTypeLimitReached�The limit of StatTypes allowed for an asset has been reached.tTransferConditionLimitReached
The limit of TransferConditions allowed for an asset has been reached.dStatistics module errors.�
�)�
(pallet_stoErrorT
00Unauthorized�Sender does not have required permissions. Overflow
�An arithmetic operation overflowed.lInsufficientTokensRemaining�Not enough tokens left for sale.HFundraiserNotFoundTFundraiser not found.DFundraiserNotLive�Fundraiser is either frozen or stopped.@FundraiserClosed�Fundraiser has been closed/stopped already.DFundraiserExpired�Interacting with a fundraiser past the end `Moment`.0InvalidVenuehAn invalid venue provided.DInvalidPriceTiers%
An individual price tier was invalid or a set of price tiers was invalid.TInvalidOfferingWindow	]
Window (start time, end time) has invalid parameters, e.g start time is after end time.@MaxPriceExceeded
�Price of the investment exceeded the max price.XInvestmentAmountTooLow�Investment amount is lower than minimum investment amount.�Errors for the Settlement module.�
<pallet_treasuryErrorT
LInsufficientBalancexProposer's balance is too low.<InvalidIdentity
�Invalid identity for disbursement.xError for the treasury module.�
8pallet_utilityErrorT
@InvalidSignaturetOffchain signature is invalid@TargetCddMissing
�Target does not have a valid CDD0InvalidNoncehProvided nonce was invalid
If the provided nonce < current nonce, the call was already executed]
If the provided nonce > current nonce, the call(s) before the current failed to execute�
,pallet_baseErrorT
TooLong�Exceeded a generic length limit.
The limit could be for any sort of lists of things, including a string.<CounterOverflow
�The sequence counter for something overflowed.
When this happens depends on e.g., the capacity of the identifier type.9
For example, we might have `pub struct PipId(u32);`, with `u32::MAX` capacity.Y
In practice, these errors will never happen but no code path should result in a panic,�so these corner cases need to be covered with an error variant.�
�
�
Xpallet_external_agentsErrorT
 NoSuchAG�An AG with the given `AGId` did not exist for the `Ticker`.DUnauthorizedAgent
�The agent is not authorized to call the current extrinsic.8AlreadyAnAgent�The provided `agent` is already an agent for the `Ticker`.(NotAnAgent�The provided `agent` is not an agent for the `Ticker`.TRemovingLastFullAgent�This agent is the last full one, and it's being removed,hmaking the asset orphaned.�SecondaryKeyNotAuthorizedForAsset
The caller's secondary key does not have the required asset permission.�
8pallet_relayerSubsidyAcc

(paying_key
Acc
$remaining
Balance�
8pallet_relayerErrorT
DUserKeyCddMissing�The `user_key` is not attached to a CDD'd identity.LPayingKeyCddMissing
�The `user_key` is not attached to a CDD'd identity.,NoPayingKey�The `user_key` doesn't have a `paying_key`.0NotPayingKey�The `user_key` has a different `paying_key`.dNotAuthorizedForPayingKey�The signer is not authorized for `paying_key`.\NotAuthorizedForUserKey�The signer is not authorized for `user_key`. Overflow�The remaining POLYX for `user_key` overflowed.�
8pallet_rewardsErrorT
DUnknownItnAddress�Address was not found in the list of Itn addresses.\ItnRewardAlreadyClaimed
|Itn reward was already claimed.@InvalidSignature|Provided signature was invalid.TUnableToCovertBalance�Balance can not be converted to a primitive.�
@pallet_contractswasm@PrefabWasmModuleT
linstruction_weights_version�
u32
initial�
u32
maximum�
u32
code(
Vec<u8>�
@pallet_contractswasm$OwnerInfoT
owner
8AccountIdOf<T>
deposit�

0BalanceOf<T>
 refcount!
u64�
@pallet_contractsstorage<RawContractInfo CodeHash
$Balance

trie_id(
TrieId
$code_hash$
 CodeHash
<storage_deposit
Balance�
�
�
@pallet_contractsstorage<DeletedContract
trie_id(
TrieId�
@pallet_contracts schedule ScheduleT
limits�

Limits
Linstruction_weights�

TInstructionWeights<T>
<host_fn_weights�

@HostFnWeights<T>�
@pallet_contracts scheduleLimits,
0event_topics
u32
0stack_height!
,Option<u32>
globals
u32
(parameters
u32
0memory_pages
u32
(table_size
u32
4br_table_size
u32
,subject_len
u32
(call_depth
u32
,payload_len
u32
 code_len
u32�
@pallet_contracts scheduleHInstructionWeightsT�
version
u32
 i64const
u32
i64load
u32
 i64store
u32
select
u32
r#if
u32
br
u32
br_if
u32
 br_table
u32
Hbr_table_per_entry
u32
call
u32
4call_indirect
u32
\call_indirect_per_param
u32
$local_get
u32
$local_set
u32
$local_tee
u32
(global_get
u32
(global_set
u32
8memory_current
u32
,memory_grow
u32
i64clz
u32
i64ctz
u32
$i64popcnt
u32
i64eqz
u32
4i64extendsi32
u32
4i64extendui32
u32
(i32wrapi64
u32
i64eq
u32
i64ne
u32
i64lts
u32
i64ltu
u32
i64gts
u32
i64gtu
u32
i64les
u32
i64leu
u32
i64ges
u32
i64geu
u32
i64add
u32
i64sub
u32
i64mul
u32
i64divs
u32
i64divu
u32
i64rems
u32
i64remu
u32
i64and
u32
i64or
u32
i64xor
u32
i64shl
u32
i64shrs
u32
i64shru
u32
i64rotl
u32
i64rotr
u32�
@pallet_contracts schedule4HostFnWeightsT�
caller 
Weight
,is_contract 
Weight
$code_hash 
Weight
4own_code_hash 
Weight
@caller_is_origin 
Weight
address 
Weight
 gas_left 
Weight
balance 
Weight
Dvalue_transferred 
Weight
<minimum_balance 
Weight
0block_number 
Weight
now 
Weight
4weight_to_fee 
Weight
gas 
Weight
input 
Weight
8input_per_byte 
Weight
 r#return 
Weight
<return_per_byte 
Weight
$terminate 
Weight
random 
Weight
4deposit_event 
Weight
\deposit_event_per_topic 
Weight
Xdeposit_event_per_byte 
Weight
4debug_message 
Weight
,set_storage 
Weight
`set_storage_per_new_byte 
Weight
`set_storage_per_old_byte 
Weight
4set_code_hash 
Weight
4clear_storage 
Weight
Xclear_storage_per_byte 
Weight
@contains_storage 
Weight
dcontains_storage_per_byte 
Weight
,get_storage 
Weight
Pget_storage_per_byte 
Weight
0take_storage 
Weight
Ttake_storage_per_byte 
Weight
 transfer 
Weight
call 
Weight
4delegate_call 
Weight
\call_transfer_surcharge 
Weight
Pcall_per_cloned_byte 
Weight
,instantiate 
Weight
xinstantiate_transfer_surcharge 
Weight
dinstantiate_per_salt_byte 
Weight
4hash_sha2_256 
Weight
Xhash_sha2_256_per_byte 
Weight
<hash_keccak_256 
Weight
`hash_keccak_256_per_byte 
Weight
<hash_blake2_256 
Weight
`hash_blake2_256_per_byte 
Weight
<hash_blake2_128 
Weight
`hash_blake2_128_per_byte 
Weight
4ecdsa_recover 
Weight
Pecdsa_to_eth_address 
Weight�
@pallet_contractspalletErrorT
tXInvalidScheduleVersion

A new schedule must have a greater version than the current one.@InvalidCallFlags
5
Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`. OutOfGas�The executed contract exhausted its gas limit.POutputBufferTooSmall

The output buffer supplied to a contract API call was too small.8TransferFailed5
Performing the requested transfer failed. Probably because there isn't enough�free balance in the sender's account.LMaxCallDepthReached!
Performing a call was denied because the calling depth reached the limit�of what is specified in the schedule.@ContractNotFound�No contract was found at the specified address.0CodeTooLarge=
The code supplied to `instantiate_with_code` exceeds the limit specified in theDcurrent schedule.0CodeNotFound�No code could be found at the supplied code hash.,OutOfBounds	%
A buffer outside of sandbox memory was passed to a contract API function.8DecodingFailed
)
Input passed to a contract API function failed to decode as expected type.<ContractTrapped�Contract trapped during execution.4ValueTooLarge�The size defined in `T::MaxValueSize` was exceeded.`TerminatedWhileReentrant

Termination of a contract is not allowed while the contract is already�on the call stack. Can be triggered by `seal_terminate`.8InputForwardedA
`seal_call` forwarded this contracts input. It therefore is no longer available.PRandomSubjectTooLong�The subject passed to `seal_random` exceeds the limit.4TooManyTopics
The amount of topics passed to `seal_deposit_events` exceeds the limit.<DuplicateTopics-
The topics passed to `seal_deposit_events` contains at least one duplicate.@NoChainExtensionE
The chain does not provide a chain extension. Calling the chain extension resultsM
in this error. Note that this usually  shouldn't happen as deploying such contracts0is rejected.DDeletionQueueFull

Removal of a contract failed because the deletion queue is full.�This can happen when calling `seal_terminate`.M
The queue is filled by deleting contracts and emptied by a fixed amount each block.!
Trying again during another block is the only way to resolve this issue.DDuplicateContract�A contract with the same AccountId already exists.\TerminatedInConstructor�A contract self destructed in its constructor.�This can be triggered by a call to `seal_terminate`.\DebugMessageInvalidUTF8=
The debug message specified to `seal_debug_message` does contain invalid UTF-8.@ReentranceDenied

A call tried to invoke a contract that is flagged as non-reentrant.pStorageDepositNotEnoughFunds!
Origin doesn't have enough balance to pay the required storage deposits.pStorageDepositLimitExhausted

More storage was created than allowed by the storage deposit limit.$CodeInUseI
Code removal was denied because the code is still in use by at least one contract.@ContractReverted%
The contract ran to completion but decided to revert its storage changes.I
Please note that this error is only returned from extrinsics. When called directly]
or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags�to determine whether a reversion has taken place.0CodeRejectedE
The contract's code was found to be invalid during validation or instrumentation.Q
A more detailed error can be found on the node console if debug messages are enabled�or in the debug buffer which is returned to RPC clients.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
			�
Hpolymesh_contractsErrorT
 4InvalidFuncId�Invalid `func_id` provided from contract.HInvalidRuntimeCall
�Failed to decode a valid `RuntimeCall`.DReadStorageFailed�`ReadStorage` failed to write value into the contract's buffer.TDataLeftAfterDecoding�Data left in input when decoding arguments of a call.4InLenTooLarge9
Input data that a contract passed when using the ChainExtension was too large.8OutLenTooLarge�Output data returned from the ChainExtension was too large.hInstantiatorWithNoIdentity�A contract was attempted to be instantiated,

but no identity was given to associate the new contract's key with.DRuntimeCallDenied�Extrinsic is not allowed to be called by contracts.�
<pallet_preimage4RequestStatus$AccountId
Balance

,Unrequested�

pOption<(AccountId, Balance)>$Requested
u32
�
OptionT
�
NoneSome�

4frame_supportstorage,bounded_vec(BoundedVecT
S(
Vec<T><pallet_preimagepalletErrorT
 TooLarge�Preimage is too large to store on-chain.0AlreadyNoted
�Preimage has already been noted on-chain.4NotAuthorized�The user is not authorized to perform this action. NotNoted�The preimage cannot be removed since it has not yet been noted.$Requested	
A preimage may not be removed when there are outstanding requests.0NotRequested-
The preimage request cannot be removed since no outstanding requests exist.�

			Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors)
			of this pallet.
				Dpallet_test_utilsErrorT

(sp_runtimegenericLunchecked_extrinsicHUncheckedExtrinsicAddress
UCall
�$Signature
�Extra
( !)-590frame_system(extensionsHcheck_spec_version@CheckSpecVersionT0frame_system(extensions@check_tx_version8CheckTxVersionT0frame_system(extensions4check_genesis0CheckGenesisT!0frame_system(extensions<check_mortality8CheckMortalityT%
Era%(sp_runtimegenericeraEra

 ImmortalMortal1
Mortal2Mortal3Mortal4Mortal5Mortal6Mortal7Mortal8Mortal9	 Mortal10
 Mortal11 Mortal12 Mortal13
 Mortal14 Mortal15 Mortal16 Mortal17 Mortal18 Mortal19 Mortal20 Mortal21 Mortal22 Mortal23 Mortal24 Mortal25 Mortal26 Mortal27 Mortal28 Mortal29 Mortal30 Mortal31 Mortal32  Mortal33! Mortal34" Mortal35# Mortal36$ Mortal37% Mortal38& Mortal39' Mortal40( Mortal41) Mortal42* Mortal43+ Mortal44, Mortal45- Mortal46. Mortal47/ Mortal480 Mortal491 Mortal502 Mortal513 Mortal524 Mortal535 Mortal546 Mortal557 Mortal568 Mortal579 Mortal58: Mortal59; Mortal60< Mortal61= Mortal62> Mortal63? Mortal64@ Mortal65A Mortal66B Mortal67C Mortal68D Mortal69E Mortal70F Mortal71G Mortal72H Mortal73I Mortal74J Mortal75K Mortal76L Mortal77M Mortal78N Mortal79O Mortal80P Mortal81Q Mortal82R Mortal83S Mortal84T Mortal85U Mortal86V Mortal87W Mortal88X Mortal89Y Mortal90Z Mortal91[ Mortal92\ Mortal93] Mortal94^ Mortal95_ Mortal96` Mortal97a Mortal98b Mortal99c$Mortal100d$Mortal101e$Mortal102f$Mortal103g$Mortal104h$Mortal105i$Mortal106j$Mortal107k$Mortal108l$Mortal109m$Mortal110n$Mortal111o$Mortal112p$Mortal113q$Mortal114r$Mortal115s$Mortal116t$Mortal117u$Mortal118v$Mortal119w$Mortal120x$Mortal121y$Mortal122z$Mortal123{$Mortal124|$Mortal125}$Mortal126~$Mortal127$Mortal128�$Mortal129�$Mortal130�$Mortal131�$Mortal132�$Mortal133�$Mortal134�$Mortal135�$Mortal136�$Mortal137�$Mortal138�$Mortal139�$Mortal140�$Mortal141�$Mortal142�$Mortal143�$Mortal144�$Mortal145�$Mortal146�$Mortal147�$Mortal148�$Mortal149�$Mortal150�$Mortal151�$Mortal152�$Mortal153�$Mortal154�$Mortal155�$Mortal156�$Mortal157�$Mortal158�$Mortal159�$Mortal160�$Mortal161�$Mortal162�$Mortal163�$Mortal164�$Mortal165�$Mortal166�$Mortal167�$Mortal168�$Mortal169�$Mortal170�$Mortal171�$Mortal172�$Mortal173�$Mortal174�$Mortal175�$Mortal176�$Mortal177�$Mortal178�$Mortal179�$Mortal180�$Mortal181�$Mortal182�$Mortal183�$Mortal184�$Mortal185�$Mortal186�$Mortal187�$Mortal188�$Mortal189�$Mortal190�$Mortal191�$Mortal192�$Mortal193�$Mortal194�$Mortal195�$Mortal196�$Mortal197�$Mortal198�$Mortal199�$Mortal200�$Mortal201�$Mortal202�$Mortal203�$Mortal204�$Mortal205�$Mortal206�$Mortal207�$Mortal208�$Mortal209�$Mortal210�$Mortal211�$Mortal212�$Mortal213�$Mortal214�$Mortal215�$Mortal216�$Mortal217�$Mortal218�$Mortal219�$Mortal220�$Mortal221�$Mortal222�$Mortal223�$Mortal224�$Mortal225�$Mortal226�$Mortal227�$Mortal228�$Mortal229�$Mortal230�$Mortal231�$Mortal232�$Mortal233�$Mortal234�$Mortal235�$Mortal236�$Mortal237�$Mortal238�$Mortal239�$Mortal240�$Mortal241�$Mortal242�$Mortal243�$Mortal244�$Mortal245�$Mortal246�$Mortal247�$Mortal248�$Mortal249�$Mortal250�$Mortal251�$Mortal252�$Mortal253�$Mortal254�$Mortal255�)0frame_system(extensions,check_nonce(CheckNonceT�
 T::Index-Lpolymesh_extensions0check_weight,CheckWeightT1
CW<T>10frame_system(extensions0check_weight,CheckWeightT5hpallet_transaction_payment`ChargeTransactionPaymentT�

0BalanceOf<T>9Hpallet_permissionsDStoreCallMetadataT=`polymesh_runtime_developruntimeRuntime�System
System@Account

A
� The full account information for a particular account ID.8ExtrinsicCount� Total extrinsics count for the current block.,BlockWeight
`� The current weight for the block.@AllExtrinsicsLenA
 Total length (in bytes) for all extrinsics put together, for the current block.$BlockHash

$�� Map of block numbers to block hashes.4ExtrinsicData

(=
 Extrinsics data for the current block (maps an extrinsic's index to its data).Number
	
 The current block number being processed. Set by `execute_block`.(ParentHash
$�p Hash of the previous block.Digest
,� Digest of the current block, also part of the block header.Events
<� Events deposited for the current block.
 NOTE: The item is unbound and should therefore never be read on chain.� It could otherwise inflate the PoV size of a block.-
 Events have a large in-memory size. Box the events to not go out-of-memory� just in case someone still reads them from within the runtime.(EventCount
� The number of events in the `Events<T>` list.,EventTopics

$�(%
 Mapping between a topic (represented by T::Hash) and a vector of indexes� of events in the `<Events<T>>` list.Q
 All topic vectors have deterministic storage locations depending on the topic. ThisE
 allows light-clients to leverage the changes trie storage tracking mechanism and� in case of changes fetch the list of events of interest.M
 The value has the type `(T::BlockNumber, EventIndex)` because if we used only justM
 the `EventIndex` then in case if the topic has the same contents on the next block

 no notification will be triggered thus the event might be lost.HLastRuntimeUpgrade�U
 Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.TUpgradedToU32RefCount

M
 True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.`UpgradedToTripleRefCount

]
 True if we have upgraded so that AccountInfo contains three types of `RefCount`. FalseH (default) if not.8ExecutionPhase}� The execution phase of the block.
�
H0BlockWeights��
�� J��
�6�&
��K�.

��>]

�6�&
���

 J��

�Rjt�6�&� Block & extrinsics weights: base values and limits.,BlockLength�0x��� The maximum length of a block (in bytes).8BlockHashCountU
 Maximum number of block number to block hash mappings to keep (oldest pruned first). DbWeight�@�����	
 The weight of runtime database operations the runtime can invoke.Version�A0polymesh_dev0polymesh_dev
SLL�j�h�`�7��|���
@�:�
���Ҽ���Џ��'��?EL�Ŭ�^����%�#�hz�J��
����O[�?
h�k�"�?�
7ȻP���
�<r)�
�X��{�p
2�B�Gs
)�}
�
򎀀�����k�<\�x�$,,�o?�
YZ�L^���

� Get the chain's current version.(SS58PrefixE*� The designated SS85 prefix of this chain.9
 This replaces the "ss58Format" property declared in the chain spec. Reason is1
 that the runtime should know about the prefix in order to make use of it asp an identifier of the chain.
�Babe
Babe@(EpochIndex
  T Current epoch index.,Authorities
�l Current epoch authorities.,GenesisSlot
� � The slot at which the first epoch actually started. This is 0� until the first block of the chain.,CurrentSlot
� T Current slot number.(Randomness
�(� The epoch randomness for the *current* epoch., # Security
 This MUST NOT be used for gambling, as it can be influenced by a� malicious validator in the short term. It MAY be used in many
 cryptographic protocols, however, so long as one remembers that this
 (like everything else on-chain) it is public. For example, it can be
 used where a number is needed that cannot have been chosen by an

 adversary, for purposes such as public-coin zero-knowledge proofs.`PendingEpochConfigChange�a
 Pending epoch configuration change that will be applied when the next epoch is enacted.8NextRandomness
�\ Next epoch randomness.<NextAuthorities
�` Next epoch authorities.0SegmentIndex
$| Randomness under construction.� We make a trade-off between storage accesses and list length.

 We store the under-construction randomness in segments of up to� `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.� Once a segment reaches this length, we begin the next one.	
 We reset all segments and return to `0` at the beginning of every epoch.DUnderConstruction

�
 TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.,Initialized�

 Temporary value (cleared at block finalization) which is `Some`
 if per-block initialization has already been called for current block.LAuthorVrfRandomness
�
 This field should always be populated during block processing unless
 secondary plain slots are enabled (which don't contain a VRF output).Q
 It is set in `on_initialize`, before it will contain the value from the last block.(EpochStart
� ]
 The block numbers when the last and current epoch have started, respectively `N-1` and `N`.I
 NOTE: We track this is in order to annotate the block number when a given pool ofY
 entropy was fixed (i.e. it was known to chain observers). Since epochs are defined inY
 slots, which may be skipped, the block numbers may not line up with the slot numbers. Lateness
� How late the current block is compared to its parent.
 This entry is populated as part of block execution and is cleaned up
 on block finalization. Querying this storage entry outside of block� execution context should always yield zero.,EpochConfig
a
 The configuration for the current epoch. Should never be `None` as it is initialized in$ genesis.<NextEpochConfig
-
 The configuration for the next epoch, `None` if the config will not change� (you can fallback to `EpochConfig` instead in that case).
4EpochDuration  ,
� The amount of time, in slots, that each epoch should last.
 NOTE: Currently it is not possible to change the epoch duration after!
 the chain has started. Attempting to do so will brick block production.DExpectedBlockTime  p
 The expected average block time at which BABE should be creating
 blocks. Since BABE is probabilistic it is not trivial to figure out
 what the expected average block time should be based on the slot	
 duration and the security parameter `c` (where `1 - c` represents� the probability of a slot being empty).8MaxAuthorities��
� Max number of authorities allowed

$Timestamp
$TimestampNow
  � Current time for the current block.$DidUpdate

� Did the timestamp get updated in this block?
4MinimumPeriod  �M
 The minimum period between blocks. Beware that this is different to the *expected*]
 period that the block production apparatus provides. Your chosen consensus system will]
 generally work with this to determine a sensible block time. e.g. For Aura, it will be� double this period on default settings.Indices
Indices Accounts
%� The lookup from index to account.
)
lDeposit@@B� The deposit needed for reserving an index.
-(Authorship
(AuthorshipUncles
1 UnclesAuthord Author of current block.0DidSetUncles

� Whether uncles were already set in this block.
9@UncleGenerations� The number of blocks back we should accept uncles.� This means that we will deal with uncle-parents that are� `UncleGenerations + 1` before `now`.
A Balances
 Balances4TotalIssuance
@� The total units issued in the system.Locks

E� Any liquidity locks on some account balances.%
 NOTE: Should only be accessed when setting, changing and freeing a lock.
Q
pHExistentialDeposit@� The minimum amount required to keep an account open.
YHTransactionPayment
HTransactionPaymentDNextFeeMultiplier
]@d����
8StorageVersion
aHTransactionByteFee@d

 The fee to be paid for making a transaction; the per-byte portion.,WeightToFeee\I�


 The polynomial that is applied in order to derive fee from weight. Identity
 IdentityH(DidRecords
xmT DID -> identity info,IsDidFrozen

x
� DID -> bool that indicates if secondary keys are frozen.(CurrentDidx� It stores the current identity for current transaction.0CurrentPayer

 It stores the current gas fee payer for the current transactionClaims

q��
� (Target ID, claim type) (issuer,scope) -> Associated claims0CustomClaims


(� CustomClaimTypeId -> String constantLCustomClaimsInverse

(
� String constant -> CustomClaimTypeIdTCustomClaimIdSequence

x The next `CustomClaimTypeId`.(KeyRecords
}E
 Map from AccountId to `KeyRecord` that holds the key's identity and permissions.DidKeys

�


 A reverse double map to allow finding all keys for an identity.DMultiPurposeNonce
  � Nonce to ensure unique actions. starts from 1.hOffChainAuthorizationNonce

x  � Authorization nonce per Identity. Initially is 0.8Authorizations
��� All authorizations that an identity/key hasLAuthorizationsGiven

�q
�M
 All authorizations that an identity has given. (Authorizer, auth_id -> authorized)lCddAuthForMasterKeyRotation

e
 Obsoleted storage variable superceded by `CddAuthForPrimaryKeyRotation`. It is kept here� for the purpose of storage migration.pCddAuthForPrimaryKeyRotation

]
 A config flag that, if set, instructs an authorization from a CDD provider in order to� change the primary key of an identity.8StorageVersion
�D Storage version.HAccountKeyRefCount

  � How many "strong" references to the account key.� Strong references will block a key from leaving it's identity.� Pallets using "strong" references to account keys:� * Relayer: For `user_key` and `paying_key`
�
�0InitialPOLYX@
�LCddServiceProviders
8Instance2Group4ActiveMembers
)
� The current "active" membership, stored as an ordered Vec.<InactiveMembers
�� The current "inactive" membership, stored as an ordered Vec.HActiveMembersLimit
� Limit of how many "active" members there can be.
�
!

�DPolymeshCommittee
HInstance1Committee$$Proposals
�� The hashes of the active proposals.(ProposalOf
$�� Actual proposal for a given hash.Voting
$]� PolymeshVotes on a given proposal, if it is ongoing.4ProposalCount
H Proposals so far.Members
)
� The current members of the committee.4VoteThreshold
� � Vote threshold for an approval.HReleaseCoordinatorxT Release coordinator.0ExpiresAfter
=

� Time after which a proposal will expire.8StorageVersion
aD Storage version.
�
-

e	LCommitteeMembership
8Instance1Group4ActiveMembers
)
� The current "active" membership, stored as an ordered Vec.<InactiveMembers
�� The current "inactive" membership, stored as an ordered Vec.HActiveMembersLimit
� Limit of how many "active" members there can be.
�
A

i
HTechnicalCommittee
HInstance3Committee$$Proposals
�� The hashes of the active proposals.(ProposalOf
$�� Actual proposal for a given hash.Voting
$]� PolymeshVotes on a given proposal, if it is ongoing.4ProposalCount
H Proposals so far.Members
)
� The current members of the committee.4VoteThreshold
� � Vote threshold for an approval.HReleaseCoordinatorxT Release coordinator.0ExpiresAfter
=

� Time after which a proposal will expire.8StorageVersion
aD Storage version.
�
I

mpTechnicalCommitteeMembership
8Instance3Group4ActiveMembers
)
� The current "active" membership, stored as an ordered Vec.<InactiveMembers
�� The current "inactive" membership, stored as an ordered Vec.HActiveMembersLimit
� Limit of how many "active" members there can be.
�
Q

q@UpgradeCommittee
HInstance4Committee$$Proposals
�� The hashes of the active proposals.(ProposalOf
$�� Actual proposal for a given hash.Voting
$]� PolymeshVotes on a given proposal, if it is ongoing.4ProposalCount
H Proposals so far.Members
)
� The current members of the committee.4VoteThreshold
� � Vote threshold for an approval.HReleaseCoordinatorxT Release coordinator.0ExpiresAfter
=

� Time after which a proposal will expire.8StorageVersion
aD Storage version.
�
Y

u
hUpgradeCommitteeMembership
8Instance4Group4ActiveMembers
)
� The current "active" membership, stored as an ordered Vec.<InactiveMembers
�� The current "inactive" membership, stored as an ordered Vec.HActiveMembersLimit
� Limit of how many "active" members there can be.
�
a

y MultiSig
 MultiSig04MultiSigNonce
  !
 Nonce to ensure unique MultiSig addresses are generated; starts from 1.<MultiSigSigners

}
� Signers of a multisig. (multisig, signer) => bool.<NumberOfSigners

  � Number of approved/accepted signers of a multisig.TMultiSigSignsRequired

  � Confirmations required before processing a multisig tx.8MultiSigTxDone

  5
 Number of transactions proposed in a multisig. Used as tx id; starts from 0.$Proposals
��u
 Proposals presented for voting to a multisig (multisig, proposal id) => Option<T::Proposal>.,ProposalIds
� � A mapping of proposals to their IDs.Votes

�
%
 Individual multisig signer votes. (multi sig, signer, proposal) => vote.HMultiSigToIdentity

x�� Maps a multisig account to its identity.8ProposalDetail

��L| Details of a multisig proposalHTransactionVersion
� The last transaction version, used for `on_runtime_upgrade`.8StorageVersion
�D Storage version.
�
i

�Bridge
Bridge((Controller
�A
 The multisig account of the bridge controller. The genesis signers accept theirE
 authorizations and are able to get their proposals delivered. The bridge creator� transfers some POLY to their identity.<BridgeTxDetails

���Y
 Details of bridge transactions identified with pairs of the recipient account and theh bridge transaction nonce.Admin
�< The admin key.Frozen

� Whether or not the bridge operation is frozen.0FreezeAdmins


	
 Freeze bridge admins.  These accounts can only freeze the bridge. Timelock
=
 The bridge transaction timelock period, in blocks, since the acceptance of the1
 transaction proposal during which the admin key can freeze the transaction.,BridgeLimit
�P)
 The maximum number of bridged POLYX per identity within a set interval of� blocks. Fields: POLYX amount and the block interval duration.0PolyxBridged

x�PQ
 Amount of POLYX bridged by the identity in last block interval. Fields: the bridged� amount and the last interval number.LBridgeLimitExempted

x
� Identities not constrained by the bridge limit.8StorageVersion
�D Storage version.
�
u

�Staking
Staking�0HistoryDepth
T� Number of eras to keep in history.9
 Information is kept for eras in `[current_era - history_depth; current_era]`.a
 Must be more than the number of eras delayed by session otherwise. I.e. active era must9
 always be in history. I.e. `active_era > current_era - history_depth` must be0 guaranteed.8ValidatorCount
� The ideal number of staking participants.TMinimumValidatorCount
A
 Minimum number of staking participants before emergency conditions are imposed.4Invulnerables
�Y
 Any validators that may never be slashed or forcibly kicked. It's a Vec since they'reM
 easy to initialize and the performance hit is minimal (we expect no more than four� invulnerables) and restricted to testnets.Bonded


 Map from all locked "stash" accounts to the controller account.Ledger
�E
 Map from all (unlocked) "controller" accounts to the info regarding the staking.Payee


� Where the reward payment should be made. Keyed by stash.(Validators

E
 The map from (wannabe) validator stash key to the preferences of that validator.(Nominators
�e
 The map from nominator stash key to the set of stash keys of all validators to nominate.(CurrentEra\ The current era index.e
 This is the latest planned era, depending on how the Session pallet queues the validator� set, it might be active or not.$ActiveEra�� The active era information, it holds index and start.Y
 The active era is the era being currently rewarded. Validator set of this era must be� equal to [`SessionInterface::validators`].TErasStartSessionIndex
1
 The session index at which the era start for the last `HISTORY_DEPTH` eras.a
 Note: This tracks the starting session (i.e. session index when era start being active)� for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.,ErasStakers

��
x Exposure of validator at era.a
 This is keyed first by the era index to allow bulk deletion and then the stash account.� Is it removed after `HISTORY_DEPTH` eras.A
 If stakers hasn't been set or has been removed then empty exposure is returned.HErasStakersClipped

��
,� Clipped Exposure of validator at era.Y
 This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the� `T::MaxNominatorRewardedPerValidator` biggest stakers.
 (Note: the field `total` and `own` of the exposure remains unchanged).� This is used to limit the i/o cost for the nominator payout.]
 This is keyed fist by the era index to allow bulk deletion and then the stash account.� Is it removed after `HISTORY_DEPTH` eras.A
 If stakers hasn't been set or has been removed then empty exposure is returned.HErasValidatorPrefs

�
 Similar to `ErasStakers`, this holds the preferences of validators.a
 This is keyed first by the era index to allow bulk deletion and then the stash account.� Is it removed after `HISTORY_DEPTH` eras.LErasValidatorReward
	
 The total validator era payout for the last `HISTORY_DEPTH` eras.!
 Eras that haven't finished yet or has been removed doesn't have reward.@ErasRewardPoints

�� Rewards for the last `HISTORY_DEPTH` eras.%
 If reward hasn't been set or has been removed then 0 reward is returned.8ErasTotalStake

@� The total amount staked for the last `HISTORY_DEPTH` eras.
 If total hasn't been set or has been removed then 0 stake is returned. ForceEra
�T Mode of era forcing.LSlashRewardFraction
�
� The percentage of the slash that is distributed to reporters.� The rest of the slashed value is handled by the `Slash`.LCanceledSlashPayout
@
 The amount of currency given to reporters of a slash event which was� canceled by extraordinary circumstances (e.g. governance).@UnappliedSlashes

�� All unapplied slashes that are queued for later.(BondedEras
�%
 A mapping from still-bonded eras to the first session index of that era.� Must contains information for eras for the range:� `[active_era - bounding_duration; active_era]`LValidatorSlashInEra
��E
 All slashing events on validators, mapped by era to the highest slash proportionp and slash value of the era.LNominatorSlashInEra
�a
 All slashing events on nominators, mapped by era to the highest slash value of the era.4SlashingSpans
�� Slashing spans for stash accounts.$SpanSlash

���=
 Records information about the maximum slash of a stash within a slashing span,� as well as how much reward has been paid out.XEarliestUnappliedSlash� The earliest era for which we have a pending, unapplied slash.LOffendingValidators
�$i
 Indices of validators that have offended in the active era and whether they are currently( disabled.i
 This value should be a superset of disabled validators since not all offences lead to theq
 validator being disabled (if there was no slash). This is needed to track the percentage ofI
 validators that have offended in the current era, ensuring a new era is forced ifu
 `OffendingValidatorsThreshold` is reached. The vec is always kept sorted so that we can findq
 whether a given validator has previously offended using binary search. It gets cleared when8 the era ends.HSnapshotValidators�e
 Snapshot of validators at the beginning of the current election window. This should only
 have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`.HSnapshotNominators�e
 Snapshot of nominators at the beginning of the current election window. This should only
 have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`.4QueuedElected
	e
 The next validator set. At the end of an era, if this is available (potentially from thea
 result of an offchain worker), it is immediately used. Otherwise, the on-chain election4 is executed.,QueuedScore�� The score of the current [`QueuedElected`].DEraElectionStatus
	I
 Flag to control the execution of the offchain election. When `Open(_)`, we acceptl solutions to be submitted.TIsCurrentSessionFinal

M
 True if the current **planned** session is final. Note that this does not take eraX forcing into account.PPermissionedIdentity
x		� Entities that are allowed to run operator/validator nodes.XValidatorCommissionCap
�

 Every validator has commission that should be in the range [0, Cap].PMinimumBondThreshold
@� The minimum amount with which a validator can bond.HSlashingAllowedFor
�
8StorageVersion

	� True if network has been upgraded to this version.| Storage version of the pallet.� This is set to v6.0.1 for new networks.XPolymeshStorageVersion
	h Polymesh Storage version.
	
�
,8SessionsPerErap Number of sessions per era.<BondingDuration� Number of eras that staked funds must remain bonded for.HSlashDeferDuration

 Number of eras that slashes are deferred by, after computation.� This should be less than the bonding duration.-
 Set to 0 if slashes should be applied immediately, without opportunity for8 intervention.DElectionLookaheadKq
 The number of blocks before the end of the era from which election submissions are allowed.m
 Setting this to zero will disable the offchain compute and only on-chain seq-phragmen will$ be used.u
 This is bounded by being within the last session. Hence, setting it to a value more than the� length of a session will be pointless.4MaxIterations
)
 Maximum number of balancing iterations to run in the offchain submission.� If set to 0, balance_solution will not be executed at all.PMinSolutionScoreBump�
 �a
 The threshold of improvement that should be provided for a new solution to be accepted.�MaxNominatorRewardedPerValidator� The maximum number of nominators rewarded for each validator.i
 For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can claim!
 their reward. This used to limit the i/o cost for the nominator payout.\MaxValidatorPerIdentity�	� Maximum number of validators for each permissioned identity.Y
 Max number of validators count = `MaxValidatorPerIdentity * Self::validator_count()`.�MaxVariableInflationTotalIssuance@�Ƥ~�q
 Maximum amount of `T::currency::total_issuance()` after that non-inflated rewards get paid.DFixedYearlyReward@�DJT

 Total year rewards that gets paid during fixed reward schedule.,MinimumBond@@B� Minimum amount of POLYX that must be bonded for a new bond.
	 Offences
 OffencesReports
$	I
 The primary structure that holds all offence records keyed by report identifiers.XConcurrentReportsIndex

	�)
 A vector of reports of the same kind that happened at the same time slot.HReportsByKindIndex

�
(
 Enumerates all reports of a kind along with the time they happened.� All reports are sorted by the time of offence.I
 Note that the actual type of this mapping is `Vec<u8>`, this is because values ofi
 different types are not supported at the moment so we are doing the manual serialization.
�
Session
Session(Validators
�| The current set of validators.0CurrentIndex
x Current index of the session.4QueuedChanged

9
 True if the underlying economic identities or weighting behind the validators� has changed in the queued validator set.(QueuedKeys
!	=
 The queued keys for the next session. When the next session begins, these keys� will be used to determine the validator's session keys.HDisabledValidators
I� Indices of disabled validators.=
 The vec is always kept sorted so that we can find whether a given validator is=
 disabled using binary search. It gets cleared when `on_session_ending` returnsd a new set of identities. NextKeys

� The next session keys for a validator. KeyOwner
)		
 The owner of a key. The key is the `KeyTypeId` + the encoded key.
�
�

1	HAuthorityDiscoveryGrandpa
GrandpaState
5	� State of the current authority set.4PendingChange9	� Pending change: (signaled at, scheduled change).(NextForced� next block number where we can force a change.Stalled�� `true` if we are currently stalled.0CurrentSetId
  ]
 The number of changes (both in terms of keys and underlying economic responsibilities)� in the "set" of Grandpa validators from genesis.0SetIdSession
 Y
 A mapping from grandpa set ID to the index of the *most recent* session for which itsh members were responsible.� TWOX-NOTE: `SetId` is not under user control.
	
�
8MaxAuthorities��
\ Max Authorities in use
A	(Historical ImOnline
 ImOnline8HeartbeatAfter
,
 The block number after which it's ok to send heartbeats in the current$ session.%
 At the beginning of each session we set this to a value that should fall5
 roughly in the middle of the session duration. The idea is to first wait for
 the validators to produce a block in the current session, so that the� heartbeat later on will not be necessary.9
 This value will only be used as a fallback if we fail to get a proper session-
 progress estimate from `NextSessionRotation`, as those estimates should be

 more accurate then the value we calculate for `HeartbeatAfter`.Keys
E	� The current set of keys that may issue a heartbeat.HReceivedHeartbeats
�M	=
 For each session index, we keep a mapping of `SessionIndex` and `AuthIndex` to� `WrapperOpaque<BoundedOpaqueNetworkState>`.8AuthoredBlocks

�
 For each session index, we keep a mapping of `ValidatorId<T>` to the� number of blocks authored by the given authority.
5
�
@UnsignedPriority  ��������� A configuration for base priority of unsigned transactions.
 This is exposed so that it can be tuned for particular runtime, when� multiple pallets send unsigned transactions.
a	`RandomnessCollectiveFlip
`RandomnessCollectiveFlip8RandomMaterial
e	a
 Series of block headers from the last 81 blocks that acts as random seed material. Thisa
 is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` ofD the oldest hash.Sudo
SudoKey
�� The `AccountId` of the sudo key.
U
�

i	Asset
Asset|Tickers

�m	�t Ticker registration details.| (ticker) -> TickerRegistration0TickerConfig
mp Ticker registration config.� (ticker) -> TickerRegistrationConfigTokens

�q	�� Details of the token corresponding to the token ticker.
 (ticker) -> SecurityToken details [returns SecurityToken struct](AssetNames

��
� Asset name of the token corresponding to the token ticker.` (ticker) -> `AssetName`$BalanceOf

u	@� The total asset ticker balance per identity.d (ticker, DID) -> Balance,Identifiers

��
� A map of a ticker name and asset identifiers.PCustomTypeIdSequence
�
� The next `AssetType::Custom` ID in the sequence.� Numbers in the sequence start from 1 rather than 0.,CustomTypes

�
(� Maps custom asset type ids to the registered string contents.HCustomTypesInverse

(�
a
 Inverse map of `CustomTypes`, from registered string contents to custom asset type ids.0FundingRound

��
� The name of the current funding round.` ticker -> funding roundPIssuedInFundingRound

y	@
 The total balances of tokens issued in all recorded funding rounds.� (ticker, funding round) -> balanceFrozen

�
� The set of frozen assets implemented as a membership map.< ticker -> bool\AssetOwnershipRelations

}	�	� Tickers and token owned by a user� (user, ticker) -> AssetOwnership8AssetDocuments

�	
| Documents attached to an Assett (ticker, doc_id) -> document`AssetDocumentsIdSequence

�	� Per-ticker document ID counter.L (ticker) -> doc_id8ClassicTickers
��	� Ticker registration details on Polymath Classic / Ethereum.@BalanceOfAtScope

�	@� Balances get stored on the basis of the `ScopeId`.�
 Right now it is only helpful for the UI purposes but in future it can be used to do miracles on-chain.� (ScopeId, IdentityId) => Balance.@AggregateBalance

u	@%
 Store aggregate balance of those identities that has the same `ScopeId`.x (Ticker, ScopeId) => Balance.$ScopeIdOf

u	x�� Tracks the ScopeId of the identity for a given ticker.� (Ticker, IdentityId) => ScopeId.dDisableInvestorUniqueness

�
1
 Decides whether investor uniqueness requirement is enforced for this asset.� `false` means that it is enforced.@ Ticker => bool.LAssetMetadataValues
�	=| Metatdata values for an asset.dAssetMetadataValueDetails
�	E� Details for an asset's Metadata values.lAssetMetadataLocalNameToKey
�	Q� Asset Metadata Local Name -> Key.pAssetMetadataGlobalNameToKey
Mm� Asset Metadata Global Name -> Key.lAssetMetadataLocalKeyToName
�	M� Asset Metadata Local Key -> Name.pAssetMetadataGlobalKeyToName
mM� Asset Metadata Global Key -> Name.\AssetMetadataLocalSpecs
�	U� Asset Metadata Local Key specs.`AssetMetadataGlobalSpecs
mU� Asset Metadata Global Key specs.dAssetMetadataNextLocalKey

�Q | Next Asset Metadata Local Key.hAssetMetadataNextGlobalKey
m � Next Asset Metadata Global Key.8StorageVersion
�	D Storage version.
Y
�
HAssetNameMaxLength�dFundingRoundNameMaxLength�hAssetMetadataNameMaxLength
lAssetMetadataValueMaxLength tAssetMetadataTypeDefMaxLength 
�	LCapitalDistribution
LCapitalDistribution4Distributions
y�5
 All capital distributions, tied to their respective corporate actions (CAs).\ (CAId) => Distribution(HolderPaid

�	
� Has an asset holder been paid yet?� (CAId, DID) -> Was DID paid in the CAId?8StorageVersion
�	D Storage version.
u
q
�	(Checkpoint
(Checkpoint,,TotalSupply

�	@� Total supply of the token at the checkpoint.� (ticker, checkpointId) -> total supply at given checkpointBalance

�	@� Balance of a DID at a checkpoint.
 (ticker, did, checkpoint ID) -> Balance of a DID at a checkpointPCheckpointIdSequence

�� � Checkpoints ID generator sequence.� ID of first checkpoint is 1 instead of 0.| (ticker) -> no. of checkpoints8BalanceUpdates

u	�	� Checkpoints where a DID's balance was updated.� (ticker, did) -> [checkpoint ID where user balance changed](Timestamps

�	  \ Checkpoint timestamps.	
 Every schedule-originated checkpoint maps its ID to its due time.!
 Every checkpoint manually created maps its ID to the time of recording.� (ticker) -> (checkpoint ID) -> checkpoint timestampXSchedulesMaxComplexity
  
 The maximum complexity allowed for an arbitrary ticker's schedule set� (i.e. `Schedules` storage item below).HScheduleIdSequence

�� � Checkpoint schedule ID sequence for tickers.` (ticker) -> schedule ID$Schedules

��	� Checkpoint schedules for tickers.\ (ticker) -> [schedule]@ScheduleRefCount

�	 

 How many "strong" references are there to a given `ScheduleId`?� The presence of a "strong" reference, in the sense of `Rc<T>`,� entails that the referenced schedule cannot be removed.� Thus, as long as `strong_ref_count(schedule_id) > 0`,� `remove_schedule(schedule_id)` will error.� (ticker, schedule ID) -> strong ref count8SchedulePoints

�	�	� All the checkpoints a given schedule originated.� (ticker, schedule ID) -> [checkpoint ID]8StorageVersion
�	D Storage version.
}
�
�	DComplianceManager
DComplianceManager@AssetCompliances

��	� Asset compliance for a ticker (Ticker -> AssetCompliance)HTrustedClaimIssuer

��� List of trusted claim issuer Ticker -> Issuer Identity8StorageVersion
�	D Storage version.
�
�XMaxConditionComplexity2
�	<CorporateAction
<CorporateAction$@MaxDetailsLength
]
 Determines the maximum number of bytes that the free-form `details` of a CA can store.)
 Note that this is not the number of `char`s or the number of [graphemes].A
 While this may be unnatural in terms of human understanding of a text's length,e
 it more closely reflects actual storage costs (`'a'` is cheaper to store than an emoji).� [graphemes]: https://en.wikipedia.org/wiki/Grapheme\DefaultTargetIdentities

��
� The identities targeted by default for CAs for this ticker,� either to be excluded or included.x (ticker => target identities)TDefaultWithholdingTax

�� �
 The default amount of tax to withhold ("withholding tax", WT) for this ticker when distributing dividends.5
 To understand withholding tax, e.g., let's assume that you hold ACME shares.� ACME now decides to distribute 100 SEK to Alice.Y
 Alice lives in Sweden, so Skatteverket (the Swedish tax authority) wants 30% of that.]
 Then those 100 * 30% are withheld from Alice, and ACME will send them to Skatteverket.h (ticker => % to withhold)DDidWithholdingTax

�
I
 The amount of tax to withhold ("withholding tax", WT) for a certain ticker x DID.m
 If an entry exists for a certain DID, it overrides the default in `DefaultWithholdingTax`.� (ticker => [(did, % to withhold)]0CAIdSequence

�}� The next per-`Ticker` CA ID in the sequence.M
 The full ID is defined as a combination of `Ticker` and a number in this sequence.@CorporateActions
�	�l All recorded CAs thus far.� Only generic information is stored here.}
 Specific `CAKind`s, e.g., benefits and corporate ballots, may use additional on-chain storage.� (ticker => local ID => the corporate action)$CADocLink

y
� Associations from CAs to `Document`s via their IDs.\ (CAId => [DocumentId])
 The `CorporateActions` map stores `Ticker => LocalId => The CA`,%
 so we can infer `Ticker => CAId`. Therefore, we don't need a double map.Details

y	� Associates details in free-form text with a CA by its ID.P (CAId => CADetails)8StorageVersion
�	D Storage version.
�
�0MaxTargetIds�(MaxDidWhts�
�	<CorporateBallot
<CorporateBallotMetas
y� Metadata of a corporate ballot.T (CAId) => BallotMeta(TimeRanges
y� Time details of a corporate ballot associated with a CA.� The timestamps denote when voting starts and stops.h (CAId) => BallotTimeRange@MotionNumChoices

y%$� Stores how many choices there are in each motion.%
 At all times, the invariant holds that `motion_choices[idx]` is equal to1
 `metas.unwrap().motions[idx].choices.len()`. That is, this is just a cache,
 used to avoid fetching all the motions with their associated texts.

 `u16` choices should be more than enough to fit real use cases.� (CAId) => Number of choices in each motion.RCV

y
� Is ranked choice voting (RCV) enabled for this ballot?e
 For an understanding of how RCV is handled, see note on `BallotVote`'s `fallback` field.< (CAId) => boolResults

y�	� Stores the total vote tally on each choice.h RCV is not accounted for,� as there are too many wants to interpret the graph,� and because it would not be efficient.� (CAId) => [current vote weights]Votes

�	9� Stores each DID's votes in a given ballot.� See the documentation of `BallotVote` for notes on semantics.� (CAId) => (DID) => [vote weight]
 User must enter 0 vote weight if they don't want to vote for a choice.
�

�	,Permissions
�	 Pips
PipsXLPruneHistoricalPips

� Determines whether historical PIP data is persisted or removedXMinimumProposalDeposit
@
 The minimum amount to be used as a deposit for community PIP creation.XDefaultEnactmentPeriod
9
 Default enactment period that will be use after a proposal is accepted by GC.@PendingPipExpiry
=

� How many blocks will it take, after a `Pending` PIP expires,� assuming it has not transitioned to another `ProposalState`?<MaxPipSkipCount
�
 Maximum times a PIP can be skipped before triggering `CannotSkipPip` in `enact_snapshot_results`.8ActivePipLimit
� The maximum allowed number for `ActivePipCount`.

 Once reached, new PIPs cannot be proposed by community members.4PipIdSequence
U	
 Proposals so far. id can be used to keep track of PIPs off-chain.HSnapshotIdSequence
i
 Snapshots so far. id can be used to keep track of snapshots off-chain.8ActivePipCount
� Total count of current pending or scheduled PIPs.@ProposalMetadata
U�	� The metadata of the active proposals. Deposits

�	�	�� Those who have locked a deposit.� proposal (id, proposer) -> deposit$Proposals
U�	� Actual proposal for a given id, if it's current.` proposal id -> proposal8ProposalResult

U

�� PolymeshVotes on a given proposal, if it is ongoing.h proposal id -> vote count4ProposalVotes
�	

 Votes per Proposal and account. Used to avoid double vote issue.| (proposal id, account) -> Vote4PipToSchedule
U� Maps PIPs to the block at which they will be executed, if any.$LiveQueue
m� A live priority queue (lowest priority at index 0)� of pending PIPs up to the active limit.� Priority is defined by the `weight` in the `SnapshottedPip`.E
 Unlike `SnapshotQueue`, this queue is live, getting updated with each vote cast.-
 The snapshot is therefore essentially a point-in-time clone of this queue.4SnapshotQueue
mY
 The priority queue (lowest priority at index 0) of PIPs at the point of snapshotting.� Priority is defined by the `weight` in the `SnapshottedPip`.	
 A queued PIP can be skipped. Doing so bumps the `pip_skip_count`.5
 Once a (configurable) threshhold is exceeded, a PIP cannot be skipped again.0SnapshotMeta	
� The metadata of the snapshot, if there is one.0PipSkipCount

U� The number of times a certain PIP has been skipped.5
 Once a (configurable) threshhold is exceeded, a PIP cannot be skipped again.4CommitteePips
�� All existing PIPs where the proposer is a committee.9
 This list is a cache of all ids in `Proposals` with `Proposer::Committee(_)`.8ProposalStates
Ue| Proposal state for a given id.t proposal id -> proposalState8StorageVersion


�
I

!$Portfolio
$Portfolio$LNextPortfolioNumber

x� 
� The next portfolio sequence number of an identity.(Portfolios


�A
 The set of existing portfolios with their names. If a certain pair of a DID andY
 portfolio number maps to `None` then such a portfolio doesn't exist. Conversely, if a5
 pair maps to `Some(name)` then such a portfolio exists and is called `name`.0NameToNumber

�� Inverse map of `Portfolios` used to ensure bijectivitiy,� and uniqueness of names in `Portfolios`.LPortfolioAssetCount

�  � How many assets with non-zero balance this portfolio contains.XPortfolioAssetBalances


@� The asset balances of portfolios.TPortfolioLockedAssets


@� Amount of assets locked in a portfolio.-
 These assets show up in portfolio balance but can not be transferred away.HPortfolioCustodian
�x�
 The custodian of a particular portfolio. None implies that the identity owner is the custodian.LPortfoliosInCustody

!

U
 Tracks all the portfolios in custody of a particular identity. Only used by the UIs.�
 When `true` is stored as the value for a given `(did, pid)`, it means that `pid` is in custody of `did`.�
 `false` values are never explicitly stored in the map, and are instead inferred by the absence of a key.8StorageVersion
%
D Storage version.
�
�
)
",ProtocolFee
,ProtocolFee BaseFees

�@
 The mapping of operation names to the base fees of those operations.,Coefficient
� 


 The fee coefficient as a positive rational (numerator, denominator).
�
�
-
#$Scheduler
$SchedulerAgenda

1
M
 Items to be executed, indexed by the block number that they should be executed on.Lookup
(�

 Lookup from identity to the block number and index of the task.
�
�4MaximumWeight  �n�t
E
 The maximum weight that may be scheduled per block for any dispatchables of less� priority than `schedule::HARD_DEADLINE`.PMaxScheduledPerBlock2
 The maximum number of scheduled calls in the queue for a single block.� Not strictly enforced, but used for weight estimation.
U
$(Settlement
(SettlementH$VenueInfo
�Y
� Info about a venue. venue_id -> venueDetails

��� Free-form text about a venue. venue_id -> `VenueDetails`` Only needed for the UI.DVenueInstructions

]
9
p Instructions under a venue.` Only needed for the UI.� venue_id -> instruction_id -> ()0VenueSigners

a

� Signers allowed by the venue. (venue_id, signer) -> bool(UserVenues

x�q
 Array of venues created by an identity. Only needed for the UI. IdentityId -> Vec<venue_id>HInstructionDetails

�e
T
 Details about an instruction. instruction_id -> instruction_details<InstructionLegs

m
�y
� Legs under an instruction. (instruction_id, leg_id) -> LegPInstructionLegStatus

m
q
1
 Status of a leg under an instruction. (instruction_id, leg_id) -> LegStatusdInstructionAffirmsPending

�  �
 Number of affirmations pending before instruction is executed. instruction_id -> affirm_pending<AffirmsReceived

u
y
�
 Tracks affirmations received for an instruction. (instruction_id, counter_party) -> AffirmationStatus@UserAffirmations

}
y
U
 Helps a user track their pending instructions and affirmations (only needed for UI).� (counter_party, instruction_id) -> AffirmationStatus0ReceiptsUsed

�

 Tracks redemption of receipts. (signer, receipt_uid) -> receipt_used8VenueFiltering

�
�
 Tracks if a token has enabled filtering venues that can create instructions involving their token. Ticker -> filtering_enabled8VenueAllowList

�

�
 Venues that are allowed to create instructions involving a particular ticker. Only used if filtering is enabled.x (ticker, venue_id) -> allowed0VenueCounter
� 
 Number of venues in the system (It's one more than the actual number)HInstructionCounter
� 1
 Number of instructions in the system (It's one more than the actual number)8StorageVersion
�
D Storage version.@InstructionMemos
��D Instruction memo
�
�
�
%(Statistics
(Statistics@ActiveAssetStats

���
 Active stats for a ticker/company.  There should be a max limit on the number of active stats for a ticker/company.(AssetStats

�
@4 Asset stats.`AssetTransferCompliances

��
=
 Asset transfer compliance for a ticker (AssetScope -> AssetTransferCompliance)|TransferConditionExemptEntities

�

� Entities exempt from a Transfer Compliance rule.8StorageVersion
�
l Storage migration version.
�
�@MaxStatsPerAsset
tMaxTransferConditionsPerAsset
�
&Sto
Sto,Fundraisers
�
1� All fundraisers that are currently running.� (ticker, fundraiser_id) -> Fundraiser<FundraiserCount

�) � Total fundraisers created for a token.<FundraiserNames

�
-� Name for the Fundraiser. Only used offchain.� (ticker, fundraiser_id) -> Fundraiser name


%
�
' Treasury

A
�
(Utility
UtilityNonces

  

E
�
)Base
)
UMaxLen
�
*8ExternalAgents
8ExternalAgents0AGIdSequence

�
� The next per-`Ticker` AG ID in the sequence.M
 The full ID is defined as a combination of `Ticker` and a number in this sequence,� which starts from 1, rather than 0.AgentOf

}	9
)
 Maps an agent (`IdentityId`) to all all `Ticker`s they belong to, if any.0GroupOfAgent
u	
5
 Maps agents (`IdentityId`) for a `Ticker` to what AG they belong to, if any.4NumFullAgents

�� Maps a `Ticker` to the number of `Full` agents for it.@GroupPermissions
�
�]
 For custom AGs of a `Ticker`, maps to what permissions an agent in that AG would have.
-
]
�
+Relayer
Relayer$Subsidies
�
� The subsidy for a `user_key` if they are being subsidised,� as a map `user_key` => `Subsidy`.	
 A key can only have one subsidy at a time.  To change subsidisers
 a key needs to call `remove_paying_key` to remove the current subsidy,� before they can accept a new subsidiser.
1
a
�
,Rewards
Rewards(ItnRewards
9

 Map of (Itn Address `AccountId`) -> (Reward `ItnRewardStatus`).
5
e
�
-$Contracts
$Contracts0PristineCode
$(e
 A mapping from an original code hash to the original code, untouched by instrumentation.,CodeStorage
$�
e
 A mapping between an original code hash and instrumented wasm code, ready for execution.,OwnerInfoOf
$�


 A mapping between an original code hash and its owner information.Nonce
  X
 This is a **monotonic** counter incremented on contract instantiation.
 This is used in order to generate unique trie ids for contracts.)
 The trie id of a new contract is calculated from hash(account_id, nonce).5
 The nonce is required because otherwise the following sequence would lead to� a possible collision of storage:h 1. Create a new contract.l 2. Terminate the contract.� 3. Immediately recreate the contract with the same account_id.E
 This is bad because the contents of a trie are deleted lazily and there might beY
 storage of the old instantiation still in it when the new contract is created. PleaseY
 note that we can't replace the counter by the block number because the sequence aboveQ
 can happen in the same block. We also can't keep the account counter in memory onlyI
 because storage is the only way to communicate across different extrinsics in the0 same block. # Note=
 Do not use it to determine the number of contracts. It won't be decremented ifd a contract is destroyed.8ContractInfoOf
�
� The code associated with a given account.� TWOX-NOTE: SAFE since `AccountId` is a secure hash.4DeletionQueue
�
� Evicted contracts that await child trie deletion.I
 Child trie deletion is a heavy operation depending on the amount of storage itemsY
 stored in said trie. Therefore this operation is performed lazily in `on_initialize`.
=
i Schedule�
�

�
  @�p� \'��(�
�L
��<�Z#�+8��D��XJD�pHRp�zf4Rb��>+d-R+�-����H\R\�N��3>�?.650U�8��Pb�T�U�J(� ��&t��m�JR	�P-x�!�*C$
n�NM�� d�T'c��,olT&�����
�����d�
$�9L!+�����
���	�B}	�<�G��/	h Cost schedule and limits.HDeletionQueueDepth<	
 The maximum number of contracts that can be pending for deletion.=
 When a contract is deleted by calling `seal_terminate` it becomes inaccessibleM
 immediately, but the deletion of the storage items it has accumulated is performed)
 later. The contract is put into the deletion queue. This defines how many]
 contracts can be queued up at the same time. If that limit is reached `seal_terminate`
 will fail. The action must be retried in a later block in that case.� The reasons for limiting the queue depth are:Y
 1. The queue is in storage in order to be persistent between blocks. We want to limit� 	the amount of storage that can be consumed.M
 2. The queue is stored in a vector and needs to be decoded as a whole when readingE
		it at the end of each block. Longer queues take more weight to decode and hence�		limit the amount of items that can be deleted per block.LDeletionWeightLimit  �RjtM
 The maximum amount of weight that can be consumed per block for lazy trie removal.]
 The amount of weight that is dedicated per block to work on the deletion queue. LargerE
 values allow more trie keys to be deleted in each block but reduce the amount ofA
 weight that is left for transactions. See [`Self::DeletionQueueDepth`] for more� information about the deletion queue.8DepositPerByte@`�
 The amount of balance a caller has to pay for each byte of storage. # Note)
 Changing this value for an existing chain might need a storage migration.8DepositPerItem@�I
 The amount of balance a caller has to pay for each storage item. # Note)
 Changing this value for an existing chain might need a storage migration.
�
.DPolymeshContracts
$ContractsPCallRuntimeWhitelist

Q
� Whitelist of extrinsics allowed to be called from contracts.
E
m
�
/ Preimage
 Preimage$StatusFor
$�
� The request status of a given hash.,PreimageFor
$
� The preimages stored by this pallet.
U
q
0$TestUtils
$TestUtils
Y
u
	2
 @CheckSpecVersion8CheckTxVersion0CheckGenesis$8CheckMortality!$(CheckNonce)9
,CheckWeight-9
`ChargeTransactionPayment59
DStoreCallMetadata99
=