diff --git a/src/interfaces/augment-api-consts.ts b/src/interfaces/augment-api-consts.ts
deleted file mode 100644
index ddaa946..0000000
--- a/src/interfaces/augment-api-consts.ts
+++ /dev/null
@@ -1,249 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
-/* eslint-disable */
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/consts';
-
-import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types';
-import type { u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
-import type { Codec } from '@polkadot/types-codec/types';
-
-export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
-
-declare module '@polkadot/api-base/types/consts' {
-  interface AugmentedConsts<ApiType extends ApiTypes> {
-    asset: {
-      /**
-       * The minimum balance to create class
-       **/
-      createAssetClassDeposit: u128 & AugmentedConst<ApiType>;
-      maxAssetMetadata: u32 & AugmentedConst<ApiType>;
-      maxClassMetadata: u32 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    bag: {
-      /**
-       * The minimum balance to create bag
-       **/
-      createBagDeposit: u128 & AugmentedConst<ApiType>;
-      /**
-       * Max number of owners
-       **/
-      maxOwners: u32 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    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: u128 & AugmentedConst<ApiType>;
-      /**
-       * The maximum number of individual freeze locks that can exist on an account at any time.
-       **/
-      maxFreezes: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum number of holds that can exist on an account at any time.
-       **/
-      maxHolds: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum number of locks that should exist on an account.
-       * Not strictly enforced, but used for weight estimation.
-       **/
-      maxLocks: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum number of named reserves that can exist on an account.
-       **/
-      maxReserves: u32 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    bundle: {
-      /**
-       * Max number of asset classes and per asset_id in a bundle
-       **/
-      maxAssets: u32 & AugmentedConst<ApiType>;
-      palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    council: {
-      /**
-       * The maximum weight of a dispatch call that can be proposed and executed.
-       **/
-      maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    fula: {
-      maxManifestMetadata: u32 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    grandpa: {
-      /**
-       * Max Authorities in use
-       **/
-      maxAuthorities: u32 & AugmentedConst<ApiType>;
-      /**
-       * 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: u64 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    market: {
-      /**
-       * Max metadata size
-       **/
-      maxMetadata: u32 & AugmentedConst<ApiType>;
-      /**
-       * Max number of rates per market_rate
-       **/
-      maxRates: u32 & AugmentedConst<ApiType>;
-      palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    pool: {
-      /**
-       * The maximum number of pool participants. We are aiming at `u8::MAX`.
-       **/
-      maxPoolParticipants: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum length of a name or symbol stored on-chain. See if this can be limited to
-       * `u8::MAX`.
-       **/
-      stringLimit: u32 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    scheduler: {
-      /**
-       * The maximum weight that may be scheduled per block for any dispatchables.
-       **/
-      maximumWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
-      /**
-       * The maximum number of scheduled calls in the queue for a single block.
-       * 
-       * NOTE:
-       * + Dependent pallets' benchmarks might require a higher limit for the setting. Set a
-       * higher limit under `runtime-benchmarks` feature.
-       **/
-      maxScheduledPerBlock: u32 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    system: {
-      /**
-       * Maximum number of block number to block hash mappings to keep (oldest pruned first).
-       **/
-      blockHashCount: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum length of a block (in bytes).
-       **/
-      blockLength: FrameSystemLimitsBlockLength & AugmentedConst<ApiType>;
-      /**
-       * Block & extrinsics weights: base values and limits.
-       **/
-      blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst<ApiType>;
-      /**
-       * The weight of runtime database operations the runtime can invoke.
-       **/
-      dbWeight: SpWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
-      /**
-       * 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: u16 & AugmentedConst<ApiType>;
-      /**
-       * Get the chain's current version.
-       **/
-      version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    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: u64 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-    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: u8 & AugmentedConst<ApiType>;
-      /**
-       * Generic const
-       **/
-      [key: string]: Codec;
-    };
-  } // AugmentedConsts
-} // declare module
diff --git a/src/interfaces/augment-api-events.ts b/src/interfaces/augment-api-events.ts
deleted file mode 100644
index 4a93988..0000000
--- a/src/interfaces/augment-api-events.ts
+++ /dev/null
@@ -1,398 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
-/* eslint-disable */
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/events';
-
-import type { ApiTypes, AugmentedEvent } from '@polkadot/api-base/types';
-import type { Bytes, Null, Option, Result, U8aFixed, Vec, bool, i32, u128, u16, u32, u64 } from '@polkadot/types-codec';
-import type { ITuple } from '@polkadot/types-codec/types';
-import type { AccountId32, H256 } from '@polkadot/types/interfaces/runtime';
-
-export type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
-
-declare module '@polkadot/api-base/types/events' {
-  interface AugmentedEvents<ApiType extends ApiTypes> {
-    asset: {
-      AssetCreated: AugmentedEvent<ApiType, [classId: u64, assetId: u64, who: AccountId32], { classId: u64, assetId: u64, who: AccountId32 }>;
-      AssetMetadataUpdated: AugmentedEvent<ApiType, [classId: u64, assetId: u64, who: AccountId32, metadata: Bytes], { classId: u64, assetId: u64, who: AccountId32, metadata: Bytes }>;
-      BatchBurn: AugmentedEvent<ApiType, [who: AccountId32, from: AccountId32, classId: u64, assetIds: Vec<u64>, amounts: Vec<u128>], { who: AccountId32, from: AccountId32, classId: u64, assetIds: Vec<u64>, amounts: Vec<u128> }>;
-      BatchMint: AugmentedEvent<ApiType, [who: AccountId32, to: AccountId32, classId: u64, assetIds: Vec<u64>, amounts: Vec<u128>], { who: AccountId32, to: AccountId32, classId: u64, assetIds: Vec<u64>, amounts: Vec<u128> }>;
-      BatchTransferred: AugmentedEvent<ApiType, [who: AccountId32, from: AccountId32, to: AccountId32, classId: u64, assetIds: Vec<u64>, amounts: Vec<u128>], { who: AccountId32, from: AccountId32, to: AccountId32, classId: u64, assetIds: Vec<u64>, amounts: Vec<u128> }>;
-      Burn: AugmentedEvent<ApiType, [who: AccountId32, from: AccountId32, classId: u64, assetId: u64, amount: u128], { who: AccountId32, from: AccountId32, classId: u64, assetId: u64, amount: u128 }>;
-      ClassCreated: AugmentedEvent<ApiType, [classId: u64, who: AccountId32], { classId: u64, who: AccountId32 }>;
-      Mint: AugmentedEvent<ApiType, [who: AccountId32, to: AccountId32, classId: u64, assetId: u64, amount: u128], { who: AccountId32, to: AccountId32, classId: u64, assetId: u64, amount: u128 }>;
-      OperatorApprovalForAll: AugmentedEvent<ApiType, [who: AccountId32, operator: AccountId32, classId: u64, approved: bool], { who: AccountId32, operator: AccountId32, classId: u64, approved: bool }>;
-      Transferred: AugmentedEvent<ApiType, [who: AccountId32, from: AccountId32, to: AccountId32, classId: u64, assetId: u64, amount: u128], { who: AccountId32, from: AccountId32, to: AccountId32, classId: u64, assetId: u64, amount: u128 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    bag: {
-      Created: AugmentedEvent<ApiType, [bag: AccountId32, who: AccountId32, classId: u64, assetId: u64, owners: Vec<AccountId32>], { bag: AccountId32, who: AccountId32, classId: u64, assetId: u64, owners: Vec<AccountId32> }>;
-      Deposit: AugmentedEvent<ApiType, [bag: AccountId32, who: AccountId32], { bag: AccountId32, who: AccountId32 }>;
-      Register: AugmentedEvent<ApiType, [who: AccountId32, classId: u64], { who: AccountId32, classId: u64 }>;
-      Sweep: AugmentedEvent<ApiType, [bag: AccountId32, who: AccountId32, to: AccountId32], { bag: AccountId32, who: AccountId32, to: AccountId32 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    balances: {
-      /**
-       * A balance was set by root.
-       **/
-      BalanceSet: AugmentedEvent<ApiType, [who: AccountId32, free: u128], { who: AccountId32, free: u128 }>;
-      /**
-       * Some amount was burned from an account.
-       **/
-      Burned: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Some amount was deposited (e.g. for transaction fees).
-       **/
-      Deposit: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * An account was removed whose balance was non-zero but below ExistentialDeposit,
-       * resulting in an outright loss.
-       **/
-      DustLost: AugmentedEvent<ApiType, [account: AccountId32, amount: u128], { account: AccountId32, amount: u128 }>;
-      /**
-       * An account was created with some free balance.
-       **/
-      Endowed: AugmentedEvent<ApiType, [account: AccountId32, freeBalance: u128], { account: AccountId32, freeBalance: u128 }>;
-      /**
-       * Some balance was frozen.
-       **/
-      Frozen: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Total issuance was increased by `amount`, creating a credit to be balanced.
-       **/
-      Issued: AugmentedEvent<ApiType, [amount: u128], { amount: u128 }>;
-      /**
-       * Some balance was locked.
-       **/
-      Locked: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Some amount was minted into an account.
-       **/
-      Minted: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Total issuance was decreased by `amount`, creating a debt to be balanced.
-       **/
-      Rescinded: AugmentedEvent<ApiType, [amount: u128], { amount: u128 }>;
-      /**
-       * Some balance was reserved (moved from free to reserved).
-       **/
-      Reserved: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Some balance was moved from the reserve of the first account to the second account.
-       * Final argument indicates the destination balance type.
-       **/
-      ReserveRepatriated: AugmentedEvent<ApiType, [from: AccountId32, to: AccountId32, amount: u128, destinationStatus: FrameSupportTokensMiscBalanceStatus], { from: AccountId32, to: AccountId32, amount: u128, destinationStatus: FrameSupportTokensMiscBalanceStatus }>;
-      /**
-       * Some amount was restored into an account.
-       **/
-      Restored: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Some amount was removed from the account (e.g. for misbehavior).
-       **/
-      Slashed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Some amount was suspended from an account (it can be restored later).
-       **/
-      Suspended: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Some balance was thawed.
-       **/
-      Thawed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Transfer succeeded.
-       **/
-      Transfer: AugmentedEvent<ApiType, [from: AccountId32, to: AccountId32, amount: u128], { from: AccountId32, to: AccountId32, amount: u128 }>;
-      /**
-       * Some balance was unlocked.
-       **/
-      Unlocked: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Some balance was unreserved (moved from reserved to free).
-       **/
-      Unreserved: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * An account was upgraded.
-       **/
-      Upgraded: AugmentedEvent<ApiType, [who: AccountId32], { who: AccountId32 }>;
-      /**
-       * Some amount was withdrawn from the account (e.g. for transaction fees).
-       **/
-      Withdraw: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], { who: AccountId32, amount: u128 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    bundle: {
-      Burn: AugmentedEvent<ApiType, [bundleId: H256, who: AccountId32, from: AccountId32, to: AccountId32, amount: u128], { bundleId: H256, who: AccountId32, from: AccountId32, to: AccountId32, amount: u128 }>;
-      Mint: AugmentedEvent<ApiType, [bundleId: H256, who: AccountId32, from: AccountId32, to: AccountId32, amount: u128], { bundleId: H256, who: AccountId32, from: AccountId32, to: AccountId32, amount: u128 }>;
-      Register: AugmentedEvent<ApiType, [bundleId: H256, who: AccountId32, classId: u64, assetId: u64], { bundleId: H256, who: AccountId32, classId: u64, assetId: u64 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    council: {
-      /**
-       * A motion was approved by the required threshold.
-       **/
-      Approved: AugmentedEvent<ApiType, [proposalHash: H256], { proposalHash: H256 }>;
-      /**
-       * A proposal was closed because its threshold was reached or after its duration was up.
-       **/
-      Closed: AugmentedEvent<ApiType, [proposalHash: H256, yes: u32, no: u32], { proposalHash: H256, yes: u32, no: u32 }>;
-      /**
-       * A motion was not approved by the required threshold.
-       **/
-      Disapproved: AugmentedEvent<ApiType, [proposalHash: H256], { proposalHash: H256 }>;
-      /**
-       * A motion was executed; result will be `Ok` if it returned without error.
-       **/
-      Executed: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], { proposalHash: H256, result: Result<Null, SpRuntimeDispatchError> }>;
-      /**
-       * A single member did some action; result will be `Ok` if it returned without error.
-       **/
-      MemberExecuted: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], { proposalHash: H256, result: Result<Null, SpRuntimeDispatchError> }>;
-      /**
-       * A motion (given hash) has been proposed (by given account) with a threshold (given
-       * `MemberCount`).
-       **/
-      Proposed: AugmentedEvent<ApiType, [account: AccountId32, proposalIndex: u32, proposalHash: H256, threshold: u32], { account: AccountId32, proposalIndex: u32, proposalHash: H256, threshold: u32 }>;
-      /**
-       * A motion (given hash) has been voted on by given account, leaving
-       * a tally (yes votes and no votes given respectively as `MemberCount`).
-       **/
-      Voted: AugmentedEvent<ApiType, [account: AccountId32, proposalHash: H256, voted: bool, yes: u32, no: u32], { account: AccountId32, proposalHash: H256, voted: bool, yes: u32, no: u32 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    dao: {
-      /**
-       * Event documentation should end with an array that provides descriptive names for event
-       * parameters. [something, who]
-       **/
-      SomethingStored: AugmentedEvent<ApiType, [u32, AccountId32]>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    exgine: {
-      /**
-       * Event documentation should end with an array that provides descriptive names for event
-       * parameters. [something, who]
-       **/
-      SomethingStored: AugmentedEvent<ApiType, [u32, AccountId32]>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    fula: {
-      BatchManifestOutput: AugmentedEvent<ApiType, [uploader: AccountId32, poolIds: Vec<u32>, manifests: Vec<Bytes>], { uploader: AccountId32, poolIds: Vec<u32>, manifests: Vec<Bytes> }>;
-      BatchManifestRemoved: AugmentedEvent<ApiType, [uploader: AccountId32, poolIds: Vec<u32>, cids: Vec<Bytes>], { uploader: AccountId32, poolIds: Vec<u32>, cids: Vec<Bytes> }>;
-      BatchRemoveStorerOutput: AugmentedEvent<ApiType, [storer: AccountId32, poolId: u32, cids: Vec<Bytes>], { storer: AccountId32, poolId: u32, cids: Vec<Bytes> }>;
-      BatchStorageManifestOutput: AugmentedEvent<ApiType, [storer: AccountId32, poolId: u32, cids: Vec<Bytes>], { storer: AccountId32, poolId: u32, cids: Vec<Bytes> }>;
-      Challenge: AugmentedEvent<ApiType, [challenger: AccountId32, challenged: AccountId32, cid: Bytes, state: FunctionlandFulaChallengeState], { challenger: AccountId32, challenged: AccountId32, cid: Bytes, state: FunctionlandFulaChallengeState }>;
-      GetAvailableManifests: AugmentedEvent<ApiType, [manifests: Vec<FunctionlandFulaManifestAvailable>], { manifests: Vec<FunctionlandFulaManifestAvailable> }>;
-      GetManifests: AugmentedEvent<ApiType, [manifests: Vec<FunctionlandFulaManifestWithPoolId>], { manifests: Vec<FunctionlandFulaManifestWithPoolId> }>;
-      GetManifestsStorerData: AugmentedEvent<ApiType, [manifests: Vec<FunctionlandFulaStorerData>], { manifests: Vec<FunctionlandFulaStorerData> }>;
-      ManifestOutput: AugmentedEvent<ApiType, [uploader: AccountId32, storer: Vec<AccountId32>, poolId: u32, manifest: Bytes], { uploader: AccountId32, storer: Vec<AccountId32>, poolId: u32, manifest: Bytes }>;
-      ManifestRemoved: AugmentedEvent<ApiType, [uploader: AccountId32, poolId: u32, cid: Bytes], { uploader: AccountId32, poolId: u32, cid: Bytes }>;
-      ManifestStorageUpdated: AugmentedEvent<ApiType, [storer: AccountId32, poolId: u32, cid: Bytes, activeCycles: u16, missedCycles: u16, activeDays: i32], { storer: AccountId32, poolId: u32, cid: Bytes, activeCycles: u16, missedCycles: u16, activeDays: i32 }>;
-      MintedLaborTokens: AugmentedEvent<ApiType, [account: AccountId32, classId: u64, assetId: u64, amount: u128, calculatedAmount: u128], { account: AccountId32, classId: u64, assetId: u64, amount: u128, calculatedAmount: u128 }>;
-      RemoveStorerOutput: AugmentedEvent<ApiType, [storer: Option<AccountId32>, poolId: u32, cid: Bytes], { storer: Option<AccountId32>, poolId: u32, cid: Bytes }>;
-      StorageManifestOutput: AugmentedEvent<ApiType, [storer: AccountId32, poolId: u32, cid: Bytes], { storer: AccountId32, poolId: u32, cid: Bytes }>;
-      UpdateFileSizeOutput: AugmentedEvent<ApiType, [account: AccountId32, poolId: u32, cid: Bytes, size_: u64], { account: AccountId32, poolId: u32, cid: Bytes, size_: u64 }>;
-      UpdateFileSizesOutput: AugmentedEvent<ApiType, [account: AccountId32, poolId: u32, cids: Vec<Bytes>, sizes: Vec<u64>], { account: AccountId32, poolId: u32, cids: Vec<Bytes>, sizes: Vec<u64> }>;
-      VerifiedChallenges: AugmentedEvent<ApiType, [challenged: AccountId32, successful: Vec<Bytes>, failed: Vec<Bytes>], { challenged: AccountId32, successful: Vec<Bytes>, failed: Vec<Bytes> }>;
-      VerifiedStorerManifests: AugmentedEvent<ApiType, [storer: AccountId32, validCids: Vec<Bytes>, invalidCids: Vec<Bytes>], { storer: AccountId32, validCids: Vec<Bytes>, invalidCids: Vec<Bytes> }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    grandpa: {
-      /**
-       * New authority set has been applied.
-       **/
-      NewAuthorities: AugmentedEvent<ApiType, [authoritySet: Vec<ITuple<[SpConsensusGrandpaAppPublic, u64]>>], { authoritySet: Vec<ITuple<[SpConsensusGrandpaAppPublic, u64]>> }>;
-      /**
-       * Current authority set has been paused.
-       **/
-      Paused: AugmentedEvent<ApiType, []>;
-      /**
-       * Current authority set has been resumed.
-       **/
-      Resumed: AugmentedEvent<ApiType, []>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    market: {
-      Created: AugmentedEvent<ApiType, [marketId: u64, who: AccountId32], { marketId: u64, who: AccountId32 }>;
-      Deposit: AugmentedEvent<ApiType, [who: AccountId32, marketId: u64, marketRateId: u64, amount: u128, balances: Vec<SugarfungeMarketRateBalance>, success: bool], { who: AccountId32, marketId: u64, marketRateId: u64, amount: u128, balances: Vec<SugarfungeMarketRateBalance>, success: bool }>;
-      Exchanged: AugmentedEvent<ApiType, [buyer: AccountId32, marketId: u64, marketRateId: u64, amount: u128, balances: Vec<SugarfungeMarketRateBalance>, success: bool], { buyer: AccountId32, marketId: u64, marketRateId: u64, amount: u128, balances: Vec<SugarfungeMarketRateBalance>, success: bool }>;
-      LiquidityAdded: AugmentedEvent<ApiType, [who: AccountId32, marketId: u64, marketRateId: u64, classIds: Vec<u64>, assetIds: Vec<Vec<u64>>, amounts: Vec<Vec<u128>>], { who: AccountId32, marketId: u64, marketRateId: u64, classIds: Vec<u64>, assetIds: Vec<Vec<u64>>, amounts: Vec<Vec<u128>> }>;
-      LiquidityRemoved: AugmentedEvent<ApiType, [who: AccountId32, marketId: u64, marketRateId: u64, classIds: Vec<u64>, assetIds: Vec<Vec<u64>>, amounts: Vec<Vec<u128>>], { who: AccountId32, marketId: u64, marketRateId: u64, classIds: Vec<u64>, assetIds: Vec<Vec<u64>>, amounts: Vec<Vec<u128>> }>;
-      RateCreated: AugmentedEvent<ApiType, [marketId: u64, marketRateId: u64, who: AccountId32], { marketId: u64, marketRateId: u64, who: AccountId32 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    pool: {
-      /**
-       * Pool's capacity has been reached,
-       **/
-      CapacityReached: AugmentedEvent<ApiType, [poolId: u32], { poolId: u32 }>;
-      /**
-       * A user requested to join a pool.
-       **/
-      JoinRequested: AugmentedEvent<ApiType, [account: AccountId32, poolId: u32], { account: AccountId32, poolId: u32 }>;
-      /**
-       * Pool participant left.
-       **/
-      ParticipantLeft: AugmentedEvent<ApiType, [account: AccountId32, poolId: u32], { account: AccountId32, poolId: u32 }>;
-      /**
-       * A pool has been created.
-       **/
-      PoolCreated: AugmentedEvent<ApiType, [owner: Option<AccountId32>, poolId: u32], { owner: Option<AccountId32>, poolId: u32 }>;
-      /**
-       * A user has withdrawn their request to join a pool.
-       **/
-      RequestWithdrawn: AugmentedEvent<ApiType, [account: AccountId32, poolId: u32], { account: AccountId32, poolId: u32 }>;
-      VotingResult: AugmentedEvent<ApiType, [account: AccountId32, poolId: u32, result: Bytes], { account: AccountId32, poolId: u32, result: Bytes }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    scheduler: {
-      /**
-       * The call for the provided hash was not found so the task has been aborted.
-       **/
-      CallUnavailable: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], { task: ITuple<[u32, u32]>, id: Option<U8aFixed> }>;
-      /**
-       * Canceled some task.
-       **/
-      Canceled: AugmentedEvent<ApiType, [when: u32, index: u32], { when: u32, index: u32 }>;
-      /**
-       * Dispatched some task.
-       **/
-      Dispatched: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>, result: Result<Null, SpRuntimeDispatchError>], { task: ITuple<[u32, u32]>, id: Option<U8aFixed>, result: Result<Null, SpRuntimeDispatchError> }>;
-      /**
-       * The given task was unable to be renewed since the agenda is full at that block.
-       **/
-      PeriodicFailed: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], { task: ITuple<[u32, u32]>, id: Option<U8aFixed> }>;
-      /**
-       * The given task can never be executed since it is overweight.
-       **/
-      PermanentlyOverweight: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], { task: ITuple<[u32, u32]>, id: Option<U8aFixed> }>;
-      /**
-       * Scheduled some task.
-       **/
-      Scheduled: AugmentedEvent<ApiType, [when: u32, index: u32], { when: u32, index: u32 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    session: {
-      /**
-       * New session has happened. Note that the argument is the session index, not the
-       * block number as the type might suggest.
-       **/
-      NewSession: AugmentedEvent<ApiType, [sessionIndex: u32], { sessionIndex: u32 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    sudo: {
-      /**
-       * The \[sudoer\] just switched identity; the old key is supplied if one existed.
-       **/
-      KeyChanged: AugmentedEvent<ApiType, [oldSudoer: Option<AccountId32>], { oldSudoer: Option<AccountId32> }>;
-      /**
-       * A sudo just took place. \[result\]
-       **/
-      Sudid: AugmentedEvent<ApiType, [sudoResult: Result<Null, SpRuntimeDispatchError>], { sudoResult: Result<Null, SpRuntimeDispatchError> }>;
-      /**
-       * A sudo just took place. \[result\]
-       **/
-      SudoAsDone: AugmentedEvent<ApiType, [sudoResult: Result<Null, SpRuntimeDispatchError>], { sudoResult: Result<Null, SpRuntimeDispatchError> }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    system: {
-      /**
-       * `:code` was updated.
-       **/
-      CodeUpdated: AugmentedEvent<ApiType, []>;
-      /**
-       * An extrinsic failed.
-       **/
-      ExtrinsicFailed: AugmentedEvent<ApiType, [dispatchError: SpRuntimeDispatchError, dispatchInfo: FrameSupportDispatchDispatchInfo], { dispatchError: SpRuntimeDispatchError, dispatchInfo: FrameSupportDispatchDispatchInfo }>;
-      /**
-       * An extrinsic completed successfully.
-       **/
-      ExtrinsicSuccess: AugmentedEvent<ApiType, [dispatchInfo: FrameSupportDispatchDispatchInfo], { dispatchInfo: FrameSupportDispatchDispatchInfo }>;
-      /**
-       * An account was reaped.
-       **/
-      KilledAccount: AugmentedEvent<ApiType, [account: AccountId32], { account: AccountId32 }>;
-      /**
-       * A new account was created.
-       **/
-      NewAccount: AugmentedEvent<ApiType, [account: AccountId32], { account: AccountId32 }>;
-      /**
-       * On on-chain remark happened.
-       **/
-      Remarked: AugmentedEvent<ApiType, [sender: AccountId32, hash_: H256], { sender: AccountId32, hash_: H256 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    transactionPayment: {
-      /**
-       * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
-       * has been paid by `who`.
-       **/
-      TransactionFeePaid: AugmentedEvent<ApiType, [who: AccountId32, actualFee: u128, tip: u128], { who: AccountId32, actualFee: u128, tip: u128 }>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-    validatorSet: {
-      /**
-       * New validator addition initiated. Effective in ~2 sessions.
-       **/
-      ValidatorAdditionInitiated: AugmentedEvent<ApiType, [AccountId32]>;
-      /**
-       * Validator removal initiated. Effective in ~2 sessions.
-       **/
-      ValidatorRemovalInitiated: AugmentedEvent<ApiType, [AccountId32]>;
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-    };
-  } // AugmentedEvents
-} // declare module
diff --git a/src/interfaces/augment-api-query.ts b/src/interfaces/augment-api-query.ts
deleted file mode 100644
index 6c0c728..0000000
--- a/src/interfaces/augment-api-query.ts
+++ /dev/null
@@ -1,421 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
-/* eslint-disable */
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/storage';
-
-import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';
-import type { Bytes, Option, U8aFixed, Vec, bool, u128, u32, u64 } from '@polkadot/types-codec';
-import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
-import type { AccountId32, Call, H256 } from '@polkadot/types/interfaces/runtime';
-import type { Observable } from '@polkadot/types/types';
-
-export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
-export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
-
-declare module '@polkadot/api-base/types/storage' {
-  interface AugmentedQueries<ApiType extends ApiTypes> {
-    asset: {
-      assetCount: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<u64>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
-      assets: AugmentedQuery<ApiType, (arg1: u64 | AnyNumber | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<Option<SugarfungeAssetAsset>>, [u64, u64]> & QueryableStorageEntry<ApiType, [u64, u64]>;
-      balances: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u64 | AnyNumber | Uint8Array, arg3: u64 | AnyNumber | Uint8Array) => Observable<u128>, [AccountId32, u64, u64]> & QueryableStorageEntry<ApiType, [AccountId32, u64, u64]>;
-      classes: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<SugarfungeAssetClass>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    bag: {
-      bagClasses: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<SugarfungeBagBagClass>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
-      bags: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<SugarfungeBagBag>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      nextBagId: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<u64>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    balances: {
-      /**
-       * 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: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * Freeze locks on account balances.
-       **/
-      freezes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * Holds on account balances.
-       **/
-      holds: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * The total units of outstanding deactivated balance in the system.
-       **/
-      inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Any liquidity locks on some account balances.
-       * NOTE: Should only be accessed when setting, changing and freeing a lock.
-       **/
-      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * Named reserves on some account balances.
-       **/
-      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * The total units issued in the system.
-       **/
-      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    bundle: {
-      assetBundles: AugmentedQuery<ApiType, (arg1: u64 | AnyNumber | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u64, u64]> & QueryableStorageEntry<ApiType, [u64, u64]>;
-      bundles: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<SugarfungeBundleBundle>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    council: {
-      /**
-       * The current members of the collective. This is stored sorted (just by value).
-       **/
-      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * The prime member that helps determine the default vote behavior in case of absentations.
-       **/
-      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Proposals so far.
-       **/
-      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Actual proposal for a given hash, if it's current.
-       **/
-      proposalOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Call>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
-      /**
-       * The hashes of the active proposals.
-       **/
-      proposals: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Votes on a given proposal, if it is ongoing.
-       **/
-      voting: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletCollectiveVotes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    dao: {
-      something: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    exgine: {
-      something: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    fula: {
-      challengeRequests: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: Bytes | string | Uint8Array) => Observable<Option<FunctionlandFulaChallenge>>, [AccountId32, Bytes]> & QueryableStorageEntry<ApiType, [AccountId32, Bytes]>;
-      claims: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<FunctionlandFulaClaimData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      manifests: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: Bytes | string | Uint8Array) => Observable<Option<FunctionlandFulaManifest>>, [u32, Bytes]> & QueryableStorageEntry<ApiType, [u32, Bytes]>;
-      manifestsStorerData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: Bytes | string | Uint8Array) => Observable<Option<FunctionlandFulaManifestStorageData>>, [u32, AccountId32, Bytes]> & QueryableStorageEntry<ApiType, [u32, AccountId32, Bytes]>;
-      networkSize: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    grandpa: {
-      /**
-       * The number of changes (both in terms of keys and underlying economic responsibilities)
-       * in the "set" of Grandpa validators from genesis.
-       **/
-      currentSetId: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * next block number where we can force a change.
-       **/
-      nextForced: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Pending change: (signaled at, scheduled change).
-       **/
-      pendingChange: AugmentedQuery<ApiType, () => Observable<Option<PalletGrandpaStoredPendingChange>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * 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: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
-      /**
-       * `true` if we are currently stalled.
-       **/
-      stalled: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * State of the current authority set.
-       **/
-      state: AugmentedQuery<ApiType, () => Observable<PalletGrandpaStoredState>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    market: {
-      marketRates: AugmentedQuery<ApiType, (arg1: u64 | AnyNumber | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<Option<Vec<SugarfungeMarketAssetRate>>>, [u64, u64]> & QueryableStorageEntry<ApiType, [u64, u64]>;
-      marketRatesMetadata: AugmentedQuery<ApiType, (arg1: u64 | AnyNumber | Uint8Array, arg2: u64 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u64, u64]> & QueryableStorageEntry<ApiType, [u64, u64]>;
-      markets: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<SugarfungeMarketMarket>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    pool: {
-      /**
-       * An incremental value reflecting all pools created so far.
-       **/
-      lastPoolId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Maximum number of pools that can exist. If `None`, then an unbounded number of
-       * pools can exist.
-       **/
-      maxPools: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * PoolRequests storage
-       **/
-      poolRequests: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<FulaPoolPoolRequest>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
-      /**
-       * Pools storage
-       **/
-      pools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<FulaPoolPool>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
-      /**
-       * Users storage, useful in case a user wants to leave or join a pool.
-       **/
-      users: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<FulaPoolUser>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    scheduler: {
-      /**
-       * Items to be executed, indexed by the block number that they should be executed on.
-       **/
-      agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PalletSchedulerScheduled>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
-      incompleteSince: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Lookup from a name to the block number and index of the task.
-       * 
-       * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4
-       * identities.
-       **/
-      lookup: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    session: {
-      /**
-       * Current index of the session.
-       **/
-      currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * 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: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * The owner of a key. The key is the `KeyTypeId` + the encoded key.
-       **/
-      keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;
-      /**
-       * The next session keys for a validator.
-       **/
-      nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<SugarfungeRuntimeOpaqueSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * True if the underlying economic identities or weighting behind the validators
-       * has changed in the queued validator set.
-       **/
-      queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * 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: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, SugarfungeRuntimeOpaqueSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * The current set of validators.
-       **/
-      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    sudo: {
-      /**
-       * The `AccountId` of the sudo key.
-       **/
-      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    system: {
-      /**
-       * The full account information for a particular account ID.
-       **/
-      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
-      /**
-       * Total length (in bytes) for all extrinsics put together, for the current block.
-       **/
-      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Map of block numbers to block hashes.
-       **/
-      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
-      /**
-       * The current weight for the block.
-       **/
-      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Digest of the current block, also part of the block header.
-       **/
-      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * The number of events in the `Events<T>` list.
-       **/
-      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * 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: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * 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: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
-      /**
-       * The execution phase of the block.
-       **/
-      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Total extrinsics count for the current block.
-       **/
-      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Extrinsics data for the current block (maps an extrinsic's index to its data).
-       **/
-      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
-      /**
-       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
-       **/
-      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * The current block number being processed. Set by `execute_block`.
-       **/
-      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Hash of the previous block.
-       **/
-      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
-       * (default) if not.
-       **/
-      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
-       **/
-      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    timestamp: {
-      /**
-       * Did the timestamp get updated in this block?
-       **/
-      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Current time for the current block.
-       **/
-      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    transactionPayment: {
-      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
-      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-    validatorSet: {
-      approvedValidators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      offlineValidators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-    };
-  } // AugmentedQueries
-} // declare module
diff --git a/src/interfaces/augment-api-tx.ts b/src/interfaces/augment-api-tx.ts
deleted file mode 100644
index 241a9fb..0000000
--- a/src/interfaces/augment-api-tx.ts
+++ /dev/null
@@ -1,601 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
-/* eslint-disable */
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/submittable';
-
-import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';
-import type { Bytes, Compact, Option, U8aFixed, Vec, bool, i32, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
-import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
-import type { AccountId32, Call, H256, MultiAddress } from '@polkadot/types/interfaces/runtime';
-
-export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
-export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
-export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
-
-declare module '@polkadot/api-base/types/submittable' {
-  interface AugmentedSubmittables<ApiType extends ApiTypes> {
-    asset: {
-      batchBurn: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetIds: Vec<u64> | (u64 | AnyNumber | Uint8Array)[], amounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [AccountId32, u64, Vec<u64>, Vec<u128>]>;
-      batchMint: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetIds: Vec<u64> | (u64 | AnyNumber | Uint8Array)[], amounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [AccountId32, u64, Vec<u64>, Vec<u128>]>;
-      batchTransferFrom: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetIds: Vec<u64> | (u64 | AnyNumber | Uint8Array)[], amounts: Vec<u128> | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32, u64, Vec<u64>, Vec<u128>]>;
-      burn: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u64, u64, u128]>;
-      createAsset: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, Bytes]>;
-      createClass: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u64, Bytes]>;
-      mint: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u64, u64, u128]>;
-      transferFrom: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32, u64, u64, u128]>;
-      updateAssetMetadata: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, Bytes]>;
-      updateClassMetadata: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Bytes]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    bag: {
-      create: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, owners: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], shares: Vec<u128> | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u64, Vec<AccountId32>, Vec<u128>]>;
-      deposit: AugmentedSubmittable<(bag: AccountId32 | string | Uint8Array, classIds: Vec<u64> | (u64 | AnyNumber | Uint8Array)[], assetIds: Vec<Vec<u64>>, amounts: Vec<Vec<u128>>) => SubmittableExtrinsic<ApiType>, [AccountId32, Vec<u64>, Vec<Vec<u64>>, Vec<Vec<u128>>]>;
-      register: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Bytes]>;
-      sweep: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, bag: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    balances: {
-      /**
-       * Set the regular balance of a given account.
-       * 
-       * The dispatch origin for this call is `root`.
-       **/
-      forceSetBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;
-      /**
-       * Exactly as `transfer_allow_death`, except the origin must be root and the source account
-       * may be specified.
-       **/
-      forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;
-      /**
-       * Unreserve some balance from a user by force.
-       * 
-       * Can only be called by ROOT.
-       **/
-      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;
-      /**
-       * 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.
-       **/
-      setBalanceDeprecated: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, oldReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;
-      /**
-       * Alias for `transfer_allow_death`, provided only for name-wise compatibility.
-       * 
-       * WARNING: DEPRECATED! Will be released in approximately 3 months.
-       **/
-      transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;
-      /**
-       * 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).
-       **/
-      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;
-      /**
-       * 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.
-       **/
-      transferAllowDeath: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;
-      /**
-       * 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
-       **/
-      transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;
-      /**
-       * 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).
-       **/
-      upgradeAccounts: AugmentedSubmittable<(who: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    bundle: {
-      burnBundle: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, bundleId: H256 | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32, H256, u128]>;
-      mintBundle: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, bundleId: H256 | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32, H256, u128]>;
-      registerBundle: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, bundleId: H256 | string | Uint8Array, schema: ITuple<[Vec<u64>, Vec<Vec<u64>>, Vec<Vec<u128>>]> | [Vec<u64> | (u64 | AnyNumber | Uint8Array)[], Vec<Vec<u64>>, Vec<Vec<u128>>], metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, H256, ITuple<[Vec<u64>, Vec<Vec<u64>>, Vec<Vec<u128>>]>, Bytes]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    council: {
-      /**
-       * 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: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, SpWeightsWeightV2Weight, Compact<u32>]>;
-      /**
-       * 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
-       **/
-      disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
-      /**
-       * 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: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Compact<u32>]>;
-      /**
-       * 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: AugmentedSubmittable<(threshold: Compact<u32> | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Call, Compact<u32>]>;
-      /**
-       * 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)
-       **/
-      setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], prime: Option<AccountId32> | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Option<AccountId32>, u32]>;
-      /**
-       * 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: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, bool]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    dao: {
-      /**
-       * An example dispatchable that may throw a custom error.
-       **/
-      causeError: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
-      /**
-       * An example dispatchable that takes a singles value as a parameter, writes the value to
-       * storage and emits an event. This function must be dispatched by a signed extrinsic.
-       **/
-      doSomething: AugmentedSubmittable<(something: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    exgine: {
-      /**
-       * An example dispatchable that may throw a custom error.
-       **/
-      causeError: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
-      /**
-       * An example dispatchable that takes a singles value as a parameter, writes the value to
-       * storage and emits an event. This function must be dispatched by a signed extrinsic.
-       **/
-      doSomething: AugmentedSubmittable<(something: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    fula: {
-      batchRemoveManifest: AugmentedSubmittable<(cids: Vec<Bytes> | (Bytes | string | Uint8Array)[], poolIds: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>, Vec<u32>]>;
-      batchRemoveStoredManifest: AugmentedSubmittable<(cids: Vec<Bytes> | (Bytes | string | Uint8Array)[], poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>, u32]>;
-      batchStorageManifest: AugmentedSubmittable<(cids: Vec<Bytes> | (Bytes | string | Uint8Array)[], poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>, u32]>;
-      batchUploadManifest: AugmentedSubmittable<(manifest: Vec<Bytes> | (Bytes | string | Uint8Array)[], cids: Vec<Bytes> | (Bytes | string | Uint8Array)[], poolId: Vec<u32> | (u32 | AnyNumber | Uint8Array)[], replicationFactor: Vec<u16> | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>, Vec<Bytes>, Vec<u32>, Vec<u16>]>;
-      generateChallenge: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
-      getAvailableManifests: AugmentedSubmittable<(poolId: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;
-      getManifests: AugmentedSubmittable<(poolId: Option<u32> | null | Uint8Array | u32 | AnyNumber, uploader: Option<AccountId32> | null | Uint8Array | AccountId32 | string, storer: Option<AccountId32> | null | Uint8Array | AccountId32 | string) => SubmittableExtrinsic<ApiType>, [Option<u32>, Option<AccountId32>, Option<AccountId32>]>;
-      getManifestsStorerData: AugmentedSubmittable<(poolId: Option<u32> | null | Uint8Array | u32 | AnyNumber, storer: Option<AccountId32> | null | Uint8Array | AccountId32 | string) => SubmittableExtrinsic<ApiType>, [Option<u32>, Option<AccountId32>]>;
-      mintLaborTokens: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, u128]>;
-      removeManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;
-      removeStoredManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;
-      storageManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;
-      updateFileSize: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array, size: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32, u64]>;
-      updateFileSizes: AugmentedSubmittable<(cids: Vec<Bytes> | (Bytes | string | Uint8Array)[], poolId: u32 | AnyNumber | Uint8Array, sizes: Vec<u64> | (u64 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>, u32, Vec<u64>]>;
-      /**
-       * Updates the values of the manifest storer data given the specific data
-       **/
-      updateManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array, activeCycles: u16 | AnyNumber | Uint8Array, missedCycles: u16 | AnyNumber | Uint8Array, activeDays: i32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32, u16, u16, i32]>;
-      uploadManifest: AugmentedSubmittable<(manifest: Bytes | string | Uint8Array, cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array, replicationFactor: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes, u32, u16]>;
-      verifyChallenge: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, cids: Vec<Bytes> | (Bytes | string | Uint8Array)[], classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>, u64, u64]>;
-      verifyManifests: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    grandpa: {
-      /**
-       * 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.
-       **/
-      noteStalled: AugmentedSubmittable<(delay: u32 | AnyNumber | Uint8Array, bestFinalizedBlockNumber: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
-      /**
-       * 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.
-       **/
-      reportEquivocation: AugmentedSubmittable<(equivocationProof: SpConsensusGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpCoreVoid | null) => SubmittableExtrinsic<ApiType>, [SpConsensusGrandpaEquivocationProof, SpCoreVoid]>;
-      /**
-       * 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.
-       **/
-      reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: SpConsensusGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpCoreVoid | null) => SubmittableExtrinsic<ApiType>, [SpConsensusGrandpaEquivocationProof, SpCoreVoid]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    market: {
-      createMarket: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
-      createMarketRate: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array, marketRateId: u64 | AnyNumber | Uint8Array, rates: Vec<SugarfungeMarketAssetRate> | (SugarfungeMarketAssetRate | { classId?: any; assetId?: any; action?: any; from?: any; to?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u64, u64, Vec<SugarfungeMarketAssetRate>]>;
-      deposit: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array, marketRateId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, u128]>;
-      exchangeAssets: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array, marketRateId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, u128]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    pool: {
-      /**
-       * Cancel a `PoolRequest`, useful if a user decides to join another pool or they are stuck in
-       * the voting queue for too long.
-       **/
-      cancelJoin: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
-      /**
-       * Creates a new pool. `peer_id` is a libp2p peerID validated on the client-side.
-       * 
-       * TODO: Deposit; check the current pool number. Currently we check the PoolId to retrieve
-       * the pool number, but if we want to delete empty pools - then we need to retrieve the
-       * actual pool number from storage, for which a CountedMap should be used.
-       **/
-      create: AugmentedSubmittable<(name: Bytes | string | Uint8Array, region: Bytes | string | Uint8Array, peerId: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes, Bytes]>;
-      /**
-       * Open a `PoolRequest` to join the pool.
-       **/
-      join: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, peerId: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;
-      /**
-       * Allows for the user to leave a pool.
-       **/
-      leavePool: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
-      /**
-       * Vote for a `PoolRequest`. If `positive` is set to `false` - that's voting against.
-       * This method also calculates votes each time it's called and takes action once the result
-       * is conclusive.
-       * TODO: Currently does not cover pool overflow scenario and simply fails then.
-       **/
-      vote: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, account: AccountId32 | string | Uint8Array, positive: bool | boolean | Uint8Array, peerId: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32, bool, Bytes]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    scheduler: {
-      /**
-       * Cancel an anonymously scheduled task.
-       **/
-      cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
-      /**
-       * Cancel a named scheduled task.
-       **/
-      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;
-      /**
-       * Anonymously schedule a task.
-       **/
-      schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
-      /**
-       * Anonymously schedule a task after a delay.
-       **/
-      scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
-      /**
-       * Schedule a named task.
-       **/
-      scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
-      /**
-       * Schedule a named task after a delay.
-       **/
-      scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    session: {
-      /**
-       * 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.
-       **/
-      purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
-      /**
-       * 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.
-       **/
-      setKeys: AugmentedSubmittable<(keys: SugarfungeRuntimeOpaqueSessionKeys | { aura?: any; grandpa?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SugarfungeRuntimeOpaqueSessionKeys, Bytes]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    sudo: {
-      /**
-       * 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).
-       **/
-      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
-      /**
-       * 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: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;
-      /**
-       * 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).
-       **/
-      sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Call]>;
-      /**
-       * 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).
-       **/
-      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    system: {
-      /**
-       * 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.
-       **/
-      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;
-      /**
-       * Kill some items from storage.
-       **/
-      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;
-      /**
-       * Make some on-chain remark.
-       * 
-       * - `O(1)`
-       **/
-      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
-      /**
-       * Make some on-chain remark and emit event.
-       **/
-      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
-      /**
-       * Set the new runtime code.
-       **/
-      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
-      /**
-       * Set the new runtime code without doing any checks of the given `code`.
-       **/
-      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
-      /**
-       * Set the number of pages in the WebAssembly environment's heap.
-       **/
-      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
-      /**
-       * Set some items of storage.
-       **/
-      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    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: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-    validatorSet: {
-      /**
-       * Add a new validator.
-       * 
-       * New validator's session keys should be set in Session pallet before
-       * calling this.
-       * 
-       * The origin can be configured using the `AddRemoveOrigin` type in the
-       * host runtime. Can also be set to sudo/root.
-       **/
-      addValidator: AugmentedSubmittable<(validatorId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
-      /**
-       * Add an approved validator again when it comes back online.
-       * 
-       * For this call, the dispatch origin must be the validator itself.
-       **/
-      addValidatorAgain: AugmentedSubmittable<(validatorId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
-      /**
-       * Remove a validator.
-       * 
-       * The origin can be configured using the `AddRemoveOrigin` type in the
-       * host runtime. Can also be set to sudo/root.
-       **/
-      removeValidator: AugmentedSubmittable<(validatorId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-    };
-  } // AugmentedSubmittables
-} // declare module
diff --git a/src/interfaces/index.ts b/src/interfaces/index.ts
index 7f1de78..34587ac 100644
--- a/src/interfaces/index.ts
+++ b/src/interfaces/index.ts
@@ -1,4 +1,4 @@
 // Auto-generated via `yarn polkadot-types-from-defs`, do not edit
 /* eslint-disable */
 
-export * from './types.js';
+//export * from './types.ts';
diff --git a/src/protocols/chain-api.ts b/src/protocols/chain-api.ts
index 7358ec3..213c443 100644
--- a/src/protocols/chain-api.ts
+++ b/src/protocols/chain-api.ts
@@ -4,7 +4,6 @@ import { ApiPromise, WsProvider } from '@polkadot/api';
 import { Keyring } from '@polkadot/keyring';
 const { cryptoWaitReady } = require('@polkadot/util-crypto');
 import type * as BType from '../types/blockchain';
-import { TextEncoder } from 'text-encoding';
 
 const types = {
   FulaPoolPool: EventTypes.FulaPoolPool,
@@ -25,9 +24,9 @@ export const disconnectApi = async (api: ApiPromise): Promise<void> => {
   await api.disconnect();
 };
 
-function addDoubleSlashToSeed(seed: string): string {
+/*function addDoubleSlashToSeed(seed: string): string {
   return seed.startsWith('//') ? seed : '//' + seed;
-}
+}*/
 
 /*
   createManifest: This function batch uploads manifests
@@ -74,7 +73,6 @@ function createManifest(
   return batchUploadManifest;
 }
 
-
 export const batchUploadManifest = async (
   api: ApiPromise | undefined,
   seed: string,
@@ -112,7 +110,7 @@ export const batchUploadManifest = async (
       if (submitExtrinsic) {
         return new Promise<{ hash: string }>((resolve, reject) => {
           submitExtrinsic
-            .signAndSend(userKey, ({ status, events }) => {
+            .signAndSend(userKey, ({ status }) => {
               if (status.isInBlock || status.isFinalized) {
                 if (unsub) {
                   unsub(); // Call unsub before resolving the promise
@@ -215,6 +213,9 @@ export const checkJoinRequest = async (
   }
 };
 
+function isAccountInfo(obj: any): obj is { data: { free: any } } {
+  return 'data' in obj && 'free' in obj.data;
+}
 /*
   checkAccountExsists: This function takes accountId and checks if the account exists
   */
@@ -231,10 +232,11 @@ export const checkAccountBalance = async (
     if (!api?.query?.system?.account) {
       throw new Error('Failed to initialize api or api.query.account');
     }
-
-    let {
-      data: { free: balance },
-    } = await api.query.system.account(accountId);
+    let balance: any;
+    let accountInfo = await api.query.system.account(accountId);
+    if (isAccountInfo(accountInfo)) {
+      balance = accountInfo.data.free;
+    }
 
     if (balance && balance !== '0' && balance > 0) {
       return Promise.resolve(balance.toHuman());