@dedot/chaintypes 0.133.0 → 0.134.0

package/hydration/tx.d.ts

@@ -37,7 +37,6 @@ import type {
   PalletDemocracyVoteAccountVote,
   PalletDemocracyConviction,
   PalletDemocracyMetadataOwner,
-  PalletElectionsPhragmenRenouncing,
   HydradxRuntimeSystemProxyType,
   PalletMultisigTimepoint,
   PalletUniquesDestroyWitness,
@@ -55,6 +54,7 @@ import type {
   HydradxTraitsStableswapAssetAmount,
   HydradxTraitsRouterTrade,
   HydradxTraitsRouterAssetPair,
+  PalletDynamicFeesAssetFeeConfig,
   PalletStableswapTradability,
   PalletStableswapPegSource,
   PalletLbpWeightCurveType,
@@ -2605,461 +2605,6 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      **/
     [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
   };
-  /**
-   * Pallet `Elections`'s transaction calls
-   **/
-  elections: {
-    /**
-     * Vote for a set of candidates for the upcoming round of election. This can be called to
-     * set the initial votes, or update already existing votes.
-     *
-     * Upon initial voting, `value` units of `who`'s balance is locked and a deposit amount is
-     * reserved. The deposit is based on the number of votes and can be updated over time.
-     *
-     * The `votes` should:
-     * - not be empty.
-     * - be less than the number of possible candidates. Note that all current members and
-     * runners-up are also automatically candidates for the next round.
-     *
-     * If `value` is more than `who`'s free balance, then the maximum of the two is used.
-     *
-     * The dispatch origin of this call must be signed.
-     *
-     * ### Warning
-     *
-     * It is the responsibility of the caller to **NOT** place all of their balance into the
-     * lock and keep some for further operations.
-     *
-     * @param {Array<AccountId32Like>} votes
-     * @param {bigint} value
-     **/
-    vote: GenericTxCall<
-      Rv,
-      (
-        votes: Array<AccountId32Like>,
-        value: bigint,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Elections';
-          palletCall: {
-            name: 'Vote';
-            params: { votes: Array<AccountId32Like>; value: bigint };
-          };
-        }
-      >
-    >;
-
-    /**
-     * Remove `origin` as a voter.
-     *
-     * This removes the lock and returns the deposit.
-     *
-     * The dispatch origin of this call must be signed and be a voter.
-     *
-     **/
-    removeVoter: GenericTxCall<
-      Rv,
-      () => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Elections';
-          palletCall: {
-            name: 'RemoveVoter';
-          };
-        }
-      >
-    >;
-
-    /**
-     * Submit oneself for candidacy. A fixed amount of deposit is recorded.
-     *
-     * All candidates are wiped at the end of the term. They either become a member/runner-up,
-     * or leave the system while their deposit is slashed.
-     *
-     * The dispatch origin of this call must be signed.
-     *
-     * ### Warning
-     *
-     * Even if a candidate ends up being a member, they must call [`Call::renounce_candidacy`]
-     * to get their deposit back. Losing the spot in an election will always lead to a slash.
-     *
-     * The number of current candidates must be provided as witness data.
-     * ## Complexity
-     * O(C + log(C)) where C is candidate_count.
-     *
-     * @param {number} candidateCount
-     **/
-    submitCandidacy: GenericTxCall<
-      Rv,
-      (candidateCount: number) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Elections';
-          palletCall: {
-            name: 'SubmitCandidacy';
-            params: { candidateCount: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * Renounce one's intention to be a candidate for the next election round. 3 potential
-     * outcomes exist:
-     *
-     * - `origin` is a candidate and not elected in any set. In this case, the deposit is
-     * unreserved, returned and origin is removed as a candidate.
-     * - `origin` is a current runner-up. In this case, the deposit is unreserved, returned and
-     * origin is removed as a runner-up.
-     * - `origin` is a current member. In this case, the deposit is unreserved and origin is
-     * removed as a member, consequently not being a candidate for the next round anymore.
-     * Similar to [`remove_member`](Self::remove_member), if replacement runners exists, they
-     * are immediately used. If the prime is renouncing, then no prime will exist until the
-     * next round.
-     *
-     * The dispatch origin of this call must be signed, and have one of the above roles.
-     * The type of renouncing must be provided as witness data.
-     *
-     * ## Complexity
-     * - Renouncing::Candidate(count): O(count + log(count))
-     * - Renouncing::Member: O(1)
-     * - Renouncing::RunnerUp: O(1)
-     *
-     * @param {PalletElectionsPhragmenRenouncing} renouncing
-     **/
-    renounceCandidacy: GenericTxCall<
-      Rv,
-      (renouncing: PalletElectionsPhragmenRenouncing) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Elections';
-          palletCall: {
-            name: 'RenounceCandidacy';
-            params: { renouncing: PalletElectionsPhragmenRenouncing };
-          };
-        }
-      >
-    >;
-
-    /**
-     * Remove a particular member from the set. This is effective immediately and the bond of
-     * the outgoing member is slashed.
-     *
-     * If a runner-up is available, then the best runner-up will be removed and replaces the
-     * outgoing member. Otherwise, if `rerun_election` is `true`, a new phragmen election is
-     * started, else, nothing happens.
-     *
-     * If `slash_bond` is set to true, the bond of the member being removed is slashed. Else,
-     * it is returned.
-     *
-     * The dispatch origin of this call must be root.
-     *
-     * Note that this does not affect the designated block number of the next election.
-     *
-     * ## Complexity
-     * - Check details of remove_and_replace_member() and do_phragmen().
-     *
-     * @param {AccountId32Like} who
-     * @param {boolean} slashBond
-     * @param {boolean} rerunElection
-     **/
-    removeMember: GenericTxCall<
-      Rv,
-      (
-        who: AccountId32Like,
-        slashBond: boolean,
-        rerunElection: boolean,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Elections';
-          palletCall: {
-            name: 'RemoveMember';
-            params: { who: AccountId32Like; slashBond: boolean; rerunElection: boolean };
-          };
-        }
-      >
-    >;
-
-    /**
-     * Clean all voters who are defunct (i.e. they do not serve any purpose at all). The
-     * deposit of the removed voters are returned.
-     *
-     * This is an root function to be used only for cleaning the state.
-     *
-     * The dispatch origin of this call must be root.
-     *
-     * ## Complexity
-     * - Check is_defunct_voter() details.
-     *
-     * @param {number} numVoters
-     * @param {number} numDefunct
-     **/
-    cleanDefunctVoters: GenericTxCall<
-      Rv,
-      (
-        numVoters: number,
-        numDefunct: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Elections';
-          palletCall: {
-            name: 'CleanDefunctVoters';
-            params: { numVoters: number; numDefunct: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * Generic pallet tx call
-     **/
-    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
-  };
-  /**
-   * Pallet `Council`'s transaction calls
-   **/
-  council: {
-    /**
-     * 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)
-     *
-     * @param {Array<AccountId32Like>} newMembers
-     * @param {AccountId32Like | undefined} prime
-     * @param {number} oldCount
-     **/
-    setMembers: GenericTxCall<
-      Rv,
-      (
-        newMembers: Array<AccountId32Like>,
-        prime: AccountId32Like | undefined,
-        oldCount: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Council';
-          palletCall: {
-            name: 'SetMembers';
-            params: { newMembers: Array<AccountId32Like>; prime: AccountId32Like | undefined; oldCount: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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`
-     *
-     * @param {HydradxRuntimeRuntimeCallLike} proposal
-     * @param {number} lengthBound
-     **/
-    execute: GenericTxCall<
-      Rv,
-      (
-        proposal: HydradxRuntimeRuntimeCallLike,
-        lengthBound: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Council';
-          palletCall: {
-            name: 'Execute';
-            params: { proposal: HydradxRuntimeRuntimeCallLike; lengthBound: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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`)
-     *
-     * @param {number} threshold
-     * @param {HydradxRuntimeRuntimeCallLike} proposal
-     * @param {number} lengthBound
-     **/
-    propose: GenericTxCall<
-      Rv,
-      (
-        threshold: number,
-        proposal: HydradxRuntimeRuntimeCallLike,
-        lengthBound: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Council';
-          palletCall: {
-            name: 'Propose';
-            params: { threshold: number; proposal: HydradxRuntimeRuntimeCallLike; lengthBound: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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)
-     *
-     * @param {H256} proposal
-     * @param {number} index
-     * @param {boolean} approve
-     **/
-    vote: GenericTxCall<
-      Rv,
-      (
-        proposal: H256,
-        index: number,
-        approve: boolean,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Council';
-          palletCall: {
-            name: 'Vote';
-            params: { proposal: H256; index: number; approve: boolean };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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
-     *
-     * @param {H256} proposalHash
-     **/
-    disapproveProposal: GenericTxCall<
-      Rv,
-      (proposalHash: H256) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Council';
-          palletCall: {
-            name: 'DisapproveProposal';
-            params: { proposalHash: H256 };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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)
-     *
-     * @param {H256} proposalHash
-     * @param {number} index
-     * @param {SpWeightsWeightV2Weight} proposalWeightBound
-     * @param {number} lengthBound
-     **/
-    close: GenericTxCall<
-      Rv,
-      (
-        proposalHash: H256,
-        index: number,
-        proposalWeightBound: SpWeightsWeightV2Weight,
-        lengthBound: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Council';
-          palletCall: {
-            name: 'Close';
-            params: {
-              proposalHash: H256;
-              index: number;
-              proposalWeightBound: SpWeightsWeightV2Weight;
-              lengthBound: number;
-            };
-          };
-        }
-      >
-    >;
-
-    /**
-     * Generic pallet tx call
-     **/
-    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
-  };
   /**
    * Pallet `TechnicalCommittee`'s transaction calls
    **/
@@ -3106,418 +2651,192 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
           pallet: 'TechnicalCommittee';
           palletCall: {
             name: 'SetMembers';
-            params: { newMembers: Array<AccountId32Like>; prime: AccountId32Like | undefined; oldCount: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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`
-     *
-     * @param {HydradxRuntimeRuntimeCallLike} proposal
-     * @param {number} lengthBound
-     **/
-    execute: GenericTxCall<
-      Rv,
-      (
-        proposal: HydradxRuntimeRuntimeCallLike,
-        lengthBound: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'TechnicalCommittee';
-          palletCall: {
-            name: 'Execute';
-            params: { proposal: HydradxRuntimeRuntimeCallLike; lengthBound: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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`)
-     *
-     * @param {number} threshold
-     * @param {HydradxRuntimeRuntimeCallLike} proposal
-     * @param {number} lengthBound
-     **/
-    propose: GenericTxCall<
-      Rv,
-      (
-        threshold: number,
-        proposal: HydradxRuntimeRuntimeCallLike,
-        lengthBound: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'TechnicalCommittee';
-          palletCall: {
-            name: 'Propose';
-            params: { threshold: number; proposal: HydradxRuntimeRuntimeCallLike; lengthBound: number };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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)
-     *
-     * @param {H256} proposal
-     * @param {number} index
-     * @param {boolean} approve
-     **/
-    vote: GenericTxCall<
-      Rv,
-      (
-        proposal: H256,
-        index: number,
-        approve: boolean,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'TechnicalCommittee';
-          palletCall: {
-            name: 'Vote';
-            params: { proposal: H256; index: number; approve: boolean };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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
-     *
-     * @param {H256} proposalHash
-     **/
-    disapproveProposal: GenericTxCall<
-      Rv,
-      (proposalHash: H256) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'TechnicalCommittee';
-          palletCall: {
-            name: 'DisapproveProposal';
-            params: { proposalHash: H256 };
-          };
-        }
-      >
-    >;
-
-    /**
-     * 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)
-     *
-     * @param {H256} proposalHash
-     * @param {number} index
-     * @param {SpWeightsWeightV2Weight} proposalWeightBound
-     * @param {number} lengthBound
-     **/
-    close: GenericTxCall<
-      Rv,
-      (
-        proposalHash: H256,
-        index: number,
-        proposalWeightBound: SpWeightsWeightV2Weight,
-        lengthBound: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'TechnicalCommittee';
-          palletCall: {
-            name: 'Close';
-            params: {
-              proposalHash: H256;
-              index: number;
-              proposalWeightBound: SpWeightsWeightV2Weight;
-              lengthBound: number;
-            };
-          };
-        }
-      >
-    >;
-
-    /**
-     * Generic pallet tx call
-     **/
-    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
-  };
-  /**
-   * Pallet `Tips`'s transaction calls
-   **/
-  tips: {
-    /**
-     * Report something `reason` that deserves a tip and claim any eventual the finder's fee.
-     *
-     * The dispatch origin for this call must be _Signed_.
-     *
-     * Payment: `TipReportDepositBase` will be reserved from the origin account, as well as
-     * `DataDepositPerByte` for each byte in `reason`.
-     *
-     * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be
-     * a UTF-8-encoded URL.
-     * - `who`: The account which should be credited for the tip.
-     *
-     * Emits `NewTip` if successful.
-     *
-     * ## Complexity
-     * - `O(R)` where `R` length of `reason`.
-     * - encoding and hashing of 'reason'
-     *
-     * @param {BytesLike} reason
-     * @param {AccountId32Like} who
-     **/
-    reportAwesome: GenericTxCall<
-      Rv,
-      (
-        reason: BytesLike,
-        who: AccountId32Like,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'Tips';
-          palletCall: {
-            name: 'ReportAwesome';
-            params: { reason: BytesLike; who: AccountId32Like };
+            params: { newMembers: Array<AccountId32Like>; prime: AccountId32Like | undefined; oldCount: number };
           };
         }
       >
     >;
 
     /**
-     * Retract a prior tip-report from `report_awesome`, and cancel the process of tipping.
-     *
-     * If successful, the original deposit will be unreserved.
-     *
-     * The dispatch origin for this call must be _Signed_ and the tip identified by `hash`
-     * must have been reported by the signing account through `report_awesome` (and not
-     * through `tip_new`).
-     *
-     * - `hash`: The identity of the open tip for which a tip value is declared. This is formed
-     * as the hash of the tuple of the original tip `reason` and the beneficiary account ID.
+     * Dispatch a proposal from a member using the `Member` origin.
      *
-     * Emits `TipRetracted` if successful.
+     * Origin must be a member of the collective.
      *
-     * ## Complexity
-     * - `O(1)`
-     * - Depends on the length of `T::Hash` which is fixed.
+     * ## 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`
      *
-     * @param {H256} hash
+     * @param {HydradxRuntimeRuntimeCallLike} proposal
+     * @param {number} lengthBound
      **/
-    retractTip: GenericTxCall<
+    execute: GenericTxCall<
       Rv,
-      (hash: H256) => ChainSubmittableExtrinsic<
+      (
+        proposal: HydradxRuntimeRuntimeCallLike,
+        lengthBound: number,
+      ) => ChainSubmittableExtrinsic<
         Rv,
         {
-          pallet: 'Tips';
+          pallet: 'TechnicalCommittee';
           palletCall: {
-            name: 'RetractTip';
-            params: { hash: H256 };
+            name: 'Execute';
+            params: { proposal: HydradxRuntimeRuntimeCallLike; lengthBound: number };
           };
         }
       >
     >;
 
     /**
-     * Give a tip for something new; no finder's fee will be taken.
-     *
-     * The dispatch origin for this call must be _Signed_ and the signing account must be a
-     * member of the `Tippers` set.
+     * Add a new proposal to either be voted on or executed directly.
      *
-     * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be
-     * a UTF-8-encoded URL.
-     * - `who`: The account which should be credited for the tip.
-     * - `tip_value`: The amount of tip that the sender would like to give. The median tip
-     * value of active tippers will be given to the `who`.
+     * Requires the sender to be member.
      *
-     * Emits `NewTip` if successful.
+     * `threshold` determines whether `proposal` is executed directly (`threshold < 2`)
+     * or put up for voting.
      *
      * ## Complexity
-     * - `O(R + T)` where `R` length of `reason`, `T` is the number of tippers.
-     * - `O(T)`: decoding `Tipper` vec of length `T`. `T` is charged as upper bound given by
-     * `ContainsLengthBound`. The actual cost depends on the implementation of
-     * `T::Tippers`.
-     * - `O(R)`: hashing and encoding of reason of length `R`
+     * - `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`)
      *
-     * @param {BytesLike} reason
-     * @param {AccountId32Like} who
-     * @param {bigint} tipValue
+     * @param {number} threshold
+     * @param {HydradxRuntimeRuntimeCallLike} proposal
+     * @param {number} lengthBound
      **/
-    tipNew: GenericTxCall<
+    propose: GenericTxCall<
       Rv,
       (
-        reason: BytesLike,
-        who: AccountId32Like,
-        tipValue: bigint,
+        threshold: number,
+        proposal: HydradxRuntimeRuntimeCallLike,
+        lengthBound: number,
       ) => ChainSubmittableExtrinsic<
         Rv,
         {
-          pallet: 'Tips';
+          pallet: 'TechnicalCommittee';
           palletCall: {
-            name: 'TipNew';
-            params: { reason: BytesLike; who: AccountId32Like; tipValue: bigint };
+            name: 'Propose';
+            params: { threshold: number; proposal: HydradxRuntimeRuntimeCallLike; lengthBound: number };
           };
         }
       >
     >;
 
     /**
-     * Declare a tip value for an already-open tip.
-     *
-     * The dispatch origin for this call must be _Signed_ and the signing account must be a
-     * member of the `Tippers` set.
-     *
-     * - `hash`: The identity of the open tip for which a tip value is declared. This is formed
-     * as the hash of the tuple of the hash of the original tip `reason` and the beneficiary
-     * account ID.
-     * - `tip_value`: The amount of tip that the sender would like to give. The median tip
-     * value of active tippers will be given to the `who`.
+     * Add an aye or nay vote for the sender to the given proposal.
      *
-     * Emits `TipClosing` if the threshold of tippers has been reached and the countdown period
-     * has started.
+     * 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(T)` where `T` is the number of tippers. decoding `Tipper` vec of length `T`, insert
-     * tip and check closing, `T` is charged as upper bound given by `ContainsLengthBound`.
-     * The actual cost depends on the implementation of `T::Tippers`.
-     *
-     * Actually weight could be lower as it depends on how many tips are in `OpenTip` but it
-     * is weighted as if almost full i.e of length `T-1`.
+     * - `O(M)` where `M` is members-count (code- and governance-bounded)
      *
-     * @param {H256} hash
-     * @param {bigint} tipValue
+     * @param {H256} proposal
+     * @param {number} index
+     * @param {boolean} approve
      **/
-    tip: GenericTxCall<
+    vote: GenericTxCall<
       Rv,
       (
-        hash: H256,
-        tipValue: bigint,
+        proposal: H256,
+        index: number,
+        approve: boolean,
       ) => ChainSubmittableExtrinsic<
         Rv,
         {
-          pallet: 'Tips';
+          pallet: 'TechnicalCommittee';
           palletCall: {
-            name: 'Tip';
-            params: { hash: H256; tipValue: bigint };
+            name: 'Vote';
+            params: { proposal: H256; index: number; approve: boolean };
           };
         }
       >
     >;
 
     /**
-     * Close and payout a tip.
-     *
-     * The dispatch origin for this call must be _Signed_.
+     * Disapprove a proposal, close, and remove it from the system, regardless of its current
+     * state.
      *
-     * The tip identified by `hash` must have finished its countdown period.
+     * Must be called by the Root origin.
      *
-     * - `hash`: The identity of the open tip for which a tip value is declared. This is formed
-     * as the hash of the tuple of the original tip `reason` and the beneficiary account ID.
+     * Parameters:
+     * * `proposal_hash`: The hash of the proposal that should be disapproved.
      *
      * ## Complexity
-     * - : `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length `T`. `T`
-     * is charged as upper bound given by `ContainsLengthBound`. The actual cost depends on
-     * the implementation of `T::Tippers`.
+     * O(P) where P is the number of max proposals
      *
-     * @param {H256} hash
+     * @param {H256} proposalHash
      **/
-    closeTip: GenericTxCall<
+    disapproveProposal: GenericTxCall<
       Rv,
-      (hash: H256) => ChainSubmittableExtrinsic<
+      (proposalHash: H256) => ChainSubmittableExtrinsic<
         Rv,
         {
-          pallet: 'Tips';
+          pallet: 'TechnicalCommittee';
           palletCall: {
-            name: 'CloseTip';
-            params: { hash: H256 };
+            name: 'DisapproveProposal';
+            params: { proposalHash: H256 };
           };
         }
       >
     >;
 
     /**
-     * Remove and slash an already-open tip.
+     * 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.
      *
-     * May only be called from `T::RejectOrigin`.
+     * 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.
      *
-     * As a result, the finder is slashed and the deposits are lost.
+     * 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.
      *
-     * Emits `TipSlashed` if successful.
+     * + `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(1).
+     * - `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)
      *
-     * @param {H256} hash
+     * @param {H256} proposalHash
+     * @param {number} index
+     * @param {SpWeightsWeightV2Weight} proposalWeightBound
+     * @param {number} lengthBound
      **/
-    slashTip: GenericTxCall<
+    close: GenericTxCall<
       Rv,
-      (hash: H256) => ChainSubmittableExtrinsic<
+      (
+        proposalHash: H256,
+        index: number,
+        proposalWeightBound: SpWeightsWeightV2Weight,
+        lengthBound: number,
+      ) => ChainSubmittableExtrinsic<
         Rv,
         {
-          pallet: 'Tips';
+          pallet: 'TechnicalCommittee';
           palletCall: {
-            name: 'SlashTip';
-            params: { hash: H256 };
+            name: 'Close';
+            params: {
+              proposalHash: H256;
+              index: number;
+              proposalWeightBound: SpWeightsWeightV2Weight;
+              lengthBound: number;
+            };
           };
         }
       >
@@ -7774,6 +7093,102 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Lockdown an asset for minting
+     *
+     * Can be called only by an authority origin
+     *
+     * Parameters:
+     * - `origin`: The dispatch origin for this call. Must be `AuthorityOrigin`
+     * - `asset_id`: The identifier of an asset
+     * - `until`: The block number until which the asset is locked
+     *
+     * /// Emits `AssetLockdowned` event when successful.
+     *
+     * @param {number} assetId
+     * @param {number} until
+     **/
+    lockdownAsset: GenericTxCall<
+      Rv,
+      (
+        assetId: number,
+        until: number,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'CircuitBreaker';
+          palletCall: {
+            name: 'LockdownAsset';
+            params: { assetId: number; until: number };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Remove asset lockdown regardless of the state.
+     *
+     * Can be called only by an authority origin
+     *
+     * Parameters:
+     *
+     * - `origin`: The dispatch origin for this call. Must be `AuthorityOrigin`
+     * - `asset_id`: The identifier of an asset
+     *
+     * Emits `AssetLockdownRemoved` event when successful.
+     *
+     * @param {number} assetId
+     **/
+    forceLiftLockdown: GenericTxCall<
+      Rv,
+      (assetId: number) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'CircuitBreaker';
+          palletCall: {
+            name: 'ForceLiftLockdown';
+            params: { assetId: number };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Release deposit of an asset.
+     *
+     * It releases all the pallet reserved balance of the asset for the given account
+     *
+     * Can be called by any origin, but only if the asset is not in active lockdown.
+     *
+     * The caller does not pay for this call if successful.
+     *
+     * Parameters:
+     * - `origin`: The dispatch origin for this call. Can be signed or root.
+     * - `who`: The account that is saving the deposit.
+     * - `asset_id`: The identifier of the asset.
+     *
+     * Emits `DepositReleased` event when successful.
+     *
+     * @param {AccountId32Like} who
+     * @param {number} assetId
+     **/
+    releaseDeposit: GenericTxCall<
+      Rv,
+      (
+        who: AccountId32Like,
+        assetId: number,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'CircuitBreaker';
+          palletCall: {
+            name: 'ReleaseDeposit';
+            params: { who: AccountId32Like; assetId: number };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -8005,6 +7420,62 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
    * Pallet `DynamicFees`'s transaction calls
    **/
   dynamicFees: {
+    /**
+     * Set fee configuration for an asset
+     *
+     * This function allows setting either fixed or dynamic fee configuration for a specific asset.
+     *
+     * # Arguments
+     * * `origin` - Root origin required
+     * * `asset_id` - The asset ID to configure
+     * * `config` - Fee configuration (Fixed or Dynamic)
+     *
+     * @param {number} assetId
+     * @param {PalletDynamicFeesAssetFeeConfig} config
+     **/
+    setAssetFee: GenericTxCall<
+      Rv,
+      (
+        assetId: number,
+        config: PalletDynamicFeesAssetFeeConfig,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'DynamicFees';
+          palletCall: {
+            name: 'SetAssetFee';
+            params: { assetId: number; config: PalletDynamicFeesAssetFeeConfig };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Remove fee configuration for an asset (will use default parameters)
+     *
+     * This function removes any custom fee configuration for the specified asset.
+     * After removal, the asset will use the default dynamic fee parameters configured in the runtime.
+     *
+     * # Arguments
+     * * `origin` - Root origin required
+     * * `asset_id` - The asset ID to remove configuration for
+     *
+     * @param {number} assetId
+     **/
+    removeAssetFee: GenericTxCall<
+      Rv,
+      (assetId: number) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'DynamicFees';
+          palletCall: {
+            name: 'RemoveAssetFee';
+            params: { assetId: number };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -11516,6 +10987,41 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Unlocks DCA reserves of provided asset for the caller if they have no active schedules.
+     *
+     * This is a utility function to help users recover their reserved funds in case
+     * a DCA schedule was terminated but left some reserved amounts.
+     *
+     * This can only be called when the user has no active DCA schedules.
+     *
+     * Parameters:
+     * - `origin`: The account to unlock reserves for (must be signed)
+     * - `asset_id`: The asset ID for which reserves should be unlocked.
+     *
+     * Emits `ReserveUnlocked` event when successful.
+     *
+     *
+     * @param {AccountId32Like} who
+     * @param {number} assetId
+     **/
+    unlockReserves: GenericTxCall<
+      Rv,
+      (
+        who: AccountId32Like,
+        assetId: number,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Dca';
+          palletCall: {
+            name: 'UnlockReserves';
+            params: { who: AccountId32Like; assetId: number };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/