@d9-network/spec 1.2.2 → 1.2.4

package/node_modules/@polkadot-api/descriptors/dist/d9.d.ts

@@ -0,0 +1,3346 @@
+import { StorageDescriptor, PlainDescriptor, TxDescriptor, Enum, ApisFromDef, QueryFromPalletsDef, TxFromPalletsDef, EventsFromPalletsDef, ErrorsFromPalletsDef, ConstFromPalletsDef, ViewFnsFromPalletsDef, SS58String, FixedSizeBinary, Binary, FixedSizeArray } from "polkadot-api";
+import { Ic5m5lp1oioo8r, Ihfphjolmsqq1, Idrurqd6ddlmr3, I2na29tt2afp0j, Ia2lhg7l2hilo3, I9ft3qmrv5je1f, I8oim79f1d4kf0, I1q8tnt1cluu5j, I8ds64oj6581v0, I9bin2jc70qt6q, GrandpaStoredState, I7pe2me3i3vtn9, I9jd27rnpm8ttv, I5sesotjlssv2d, Iffmde3ekjedi9, I4mddgoa69c0a2, I4mkleqnhi2c9f, I95g6i7ilua7lq, Ieniouoqkq4icf, Phase, TransactionPaymentReleases, I3qklfjubrljqh, Ifpr2ehamqbtpn, I7svnfko10tq2e, I4s6jkha20aoh0, I2brm5b9jij1st, I78s05f59eoi8b, Idbc6j12l47q6u, I99bb69usss9gs, Iba6d6esmudd4l, Iajr55k07398gt, I4cu6usuqp8s16, I8t4pajubp34g3, I4pact7n2e9a0i, Icgdc6619k0j8h, I3jnic9t7c9s12, Icgljjb6j82uhn, Ibi8anou2vv8ko, I82jm9g7pufuel, Iegmj7n48sc3am, I6asvuaa371pho, Iahe10507jfnjb, I1sg558l3j27vd, I4qtcfejrn68ub, I633kkio6e6dvg, Iertf1uspcjckm, In7a38730s6qs, If15el53dd76v9, I9s0ave7t0vnrk, Ic6nglu2db2c36, I4q39t5hn830vp, I1q6j2f64t5q87, I35p85j063s0il, Iatgdi2kcv135n, I9v2pl8dvist4n, I99b0kdiutrec0, Ieue63tv8cm6fj, Ifngtmog63ju60, Idq1r98dclp264, I7j6vt4ra6khhv, I37gkv4ibak4u6, I29iqhd70jua80, Iddf3ptb5cr131, Iam7af3p82h77u, I4ktuaksf5i1gk, I2vudfeo4jg9um, I9bqtpv2ii35mp, I9j7pagd6d4bda, I2h9pmio37r7fb, Ibmr18suc9ikh9, I9iq22t0burs89, I3a5kuu5t5jj3g, I2hviml3snvhhn, I5ieg0uffm6362, Icnilucsdvt9dl, I8k3rnvpeeh4hv, Iducklp98fr36e, I8ofcg5rbj0g2c, I4adgbll7gku4i, I6pjjpfvhvcfru, I9pj91mj79qekl, I39uah9nss64h9, Ik64dknsq7k08, Idcr6u6361oad9, Ic357tcepuvo5c, I2rnoam876ruhj, Ic5b47dj4coa3r, Ib3qnc19gu633c, Ifira6u9hi7cu1, I72tqocvdoqfff, I2i27f3sfmvc05, I1nlrtd1epki2d, I3abtumcmempjs, Id81m8flopt8ha, I8hff7chabggkd, I49i39mtj1ivbs, Ifkr2kcak2vto1, I1ju6r8q0cs9jt, I4kpeq6j7cd5bu, I5na1ka76k6811, I59mhdb9omdqfa, I9vl5kpk0fpakt, I717jt61hu19b4, I38jfk5li8iang, I81bepctomm169, Ib8e4i1c3merv7, I2dtrijkm5601t, I2ev73t79f46tb, Ib2obgji960euh, Ia2rnh5pfua40a, I3otc7e9a35k1k, I89ier5tb9ne0s, Im2f0numhevg3, Ib51vk42m1po4n, I2agkcpojhkk43, I32rvg545edabm, I83fv0vi59md7i, I5tjjqcdd4tae0, I8lba6g6is07ov, I7e25ln6niqtfu, Iffcutbjvs7mcv, Icm9m0qeemu66d, Icnrv1mfbd3in1, I4fpsonn5j8ai1, Ie2ucfidi90b0e, I9khdgpnnuth59, I4g2n89k9snq80, Icrf0bc54q02cm, I2nufb64tt01st, Icaemmvog4s1bf, I95cgc2lf0oi91, I73402qtagb1c2, I7v7r0cihtaupi, Ibl4potoitj8d4, Ibvn4b8lrtppoe, I3015mdrqab6c7, Icv68aq8841478, Ic262ibdoec56a, Iflcfm9b6nlmdd, Ijrsf4mnp3eka, Id5fm4p8lj5qgi, I8tjvj9uq4b7hi, I4cbvqmqadhrea, I3qt1hgg4djhgb, I5768ac424h061, I34ij139cfkd29, I4sdl4mafpdt24, Ia82mnkmeo2rhc, Ik28h8117tnle, Icbccs0ug47ilf, I855j4i3kr8ko1, Ier2cke86dqbr2, I88ff3u4dpivk, I33cp947glv1ks, Ic9om1gmmqu7rq, I5hfov2b68ppb6, Ibthhb2m9vneds, Iaitn5bqfacj7k, If4ebvclj2ugvi, Ia5le7udkgbaq9, Ieduc1e6frq8rb, I9h6gbtabovtm4, Ifnsa0dkkpf465, I65dtqr2egjbc3, Ibqj3vg5s5lk0c, I6l73u513p8rna, Iefqmt2htu1dlu, Ift6f10887nk72, I7qc53b1tvqjg2, I8ugagfge33cr6, Iak7fhrgb9jnnq, Ie5222qfrr24ek, I28g8sphdu312k, I853aigjva3f0t, I7q5qk4uoanhof, I33ec4tl0gpobd, Idht9upmipvd4j, I6niuoceqveh04, I6qlgjcdbigsr7, I2hq50pu2kdjpo, I44hc4lgsn4o1j, I8iksqi3eani0a, I16enopmju1p0q, Ifgqhle2413de7, I43kq8qudg7pq9, I76riseemre533, Ie5v6njpckr05b, I38bmcrmh852rk, I4hcillge8de5f, I95l2k9b1re95f, I2evmoek0livio, Ifi8hei4mra7b1, I8uo3fpd3bcc6f, I6ouflveob4eli } from "./common-types";
+type AnonymousEnum<T extends {}> = T & {
+    __anonymous: true;
+};
+type MyTuple<T> = [T, ...T[]];
+type SeparateUndefined<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
+type Anonymize<T> = SeparateUndefined<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum<infer V> ? Enum<V> : T extends MyTuple<any> ? {
+    [K in keyof T]: T[K];
+} : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : {
+    [K in keyof T & string]: T[K];
+}>;
+type IStorage = {
+    Aura: {
+        /**
+         * The current authority set.
+         */
+        Authorities: StorageDescriptor<[], Anonymize<Ic5m5lp1oioo8r>, false, never>;
+        /**
+         * The current slot of this block.
+         *
+         * This will be set in `on_initialize`.
+         */
+        CurrentSlot: StorageDescriptor<[], bigint, false, never>;
+    };
+    D9Referral: {
+        /**
+         * from the perspective of a node in the referral tree,
+         * the MaxReferralDepth is the largest Nth ancestor node
+         * This associated type is only necessary for first run of
+         * the chain as it will define the default value for the
+         * MaxReferralDepth storage item. This value can be changed during runtime
+         * through an extrinsic call.
+         */
+        MaxReferralDepth: StorageDescriptor<[], number, false, never>;
+        /**
+         * (child -> parent) referral relationship AccountId -> AccountId
+         */
+        ReferralRelationships: StorageDescriptor<[Key: SS58String], SS58String, true, never>;
+        /**
+        
+         */
+        DirectReferralsCount: StorageDescriptor<[Key: SS58String], number, false, never>;
+    };
+    D9Treasury: {
+        /**
+         * Number of proposals that have been made.
+         */
+        Treasurer: StorageDescriptor<[], Anonymize<Ihfphjolmsqq1>, true, never>;
+    };
+    D9NodeVoting: {
+        /**
+         * defines the voting power of a user
+         */
+        UsersVotingInterests: StorageDescriptor<[Key: SS58String], Anonymize<Idrurqd6ddlmr3>, true, never>;
+        /**
+         * defines the vote distribution of a user to some candidate
+         *
+         * user -> candidate -> votes
+         * UserToNodeVotesTotals == NodeToUserVotesTotals
+         */
+        UserToNodeVotesTotals: StorageDescriptor<Anonymize<I2na29tt2afp0j>, bigint, false, never>;
+        /**
+         * defines the supporters of a candidate
+         *
+         * candidate -> supporter -> votes
+         * UserToNodeVotesTotals == NodeToUserVotesTotals
+         */
+        NodeToUserVotesTotals: StorageDescriptor<Anonymize<I2na29tt2afp0j>, bigint, false, never>;
+        /**
+         * grand total of votes for a candidate
+         *
+         * this Map can be no larger than MaxCandidates
+         */
+        NodeAccumulativeVotes: StorageDescriptor<[Key: SS58String], bigint, true, never>;
+        /**
+        
+         */
+        CurrentNumberOfCandidatesNodes: StorageDescriptor<[], number, false, never>;
+        /**
+        
+         */
+        SessionNodeList: StorageDescriptor<[Key: number], Anonymize<Ia2lhg7l2hilo3>, true, never>;
+        /**
+        
+         */
+        CurrentSessionIndex: StorageDescriptor<[], number, false, never>;
+        /**
+        
+         */
+        CurrentValidatorVoteStats: StorageDescriptor<[Key: SS58String], Anonymize<I9ft3qmrv5je1f>, true, never>;
+        /**
+        
+         */
+        NodeMetadata: StorageDescriptor<[Key: SS58String], Anonymize<I8oim79f1d4kf0>, true, never>;
+        /**
+        
+         */
+        PalletAdmin: StorageDescriptor<[], SS58String, true, never>;
+    };
+    D9NodeRewards: {
+        /**
+        
+         */
+        NodeRewardContract: StorageDescriptor<[], SS58String, true, never>;
+        /**
+        
+         */
+        PalletAdmin: StorageDescriptor<[], SS58String, true, never>;
+    };
+    Balances: {
+        /**
+         * The total units issued in the system.
+         */
+        TotalIssuance: StorageDescriptor<[], bigint, false, never>;
+        /**
+         * The total units of outstanding deactivated balance in the system.
+         */
+        InactiveIssuance: StorageDescriptor<[], bigint, false, never>;
+        /**
+         * The Balances pallet example of storing the balance of an account.
+         *
+         * # Example
+         *
+         * ```nocompile
+         * impl pallet_balances::Config for Runtime {
+         * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
+         * }
+         * ```
+         *
+         * You can also store the balance of an account in the `System` pallet.
+         *
+         * # Example
+         *
+         * ```nocompile
+         * impl pallet_balances::Config for Runtime {
+         * type AccountStore = System
+         * }
+         * ```
+         *
+         * But this comes with tradeoffs, storing account balances in the system pallet stores
+         * `frame_system` data alongside the account data contrary to storing account balances in the
+         * `Balances` pallet, which uses a `StorageMap` to store balances data only.
+         * NOTE: This is only used in the case that this pallet is used to store balances.
+         */
+        Account: StorageDescriptor<[Key: SS58String], Anonymize<I1q8tnt1cluu5j>, false, never>;
+        /**
+         * Any liquidity locks on some account balances.
+         * NOTE: Should only be accessed when setting, changing and freeing a lock.
+         */
+        Locks: StorageDescriptor<[Key: SS58String], Anonymize<I8ds64oj6581v0>, false, never>;
+        /**
+         * Named reserves on some account balances.
+         */
+        Reserves: StorageDescriptor<[Key: SS58String], Anonymize<I9bin2jc70qt6q>, false, never>;
+        /**
+         * Holds on account balances.
+         */
+        Holds: StorageDescriptor<[Key: SS58String], Anonymize<I9bin2jc70qt6q>, false, never>;
+        /**
+         * Freeze locks on account balances.
+         */
+        Freezes: StorageDescriptor<[Key: SS58String], Anonymize<I9bin2jc70qt6q>, false, never>;
+    };
+    Grandpa: {
+        /**
+         * State of the current authority set.
+         */
+        State: StorageDescriptor<[], GrandpaStoredState, false, never>;
+        /**
+         * Pending change: (signaled at, scheduled change).
+         */
+        PendingChange: StorageDescriptor<[], Anonymize<I7pe2me3i3vtn9>, true, never>;
+        /**
+         * next block number where we can force a change.
+         */
+        NextForced: StorageDescriptor<[], number, true, never>;
+        /**
+         * `true` if we are currently stalled.
+         */
+        Stalled: StorageDescriptor<[], Anonymize<I9jd27rnpm8ttv>, true, never>;
+        /**
+         * The number of changes (both in terms of keys and underlying economic responsibilities)
+         * in the "set" of Grandpa validators from genesis.
+         */
+        CurrentSetId: StorageDescriptor<[], bigint, false, never>;
+        /**
+         * A mapping from grandpa set ID to the index of the *most recent* session for which its
+         * members were responsible.
+         *
+         * This is only used for validating equivocation proofs. An equivocation proof must
+         * contains a key-ownership proof for a given session, therefore we need a way to tie
+         * together sessions and GRANDPA set ids, i.e. we need to validate that a validator
+         * was the owner of a given key on a given session, and what the active set ID was
+         * during that session.
+         *
+         * TWOX-NOTE: `SetId` is not under user control.
+         */
+        SetIdSession: StorageDescriptor<[Key: bigint], number, true, never>;
+    };
+    Sudo: {
+        /**
+         * The `AccountId` of the sudo key.
+         */
+        Key: StorageDescriptor<[], SS58String, true, never>;
+    };
+    System: {
+        /**
+         * The full account information for a particular account ID.
+         */
+        Account: StorageDescriptor<[Key: SS58String], Anonymize<I5sesotjlssv2d>, false, never>;
+        /**
+         * Total extrinsics count for the current block.
+         */
+        ExtrinsicCount: StorageDescriptor<[], number, true, never>;
+        /**
+         * The current weight for the block.
+         */
+        BlockWeight: StorageDescriptor<[], Anonymize<Iffmde3ekjedi9>, false, never>;
+        /**
+         * Total length (in bytes) for all extrinsics put together, for the current block.
+         */
+        AllExtrinsicsLen: StorageDescriptor<[], number, true, never>;
+        /**
+         * Map of block numbers to block hashes.
+         */
+        BlockHash: StorageDescriptor<[Key: number], FixedSizeBinary<32>, false, never>;
+        /**
+         * Extrinsics data for the current block (maps an extrinsic's index to its data).
+         */
+        ExtrinsicData: StorageDescriptor<[Key: number], Binary, false, never>;
+        /**
+         * The current block number being processed. Set by `execute_block`.
+         */
+        Number: StorageDescriptor<[], number, false, never>;
+        /**
+         * Hash of the previous block.
+         */
+        ParentHash: StorageDescriptor<[], FixedSizeBinary<32>, false, never>;
+        /**
+         * Digest of the current block, also part of the block header.
+         */
+        Digest: StorageDescriptor<[], Anonymize<I4mddgoa69c0a2>, false, never>;
+        /**
+         * 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.
+         */
+        Events: StorageDescriptor<[], Anonymize<I4mkleqnhi2c9f>, false, never>;
+        /**
+         * The number of events in the `Events<T>` list.
+         */
+        EventCount: StorageDescriptor<[], number, false, never>;
+        /**
+         * Mapping between a topic (represented by T::Hash) and a vector of indexes
+         * of events in the `<Events<T>>` list.
+         *
+         * All topic vectors have deterministic storage locations depending on the topic. This
+         * allows light-clients to leverage the changes trie storage tracking mechanism and
+         * in case of changes fetch the list of events of interest.
+         *
+         * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just
+         * 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.
+         */
+        EventTopics: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize<I95g6i7ilua7lq>, false, never>;
+        /**
+         * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
+         */
+        LastRuntimeUpgrade: StorageDescriptor<[], Anonymize<Ieniouoqkq4icf>, true, never>;
+        /**
+         * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
+         */
+        UpgradedToU32RefCount: StorageDescriptor<[], boolean, false, never>;
+        /**
+         * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
+         * (default) if not.
+         */
+        UpgradedToTripleRefCount: StorageDescriptor<[], boolean, false, never>;
+        /**
+         * The execution phase of the block.
+         */
+        ExecutionPhase: StorageDescriptor<[], Phase, true, never>;
+    };
+    Timestamp: {
+        /**
+         * Current time for the current block.
+         */
+        Now: StorageDescriptor<[], bigint, false, never>;
+        /**
+         * Did the timestamp get updated in this block?
+         */
+        DidUpdate: StorageDescriptor<[], boolean, false, never>;
+    };
+    TransactionPayment: {
+        /**
+        
+         */
+        NextFeeMultiplier: StorageDescriptor<[], bigint, false, never>;
+        /**
+        
+         */
+        StorageVersion: StorageDescriptor<[], TransactionPaymentReleases, false, never>;
+    };
+    Assets: {
+        /**
+         * Details of an asset.
+         */
+        Asset: StorageDescriptor<[Key: number], Anonymize<I3qklfjubrljqh>, true, never>;
+        /**
+         * The holdings of a specific account for a specific asset.
+         */
+        Account: StorageDescriptor<Anonymize<I7svnfko10tq2e>, Anonymize<Ifpr2ehamqbtpn>, true, never>;
+        /**
+         * Approved balance transfers. First balance is the amount approved for transfer. Second
+         * is the amount of `T::Currency` reserved for storing this.
+         * First key is the asset ID, second key is the owner and third key is the delegate.
+         */
+        Approvals: StorageDescriptor<Anonymize<I2brm5b9jij1st>, Anonymize<I4s6jkha20aoh0>, true, never>;
+        /**
+         * Metadata of an asset.
+         */
+        Metadata: StorageDescriptor<[Key: number], Anonymize<I78s05f59eoi8b>, false, never>;
+    };
+    AuthorityDiscovery: {
+        /**
+         * Keys of the current authority set.
+         */
+        Keys: StorageDescriptor<[], Anonymize<Ic5m5lp1oioo8r>, false, never>;
+        /**
+         * Keys of the next authority set.
+         */
+        NextKeys: StorageDescriptor<[], Anonymize<Ic5m5lp1oioo8r>, false, never>;
+    };
+    Collective: {
+        /**
+         * The hashes of the active proposals.
+         */
+        Proposals: StorageDescriptor<[], Anonymize<Ic5m5lp1oioo8r>, false, never>;
+        /**
+         * Actual proposal for a given hash, if it's current.
+         */
+        ProposalOf: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize<Idbc6j12l47q6u>, true, never>;
+        /**
+         * Votes on a given proposal, if it is ongoing.
+         */
+        Voting: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize<I99bb69usss9gs>, true, never>;
+        /**
+         * Proposals so far.
+         */
+        ProposalCount: StorageDescriptor<[], number, false, never>;
+        /**
+         * The current members of the collective. This is stored sorted (just by value).
+         */
+        Members: StorageDescriptor<[], Anonymize<Ia2lhg7l2hilo3>, false, never>;
+        /**
+         * The prime member that helps determine the default vote behavior in case of absentations.
+         */
+        Prime: StorageDescriptor<[], SS58String, true, never>;
+    };
+    Contracts: {
+        /**
+         * A mapping from an original code hash to the original code, untouched by instrumentation.
+         */
+        PristineCode: StorageDescriptor<[Key: FixedSizeBinary<32>], Binary, true, never>;
+        /**
+         * A mapping between an original code hash and instrumented wasm code, ready for execution.
+         */
+        CodeStorage: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize<Iba6d6esmudd4l>, true, never>;
+        /**
+         * A mapping between an original code hash and its owner information.
+         */
+        OwnerInfoOf: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize<Iajr55k07398gt>, true, never>;
+        /**
+         * 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).
+         * The nonce is required because otherwise the following sequence would lead to
+         * a possible collision of storage:
+         *
+         * 1. Create a new contract.
+         * 2. Terminate the contract.
+         * 3. Immediately recreate the contract with the same account_id.
+         *
+         * This is bad because the contents of a trie are deleted lazily and there might be
+         * storage of the old instantiation still in it when the new contract is created. Please
+         * note that we can't replace the counter by the block number because the sequence above
+         * can happen in the same block. We also can't keep the account counter in memory only
+         * because storage is the only way to communicate across different extrinsics in the
+         * same block.
+         *
+         * # Note
+         *
+         * Do not use it to determine the number of contracts. It won't be decremented if
+         * a contract is destroyed.
+         */
+        Nonce: StorageDescriptor<[], bigint, false, never>;
+        /**
+         * The code associated with a given account.
+         *
+         * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+         */
+        ContractInfoOf: StorageDescriptor<[Key: SS58String], Anonymize<I4cu6usuqp8s16>, true, never>;
+        /**
+         * Evicted contracts that await child trie deletion.
+         *
+         * Child trie deletion is a heavy operation depending on the amount of storage items
+         * stored in said trie. Therefore this operation is performed lazily in `on_idle`.
+         */
+        DeletionQueue: StorageDescriptor<[Key: number], Binary, true, never>;
+        /**
+         * A pair of monotonic counters used to track the latest contract marked for deletion
+         * and the latest deleted contract in queue.
+         */
+        DeletionQueueCounter: StorageDescriptor<[], Anonymize<I8t4pajubp34g3>, false, never>;
+    };
+    Historical: {
+        /**
+         * Mapping from historical session indices to session-data root hash and validator count.
+         */
+        HistoricalSessions: StorageDescriptor<[Key: number], Anonymize<I4pact7n2e9a0i>, true, never>;
+        /**
+         * The range of historical sessions we store. [first, last)
+         */
+        StoredRange: StorageDescriptor<[], Anonymize<I9jd27rnpm8ttv>, true, never>;
+    };
+    ImOnline: {
+        /**
+         * 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 fall
+         * 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.
+         *
+         * 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`.
+         */
+        HeartbeatAfter: StorageDescriptor<[], number, false, never>;
+        /**
+         * The current set of keys that may issue a heartbeat.
+         */
+        Keys: StorageDescriptor<[], Anonymize<Ic5m5lp1oioo8r>, false, never>;
+        /**
+         * For each session index, we keep a mapping of `SessionIndex` and `AuthIndex` to
+         * `WrapperOpaque<BoundedOpaqueNetworkState>`.
+         */
+        ReceivedHeartbeats: StorageDescriptor<Anonymize<I9jd27rnpm8ttv>, Anonymize<Icgdc6619k0j8h>, true, never>;
+        /**
+         * For each session index, we keep a mapping of `ValidatorId<T>` to the
+         * number of blocks authored by the given authority.
+         */
+        AuthoredBlocks: StorageDescriptor<Anonymize<I7svnfko10tq2e>, number, false, never>;
+    };
+    RandomnessCollectiveFlip: {
+        /**
+         * Series of block headers from the last 81 blocks that acts as random seed material. This
+         * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of
+         * the oldest hash.
+         */
+        RandomMaterial: StorageDescriptor<[], Anonymize<Ic5m5lp1oioo8r>, false, never>;
+    };
+    Session: {
+        /**
+         * The current set of validators.
+         */
+        Validators: StorageDescriptor<[], Anonymize<Ia2lhg7l2hilo3>, false, never>;
+        /**
+         * Current index of the session.
+         */
+        CurrentIndex: StorageDescriptor<[], number, false, never>;
+        /**
+         * True if the underlying economic identities or weighting behind the validators
+         * has changed in the queued validator set.
+         */
+        QueuedChanged: StorageDescriptor<[], boolean, false, never>;
+        /**
+         * The queued keys for the next session. When the next session begins, these keys
+         * will be used to determine the validator's session keys.
+         */
+        QueuedKeys: StorageDescriptor<[], Anonymize<I3jnic9t7c9s12>, false, never>;
+        /**
+         * 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` returns
+         * a new set of identities.
+         */
+        DisabledValidators: StorageDescriptor<[], Anonymize<Icgljjb6j82uhn>, false, never>;
+        /**
+         * The next session keys for a validator.
+         */
+        NextKeys: StorageDescriptor<[Key: SS58String], Anonymize<Ibi8anou2vv8ko>, true, never>;
+        /**
+         * The owner of a key. The key is the `KeyTypeId` + the encoded key.
+         */
+        KeyOwner: StorageDescriptor<[Key: Anonymize<I82jm9g7pufuel>], SS58String, true, never>;
+    };
+    Treasury: {
+        /**
+         * Number of proposals that have been made.
+         */
+        ProposalCount: StorageDescriptor<[], number, false, never>;
+        /**
+         * Proposals that have been made.
+         */
+        Proposals: StorageDescriptor<[Key: number], Anonymize<Iegmj7n48sc3am>, true, never>;
+        /**
+         * The amount which has been reported as inactive to Currency.
+         */
+        Deactivated: StorageDescriptor<[], bigint, false, never>;
+        /**
+         * Proposal indices that have been approved but not yet awarded.
+         */
+        Approvals: StorageDescriptor<[], Anonymize<Icgljjb6j82uhn>, false, never>;
+    };
+    CouncilLock: {
+        /**
+        
+         */
+        PalletAdmin: StorageDescriptor<[], SS58String, true, never>;
+        /**
+         * fee to proposal a lock on an account. paid by the proposer
+         */
+        ProposalFee: StorageDescriptor<[], bigint, false, never>;
+        /**
+        
+         */
+        MiningPoolContract: StorageDescriptor<[], SS58String, true, never>;
+        /**
+        
+         */
+        Proposals: StorageDescriptor<[Key: SS58String], Anonymize<I6asvuaa371pho>, true, never>;
+        /**
+        
+         */
+        Referendums: StorageDescriptor<[Key: SS58String], Anonymize<Iahe10507jfnjb>, true, never>;
+        /**
+        
+         */
+        Resolutions: StorageDescriptor<Anonymize<I7svnfko10tq2e>, Anonymize<I1sg558l3j27vd>, true, never>;
+        /**
+        
+         */
+        LockedAccounts: StorageDescriptor<[Key: SS58String], Anonymize<I4qtcfejrn68ub>, true, never>;
+    };
+    D9MultiSig: {
+        /**
+         * the existent multi signature accounts
+         *
+         * key: multi signature account address value: multi signature account
+         */
+        MultiSignatureAccounts: StorageDescriptor<[Key: SS58String], Anonymize<I633kkio6e6dvg>, true, never>;
+        /**
+         * key: normal accounts value: vec of multi signature account ids that user is a member of
+         */
+        UserMultiSigAccounts: StorageDescriptor<[Key: SS58String], Anonymize<Ia2lhg7l2hilo3>, true, never>;
+        /**
+         * (msa_address, proposal)
+         */
+        MinApprovalProposals: StorageDescriptor<[Key: SS58String], Anonymize<Iertf1uspcjckm>, true, never>;
+    };
+};
+type ICalls = {
+    D9Referral: {
+        /**
+        
+         */
+        change_referral_depth: TxDescriptor<Anonymize<Iatgdi2kcv135n>>;
+    };
+    D9Treasury: {
+        /**
+        
+         */
+        new_treasurer: TxDescriptor<Anonymize<I9v2pl8dvist4n>>;
+    };
+    D9NodeVoting: {
+        /**
+        
+         */
+        submit_candidacy: TxDescriptor<Anonymize<I99b0kdiutrec0>>;
+        /**
+        
+         */
+        add_voting_interest: TxDescriptor<Anonymize<Ieue63tv8cm6fj>>;
+        /**
+        
+         */
+        delegate_votes: TxDescriptor<Anonymize<Ifngtmog63ju60>>;
+        /**
+        
+         */
+        remove_candidacy: TxDescriptor<undefined>;
+        /**
+        
+         */
+        try_remove_votes_from_candidate: TxDescriptor<Anonymize<Idq1r98dclp264>>;
+        /**
+        
+         */
+        redistribute_votes: TxDescriptor<Anonymize<I7j6vt4ra6khhv>>;
+        /**
+        
+         */
+        change_candidate_name: TxDescriptor<Anonymize<I37gkv4ibak4u6>>;
+        /**
+        
+         */
+        change_candidate_supporter_share: TxDescriptor<Anonymize<I29iqhd70jua80>>;
+        /**
+        
+         */
+        set_pallet_admin: TxDescriptor<Anonymize<Iddf3ptb5cr131>>;
+    };
+    D9NodeRewards: {
+        /**
+        
+         */
+        set_pallet_admin: TxDescriptor<Anonymize<Iddf3ptb5cr131>>;
+        /**
+        
+         */
+        set_node_reward_contract: TxDescriptor<Anonymize<Iam7af3p82h77u>>;
+    };
+    Balances: {
+        /**
+         * Transfer some liquid free balance to another account.
+         *
+         * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.
+         * If the sender's account is below the existential deposit as a result
+         * of the transfer, the account will be reaped.
+         *
+         * The dispatch origin for this call must be `Signed` by the transactor.
+         */
+        transfer_allow_death: TxDescriptor<Anonymize<I4ktuaksf5i1gk>>;
+        /**
+         * Set the regular balance of a given account; it also takes a reserved balance but this
+         * must be the same as the account's current reserved balance.
+         *
+         * The dispatch origin for this call is `root`.
+         *
+         * WARNING: This call is DEPRECATED! Use `force_set_balance` instead.
+         */
+        set_balance_deprecated: TxDescriptor<Anonymize<I2vudfeo4jg9um>>;
+        /**
+         * Exactly as `transfer_allow_death`, except the origin must be root and the source account
+         * may be specified.
+         */
+        force_transfer: TxDescriptor<Anonymize<I9bqtpv2ii35mp>>;
+        /**
+         * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not
+         * kill the origin account.
+         *
+         * 99% of the time you want [`transfer_allow_death`] instead.
+         *
+         * [`transfer_allow_death`]: struct.Pallet.html#method.transfer
+         */
+        transfer_keep_alive: TxDescriptor<Anonymize<I4ktuaksf5i1gk>>;
+        /**
+         * Transfer the entire transferable balance from the caller account.
+         *
+         * NOTE: This function only attempts to transfer _transferable_ balances. This means that
+         * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
+         * transferred by this function. To ensure that this function results in a killed account,
+         * you might need to prepare the account by removing any reference counters, storage
+         * deposits, etc...
+         *
+         * The dispatch origin of this call must be Signed.
+         *
+         * - `dest`: The recipient of the transfer.
+         * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
+         * of the funds the account has, causing the sender account to be killed (false), or
+         * transfer everything except at least the existential deposit, which will guarantee to
+         * keep the sender account alive (true).
+         */
+        transfer_all: TxDescriptor<Anonymize<I9j7pagd6d4bda>>;
+        /**
+         * Unreserve some balance from a user by force.
+         *
+         * Can only be called by ROOT.
+         */
+        force_unreserve: TxDescriptor<Anonymize<I2h9pmio37r7fb>>;
+        /**
+         * Upgrade a specified account.
+         *
+         * - `origin`: Must be `Signed`.
+         * - `who`: The account to be upgraded.
+         *
+         * This will waive the transaction fee if at least all but 10% of the accounts needed to
+         * be upgraded. (We let some not have to be upgraded just in order to allow for the
+         * possibililty of churn).
+         */
+        upgrade_accounts: TxDescriptor<Anonymize<Ibmr18suc9ikh9>>;
+        /**
+         * Alias for `transfer_allow_death`, provided only for name-wise compatibility.
+         *
+         * WARNING: DEPRECATED! Will be released in approximately 3 months.
+         */
+        transfer: TxDescriptor<Anonymize<I4ktuaksf5i1gk>>;
+        /**
+         * Set the regular balance of a given account.
+         *
+         * The dispatch origin for this call is `root`.
+         */
+        force_set_balance: TxDescriptor<Anonymize<I9iq22t0burs89>>;
+    };
+    Grandpa: {
+        /**
+         * 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 offence
+         * will be reported.
+         */
+        report_equivocation: TxDescriptor<Anonymize<I3a5kuu5t5jj3g>>;
+        /**
+         * 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 offence
+         * will 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.
+         */
+        report_equivocation_unsigned: TxDescriptor<Anonymize<I3a5kuu5t5jj3g>>;
+        /**
+         * 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 block production rate (which may be slowed down because of finality lagging) should
+         * be taken into account when choosing the `delay`. The GRANDPA voters based on the new
+         * authority will start voting on top of `best_finalized_block_number` for new finalized
+         * blocks. `best_finalized_block_number` should be the highest of the latest finalized
+         * block of all validators of the new authority set.
+         *
+         * Only callable by root.
+         */
+        note_stalled: TxDescriptor<Anonymize<I2hviml3snvhhn>>;
+    };
+    Sudo: {
+        /**
+         * Authenticates the sudo key and dispatches a function call with `Root` origin.
+         *
+         * The dispatch origin for this call must be _Signed_.
+         *
+         * ## Complexity
+         * - O(1).
+         */
+        sudo: TxDescriptor<Anonymize<I5ieg0uffm6362>>;
+        /**
+         * 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_.
+         *
+         * ## Complexity
+         * - O(1).
+         */
+        sudo_unchecked_weight: TxDescriptor<Anonymize<Icnilucsdvt9dl>>;
+        /**
+         * 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_.
+         *
+         * ## Complexity
+         * - O(1).
+         */
+        set_key: TxDescriptor<Anonymize<I8k3rnvpeeh4hv>>;
+        /**
+         * 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_.
+         *
+         * ## Complexity
+         * - O(1).
+         */
+        sudo_as: TxDescriptor<Anonymize<Iducklp98fr36e>>;
+    };
+    System: {
+        /**
+         * Make some on-chain remark.
+         *
+         * ## Complexity
+         * - `O(1)`
+         */
+        remark: TxDescriptor<Anonymize<I8ofcg5rbj0g2c>>;
+        /**
+         * Set the number of pages in the WebAssembly environment's heap.
+         */
+        set_heap_pages: TxDescriptor<Anonymize<I4adgbll7gku4i>>;
+        /**
+         * Set the new runtime code.
+         *
+         * ## Complexity
+         * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`
+         */
+        set_code: TxDescriptor<Anonymize<I6pjjpfvhvcfru>>;
+        /**
+         * Set the new runtime code without doing any checks of the given `code`.
+         *
+         * ## Complexity
+         * - `O(C)` where `C` length of `code`
+         */
+        set_code_without_checks: TxDescriptor<Anonymize<I6pjjpfvhvcfru>>;
+        /**
+         * Set some items of storage.
+         */
+        set_storage: TxDescriptor<Anonymize<I9pj91mj79qekl>>;
+        /**
+         * Kill some items from storage.
+         */
+        kill_storage: TxDescriptor<Anonymize<I39uah9nss64h9>>;
+        /**
+         * Kill all storage items with a key that starts with the given prefix.
+         *
+         * **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.
+         */
+        kill_prefix: TxDescriptor<Anonymize<Ik64dknsq7k08>>;
+        /**
+         * Make some on-chain remark and emit event.
+         */
+        remark_with_event: TxDescriptor<Anonymize<I8ofcg5rbj0g2c>>;
+    };
+    Timestamp: {
+        /**
+         * Set the current time.
+         *
+         * 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.
+         *
+         * The timestamp should be greater than the previous one by the amount specified by
+         * `MinimumPeriod`.
+         *
+         * The dispatch origin for this call must be `Inherent`.
+         *
+         * ## Complexity
+         * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
+         * - 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)`.
+         */
+        set: TxDescriptor<Anonymize<Idcr6u6361oad9>>;
+    };
+    Assets: {
+        /**
+         * Issue a new class of fungible assets from a public origin.
+         *
+         * This new asset class has no assets initially and its owner is the origin.
+         *
+         * The origin must conform to the configured `CreateOrigin` and have sufficient funds free.
+         *
+         * Funds of sender are reserved by `AssetDeposit`.
+         *
+         * Parameters:
+         * - `id`: The identifier of the new asset. This must not be currently in use to identify
+         * an existing asset.
+         * - `admin`: The admin of this class of assets. The admin is the initial address of each
+         * member of the asset class's admin team.
+         * - `min_balance`: The minimum balance of this new asset that any single account must
+         * have. If an account's balance is reduced below this, then it collapses to zero.
+         *
+         * Emits `Created` event when successful.
+         *
+         * Weight: `O(1)`
+         */
+        create: TxDescriptor<Anonymize<Ic357tcepuvo5c>>;
+        /**
+         * Issue a new class of fungible assets from a privileged origin.
+         *
+         * This new asset class has no assets initially.
+         *
+         * The origin must conform to `ForceOrigin`.
+         *
+         * Unlike `create`, no funds are reserved.
+         *
+         * - `id`: The identifier of the new asset. This must not be currently in use to identify
+         * an existing asset.
+         * - `owner`: The owner of this class of assets. The owner has full superuser permissions
+         * over this asset, but may later change and configure the permissions using
+         * `transfer_ownership` and `set_team`.
+         * - `min_balance`: The minimum balance of this new asset that any single account must
+         * have. If an account's balance is reduced below this, then it collapses to zero.
+         *
+         * Emits `ForceCreated` event when successful.
+         *
+         * Weight: `O(1)`
+         */
+        force_create: TxDescriptor<Anonymize<I2rnoam876ruhj>>;
+        /**
+         * Start the process of destroying a fungible asset class.
+         *
+         * `start_destroy` is the first in a series of extrinsics that should be called, to allow
+         * destruction of an asset class.
+         *
+         * The origin must conform to `ForceOrigin` or must be `Signed` by the asset's `owner`.
+         *
+         * - `id`: The identifier of the asset to be destroyed. This must identify an existing
+         * asset.
+         *
+         * The asset class must be frozen before calling `start_destroy`.
+         */
+        start_destroy: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Destroy all accounts associated with a given asset.
+         *
+         * `destroy_accounts` should only be called after `start_destroy` has been called, and the
+         * asset is in a `Destroying` state.
+         *
+         * Due to weight restrictions, this function may need to be called multiple times to fully
+         * destroy all accounts. It will destroy `RemoveItemsLimit` accounts at a time.
+         *
+         * - `id`: The identifier of the asset to be destroyed. This must identify an existing
+         * asset.
+         *
+         * Each call emits the `Event::DestroyedAccounts` event.
+         */
+        destroy_accounts: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Destroy all approvals associated with a given asset up to the max (T::RemoveItemsLimit).
+         *
+         * `destroy_approvals` should only be called after `start_destroy` has been called, and the
+         * asset is in a `Destroying` state.
+         *
+         * Due to weight restrictions, this function may need to be called multiple times to fully
+         * destroy all approvals. It will destroy `RemoveItemsLimit` approvals at a time.
+         *
+         * - `id`: The identifier of the asset to be destroyed. This must identify an existing
+         * asset.
+         *
+         * Each call emits the `Event::DestroyedApprovals` event.
+         */
+        destroy_approvals: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Complete destroying asset and unreserve currency.
+         *
+         * `finish_destroy` should only be called after `start_destroy` has been called, and the
+         * asset is in a `Destroying` state. All accounts or approvals should be destroyed before
+         * hand.
+         *
+         * - `id`: The identifier of the asset to be destroyed. This must identify an existing
+         * asset.
+         *
+         * Each successful call emits the `Event::Destroyed` event.
+         */
+        finish_destroy: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Mint assets of a particular class.
+         *
+         * The origin must be Signed and the sender must be the Issuer of the asset `id`.
+         *
+         * - `id`: The identifier of the asset to have some amount minted.
+         * - `beneficiary`: The account to be credited with the minted assets.
+         * - `amount`: The amount of the asset to be minted.
+         *
+         * Emits `Issued` event when successful.
+         *
+         * Weight: `O(1)`
+         * Modes: Pre-existing balance of `beneficiary`; Account pre-existence of `beneficiary`.
+         */
+        mint: TxDescriptor<Anonymize<Ib3qnc19gu633c>>;
+        /**
+         * Reduce the balance of `who` by as much as possible up to `amount` assets of `id`.
+         *
+         * Origin must be Signed and the sender should be the Manager of the asset `id`.
+         *
+         * Bails with `NoAccount` if the `who` is already dead.
+         *
+         * - `id`: The identifier of the asset to have some amount burned.
+         * - `who`: The account to be debited from.
+         * - `amount`: The maximum amount by which `who`'s balance should be reduced.
+         *
+         * Emits `Burned` with the actual amount burned. If this takes the balance to below the
+         * minimum for the asset, then the amount burned is increased to take it to zero.
+         *
+         * Weight: `O(1)`
+         * Modes: Post-existence of `who`; Pre & post Zombie-status of `who`.
+         */
+        burn: TxDescriptor<Anonymize<Ifira6u9hi7cu1>>;
+        /**
+         * Move some assets from the sender account to another.
+         *
+         * Origin must be Signed.
+         *
+         * - `id`: The identifier of the asset to have some amount transferred.
+         * - `target`: The account to be credited.
+         * - `amount`: The amount by which the sender's balance of assets should be reduced and
+         * `target`'s balance increased. The amount actually transferred may be slightly greater in
+         * the case that the transfer would otherwise take the sender balance above zero but below
+         * the minimum balance. Must be greater than zero.
+         *
+         * Emits `Transferred` with the actual amount transferred. If this takes the source balance
+         * to below the minimum for the asset, then the amount transferred is increased to take it
+         * to zero.
+         *
+         * Weight: `O(1)`
+         * Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of
+         * `target`.
+         */
+        transfer: TxDescriptor<Anonymize<I72tqocvdoqfff>>;
+        /**
+         * Move some assets from the sender account to another, keeping the sender account alive.
+         *
+         * Origin must be Signed.
+         *
+         * - `id`: The identifier of the asset to have some amount transferred.
+         * - `target`: The account to be credited.
+         * - `amount`: The amount by which the sender's balance of assets should be reduced and
+         * `target`'s balance increased. The amount actually transferred may be slightly greater in
+         * the case that the transfer would otherwise take the sender balance above zero but below
+         * the minimum balance. Must be greater than zero.
+         *
+         * Emits `Transferred` with the actual amount transferred. If this takes the source balance
+         * to below the minimum for the asset, then the amount transferred is increased to take it
+         * to zero.
+         *
+         * Weight: `O(1)`
+         * Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of
+         * `target`.
+         */
+        transfer_keep_alive: TxDescriptor<Anonymize<I72tqocvdoqfff>>;
+        /**
+         * Move some assets from one account to another.
+         *
+         * Origin must be Signed and the sender should be the Admin of the asset `id`.
+         *
+         * - `id`: The identifier of the asset to have some amount transferred.
+         * - `source`: The account to be debited.
+         * - `dest`: The account to be credited.
+         * - `amount`: The amount by which the `source`'s balance of assets should be reduced and
+         * `dest`'s balance increased. The amount actually transferred may be slightly greater in
+         * the case that the transfer would otherwise take the `source` balance above zero but
+         * below the minimum balance. Must be greater than zero.
+         *
+         * Emits `Transferred` with the actual amount transferred. If this takes the source balance
+         * to below the minimum for the asset, then the amount transferred is increased to take it
+         * to zero.
+         *
+         * Weight: `O(1)`
+         * Modes: Pre-existence of `dest`; Post-existence of `source`; Account pre-existence of
+         * `dest`.
+         */
+        force_transfer: TxDescriptor<Anonymize<I2i27f3sfmvc05>>;
+        /**
+         * Disallow further unprivileged transfers from an account.
+         *
+         * Origin must be Signed and the sender should be the Freezer of the asset `id`.
+         *
+         * - `id`: The identifier of the asset to be frozen.
+         * - `who`: The account to be frozen.
+         *
+         * Emits `Frozen`.
+         *
+         * Weight: `O(1)`
+         */
+        freeze: TxDescriptor<Anonymize<I1nlrtd1epki2d>>;
+        /**
+         * Allow unprivileged transfers from an account again.
+         *
+         * Origin must be Signed and the sender should be the Admin of the asset `id`.
+         *
+         * - `id`: The identifier of the asset to be frozen.
+         * - `who`: The account to be unfrozen.
+         *
+         * Emits `Thawed`.
+         *
+         * Weight: `O(1)`
+         */
+        thaw: TxDescriptor<Anonymize<I1nlrtd1epki2d>>;
+        /**
+         * Disallow further unprivileged transfers for the asset class.
+         *
+         * Origin must be Signed and the sender should be the Freezer of the asset `id`.
+         *
+         * - `id`: The identifier of the asset to be frozen.
+         *
+         * Emits `Frozen`.
+         *
+         * Weight: `O(1)`
+         */
+        freeze_asset: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Allow unprivileged transfers for the asset again.
+         *
+         * Origin must be Signed and the sender should be the Admin of the asset `id`.
+         *
+         * - `id`: The identifier of the asset to be thawed.
+         *
+         * Emits `Thawed`.
+         *
+         * Weight: `O(1)`
+         */
+        thaw_asset: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Change the Owner of an asset.
+         *
+         * Origin must be Signed and the sender should be the Owner of the asset `id`.
+         *
+         * - `id`: The identifier of the asset.
+         * - `owner`: The new Owner of this asset.
+         *
+         * Emits `OwnerChanged`.
+         *
+         * Weight: `O(1)`
+         */
+        transfer_ownership: TxDescriptor<Anonymize<I3abtumcmempjs>>;
+        /**
+         * Change the Issuer, Admin and Freezer of an asset.
+         *
+         * Origin must be Signed and the sender should be the Owner of the asset `id`.
+         *
+         * - `id`: The identifier of the asset to be frozen.
+         * - `issuer`: The new Issuer of this asset.
+         * - `admin`: The new Admin of this asset.
+         * - `freezer`: The new Freezer of this asset.
+         *
+         * Emits `TeamChanged`.
+         *
+         * Weight: `O(1)`
+         */
+        set_team: TxDescriptor<Anonymize<Id81m8flopt8ha>>;
+        /**
+         * Set the metadata for an asset.
+         *
+         * Origin must be Signed and the sender should be the Owner of the asset `id`.
+         *
+         * Funds of sender are reserved according to the formula:
+         * `MetadataDepositBase + MetadataDepositPerByte * (name.len + symbol.len)` taking into
+         * account any already reserved funds.
+         *
+         * - `id`: The identifier of the asset to update.
+         * - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.
+         * - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
+         * - `decimals`: The number of decimals this asset uses to represent one unit.
+         *
+         * Emits `MetadataSet`.
+         *
+         * Weight: `O(1)`
+         */
+        set_metadata: TxDescriptor<Anonymize<I8hff7chabggkd>>;
+        /**
+         * Clear the metadata for an asset.
+         *
+         * Origin must be Signed and the sender should be the Owner of the asset `id`.
+         *
+         * Any deposit is freed for the asset owner.
+         *
+         * - `id`: The identifier of the asset to clear.
+         *
+         * Emits `MetadataCleared`.
+         *
+         * Weight: `O(1)`
+         */
+        clear_metadata: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Force the metadata for an asset to some value.
+         *
+         * Origin must be ForceOrigin.
+         *
+         * Any deposit is left alone.
+         *
+         * - `id`: The identifier of the asset to update.
+         * - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.
+         * - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
+         * - `decimals`: The number of decimals this asset uses to represent one unit.
+         *
+         * Emits `MetadataSet`.
+         *
+         * Weight: `O(N + S)` where N and S are the length of the name and symbol respectively.
+         */
+        force_set_metadata: TxDescriptor<Anonymize<I49i39mtj1ivbs>>;
+        /**
+         * Clear the metadata for an asset.
+         *
+         * Origin must be ForceOrigin.
+         *
+         * Any deposit is returned.
+         *
+         * - `id`: The identifier of the asset to clear.
+         *
+         * Emits `MetadataCleared`.
+         *
+         * Weight: `O(1)`
+         */
+        force_clear_metadata: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Alter the attributes of a given asset.
+         *
+         * Origin must be `ForceOrigin`.
+         *
+         * - `id`: The identifier of the asset.
+         * - `owner`: The new Owner of this asset.
+         * - `issuer`: The new Issuer of this asset.
+         * - `admin`: The new Admin of this asset.
+         * - `freezer`: The new Freezer of this asset.
+         * - `min_balance`: The minimum balance of this new asset that any single account must
+         * have. If an account's balance is reduced below this, then it collapses to zero.
+         * - `is_sufficient`: Whether a non-zero balance of this asset is deposit of sufficient
+         * value to account for the state bloat associated with its balance storage. If set to
+         * `true`, then non-zero balances may be stored without a `consumer` reference (and thus
+         * an ED in the Balances pallet or whatever else is used to control user-account state
+         * growth).
+         * - `is_frozen`: Whether this asset class is frozen except for permissioned/admin
+         * instructions.
+         *
+         * Emits `AssetStatusChanged` with the identity of the asset.
+         *
+         * Weight: `O(1)`
+         */
+        force_asset_status: TxDescriptor<Anonymize<Ifkr2kcak2vto1>>;
+        /**
+         * Approve an amount of asset for transfer by a delegated third-party account.
+         *
+         * Origin must be Signed.
+         *
+         * Ensures that `ApprovalDeposit` worth of `Currency` is reserved from signing account
+         * for the purpose of holding the approval. If some non-zero amount of assets is already
+         * approved from signing account to `delegate`, then it is topped up or unreserved to
+         * meet the right value.
+         *
+         * NOTE: The signing account does not need to own `amount` of assets at the point of
+         * making this call.
+         *
+         * - `id`: The identifier of the asset.
+         * - `delegate`: The account to delegate permission to transfer asset.
+         * - `amount`: The amount of asset that may be transferred by `delegate`. If there is
+         * already an approval in place, then this acts additively.
+         *
+         * Emits `ApprovedTransfer` on success.
+         *
+         * Weight: `O(1)`
+         */
+        approve_transfer: TxDescriptor<Anonymize<I1ju6r8q0cs9jt>>;
+        /**
+         * Cancel all of some asset approved for delegated transfer by a third-party account.
+         *
+         * Origin must be Signed and there must be an approval in place between signer and
+         * `delegate`.
+         *
+         * Unreserves any deposit previously reserved by `approve_transfer` for the approval.
+         *
+         * - `id`: The identifier of the asset.
+         * - `delegate`: The account delegated permission to transfer asset.
+         *
+         * Emits `ApprovalCancelled` on success.
+         *
+         * Weight: `O(1)`
+         */
+        cancel_approval: TxDescriptor<Anonymize<I4kpeq6j7cd5bu>>;
+        /**
+         * Cancel all of some asset approved for delegated transfer by a third-party account.
+         *
+         * Origin must be either ForceOrigin or Signed origin with the signer being the Admin
+         * account of the asset `id`.
+         *
+         * Unreserves any deposit previously reserved by `approve_transfer` for the approval.
+         *
+         * - `id`: The identifier of the asset.
+         * - `delegate`: The account delegated permission to transfer asset.
+         *
+         * Emits `ApprovalCancelled` on success.
+         *
+         * Weight: `O(1)`
+         */
+        force_cancel_approval: TxDescriptor<Anonymize<I5na1ka76k6811>>;
+        /**
+         * Transfer some asset balance from a previously delegated account to some third-party
+         * account.
+         *
+         * Origin must be Signed and there must be an approval in place by the `owner` to the
+         * signer.
+         *
+         * If the entire amount approved for transfer is transferred, then any deposit previously
+         * reserved by `approve_transfer` is unreserved.
+         *
+         * - `id`: The identifier of the asset.
+         * - `owner`: The account which previously approved for a transfer of at least `amount` and
+         * from which the asset balance will be withdrawn.
+         * - `destination`: The account to which the asset balance of `amount` will be transferred.
+         * - `amount`: The amount of assets to transfer.
+         *
+         * Emits `TransferredApproved` on success.
+         *
+         * Weight: `O(1)`
+         */
+        transfer_approved: TxDescriptor<Anonymize<I59mhdb9omdqfa>>;
+        /**
+         * Create an asset account for non-provider assets.
+         *
+         * A deposit will be taken from the signer account.
+         *
+         * - `origin`: Must be Signed; the signer account must have sufficient funds for a deposit
+         * to be taken.
+         * - `id`: The identifier of the asset for the account to be created.
+         *
+         * Emits `Touched` event when successful.
+         */
+        touch: TxDescriptor<Anonymize<Ic5b47dj4coa3r>>;
+        /**
+         * Return the deposit (if any) of an asset account.
+         *
+         * The origin must be Signed.
+         *
+         * - `id`: The identifier of the asset for the account to be created.
+         * - `allow_burn`: If `true` then assets may be destroyed in order to complete the refund.
+         *
+         * Emits `Refunded` event when successful.
+         */
+        refund: TxDescriptor<Anonymize<I9vl5kpk0fpakt>>;
+        /**
+         * Sets the minimum balance of an asset.
+         *
+         * Only works if there aren't any accounts that are holding the asset or if
+         * the new value of `min_balance` is less than the old one.
+         *
+         * Origin must be Signed and the sender has to be the Owner of the
+         * asset `id`.
+         *
+         * - `id`: The identifier of the asset.
+         * - `min_balance`: The new value of `min_balance`.
+         *
+         * Emits `AssetMinBalanceChanged` event when successful.
+         */
+        set_min_balance: TxDescriptor<Anonymize<I717jt61hu19b4>>;
+    };
+    Collective: {
+        /**
+         * Set the collective's membership.
+         *
+         * - `new_members`: The new member list. Be nice to the chain and provide it sorted.
+         * - `prime`: The prime member whose vote sets the default.
+         * - `old_count`: The upper bound for the previous number of members in storage. Used for
+         * weight estimation.
+         *
+         * The dispatch of this call must be `SetMembersOrigin`.
+         *
+         * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
+         * the weight estimations rely on it to estimate dispatchable weight.
+         *
+         * # WARNING:
+         *
+         * The `pallet-collective` can also be managed by logic outside of the pallet through the
+         * implementation of the trait [`ChangeMembers`].
+         * Any call to `set_members` must be careful that the member set doesn't get out of sync
+         * with other logic managing the member set.
+         *
+         * ## Complexity:
+         * - `O(MP + N)` where:
+         * - `M` old-members-count (code- and governance-bounded)
+         * - `N` new-members-count (code- and governance-bounded)
+         * - `P` proposals-count (code-bounded)
+         */
+        set_members: TxDescriptor<Anonymize<I38jfk5li8iang>>;
+        /**
+         * Dispatch a proposal from a member using the `Member` origin.
+         *
+         * Origin must be a member of the collective.
+         *
+         * ## Complexity:
+         * - `O(B + M + P)` where:
+         * - `B` is `proposal` size in bytes (length-fee-bounded)
+         * - `M` members-count (code-bounded)
+         * - `P` complexity of dispatching `proposal`
+         */
+        execute: TxDescriptor<Anonymize<I81bepctomm169>>;
+        /**
+         * Add a new proposal to either be voted on or executed directly.
+         *
+         * Requires the sender to be member.
+         *
+         * `threshold` determines whether `proposal` is executed directly (`threshold < 2`)
+         * or put up for voting.
+         *
+         * ## Complexity
+         * - `O(B + M + P1)` or `O(B + M + P2)` where:
+         * - `B` is `proposal` size in bytes (length-fee-bounded)
+         * - `M` is members-count (code- and governance-bounded)
+         * - branching is influenced by `threshold` where:
+         * - `P1` is proposal execution complexity (`threshold < 2`)
+         * - `P2` is proposals-count (code-bounded) (`threshold >= 2`)
+         */
+        propose: TxDescriptor<Anonymize<Ib8e4i1c3merv7>>;
+        /**
+         * Add an aye or nay vote for the sender to the given proposal.
+         *
+         * Requires the sender to be a member.
+         *
+         * Transaction fees will be waived if the member is voting on any particular proposal
+         * for the first time and the call is successful. Subsequent vote changes will charge a
+         * fee.
+         * ## Complexity
+         * - `O(M)` where `M` is members-count (code- and governance-bounded)
+         */
+        vote: TxDescriptor<Anonymize<I2dtrijkm5601t>>;
+        /**
+         * Disapprove a proposal, close, and remove it from the system, regardless of its current
+         * state.
+         *
+         * Must be called by the Root origin.
+         *
+         * Parameters:
+         * * `proposal_hash`: The hash of the proposal that should be disapproved.
+         *
+         * ## Complexity
+         * O(P) where P is the number of max proposals
+         */
+        disapprove_proposal: TxDescriptor<Anonymize<I2ev73t79f46tb>>;
+        /**
+         * Close a vote that is either approved, disapproved or whose voting period has ended.
+         *
+         * May be called by any signed account in order to finish voting and close the proposal.
+         *
+         * If called before the end of the voting period it will only close the vote if it is
+         * has enough votes to be approved or disapproved.
+         *
+         * If called after the end of the voting period abstentions are counted as rejections
+         * unless there is a prime member set and the prime member cast an approval.
+         *
+         * If the close operation completes successfully with disapproval, the transaction fee will
+         * be waived. Otherwise execution of the approved operation will be charged to the caller.
+         *
+         * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed
+         * proposal.
+         * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via
+         * `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.
+         *
+         * ## Complexity
+         * - `O(B + M + P1 + P2)` where:
+         * - `B` is `proposal` size in bytes (length-fee-bounded)
+         * - `M` is members-count (code- and governance-bounded)
+         * - `P1` is the complexity of `proposal` preimage.
+         * - `P2` is proposal-count (code-bounded)
+         */
+        close: TxDescriptor<Anonymize<Ib2obgji960euh>>;
+    };
+    Contracts: {
+        /**
+         * Deprecated version if [`Self::call`] for use in an in-storage `Call`.
+         */
+        call_old_weight: TxDescriptor<Anonymize<Ia2rnh5pfua40a>>;
+        /**
+         * Deprecated version if [`Self::instantiate_with_code`] for use in an in-storage `Call`.
+         */
+        instantiate_with_code_old_weight: TxDescriptor<Anonymize<I3otc7e9a35k1k>>;
+        /**
+         * Deprecated version if [`Self::instantiate`] for use in an in-storage `Call`.
+         */
+        instantiate_old_weight: TxDescriptor<Anonymize<I89ier5tb9ne0s>>;
+        /**
+         * Upload new `code` without instantiating a contract from it.
+         *
+         * If the code does not already exist a deposit is reserved from the caller
+         * and unreserved only when [`Self::remove_code`] is called. The size of the reserve
+         * depends on the instrumented size of the the supplied `code`.
+         *
+         * If the code already exists in storage it will still return `Ok` and upgrades
+         * the in storage version to the current
+         * [`InstructionWeights::version`](InstructionWeights).
+         *
+         * - `determinism`: If this is set to any other value but [`Determinism::Enforced`] then
+         * the only way to use this code is to delegate call into it from an offchain execution.
+         * Set to [`Determinism::Enforced`] if in doubt.
+         *
+         * # Note
+         *
+         * Anyone can instantiate a contract from any uploaded code and thus prevent its removal.
+         * To avoid this situation a constructor could employ access control so that it can
+         * only be instantiated by permissioned entities. The same is true when uploading
+         * through [`Self::instantiate_with_code`].
+         */
+        upload_code: TxDescriptor<Anonymize<Im2f0numhevg3>>;
+        /**
+         * Remove the code stored under `code_hash` and refund the deposit to its owner.
+         *
+         * A code can only be removed by its original uploader (its owner) and only if it is
+         * not used by any contract.
+         */
+        remove_code: TxDescriptor<Anonymize<Ib51vk42m1po4n>>;
+        /**
+         * Privileged function that changes the code of an existing contract.
+         *
+         * This takes care of updating refcounts and all other necessary operations. Returns
+         * an error if either the `code_hash` or `dest` do not exist.
+         *
+         * # Note
+         *
+         * This does **not** change the address of the contract in question. This means
+         * that the contract address is no longer derived from its code hash after calling
+         * this dispatchable.
+         */
+        set_code: TxDescriptor<Anonymize<I2agkcpojhkk43>>;
+        /**
+         * Makes a call to an account, optionally transferring some balance.
+         *
+         * # 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.
+         * * `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.
+         * * 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.
+         */
+        call: TxDescriptor<Anonymize<I32rvg545edabm>>;
+        /**
+         * Instantiates a new contract from the supplied `code` optionally transferring
+         * some 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`].
+         *
+         * # Parameters
+         *
+         * * `value`: The balance to transfer from the `origin` to the newly created contract.
+         * * `gas_limit`: The gas limit enforced when executing the constructor.
+         * * `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.
+         * * `salt`: Used for the address derivation. See [`Pallet::contract_address`].
+         *
+         * Instantiation is executed as follows:
+         *
+         * - The supplied `code` is instrumented, deployed, and a `code_hash` is created for that
+         * code.
+         * - If the `code_hash` already exists on the chain the underlying `code` will be shared.
+         * - 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.
+         * - The `deploy` function is executed in the context of the newly-created account.
+         */
+        instantiate_with_code: TxDescriptor<Anonymize<I83fv0vi59md7i>>;
+        /**
+         * Instantiates a contract from a previously deployed wasm binary.
+         *
+         * This function is identical to [`Self::instantiate_with_code`] but without the
+         * code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary
+         * must be supplied.
+         */
+        instantiate: TxDescriptor<Anonymize<I5tjjqcdd4tae0>>;
+    };
+    ImOnline: {
+        /**
+         * ## 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`
+         */
+        heartbeat: TxDescriptor<Anonymize<I8lba6g6is07ov>>;
+    };
+    Session: {
+        /**
+         * 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.
+         *
+         * ## Complexity
+         * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is
+         * fixed.
+         */
+        set_keys: TxDescriptor<Anonymize<I7e25ln6niqtfu>>;
+        /**
+         * Removes any session key(s) of the function caller.
+         *
+         * This doesn't take effect until the next session.
+         *
+         * 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 usually
+         * means being a controller account) or directly convertible into a validator ID (which
+         * usually means being a stash account).
+         *
+         * ## Complexity
+         * - `O(1)` in number of key types. Actual cost depends on the number of length of
+         * `T::Keys::key_ids()` which is fixed.
+         */
+        purge_keys: TxDescriptor<undefined>;
+    };
+    Treasury: {
+        /**
+         * Put forward a suggestion for spending. A deposit proportional to the value
+         * is reserved and slashed if the proposal is rejected. It is returned once the
+         * proposal is awarded.
+         *
+         * ## Complexity
+         * - O(1)
+         */
+        propose_spend: TxDescriptor<Anonymize<Iffcutbjvs7mcv>>;
+        /**
+         * Reject a proposed spend. The original deposit will be slashed.
+         *
+         * May only be called from `T::RejectOrigin`.
+         *
+         * ## Complexity
+         * - O(1)
+         */
+        reject_proposal: TxDescriptor<Anonymize<Icm9m0qeemu66d>>;
+        /**
+         * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary
+         * and the original deposit will be returned.
+         *
+         * May only be called from `T::ApproveOrigin`.
+         *
+         * ## Complexity
+         * - O(1).
+         */
+        approve_proposal: TxDescriptor<Anonymize<Icm9m0qeemu66d>>;
+        /**
+         * Propose and approve a spend of treasury funds.
+         *
+         * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.
+         * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.
+         * - `beneficiary`: The destination account for the transfer.
+         *
+         * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the
+         * beneficiary.
+         */
+        spend: TxDescriptor<Anonymize<Icnrv1mfbd3in1>>;
+        /**
+         * Force a previously approved proposal to be removed from the approval queue.
+         * The original deposit will no longer be returned.
+         *
+         * May only be called from `T::RejectOrigin`.
+         * - `proposal_id`: The index of a proposal
+         *
+         * ## Complexity
+         * - O(A) where `A` is the number of approvals
+         *
+         * Errors:
+         * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,
+         * i.e., the proposal has not been approved. This could also mean the proposal does not
+         * exist altogether, thus there is no way it would have been approved in the first place.
+         */
+        remove_approval: TxDescriptor<Anonymize<Icm9m0qeemu66d>>;
+    };
+    CouncilLock: {
+        /**
+        
+         */
+        set_pallet_admin: TxDescriptor<Anonymize<Iddf3ptb5cr131>>;
+        /**
+        
+         */
+        set_mining_pool_contract: TxDescriptor<Anonymize<Iam7af3p82h77u>>;
+        /**
+        
+         */
+        propose_lock: TxDescriptor<Anonymize<I4fpsonn5j8ai1>>;
+        /**
+        
+         */
+        propose_unlock: TxDescriptor<Anonymize<Ie2ucfidi90b0e>>;
+        /**
+        
+         */
+        vote_in_referendum: TxDescriptor<Anonymize<I9khdgpnnuth59>>;
+        /**
+        
+         */
+        set_proposal_fee: TxDescriptor<Anonymize<I4g2n89k9snq80>>;
+        /**
+        
+         */
+        admin_lock_accounts: TxDescriptor<Anonymize<Icrf0bc54q02cm>>;
+        /**
+        
+         */
+        admin_unlock_accounts: TxDescriptor<Anonymize<I2nufb64tt01st>>;
+        /**
+        
+         */
+        admin_remove_proposal: TxDescriptor<Anonymize<Icaemmvog4s1bf>>;
+    };
+    D9MultiSig: {
+        /**
+         * create a new multi signature account
+         *
+         * signatories must have cardinality of at least 2 and
+         * less than T::MaxSignatories, with all unique elements.
+         * origin must be an element of signatories and authors a
+         * subset of signatories.
+         * Parameters:
+         * - `signatories`: the list of signatories
+         * - `authors_opt`: the list of authors, if None all signatories are authors
+         * - `min_approving_signatories`: the minimum number of signatories required to approve a call
+         */
+        create_multi_sig_account: TxDescriptor<Anonymize<I95cgc2lf0oi91>>;
+        /**
+         * create a call for a msa
+         *
+         * only authors can create calls
+         * Parameters:
+         * - `multi_sig_account`: the multi signature account
+         * - `call`: the call to be executed (runtime call. the js polkadot can help create it)
+         */
+        author_a_call: TxDescriptor<Anonymize<I73402qtagb1c2>>;
+        /**
+         * signatories approve a call
+         *
+         * Parameters:
+         * - `multi_sig_account`: the multi signature account
+         * - `call_id`: the call to be approved
+         */
+        add_call_approval: TxDescriptor<Anonymize<I7v7r0cihtaupi>>;
+        /**
+         * remove approval for a call
+         *
+         * Parameters:
+         * - `multi_sig_account`: the multi signature account
+         * - `call_id`: the call to be approved
+         */
+        remove_call_approval: TxDescriptor<Anonymize<I7v7r0cihtaupi>>;
+        /**
+         * propose a new minimum approvals for a multi signature account
+         *
+         * Parameters:
+         * - `msa_address`: the multi signature account
+         * - `new_min_approvals`: the new minimum approvals
+         */
+        proposal_msa_new_minimum: TxDescriptor<Anonymize<Ibl4potoitj8d4>>;
+        /**
+        
+         */
+        approve_msa_new_minimum: TxDescriptor<Anonymize<Ibvn4b8lrtppoe>>;
+        /**
+        
+         */
+        revoke_approval_for_msa_new_minimum: TxDescriptor<Anonymize<Ibvn4b8lrtppoe>>;
+        /**
+        
+         */
+        remove_call: TxDescriptor<Anonymize<I7v7r0cihtaupi>>;
+    };
+};
+type IEvent = {
+    D9Referral: {
+        /**
+        
+         */
+        NewReferralRelationshipCreated: PlainDescriptor<Anonymize<I2na29tt2afp0j>>;
+        /**
+        
+         */
+        NewReferralDepthSet: PlainDescriptor<number>;
+        /**
+        
+         */
+        NewDefaultParentSet: PlainDescriptor<SS58String>;
+    };
+    D9Treasury: {
+        /**
+        
+         */
+        NewTreasurer: PlainDescriptor<SS58String>;
+    };
+    D9NodeVoting: {
+        /**
+        
+         */
+        CandidacySubmitted: PlainDescriptor<SS58String>;
+        /**
+        
+         */
+        VotesDelegatedBy: PlainDescriptor<SS58String>;
+        /**
+        
+         */
+        CandidacyRemoved: PlainDescriptor<SS58String>;
+    };
+    D9NodeRewards: {
+        /**
+        
+         */
+        ErrorIssuingRewards: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ContractError: PlainDescriptor<Anonymize<I3015mdrqab6c7>>;
+    };
+    Balances: {
+        /**
+         * An account was created with some free balance.
+         */
+        Endowed: PlainDescriptor<Anonymize<Icv68aq8841478>>;
+        /**
+         * An account was removed whose balance was non-zero but below ExistentialDeposit,
+         * resulting in an outright loss.
+         */
+        DustLost: PlainDescriptor<Anonymize<Ic262ibdoec56a>>;
+        /**
+         * Transfer succeeded.
+         */
+        Transfer: PlainDescriptor<Anonymize<Iflcfm9b6nlmdd>>;
+        /**
+         * A balance was set by root.
+         */
+        BalanceSet: PlainDescriptor<Anonymize<Ijrsf4mnp3eka>>;
+        /**
+         * Some balance was reserved (moved from free to reserved).
+         */
+        Reserved: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some balance was unreserved (moved from reserved to free).
+         */
+        Unreserved: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some balance was moved from the reserve of the first account to the second account.
+         * Final argument indicates the destination balance type.
+         */
+        ReserveRepatriated: PlainDescriptor<Anonymize<I8tjvj9uq4b7hi>>;
+        /**
+         * Some amount was deposited (e.g. for transaction fees).
+         */
+        Deposit: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some amount was withdrawn from the account (e.g. for transaction fees).
+         */
+        Withdraw: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some amount was removed from the account (e.g. for misbehavior).
+         */
+        Slashed: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some amount was minted into an account.
+         */
+        Minted: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some amount was burned from an account.
+         */
+        Burned: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some amount was suspended from an account (it can be restored later).
+         */
+        Suspended: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some amount was restored into an account.
+         */
+        Restored: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * An account was upgraded.
+         */
+        Upgraded: PlainDescriptor<Anonymize<I4cbvqmqadhrea>>;
+        /**
+         * Total issuance was increased by `amount`, creating a credit to be balanced.
+         */
+        Issued: PlainDescriptor<Anonymize<I3qt1hgg4djhgb>>;
+        /**
+         * Total issuance was decreased by `amount`, creating a debt to be balanced.
+         */
+        Rescinded: PlainDescriptor<Anonymize<I3qt1hgg4djhgb>>;
+        /**
+         * Some balance was locked.
+         */
+        Locked: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some balance was unlocked.
+         */
+        Unlocked: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some balance was frozen.
+         */
+        Frozen: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+        /**
+         * Some balance was thawed.
+         */
+        Thawed: PlainDescriptor<Anonymize<Id5fm4p8lj5qgi>>;
+    };
+    Grandpa: {
+        /**
+         * New authority set has been applied.
+         */
+        NewAuthorities: PlainDescriptor<Anonymize<I5768ac424h061>>;
+        /**
+         * Current authority set has been paused.
+         */
+        Paused: PlainDescriptor<undefined>;
+        /**
+         * Current authority set has been resumed.
+         */
+        Resumed: PlainDescriptor<undefined>;
+    };
+    Sudo: {
+        /**
+         * A sudo just took place. \[result\]
+         */
+        Sudid: PlainDescriptor<Anonymize<I34ij139cfkd29>>;
+        /**
+         * The \[sudoer\] just switched identity; the old key is supplied if one existed.
+         */
+        KeyChanged: PlainDescriptor<Anonymize<I4sdl4mafpdt24>>;
+        /**
+         * A sudo just took place. \[result\]
+         */
+        SudoAsDone: PlainDescriptor<Anonymize<I34ij139cfkd29>>;
+    };
+    System: {
+        /**
+         * An extrinsic completed successfully.
+         */
+        ExtrinsicSuccess: PlainDescriptor<Anonymize<Ia82mnkmeo2rhc>>;
+        /**
+         * An extrinsic failed.
+         */
+        ExtrinsicFailed: PlainDescriptor<Anonymize<Ik28h8117tnle>>;
+        /**
+         * `:code` was updated.
+         */
+        CodeUpdated: PlainDescriptor<undefined>;
+        /**
+         * A new account was created.
+         */
+        NewAccount: PlainDescriptor<Anonymize<Icbccs0ug47ilf>>;
+        /**
+         * An account was reaped.
+         */
+        KilledAccount: PlainDescriptor<Anonymize<Icbccs0ug47ilf>>;
+        /**
+         * On on-chain remark happened.
+         */
+        Remarked: PlainDescriptor<Anonymize<I855j4i3kr8ko1>>;
+    };
+    TransactionPayment: {
+        /**
+         * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+         * has been paid by `who`.
+         */
+        TransactionFeePaid: PlainDescriptor<Anonymize<Ier2cke86dqbr2>>;
+    };
+    Assets: {
+        /**
+         * Some asset class was created.
+         */
+        Created: PlainDescriptor<Anonymize<I88ff3u4dpivk>>;
+        /**
+         * Some assets were issued.
+         */
+        Issued: PlainDescriptor<Anonymize<I33cp947glv1ks>>;
+        /**
+         * Some assets were transferred.
+         */
+        Transferred: PlainDescriptor<Anonymize<Ic9om1gmmqu7rq>>;
+        /**
+         * Some assets were destroyed.
+         */
+        Burned: PlainDescriptor<Anonymize<I5hfov2b68ppb6>>;
+        /**
+         * The management team changed.
+         */
+        TeamChanged: PlainDescriptor<Anonymize<Ibthhb2m9vneds>>;
+        /**
+         * The owner changed.
+         */
+        OwnerChanged: PlainDescriptor<Anonymize<Iaitn5bqfacj7k>>;
+        /**
+         * Some account `who` was frozen.
+         */
+        Frozen: PlainDescriptor<Anonymize<If4ebvclj2ugvi>>;
+        /**
+         * Some account `who` was thawed.
+         */
+        Thawed: PlainDescriptor<Anonymize<If4ebvclj2ugvi>>;
+        /**
+         * Some asset `asset_id` was frozen.
+         */
+        AssetFrozen: PlainDescriptor<Anonymize<Ia5le7udkgbaq9>>;
+        /**
+         * Some asset `asset_id` was thawed.
+         */
+        AssetThawed: PlainDescriptor<Anonymize<Ia5le7udkgbaq9>>;
+        /**
+         * Accounts were destroyed for given asset.
+         */
+        AccountsDestroyed: PlainDescriptor<Anonymize<Ieduc1e6frq8rb>>;
+        /**
+         * Approvals were destroyed for given asset.
+         */
+        ApprovalsDestroyed: PlainDescriptor<Anonymize<I9h6gbtabovtm4>>;
+        /**
+         * An asset class is in the process of being destroyed.
+         */
+        DestructionStarted: PlainDescriptor<Anonymize<Ia5le7udkgbaq9>>;
+        /**
+         * An asset class was destroyed.
+         */
+        Destroyed: PlainDescriptor<Anonymize<Ia5le7udkgbaq9>>;
+        /**
+         * Some asset class was force-created.
+         */
+        ForceCreated: PlainDescriptor<Anonymize<Iaitn5bqfacj7k>>;
+        /**
+         * New metadata has been set for an asset.
+         */
+        MetadataSet: PlainDescriptor<Anonymize<Ifnsa0dkkpf465>>;
+        /**
+         * Metadata has been cleared for an asset.
+         */
+        MetadataCleared: PlainDescriptor<Anonymize<Ia5le7udkgbaq9>>;
+        /**
+         * (Additional) funds have been approved for transfer to a destination account.
+         */
+        ApprovedTransfer: PlainDescriptor<Anonymize<I65dtqr2egjbc3>>;
+        /**
+         * An approval for account `delegate` was cancelled by `owner`.
+         */
+        ApprovalCancelled: PlainDescriptor<Anonymize<Ibqj3vg5s5lk0c>>;
+        /**
+         * An `amount` was transferred in its entirety from `owner` to `destination` by
+         * the approved `delegate`.
+         */
+        TransferredApproved: PlainDescriptor<Anonymize<I6l73u513p8rna>>;
+        /**
+         * An asset has had its attributes changed by the `Force` origin.
+         */
+        AssetStatusChanged: PlainDescriptor<Anonymize<Ia5le7udkgbaq9>>;
+        /**
+         * The min_balance of an asset has been updated by the asset owner.
+         */
+        AssetMinBalanceChanged: PlainDescriptor<Anonymize<Iefqmt2htu1dlu>>;
+    };
+    Collective: {
+        /**
+         * A motion (given hash) has been proposed (by given account) with a threshold (given
+         * `MemberCount`).
+         */
+        Proposed: PlainDescriptor<Anonymize<Ift6f10887nk72>>;
+        /**
+         * A motion (given hash) has been voted on by given account, leaving
+         * a tally (yes votes and no votes given respectively as `MemberCount`).
+         */
+        Voted: PlainDescriptor<Anonymize<I7qc53b1tvqjg2>>;
+        /**
+         * A motion was approved by the required threshold.
+         */
+        Approved: PlainDescriptor<Anonymize<I2ev73t79f46tb>>;
+        /**
+         * A motion was not approved by the required threshold.
+         */
+        Disapproved: PlainDescriptor<Anonymize<I2ev73t79f46tb>>;
+        /**
+         * A motion was executed; result will be `Ok` if it returned without error.
+         */
+        Executed: PlainDescriptor<Anonymize<I8ugagfge33cr6>>;
+        /**
+         * A single member did some action; result will be `Ok` if it returned without error.
+         */
+        MemberExecuted: PlainDescriptor<Anonymize<I8ugagfge33cr6>>;
+        /**
+         * A proposal was closed because its threshold was reached or after its duration was up.
+         */
+        Closed: PlainDescriptor<Anonymize<Iak7fhrgb9jnnq>>;
+    };
+    Contracts: {
+        /**
+         * Contract deployed by address at the specified address.
+         */
+        Instantiated: PlainDescriptor<Anonymize<Ie5222qfrr24ek>>;
+        /**
+         * Contract has been removed.
+         *
+         * # Note
+         *
+         * The only way for a contract to be removed and emitting this event is by calling
+         * `seal_terminate`.
+         */
+        Terminated: PlainDescriptor<Anonymize<I28g8sphdu312k>>;
+        /**
+         * Code with the specified hash has been stored.
+         */
+        CodeStored: PlainDescriptor<Anonymize<Ib51vk42m1po4n>>;
+        /**
+         * A custom event emitted by the contract.
+         */
+        ContractEmitted: PlainDescriptor<Anonymize<I853aigjva3f0t>>;
+        /**
+         * A code with the specified hash was removed.
+         */
+        CodeRemoved: PlainDescriptor<Anonymize<Ib51vk42m1po4n>>;
+        /**
+         * A contract's code was updated.
+         */
+        ContractCodeUpdated: PlainDescriptor<Anonymize<I7q5qk4uoanhof>>;
+        /**
+         * A contract was called either by a plain account or another contract.
+         *
+         * # Note
+         *
+         * Please keep in mind that like all events this is only emitted for successful
+         * calls. This is because on failure all storage changes including events are
+         * rolled back.
+         */
+        Called: PlainDescriptor<Anonymize<I33ec4tl0gpobd>>;
+        /**
+         * A contract delegate called a code hash.
+         *
+         * # Note
+         *
+         * Please keep in mind that like all events this is only emitted for successful
+         * calls. This is because on failure all storage changes including events are
+         * rolled back.
+         */
+        DelegateCalled: PlainDescriptor<Anonymize<Idht9upmipvd4j>>;
+    };
+    ImOnline: {
+        /**
+         * A new heartbeat was received from `AuthorityId`.
+         */
+        HeartbeatReceived: PlainDescriptor<Anonymize<I6niuoceqveh04>>;
+        /**
+         * At the end of the session, no offence was committed.
+         */
+        AllGood: PlainDescriptor<undefined>;
+        /**
+         * At the end of the session, at least one validator was found to be offline.
+         */
+        SomeOffline: PlainDescriptor<Anonymize<I6qlgjcdbigsr7>>;
+    };
+    Session: {
+        /**
+         * New session has happened. Note that the argument is the session index, not the
+         * block number as the type might suggest.
+         */
+        NewSession: PlainDescriptor<Anonymize<I2hq50pu2kdjpo>>;
+    };
+    Treasury: {
+        /**
+         * New proposal.
+         */
+        Proposed: PlainDescriptor<Anonymize<I44hc4lgsn4o1j>>;
+        /**
+         * We have ended a spend period and will now allocate funds.
+         */
+        Spending: PlainDescriptor<Anonymize<I8iksqi3eani0a>>;
+        /**
+         * Some funds have been allocated.
+         */
+        Awarded: PlainDescriptor<Anonymize<I16enopmju1p0q>>;
+        /**
+         * A proposal was rejected; funds were slashed.
+         */
+        Rejected: PlainDescriptor<Anonymize<Ifgqhle2413de7>>;
+        /**
+         * Some of our funds have been burnt.
+         */
+        Burnt: PlainDescriptor<Anonymize<I43kq8qudg7pq9>>;
+        /**
+         * Spending has finished; this is the amount that rolls over until next spend.
+         */
+        Rollover: PlainDescriptor<Anonymize<I76riseemre533>>;
+        /**
+         * Some funds have been deposited.
+         */
+        Deposit: PlainDescriptor<Anonymize<Ie5v6njpckr05b>>;
+        /**
+         * A new spend proposal has been approved.
+         */
+        SpendApproved: PlainDescriptor<Anonymize<I38bmcrmh852rk>>;
+        /**
+         * The inactive funds of the pallet have been updated.
+         */
+        UpdatedInactive: PlainDescriptor<Anonymize<I4hcillge8de5f>>;
+    };
+    CouncilLock: {
+        /**
+        
+         */
+        AccountNominatedForLock: PlainDescriptor<SS58String>;
+        /**
+        
+         */
+        ProposalFeePaid: PlainDescriptor<Anonymize<I95l2k9b1re95f>>;
+        /**
+         * voter, proposed account lock state, decision
+         */
+        VoteRecorded: PlainDescriptor<Anonymize<I2evmoek0livio>>;
+        /**
+        
+         */
+        AccountLocked: PlainDescriptor<SS58String>;
+        /**
+        
+         */
+        AccountUnlocked: PlainDescriptor<SS58String>;
+        /**
+        
+         */
+        AccountNominatedForUnlock: PlainDescriptor<SS58String>;
+        /**
+        
+         */
+        VoteStarted: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        VoteEnded: PlainDescriptor<Anonymize<Ifi8hei4mra7b1>>;
+    };
+    D9MultiSig: {
+        /**
+         * (creator, created)
+         */
+        MultiSignatureAccountCreated: PlainDescriptor<Anonymize<I2na29tt2afp0j>>;
+        /**
+         * (updater, updated)
+         */
+        MultiSignatureAccountUpdated: PlainDescriptor<Anonymize<I2na29tt2afp0j>>;
+        /**
+         * new transaction authors (author, call_id)
+         */
+        NewCallAuthored: PlainDescriptor<Anonymize<I8uo3fpd3bcc6f>>;
+        /**
+         * add approval to transaction (multi signature account, approver)
+         */
+        ApprovalAdded: PlainDescriptor<Anonymize<I2na29tt2afp0j>>;
+        /**
+         * remove approval from transaction (multi signature account, approver)
+         */
+        ApprovalRemoved: PlainDescriptor<Anonymize<I2na29tt2afp0j>>;
+        /**
+         * (executor)
+         */
+        CallExecuted: PlainDescriptor<FixedSizeBinary<32>>;
+        /**
+         * msa set new minimum approvals (multi signature account, new minimum)
+         */
+        MinApprovalsChanged: PlainDescriptor<Anonymize<I6ouflveob4eli>>;
+    };
+};
+type IError = {
+    D9Referral: {
+        /**
+        
+         */
+        NoReferralAccountRecord: PlainDescriptor<undefined>;
+    };
+    D9Treasury: {
+        /**
+        
+         */
+        OnlyTreasurerCanDoThis: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        NoTreasurerSet: PlainDescriptor<undefined>;
+    };
+    D9NodeVoting: {
+        /**
+        
+         */
+        HexDecodeError: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        EmptyDelegationList: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        DelegationListTooLarge: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        DelegatorHasNoVotingCapacity: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        DelegatorHasNoAvailableVotes: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        DelegatorHasInsufficientVotes: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        AttemptingToRemoveMoreVotesThanDelegated: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        CandidateDoesNotExist: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        CandidateAlreadyExists: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ErrorGettingNodeMetadata: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        VoterDidntDelegateToThisCandidate: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        NotActiveValidator: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        AtMaximumNumberOfCandidates: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        BurnAmountMustBeGreaterThan100: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        SupporterShareOutOfRange: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        CurrentValidatorCanNotChangeSharePercentage: PlainDescriptor<undefined>;
+    };
+    D9NodeRewards: {
+        /**
+        
+         */
+        RestrictedAccess: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        NodeRewardContractNotSet: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ErrorUpdatingNodeRewardContract: PlainDescriptor<undefined>;
+    };
+    Balances: {
+        /**
+         * Vesting balance too high to send value.
+         */
+        VestingBalance: PlainDescriptor<undefined>;
+        /**
+         * Account liquidity restrictions prevent withdrawal.
+         */
+        LiquidityRestrictions: PlainDescriptor<undefined>;
+        /**
+         * Balance too low to send value.
+         */
+        InsufficientBalance: PlainDescriptor<undefined>;
+        /**
+         * Value too low to create account due to existential deposit.
+         */
+        ExistentialDeposit: PlainDescriptor<undefined>;
+        /**
+         * Transfer/payment would kill account.
+         */
+        Expendability: PlainDescriptor<undefined>;
+        /**
+         * A vesting schedule already exists for this account.
+         */
+        ExistingVestingSchedule: PlainDescriptor<undefined>;
+        /**
+         * Beneficiary account must pre-exist.
+         */
+        DeadAccount: PlainDescriptor<undefined>;
+        /**
+         * Number of named reserves exceed `MaxReserves`.
+         */
+        TooManyReserves: PlainDescriptor<undefined>;
+        /**
+         * Number of holds exceed `MaxHolds`.
+         */
+        TooManyHolds: PlainDescriptor<undefined>;
+        /**
+         * Number of freezes exceed `MaxFreezes`.
+         */
+        TooManyFreezes: PlainDescriptor<undefined>;
+    };
+    Grandpa: {
+        /**
+         * Attempt to signal GRANDPA pause when the authority set isn't live
+         * (either paused or already pending pause).
+         */
+        PauseFailed: PlainDescriptor<undefined>;
+        /**
+         * Attempt to signal GRANDPA resume when the authority set isn't paused
+         * (either live or already pending resume).
+         */
+        ResumeFailed: PlainDescriptor<undefined>;
+        /**
+         * Attempt to signal GRANDPA change with one already pending.
+         */
+        ChangePending: PlainDescriptor<undefined>;
+        /**
+         * Cannot signal forced change so soon after last.
+         */
+        TooSoon: PlainDescriptor<undefined>;
+        /**
+         * A key ownership proof provided as part of an equivocation report is invalid.
+         */
+        InvalidKeyOwnershipProof: PlainDescriptor<undefined>;
+        /**
+         * An equivocation proof provided as part of an equivocation report is invalid.
+         */
+        InvalidEquivocationProof: PlainDescriptor<undefined>;
+        /**
+         * A given equivocation report is valid but already previously reported.
+         */
+        DuplicateOffenceReport: PlainDescriptor<undefined>;
+    };
+    Sudo: {
+        /**
+         * Sender must be the Sudo account
+         */
+        RequireSudo: PlainDescriptor<undefined>;
+    };
+    System: {
+        /**
+         * The name of specification does not match between the current runtime
+         * and the new runtime.
+         */
+        InvalidSpecName: PlainDescriptor<undefined>;
+        /**
+         * The specification version is not allowed to decrease between the current runtime
+         * and the new runtime.
+         */
+        SpecVersionNeedsToIncrease: PlainDescriptor<undefined>;
+        /**
+         * Failed to extract the runtime version from the new runtime.
+         *
+         * Either calling `Core_version` or decoding `RuntimeVersion` failed.
+         */
+        FailedToExtractRuntimeVersion: PlainDescriptor<undefined>;
+        /**
+         * Suicide called when the account has non-default composite data.
+         */
+        NonDefaultComposite: PlainDescriptor<undefined>;
+        /**
+         * There is a non-zero reference count preventing the account from being purged.
+         */
+        NonZeroRefCount: PlainDescriptor<undefined>;
+        /**
+         * The origin filter prevent the call to be dispatched.
+         */
+        CallFiltered: PlainDescriptor<undefined>;
+    };
+    Assets: {
+        /**
+         * Account balance must be greater than or equal to the transfer amount.
+         */
+        BalanceLow: PlainDescriptor<undefined>;
+        /**
+         * The account to alter does not exist.
+         */
+        NoAccount: PlainDescriptor<undefined>;
+        /**
+         * The signing account has no permission to do the operation.
+         */
+        NoPermission: PlainDescriptor<undefined>;
+        /**
+         * The given asset ID is unknown.
+         */
+        Unknown: PlainDescriptor<undefined>;
+        /**
+         * The origin account is frozen.
+         */
+        Frozen: PlainDescriptor<undefined>;
+        /**
+         * The asset ID is already taken.
+         */
+        InUse: PlainDescriptor<undefined>;
+        /**
+         * Invalid witness data given.
+         */
+        BadWitness: PlainDescriptor<undefined>;
+        /**
+         * Minimum balance should be non-zero.
+         */
+        MinBalanceZero: PlainDescriptor<undefined>;
+        /**
+         * Unable to increment the consumer reference counters on the account. Either no provider
+         * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
+         * fewer then the maximum number of consumers has been reached.
+         */
+        UnavailableConsumer: PlainDescriptor<undefined>;
+        /**
+         * Invalid metadata given.
+         */
+        BadMetadata: PlainDescriptor<undefined>;
+        /**
+         * No approval exists that would allow the transfer.
+         */
+        Unapproved: PlainDescriptor<undefined>;
+        /**
+         * The source account would not survive the transfer and it needs to stay alive.
+         */
+        WouldDie: PlainDescriptor<undefined>;
+        /**
+         * The asset-account already exists.
+         */
+        AlreadyExists: PlainDescriptor<undefined>;
+        /**
+         * The asset-account doesn't have an associated deposit.
+         */
+        NoDeposit: PlainDescriptor<undefined>;
+        /**
+         * The operation would result in funds being burned.
+         */
+        WouldBurn: PlainDescriptor<undefined>;
+        /**
+         * The asset is a live asset and is actively being used. Usually emit for operations such
+         * as `start_destroy` which require the asset to be in a destroying state.
+         */
+        LiveAsset: PlainDescriptor<undefined>;
+        /**
+         * The asset is not live, and likely being destroyed.
+         */
+        AssetNotLive: PlainDescriptor<undefined>;
+        /**
+         * The asset status is not the expected status.
+         */
+        IncorrectStatus: PlainDescriptor<undefined>;
+        /**
+         * The asset should be frozen before the given operation.
+         */
+        NotFrozen: PlainDescriptor<undefined>;
+        /**
+         * Callback action resulted in error
+         */
+        CallbackFailed: PlainDescriptor<undefined>;
+    };
+    Collective: {
+        /**
+         * Account is not a member
+         */
+        NotMember: PlainDescriptor<undefined>;
+        /**
+         * Duplicate proposals not allowed
+         */
+        DuplicateProposal: PlainDescriptor<undefined>;
+        /**
+         * Proposal must exist
+         */
+        ProposalMissing: PlainDescriptor<undefined>;
+        /**
+         * Mismatched index
+         */
+        WrongIndex: PlainDescriptor<undefined>;
+        /**
+         * Duplicate vote ignored
+         */
+        DuplicateVote: PlainDescriptor<undefined>;
+        /**
+         * Members are already initialized!
+         */
+        AlreadyInitialized: PlainDescriptor<undefined>;
+        /**
+         * The close call was made too early, before the end of the voting.
+         */
+        TooEarly: PlainDescriptor<undefined>;
+        /**
+         * There can only be a maximum of `MaxProposals` active proposals.
+         */
+        TooManyProposals: PlainDescriptor<undefined>;
+        /**
+         * The given weight bound for the proposal was too low.
+         */
+        WrongProposalWeight: PlainDescriptor<undefined>;
+        /**
+         * The given length bound for the proposal was too low.
+         */
+        WrongProposalLength: PlainDescriptor<undefined>;
+    };
+    Contracts: {
+        /**
+         * A new schedule must have a greater version than the current one.
+         */
+        InvalidScheduleVersion: PlainDescriptor<undefined>;
+        /**
+         * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
+         */
+        InvalidCallFlags: PlainDescriptor<undefined>;
+        /**
+         * The executed contract exhausted its gas limit.
+         */
+        OutOfGas: PlainDescriptor<undefined>;
+        /**
+         * The output buffer supplied to a contract API call was too small.
+         */
+        OutputBufferTooSmall: PlainDescriptor<undefined>;
+        /**
+         * Performing the requested transfer failed. Probably because there isn't enough
+         * free balance in the sender's account.
+         */
+        TransferFailed: PlainDescriptor<undefined>;
+        /**
+         * Performing a call was denied because the calling depth reached the limit
+         * of what is specified in the schedule.
+         */
+        MaxCallDepthReached: PlainDescriptor<undefined>;
+        /**
+         * No contract was found at the specified address.
+         */
+        ContractNotFound: PlainDescriptor<undefined>;
+        /**
+         * The code supplied to `instantiate_with_code` exceeds the limit specified in the
+         * current schedule.
+         */
+        CodeTooLarge: PlainDescriptor<undefined>;
+        /**
+         * No code could be found at the supplied code hash.
+         */
+        CodeNotFound: PlainDescriptor<undefined>;
+        /**
+         * A buffer outside of sandbox memory was passed to a contract API function.
+         */
+        OutOfBounds: PlainDescriptor<undefined>;
+        /**
+         * Input passed to a contract API function failed to decode as expected type.
+         */
+        DecodingFailed: PlainDescriptor<undefined>;
+        /**
+         * Contract trapped during execution.
+         */
+        ContractTrapped: PlainDescriptor<undefined>;
+        /**
+         * The size defined in `T::MaxValueSize` was exceeded.
+         */
+        ValueTooLarge: PlainDescriptor<undefined>;
+        /**
+         * Termination of a contract is not allowed while the contract is already
+         * on the call stack. Can be triggered by `seal_terminate`.
+         */
+        TerminatedWhileReentrant: PlainDescriptor<undefined>;
+        /**
+         * `seal_call` forwarded this contracts input. It therefore is no longer available.
+         */
+        InputForwarded: PlainDescriptor<undefined>;
+        /**
+         * The subject passed to `seal_random` exceeds the limit.
+         */
+        RandomSubjectTooLong: PlainDescriptor<undefined>;
+        /**
+         * The amount of topics passed to `seal_deposit_events` exceeds the limit.
+         */
+        TooManyTopics: PlainDescriptor<undefined>;
+        /**
+         * The chain does not provide a chain extension. Calling the chain extension results
+         * in this error. Note that this usually  shouldn't happen as deploying such contracts
+         * is rejected.
+         */
+        NoChainExtension: PlainDescriptor<undefined>;
+        /**
+         * A contract with the same AccountId already exists.
+         */
+        DuplicateContract: PlainDescriptor<undefined>;
+        /**
+         * A contract self destructed in its constructor.
+         *
+         * This can be triggered by a call to `seal_terminate`.
+         */
+        TerminatedInConstructor: PlainDescriptor<undefined>;
+        /**
+         * A call tried to invoke a contract that is flagged as non-reentrant.
+         * The only other cause is that a call from a contract into the runtime tried to call back
+         * into `pallet-contracts`. This would make the whole pallet reentrant with regard to
+         * contract code execution which is not supported.
+         */
+        ReentranceDenied: PlainDescriptor<undefined>;
+        /**
+         * Origin doesn't have enough balance to pay the required storage deposits.
+         */
+        StorageDepositNotEnoughFunds: PlainDescriptor<undefined>;
+        /**
+         * More storage was created than allowed by the storage deposit limit.
+         */
+        StorageDepositLimitExhausted: PlainDescriptor<undefined>;
+        /**
+         * Code removal was denied because the code is still in use by at least one contract.
+         */
+        CodeInUse: PlainDescriptor<undefined>;
+        /**
+         * The contract ran to completion but decided to revert its storage changes.
+         * 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.
+         */
+        ContractReverted: PlainDescriptor<undefined>;
+        /**
+         * The contract's code was found to be invalid during validation or instrumentation.
+         *
+         * The most likely cause of this is that an API was used which is not supported by the
+         * node. This happens if an older node is used with a new version of ink!. Try updating
+         * your node to the newest available version.
+         *
+         * A more detailed error can be found on the node console if debug messages are enabled
+         * by supplying `-lruntime::contracts=debug`.
+         */
+        CodeRejected: PlainDescriptor<undefined>;
+        /**
+         * An indetermistic code was used in a context where this is not permitted.
+         */
+        Indeterministic: PlainDescriptor<undefined>;
+    };
+    ImOnline: {
+        /**
+         * Non existent public key.
+         */
+        InvalidKey: PlainDescriptor<undefined>;
+        /**
+         * Duplicated heartbeat.
+         */
+        DuplicatedHeartbeat: PlainDescriptor<undefined>;
+    };
+    Session: {
+        /**
+         * Invalid ownership proof.
+         */
+        InvalidProof: PlainDescriptor<undefined>;
+        /**
+         * No associated validator ID for account.
+         */
+        NoAssociatedValidatorId: PlainDescriptor<undefined>;
+        /**
+         * Registered duplicate key.
+         */
+        DuplicatedKey: PlainDescriptor<undefined>;
+        /**
+         * No keys are associated with this account.
+         */
+        NoKeys: PlainDescriptor<undefined>;
+        /**
+         * Key setting account is not live, so it's impossible to associate keys.
+         */
+        NoAccount: PlainDescriptor<undefined>;
+    };
+    Treasury: {
+        /**
+         * Proposer's balance is too low.
+         */
+        InsufficientProposersBalance: PlainDescriptor<undefined>;
+        /**
+         * No proposal or bounty at that index.
+         */
+        InvalidIndex: PlainDescriptor<undefined>;
+        /**
+         * Too many approvals in the queue.
+         */
+        TooManyApprovals: PlainDescriptor<undefined>;
+        /**
+         * The spend origin is valid but the amount it is allowed to spend is lower than the
+         * amount to be spent.
+         */
+        InsufficientPermission: PlainDescriptor<undefined>;
+        /**
+         * Proposal has not been approved.
+         */
+        ProposalNotApproved: PlainDescriptor<undefined>;
+    };
+    CouncilLock: {
+        /**
+        
+         */
+        NotValidNominator: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ProposalFeeInsufficient: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        MiningPoolContractNotSet: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ErrorGettingRankedNodes: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        AccountAlreadyLocked: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        AccountNotLocked: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ProposalAlreadyExists: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        AccountAlreadyInReferendum: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        AdminCannotBeNominated: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        LockCandidatesNotPermittedToInteract: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        LockedAccountsNotPermittedToInteract: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        LockedAccountCannotVote: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ReferendumDoesNotExist: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        NotValidCouncilMember: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        ErrorCalculatingVotes: PlainDescriptor<undefined>;
+        /**
+        
+         */
+        VoterAlreadyVoted: PlainDescriptor<undefined>;
+    };
+    D9MultiSig: {
+        /**
+         * Signers list contains duplicates
+         */
+        DuplicatesInList: PlainDescriptor<undefined>;
+        /**
+         * Caller not in signatories
+         */
+        CallerNotSignatory: PlainDescriptor<undefined>;
+        /**
+         * Multi-sig account already exists
+         */
+        MSAAlreadyExists: PlainDescriptor<undefined>;
+        /**
+         * Multi-sig account not found
+         */
+        MSANotFound: PlainDescriptor<undefined>;
+        /**
+         * Must have at least 2 signers
+         */
+        SignatoriesTooShort: PlainDescriptor<undefined>;
+        /**
+         * Too many signers
+         */
+        SignatoriesTooLong: PlainDescriptor<undefined>;
+        /**
+         * approval already exists
+         */
+        ApprovalExists: PlainDescriptor<undefined>;
+        /**
+         * attempting to remove nonexistent approval
+         */
+        ApprovalDoesntExist: PlainDescriptor<undefined>;
+        /**
+         * Minimum approvals is out of range
+         */
+        MinApprovalOutOfRange: PlainDescriptor<undefined>;
+        /**
+         * Proposal approval equals existing one
+         */
+        NewMinimumEqualsCurrentMinimum: PlainDescriptor<undefined>;
+        /**
+         * Account is already an author
+         */
+        AccountAlreadyAuthor: PlainDescriptor<undefined>;
+        /**
+         * only the msa author execute this calls
+         */
+        OnlyMSAItselfCanDoThis: PlainDescriptor<undefined>;
+        /**
+         * Authors list too long
+         */
+        AuthorVecTooLong: PlainDescriptor<undefined>;
+        /**
+         * Not an author
+         */
+        AccountNotAuthor: PlainDescriptor<undefined>;
+        /**
+         * Not a signatory
+         */
+        AccountNotSignatory: PlainDescriptor<undefined>;
+        /**
+         * Reached max possible authors
+         */
+        AccountErrorMaxAuthors: PlainDescriptor<undefined>;
+        /**
+         * Pending calls limit reached
+         */
+        CallLimit: PlainDescriptor<undefined>;
+        /**
+         * Approvals limit reached
+         */
+        ApprovalsLimitReached: PlainDescriptor<undefined>;
+        /**
+         * Failed to encode call
+         */
+        CallEncodingFailure: PlainDescriptor<undefined>;
+        /**
+         * This account hit its multi-sig limit
+         */
+        AccountAtMultiSigLimit: PlainDescriptor<undefined>;
+        /**
+         * Failed to create pending call
+         */
+        FailedToCreatePendingCall: PlainDescriptor<undefined>;
+        /**
+         * Call not found for multi-sig
+         */
+        CallNotFound: PlainDescriptor<undefined>;
+        /**
+         * Failed to decode call
+         */
+        FailureDecodingCall: PlainDescriptor<undefined>;
+        /**
+         * failure building BoundedVec
+         */
+        FailedToBuildBoundedVec: PlainDescriptor<undefined>;
+        /**
+         * Min approval proposal not found
+         */
+        ProposalNotFound: PlainDescriptor<undefined>;
+        /**
+         * proposal already pending
+         */
+        ProposalAlreadyPending: PlainDescriptor<undefined>;
+    };
+};
+type IConstants = {
+    D9NodeRewards: {
+        /**
+        
+         */
+        PalletId: PlainDescriptor<FixedSizeBinary<8>>;
+    };
+    Balances: {
+        /**
+         * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!
+         *
+         * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for
+         * this pallet. However, you do so at your own risk: this will open up a major DoS vector.
+         * In case you have multiple sources of provider references, you may also get unexpected
+         * behaviour if you set this to zero.
+         *
+         * Bottom line: Do yourself a favour and make it at least one!
+         */
+        ExistentialDeposit: PlainDescriptor<bigint>;
+        /**
+         * The maximum number of locks that should exist on an account.
+         * Not strictly enforced, but used for weight estimation.
+         */
+        MaxLocks: PlainDescriptor<number>;
+        /**
+         * The maximum number of named reserves that can exist on an account.
+         */
+        MaxReserves: PlainDescriptor<number>;
+        /**
+         * The maximum number of holds that can exist on an account at any time.
+         */
+        MaxHolds: PlainDescriptor<number>;
+        /**
+         * The maximum number of individual freeze locks that can exist on an account at any time.
+         */
+        MaxFreezes: PlainDescriptor<number>;
+    };
+    Grandpa: {
+        /**
+         * Max Authorities in use
+         */
+        MaxAuthorities: PlainDescriptor<number>;
+        /**
+         * The maximum number of entries to keep in the set id to session index mapping.
+         *
+         * Since the `SetIdSession` map is only used for validating equivocations this
+         * value should relate to the bonding duration of whatever staking system is
+         * being used (if any). If equivocation handling is not enabled then this value
+         * can be zero.
+         */
+        MaxSetIdSessionEntries: PlainDescriptor<bigint>;
+    };
+    System: {
+        /**
+         * Block & extrinsics weights: base values and limits.
+         */
+        BlockWeights: PlainDescriptor<Anonymize<In7a38730s6qs>>;
+        /**
+         * The maximum length of a block (in bytes).
+         */
+        BlockLength: PlainDescriptor<Anonymize<If15el53dd76v9>>;
+        /**
+         * Maximum number of block number to block hash mappings to keep (oldest pruned first).
+         */
+        BlockHashCount: PlainDescriptor<number>;
+        /**
+         * The weight of runtime database operations the runtime can invoke.
+         */
+        DbWeight: PlainDescriptor<Anonymize<I9s0ave7t0vnrk>>;
+        /**
+         * Get the chain's current version.
+         */
+        Version: PlainDescriptor<Anonymize<Ic6nglu2db2c36>>;
+        /**
+         * The designated SS58 prefix of this chain.
+         *
+         * This replaces the "ss58Format" property declared in the chain spec. Reason is
+         * that the runtime should know about the prefix in order to make use of it as
+         * an identifier of the chain.
+         */
+        SS58Prefix: PlainDescriptor<number>;
+    };
+    Timestamp: {
+        /**
+         * 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.
+         */
+        MinimumPeriod: PlainDescriptor<bigint>;
+    };
+    TransactionPayment: {
+        /**
+         * A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their
+         * `priority`
+         *
+         * This value is multipled by the `final_fee` to obtain a "virtual tip" that is later
+         * added to a tip component in regular `priority` calculations.
+         * It means that a `Normal` transaction can front-run a similarly-sized `Operational`
+         * extrinsic (with no tip), by including a tip value greater than the virtual tip.
+         *
+         * ```rust,ignore
+         * // For `Normal`
+         * let priority = priority_calc(tip);
+         *
+         * // For `Operational`
+         * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;
+         * let priority = priority_calc(tip + virtual_tip);
+         * ```
+         *
+         * Note that since we use `final_fee` the multiplier applies also to the regular `tip`
+         * sent with the transaction. So, not only does the transaction get a priority bump based
+         * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`
+         * transactions.
+         */
+        OperationalFeeMultiplier: PlainDescriptor<number>;
+    };
+    Assets: {
+        /**
+         * Max number of items to destroy per `destroy_accounts` and `destroy_approvals` call.
+         *
+         * Must be configured to result in a weight that makes each call fit in a block.
+         */
+        RemoveItemsLimit: PlainDescriptor<number>;
+        /**
+         * The basic amount of funds that must be reserved for an asset.
+         */
+        AssetDeposit: PlainDescriptor<bigint>;
+        /**
+         * The amount of funds that must be reserved for a non-provider asset account to be
+         * maintained.
+         */
+        AssetAccountDeposit: PlainDescriptor<bigint>;
+        /**
+         * The basic amount of funds that must be reserved when adding metadata to your asset.
+         */
+        MetadataDepositBase: PlainDescriptor<bigint>;
+        /**
+         * The additional funds that must be reserved for the number of bytes you store in your
+         * metadata.
+         */
+        MetadataDepositPerByte: PlainDescriptor<bigint>;
+        /**
+         * The amount of funds that must be reserved when creating a new approval.
+         */
+        ApprovalDeposit: PlainDescriptor<bigint>;
+        /**
+         * The maximum length of a name or symbol stored on-chain.
+         */
+        StringLimit: PlainDescriptor<number>;
+    };
+    Collective: {
+        /**
+         * The maximum weight of a dispatch call that can be proposed and executed.
+         */
+        MaxProposalWeight: PlainDescriptor<Anonymize<I4q39t5hn830vp>>;
+    };
+    Contracts: {
+        /**
+         * Cost schedule and limits.
+         */
+        Schedule: PlainDescriptor<Anonymize<I1q6j2f64t5q87>>;
+        /**
+         * 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.
+         */
+        DepositPerByte: PlainDescriptor<bigint>;
+        /**
+         * Fallback value to limit the storage deposit if it's not being set by the caller.
+         */
+        DefaultDepositLimit: PlainDescriptor<bigint>;
+        /**
+         * 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.
+         */
+        DepositPerItem: PlainDescriptor<bigint>;
+        /**
+         * The maximum length of a contract code in bytes. This limit applies to the instrumented
+         * version of the code. Therefore `instantiate_with_code` can fail even when supplying
+         * a wasm binary below this maximum size.
+         *
+         * The value should be chosen carefully taking into the account the overall memory limit
+         * your runtime has, as well as the [maximum allowed callstack
+         * depth](#associatedtype.CallStack). Look into the `integrity_test()` for some insights.
+         */
+        MaxCodeLen: PlainDescriptor<number>;
+        /**
+         * The maximum allowable length in bytes for storage keys.
+         */
+        MaxStorageKeyLen: PlainDescriptor<number>;
+        /**
+         * Make contract callable functions marked as `#[unstable]` available.
+         *
+         * Contracts that use `#[unstable]` functions won't be able to be uploaded unless
+         * this is set to `true`. This is only meant for testnets and dev nodes in order to
+         * experiment with new features.
+         *
+         * # Warning
+         *
+         * Do **not** set to `true` on productions chains.
+         */
+        UnsafeUnstableInterface: PlainDescriptor<boolean>;
+        /**
+         * The maximum length of the debug buffer in bytes.
+         */
+        MaxDebugBufferLen: PlainDescriptor<number>;
+    };
+    ImOnline: {
+        /**
+         * 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.
+         */
+        UnsignedPriority: PlainDescriptor<bigint>;
+    };
+    Treasury: {
+        /**
+         * Fraction of a proposal's value that should be bonded in order to place the proposal.
+         * An accepted proposal gets these back. A rejected proposal does not.
+         */
+        ProposalBond: PlainDescriptor<number>;
+        /**
+         * Minimum amount of funds that should be placed in a deposit for making a proposal.
+         */
+        ProposalBondMinimum: PlainDescriptor<bigint>;
+        /**
+         * Maximum amount of funds that should be placed in a deposit for making a proposal.
+         */
+        ProposalBondMaximum: PlainDescriptor<Anonymize<I35p85j063s0il>>;
+        /**
+         * Period between successive spends.
+         */
+        SpendPeriod: PlainDescriptor<number>;
+        /**
+         * Percentage of spare funds (if any) that are burnt per spend period.
+         */
+        Burn: PlainDescriptor<number>;
+        /**
+         * The treasury's pallet id, used for deriving its sovereign account ID.
+         */
+        PalletId: PlainDescriptor<FixedSizeBinary<8>>;
+        /**
+         * The maximum number of approvals that can wait in the spending queue.
+         *
+         * NOTE: This parameter is also used within the Bounties Pallet extension if enabled.
+         */
+        MaxApprovals: PlainDescriptor<number>;
+    };
+    CouncilLock: {
+        /**
+        
+         */
+        CouncilPalletId: PlainDescriptor<FixedSizeBinary<8>>;
+    };
+};
+type IViewFns = {};
+type IRuntimeCalls = {};
+export type D9DispatchError = Anonymize<I3015mdrqab6c7>;
+type IAsset = PlainDescriptor<void>;
+export type D9Extensions = {};
+type PalletsTypedef = {
+    __storage: IStorage;
+    __tx: ICalls;
+    __event: IEvent;
+    __error: IError;
+    __const: IConstants;
+    __view: IViewFns;
+};
+export type D9 = {
+    descriptors: {
+        pallets: PalletsTypedef;
+        apis: IRuntimeCalls;
+    } & Promise<any>;
+    metadataTypes: Promise<Uint8Array>;
+    asset: IAsset;
+    extensions: D9Extensions;
+    getMetadata: () => Promise<Uint8Array>;
+    genesis: string | undefined;
+};
+declare const _allDescriptors: D9;
+export default _allDescriptors;
+export type D9Apis = ApisFromDef<IRuntimeCalls>;
+export type D9Queries = QueryFromPalletsDef<PalletsTypedef>;
+export type D9Calls = TxFromPalletsDef<PalletsTypedef>;
+export type D9Events = EventsFromPalletsDef<PalletsTypedef>;
+export type D9Errors = ErrorsFromPalletsDef<PalletsTypedef>;
+export type D9Constants = ConstFromPalletsDef<PalletsTypedef>;
+export type D9ViewFns = ViewFnsFromPalletsDef<PalletsTypedef>;
+export type D9CallData = Anonymize<Idbc6j12l47q6u> & {
+    value: {
+        type: string;
+    };
+};
+type AllInteractions = {
+    storage: {
+        Aura: ['Authorities', 'CurrentSlot'];
+        D9Referral: ['MaxReferralDepth', 'ReferralRelationships', 'DirectReferralsCount'];
+        D9Treasury: ['Treasurer'];
+        D9NodeVoting: ['UsersVotingInterests', 'UserToNodeVotesTotals', 'NodeToUserVotesTotals', 'NodeAccumulativeVotes', 'CurrentNumberOfCandidatesNodes', 'SessionNodeList', 'CurrentSessionIndex', 'CurrentValidatorVoteStats', 'NodeMetadata', 'PalletAdmin'];
+        D9NodeRewards: ['NodeRewardContract', 'PalletAdmin'];
+        Balances: ['TotalIssuance', 'InactiveIssuance', 'Account', 'Locks', 'Reserves', 'Holds', 'Freezes'];
+        Grandpa: ['State', 'PendingChange', 'NextForced', 'Stalled', 'CurrentSetId', 'SetIdSession'];
+        Sudo: ['Key'];
+        System: ['Account', 'ExtrinsicCount', 'BlockWeight', 'AllExtrinsicsLen', 'BlockHash', 'ExtrinsicData', 'Number', 'ParentHash', 'Digest', 'Events', 'EventCount', 'EventTopics', 'LastRuntimeUpgrade', 'UpgradedToU32RefCount', 'UpgradedToTripleRefCount', 'ExecutionPhase'];
+        Timestamp: ['Now', 'DidUpdate'];
+        TransactionPayment: ['NextFeeMultiplier', 'StorageVersion'];
+        Assets: ['Asset', 'Account', 'Approvals', 'Metadata'];
+        AuthorityDiscovery: ['Keys', 'NextKeys'];
+        Collective: ['Proposals', 'ProposalOf', 'Voting', 'ProposalCount', 'Members', 'Prime'];
+        Contracts: ['PristineCode', 'CodeStorage', 'OwnerInfoOf', 'Nonce', 'ContractInfoOf', 'DeletionQueue', 'DeletionQueueCounter'];
+        Historical: ['HistoricalSessions', 'StoredRange'];
+        ImOnline: ['HeartbeatAfter', 'Keys', 'ReceivedHeartbeats', 'AuthoredBlocks'];
+        RandomnessCollectiveFlip: ['RandomMaterial'];
+        Session: ['Validators', 'CurrentIndex', 'QueuedChanged', 'QueuedKeys', 'DisabledValidators', 'NextKeys', 'KeyOwner'];
+        Treasury: ['ProposalCount', 'Proposals', 'Deactivated', 'Approvals'];
+        CouncilLock: ['PalletAdmin', 'ProposalFee', 'MiningPoolContract', 'Proposals', 'Referendums', 'Resolutions', 'LockedAccounts'];
+        D9MultiSig: ['MultiSignatureAccounts', 'UserMultiSigAccounts', 'MinApprovalProposals'];
+    };
+    tx: {
+        D9Referral: ['change_referral_depth'];
+        D9Treasury: ['new_treasurer'];
+        D9NodeVoting: ['submit_candidacy', 'add_voting_interest', 'delegate_votes', 'remove_candidacy', 'try_remove_votes_from_candidate', 'redistribute_votes', 'change_candidate_name', 'change_candidate_supporter_share', 'set_pallet_admin'];
+        D9NodeRewards: ['set_pallet_admin', 'set_node_reward_contract'];
+        Balances: ['transfer_allow_death', 'set_balance_deprecated', 'force_transfer', 'transfer_keep_alive', 'transfer_all', 'force_unreserve', 'upgrade_accounts', 'transfer', 'force_set_balance'];
+        Grandpa: ['report_equivocation', 'report_equivocation_unsigned', 'note_stalled'];
+        Sudo: ['sudo', 'sudo_unchecked_weight', 'set_key', 'sudo_as'];
+        System: ['remark', 'set_heap_pages', 'set_code', 'set_code_without_checks', 'set_storage', 'kill_storage', 'kill_prefix', 'remark_with_event'];
+        Timestamp: ['set'];
+        Assets: ['create', 'force_create', 'start_destroy', 'destroy_accounts', 'destroy_approvals', 'finish_destroy', 'mint', 'burn', 'transfer', 'transfer_keep_alive', 'force_transfer', 'freeze', 'thaw', 'freeze_asset', 'thaw_asset', 'transfer_ownership', 'set_team', 'set_metadata', 'clear_metadata', 'force_set_metadata', 'force_clear_metadata', 'force_asset_status', 'approve_transfer', 'cancel_approval', 'force_cancel_approval', 'transfer_approved', 'touch', 'refund', 'set_min_balance'];
+        Collective: ['set_members', 'execute', 'propose', 'vote', 'disapprove_proposal', 'close'];
+        Contracts: ['call_old_weight', 'instantiate_with_code_old_weight', 'instantiate_old_weight', 'upload_code', 'remove_code', 'set_code', 'call', 'instantiate_with_code', 'instantiate'];
+        ImOnline: ['heartbeat'];
+        Session: ['set_keys', 'purge_keys'];
+        Treasury: ['propose_spend', 'reject_proposal', 'approve_proposal', 'spend', 'remove_approval'];
+        CouncilLock: ['set_pallet_admin', 'set_mining_pool_contract', 'propose_lock', 'propose_unlock', 'vote_in_referendum', 'set_proposal_fee', 'admin_lock_accounts', 'admin_unlock_accounts', 'admin_remove_proposal'];
+        D9MultiSig: ['create_multi_sig_account', 'author_a_call', 'add_call_approval', 'remove_call_approval', 'proposal_msa_new_minimum', 'approve_msa_new_minimum', 'revoke_approval_for_msa_new_minimum', 'remove_call'];
+    };
+    events: {
+        D9Referral: ['NewReferralRelationshipCreated', 'NewReferralDepthSet', 'NewDefaultParentSet'];
+        D9Treasury: ['NewTreasurer'];
+        D9NodeVoting: ['CandidacySubmitted', 'VotesDelegatedBy', 'CandidacyRemoved'];
+        D9NodeRewards: ['ErrorIssuingRewards', 'ContractError'];
+        Balances: ['Endowed', 'DustLost', 'Transfer', 'BalanceSet', 'Reserved', 'Unreserved', 'ReserveRepatriated', 'Deposit', 'Withdraw', 'Slashed', 'Minted', 'Burned', 'Suspended', 'Restored', 'Upgraded', 'Issued', 'Rescinded', 'Locked', 'Unlocked', 'Frozen', 'Thawed'];
+        Grandpa: ['NewAuthorities', 'Paused', 'Resumed'];
+        Sudo: ['Sudid', 'KeyChanged', 'SudoAsDone'];
+        System: ['ExtrinsicSuccess', 'ExtrinsicFailed', 'CodeUpdated', 'NewAccount', 'KilledAccount', 'Remarked'];
+        TransactionPayment: ['TransactionFeePaid'];
+        Assets: ['Created', 'Issued', 'Transferred', 'Burned', 'TeamChanged', 'OwnerChanged', 'Frozen', 'Thawed', 'AssetFrozen', 'AssetThawed', 'AccountsDestroyed', 'ApprovalsDestroyed', 'DestructionStarted', 'Destroyed', 'ForceCreated', 'MetadataSet', 'MetadataCleared', 'ApprovedTransfer', 'ApprovalCancelled', 'TransferredApproved', 'AssetStatusChanged', 'AssetMinBalanceChanged'];
+        Collective: ['Proposed', 'Voted', 'Approved', 'Disapproved', 'Executed', 'MemberExecuted', 'Closed'];
+        Contracts: ['Instantiated', 'Terminated', 'CodeStored', 'ContractEmitted', 'CodeRemoved', 'ContractCodeUpdated', 'Called', 'DelegateCalled'];
+        ImOnline: ['HeartbeatReceived', 'AllGood', 'SomeOffline'];
+        Session: ['NewSession'];
+        Treasury: ['Proposed', 'Spending', 'Awarded', 'Rejected', 'Burnt', 'Rollover', 'Deposit', 'SpendApproved', 'UpdatedInactive'];
+        CouncilLock: ['AccountNominatedForLock', 'ProposalFeePaid', 'VoteRecorded', 'AccountLocked', 'AccountUnlocked', 'AccountNominatedForUnlock', 'VoteStarted', 'VoteEnded'];
+        D9MultiSig: ['MultiSignatureAccountCreated', 'MultiSignatureAccountUpdated', 'NewCallAuthored', 'ApprovalAdded', 'ApprovalRemoved', 'CallExecuted', 'MinApprovalsChanged'];
+    };
+    errors: {
+        D9Referral: ['NoReferralAccountRecord'];
+        D9Treasury: ['OnlyTreasurerCanDoThis', 'NoTreasurerSet'];
+        D9NodeVoting: ['HexDecodeError', 'EmptyDelegationList', 'DelegationListTooLarge', 'DelegatorHasNoVotingCapacity', 'DelegatorHasNoAvailableVotes', 'DelegatorHasInsufficientVotes', 'AttemptingToRemoveMoreVotesThanDelegated', 'CandidateDoesNotExist', 'CandidateAlreadyExists', 'ErrorGettingNodeMetadata', 'VoterDidntDelegateToThisCandidate', 'NotActiveValidator', 'AtMaximumNumberOfCandidates', 'BurnAmountMustBeGreaterThan100', 'SupporterShareOutOfRange', 'CurrentValidatorCanNotChangeSharePercentage'];
+        D9NodeRewards: ['RestrictedAccess', 'NodeRewardContractNotSet', 'ErrorUpdatingNodeRewardContract'];
+        Balances: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'Expendability', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves', 'TooManyHolds', 'TooManyFreezes'];
+        Grandpa: ['PauseFailed', 'ResumeFailed', 'ChangePending', 'TooSoon', 'InvalidKeyOwnershipProof', 'InvalidEquivocationProof', 'DuplicateOffenceReport'];
+        Sudo: ['RequireSudo'];
+        System: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered'];
+        Assets: ['BalanceLow', 'NoAccount', 'NoPermission', 'Unknown', 'Frozen', 'InUse', 'BadWitness', 'MinBalanceZero', 'UnavailableConsumer', 'BadMetadata', 'Unapproved', 'WouldDie', 'AlreadyExists', 'NoDeposit', 'WouldBurn', 'LiveAsset', 'AssetNotLive', 'IncorrectStatus', 'NotFrozen', 'CallbackFailed'];
+        Collective: ['NotMember', 'DuplicateProposal', 'ProposalMissing', 'WrongIndex', 'DuplicateVote', 'AlreadyInitialized', 'TooEarly', 'TooManyProposals', 'WrongProposalWeight', 'WrongProposalLength'];
+        Contracts: ['InvalidScheduleVersion', 'InvalidCallFlags', 'OutOfGas', 'OutputBufferTooSmall', 'TransferFailed', 'MaxCallDepthReached', 'ContractNotFound', 'CodeTooLarge', 'CodeNotFound', 'OutOfBounds', 'DecodingFailed', 'ContractTrapped', 'ValueTooLarge', 'TerminatedWhileReentrant', 'InputForwarded', 'RandomSubjectTooLong', 'TooManyTopics', 'NoChainExtension', 'DuplicateContract', 'TerminatedInConstructor', 'ReentranceDenied', 'StorageDepositNotEnoughFunds', 'StorageDepositLimitExhausted', 'CodeInUse', 'ContractReverted', 'CodeRejected', 'Indeterministic'];
+        ImOnline: ['InvalidKey', 'DuplicatedHeartbeat'];
+        Session: ['InvalidProof', 'NoAssociatedValidatorId', 'DuplicatedKey', 'NoKeys', 'NoAccount'];
+        Treasury: ['InsufficientProposersBalance', 'InvalidIndex', 'TooManyApprovals', 'InsufficientPermission', 'ProposalNotApproved'];
+        CouncilLock: ['NotValidNominator', 'ProposalFeeInsufficient', 'MiningPoolContractNotSet', 'ErrorGettingRankedNodes', 'AccountAlreadyLocked', 'AccountNotLocked', 'ProposalAlreadyExists', 'AccountAlreadyInReferendum', 'AdminCannotBeNominated', 'LockCandidatesNotPermittedToInteract', 'LockedAccountsNotPermittedToInteract', 'LockedAccountCannotVote', 'ReferendumDoesNotExist', 'NotValidCouncilMember', 'ErrorCalculatingVotes', 'VoterAlreadyVoted'];
+        D9MultiSig: ['DuplicatesInList', 'CallerNotSignatory', 'MSAAlreadyExists', 'MSANotFound', 'SignatoriesTooShort', 'SignatoriesTooLong', 'ApprovalExists', 'ApprovalDoesntExist', 'MinApprovalOutOfRange', 'NewMinimumEqualsCurrentMinimum', 'AccountAlreadyAuthor', 'OnlyMSAItselfCanDoThis', 'AuthorVecTooLong', 'AccountNotAuthor', 'AccountNotSignatory', 'AccountErrorMaxAuthors', 'CallLimit', 'ApprovalsLimitReached', 'CallEncodingFailure', 'AccountAtMultiSigLimit', 'FailedToCreatePendingCall', 'CallNotFound', 'FailureDecodingCall', 'FailedToBuildBoundedVec', 'ProposalNotFound', 'ProposalAlreadyPending'];
+    };
+    constants: {
+        D9NodeRewards: ['PalletId'];
+        Balances: ['ExistentialDeposit', 'MaxLocks', 'MaxReserves', 'MaxHolds', 'MaxFreezes'];
+        Grandpa: ['MaxAuthorities', 'MaxSetIdSessionEntries'];
+        System: ['BlockWeights', 'BlockLength', 'BlockHashCount', 'DbWeight', 'Version', 'SS58Prefix'];
+        Timestamp: ['MinimumPeriod'];
+        TransactionPayment: ['OperationalFeeMultiplier'];
+        Assets: ['RemoveItemsLimit', 'AssetDeposit', 'AssetAccountDeposit', 'MetadataDepositBase', 'MetadataDepositPerByte', 'ApprovalDeposit', 'StringLimit'];
+        Collective: ['MaxProposalWeight'];
+        Contracts: ['Schedule', 'DepositPerByte', 'DefaultDepositLimit', 'DepositPerItem', 'MaxCodeLen', 'MaxStorageKeyLen', 'UnsafeUnstableInterface', 'MaxDebugBufferLen'];
+        ImOnline: ['UnsignedPriority'];
+        Treasury: ['ProposalBond', 'ProposalBondMinimum', 'ProposalBondMaximum', 'SpendPeriod', 'Burn', 'PalletId', 'MaxApprovals'];
+        CouncilLock: ['CouncilPalletId'];
+    };
+    viewFns: {};
+    apis: {};
+};
+export type D9WhitelistEntry = PalletKey | `query.${NestedKey<AllInteractions['storage']>}` | `tx.${NestedKey<AllInteractions['tx']>}` | `event.${NestedKey<AllInteractions['events']>}` | `error.${NestedKey<AllInteractions['errors']>}` | `const.${NestedKey<AllInteractions['constants']>}` | `view.${NestedKey<AllInteractions['viewFns']>}` | `api.${NestedKey<AllInteractions['apis']>}`;
+type PalletKey = `*.${({
+    [K in keyof AllInteractions]: K extends 'apis' ? never : keyof AllInteractions[K];
+})[keyof AllInteractions]}`;
+type NestedKey<D extends Record<string, string[]>> = "*" | {
+    [P in keyof D & string]: `${P}.*` | `${P}.${D[P][number]}`;
+}[keyof D & string];