@decentro-dev/polkadot-sufficient-assets 0.0.1

package/packages/core/.papi/descriptors/dist/polkadot.d.ts

@@ -0,0 +1,291 @@
+import { StorageDescriptor, PlainDescriptor, TxDescriptor, Enum, QueryFromPalletsDef, TxFromPalletsDef, EventsFromPalletsDef, ErrorsFromPalletsDef, ConstFromPalletsDef, SS58String, Binary, FixedSizeBinary, FixedSizeArray } from "polkadot-api";
+import { I5sesotjlssv2d, I1q8tnt1cluu5j, I4ktuaksf5i1gk, I3gjjd2kmfr3gt, Iakevv83i18n4r, I5gi8h3e5lkbeq, I84lqest6ohk0p } from "./common-types";
+type AnonymousEnum<T extends {}> = T & {
+    __anonymous: true;
+};
+type MyTuple<T> = [T, ...T[]];
+type SeparateUndefined<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
+type Anonymize<T> = SeparateUndefined<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum<infer V> ? Enum<V> : T extends MyTuple<any> ? {
+    [K in keyof T]: T[K];
+} : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : {
+    [K in keyof T & string]: T[K];
+}>;
+type IStorage = {
+    System: {
+        /**
+         * The full account information for a particular account ID.
+         */
+        Account: StorageDescriptor<[Key: SS58String], Anonymize<I5sesotjlssv2d>, false, never>;
+    };
+    Balances: {
+        /**
+         * The total units issued in the system.
+         */
+        TotalIssuance: StorageDescriptor<[], bigint, false, never>;
+        /**
+         * The Balances pallet example of storing the balance of an account.
+         *
+         * # Example
+         *
+         * ```nocompile
+         *  impl pallet_balances::Config for Runtime {
+         *    type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
+         *  }
+         * ```
+         *
+         * You can also store the balance of an account in the `System` pallet.
+         *
+         * # Example
+         *
+         * ```nocompile
+         *  impl pallet_balances::Config for Runtime {
+         *   type AccountStore = System
+         *  }
+         * ```
+         *
+         * But this comes with tradeoffs, storing account balances in the system pallet stores
+         * `frame_system` data alongside the account data contrary to storing account balances in the
+         * `Balances` pallet, which uses a `StorageMap` to store balances data only.
+         * NOTE: This is only used in the case that this pallet is used to store balances.
+         */
+        Account: StorageDescriptor<[Key: SS58String], Anonymize<I1q8tnt1cluu5j>, false, never>;
+    };
+};
+type ICalls = {
+    Balances: {
+        /**
+         *Same as the [`transfer_allow_death`] call, but with a check that the transfer will not
+         *kill the origin account.
+         *
+         *99% of the time you want [`transfer_allow_death`] instead.
+         *
+         *[`transfer_allow_death`]: struct.Pallet.html#method.transfer
+         */
+        transfer_keep_alive: TxDescriptor<Anonymize<I4ktuaksf5i1gk>>;
+    };
+    Utility: {
+        /**
+         *Send a batch of dispatch calls and atomically execute them.
+         *The whole transaction will rollback and fail if any of the calls failed.
+         *
+         *May be called from any origin except `None`.
+         *
+         *- `calls`: The calls to be dispatched from the same origin. The number of call must not
+         *  exceed the constant: `batched_calls_limit` (available in constant metadata).
+         *
+         *If origin is root then the calls are dispatched without checking origin filter. (This
+         *includes bypassing `frame_system::Config::BaseCallFilter`).
+         *
+         *## Complexity
+         *- O(C) where C is the number of calls to be batched.
+         */
+        batch_all: TxDescriptor<Anonymize<I3gjjd2kmfr3gt>>;
+    };
+    XcmPallet: {
+        /**
+         *Teleport some assets from the local chain to some destination chain.
+         *
+         ***This function is deprecated: Use `limited_teleport_assets` instead.**
+         *
+         *Fee payment on the destination side is made from the asset in the `assets` vector of
+         *index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
+         *with all fees taken as needed from the asset.
+         *
+         *- `origin`: Must be capable of withdrawing the `assets` and executing XCM.
+         *- `dest`: Destination context for the assets. Will typically be `[Parent,
+         *  Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
+         *  relay to parachain.
+         *- `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
+         *  generally be an `AccountId32` value.
+         *- `assets`: The assets to be withdrawn. This should include the assets used to pay the
+         *  fee on the `dest` chain.
+         *- `fee_asset_item`: The index into `assets` of the item which should be used to pay
+         *  fees.
+         */
+        teleport_assets: TxDescriptor<Anonymize<Iakevv83i18n4r>>;
+        /**
+         *Transfer some assets from the local chain to the destination chain through their local,
+         *destination or remote reserve.
+         *
+         *`assets` must have same reserve location and may not be teleportable to `dest`.
+         * - `assets` have local reserve: transfer assets to sovereign account of destination
+         *   chain and forward a notification XCM to `dest` to mint and deposit reserve-based
+         *   assets to `beneficiary`.
+         * - `assets` have destination reserve: burn local assets and forward a notification to
+         *   `dest` chain to withdraw the reserve assets from this chain's sovereign account and
+         *   deposit them to `beneficiary`.
+         * - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move
+         *   reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest`
+         *   to mint and deposit reserve-based assets to `beneficiary`.
+         *
+         ***This function is deprecated: Use `limited_reserve_transfer_assets` instead.**
+         *
+         *Fee payment on the destination side is made from the asset in the `assets` vector of
+         *index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
+         *with all fees taken as needed from the asset.
+         *
+         *- `origin`: Must be capable of withdrawing the `assets` and executing XCM.
+         *- `dest`: Destination context for the assets. Will typically be `[Parent,
+         *  Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
+         *  relay to parachain.
+         *- `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
+         *  generally be an `AccountId32` value.
+         *- `assets`: The assets to be withdrawn. This should include the assets used to pay the
+         *  fee on the `dest` (and possibly reserve) chains.
+         *- `fee_asset_item`: The index into `assets` of the item which should be used to pay
+         *  fees.
+         */
+        reserve_transfer_assets: TxDescriptor<Anonymize<Iakevv83i18n4r>>;
+        /**
+         *Transfer some assets from the local chain to the destination chain through their local,
+         *destination or remote reserve.
+         *
+         *`assets` must have same reserve location and may not be teleportable to `dest`.
+         * - `assets` have local reserve: transfer assets to sovereign account of destination
+         *   chain and forward a notification XCM to `dest` to mint and deposit reserve-based
+         *   assets to `beneficiary`.
+         * - `assets` have destination reserve: burn local assets and forward a notification to
+         *   `dest` chain to withdraw the reserve assets from this chain's sovereign account and
+         *   deposit them to `beneficiary`.
+         * - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move
+         *   reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest`
+         *   to mint and deposit reserve-based assets to `beneficiary`.
+         *
+         *Fee payment on the destination side is made from the asset in the `assets` vector of
+         *index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
+         *is needed than `weight_limit`, then the operation will fail and the sent assets may be
+         *at risk.
+         *
+         *- `origin`: Must be capable of withdrawing the `assets` and executing XCM.
+         *- `dest`: Destination context for the assets. Will typically be `[Parent,
+         *  Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
+         *  relay to parachain.
+         *- `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
+         *  generally be an `AccountId32` value.
+         *- `assets`: The assets to be withdrawn. This should include the assets used to pay the
+         *  fee on the `dest` (and possibly reserve) chains.
+         *- `fee_asset_item`: The index into `assets` of the item which should be used to pay
+         *  fees.
+         *- `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
+         */
+        limited_reserve_transfer_assets: TxDescriptor<Anonymize<I5gi8h3e5lkbeq>>;
+        /**
+         *Teleport some assets from the local chain to some destination chain.
+         *
+         *Fee payment on the destination side is made from the asset in the `assets` vector of
+         *index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
+         *is needed than `weight_limit`, then the operation will fail and the sent assets may be
+         *at risk.
+         *
+         *- `origin`: Must be capable of withdrawing the `assets` and executing XCM.
+         *- `dest`: Destination context for the assets. Will typically be `[Parent,
+         *  Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
+         *  relay to parachain.
+         *- `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
+         *  generally be an `AccountId32` value.
+         *- `assets`: The assets to be withdrawn. This should include the assets used to pay the
+         *  fee on the `dest` chain.
+         *- `fee_asset_item`: The index into `assets` of the item which should be used to pay
+         *  fees.
+         *- `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
+         */
+        limited_teleport_assets: TxDescriptor<Anonymize<I5gi8h3e5lkbeq>>;
+        /**
+         *Transfer some assets from the local chain to the destination chain through their local,
+         *destination or remote reserve, or through teleports.
+         *
+         *Fee payment on the destination side is made from the asset in the `assets` vector of
+         *index `fee_asset_item` (hence referred to as `fees`), up to enough to pay for
+         *`weight_limit` of weight. If more weight is needed than `weight_limit`, then the
+         *operation will fail and the sent assets may be at risk.
+         *
+         *`assets` (excluding `fees`) must have same reserve location or otherwise be teleportable
+         *to `dest`, no limitations imposed on `fees`.
+         * - for local reserve: transfer assets to sovereign account of destination chain and
+         *   forward a notification XCM to `dest` to mint and deposit reserve-based assets to
+         *   `beneficiary`.
+         * - for destination reserve: burn local assets and forward a notification to `dest` chain
+         *   to withdraw the reserve assets from this chain's sovereign account and deposit them
+         *   to `beneficiary`.
+         * - for remote reserve: burn local assets, forward XCM to reserve chain to move reserves
+         *   from this chain's SA to `dest` chain's SA, and forward another XCM to `dest` to mint
+         *   and deposit reserve-based assets to `beneficiary`.
+         * - for teleports: burn local assets and forward XCM to `dest` chain to mint/teleport
+         *   assets and deposit them to `beneficiary`.
+         *
+         *- `origin`: Must be capable of withdrawing the `assets` and executing XCM.
+         *- `dest`: Destination context for the assets. Will typically be `X2(Parent,
+         *  Parachain(..))` to send from parachain to parachain, or `X1(Parachain(..))` to send
+         *  from relay to parachain.
+         *- `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
+         *  generally be an `AccountId32` value.
+         *- `assets`: The assets to be withdrawn. This should include the assets used to pay the
+         *  fee on the `dest` (and possibly reserve) chains.
+         *- `fee_asset_item`: The index into `assets` of the item which should be used to pay
+         *  fees.
+         *- `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
+         */
+        transfer_assets: TxDescriptor<Anonymize<I5gi8h3e5lkbeq>>;
+    };
+};
+type IEvent = {};
+type IError = {};
+type IConstants = {
+    Balances: {
+        /**
+         * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!
+         *
+         * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for
+         * this pallet. However, you do so at your own risk: this will open up a major DoS vector.
+         * In case you have multiple sources of provider references, you may also get unexpected
+         * behaviour if you set this to zero.
+         *
+         * Bottom line: Do yourself a favour and make it at least one!
+         */
+        ExistentialDeposit: PlainDescriptor<bigint>;
+    };
+};
+type IRuntimeCalls = {};
+type IAsset = PlainDescriptor<void>;
+export type PolkadotDispatchError = unknown;
+type PalletsTypedef = {
+    __storage: IStorage;
+    __tx: ICalls;
+    __event: IEvent;
+    __error: IError;
+    __const: IConstants;
+};
+type IDescriptors = {
+    descriptors: {
+        pallets: PalletsTypedef;
+        apis: IRuntimeCalls;
+    } & Promise<any>;
+    metadataTypes: Promise<Uint8Array>;
+    asset: IAsset;
+    getMetadata: () => Promise<Uint8Array>;
+    genesis: string | undefined;
+};
+declare const _allDescriptors: IDescriptors;
+export default _allDescriptors;
+export type PolkadotQueries = QueryFromPalletsDef<PalletsTypedef>;
+export type PolkadotCalls = TxFromPalletsDef<PalletsTypedef>;
+export type PolkadotEvents = EventsFromPalletsDef<PalletsTypedef>;
+export type PolkadotErrors = ErrorsFromPalletsDef<PalletsTypedef>;
+export type PolkadotConstants = ConstFromPalletsDef<PalletsTypedef>;
+export type PolkadotCallData = Anonymize<I84lqest6ohk0p> & {
+    value: {
+        type: string;
+    };
+};
+export type PolkadotWhitelistEntry = PalletKey | ApiKey<IRuntimeCalls> | `query.${NestedKey<PalletsTypedef['__storage']>}` | `tx.${NestedKey<PalletsTypedef['__tx']>}` | `event.${NestedKey<PalletsTypedef['__event']>}` | `error.${NestedKey<PalletsTypedef['__error']>}` | `const.${NestedKey<PalletsTypedef['__const']>}`;
+type PalletKey = `*.${keyof (IStorage & ICalls & IEvent & IError & IConstants & IRuntimeCalls)}`;
+type NestedKey<D extends Record<string, Record<string, any>>> = "*" | {
+    [P in keyof D & string]: `${P}.*` | {
+        [N in keyof D[P] & string]: `${P}.${N}`;
+    }[keyof D[P] & string];
+}[keyof D & string];
+type ApiKey<D extends Record<string, Record<string, any>>> = "api.*" | {
+    [P in keyof D & string]: `api.${P}.*` | {
+        [N in keyof D[P] & string]: `api.${P}.${N}`;
+    }[keyof D[P] & string];
+}[keyof D & string];