From 3e53a5dde60debbd8b9209b08b6c312711d708ab Mon Sep 17 00:00:00 2001 From: debot Date: Tue, 22 Oct 2024 01:06:35 +0000 Subject: [PATCH] chore: regenerate chaintypes --- packages/chaintypes/src/moonbeam/consts.d.ts | 27 ++ packages/chaintypes/src/moonbeam/errors.d.ts | 87 +++++ packages/chaintypes/src/moonbeam/events.d.ts | 126 ++++++- packages/chaintypes/src/moonbeam/index.d.ts | 2 +- packages/chaintypes/src/moonbeam/query.d.ts | 102 ++++-- packages/chaintypes/src/moonbeam/tx.d.ts | 333 ++++++++++++++++--- packages/chaintypes/src/moonbeam/types.d.ts | 277 +++++++++++++-- 7 files changed, 840 insertions(+), 114 deletions(-) diff --git a/packages/chaintypes/src/moonbeam/consts.d.ts b/packages/chaintypes/src/moonbeam/consts.d.ts index 698ec94..69c4da5 100644 --- a/packages/chaintypes/src/moonbeam/consts.d.ts +++ b/packages/chaintypes/src/moonbeam/consts.d.ts @@ -980,6 +980,33 @@ export interface ChainConsts extends GenericChainConsts extends GenericChainErrors; + /** + * The contract already have metadata + **/ + ContractMetadataAlreadySet: GenericPalletError; + + /** + * Contract not exist + **/ + ContractNotExist: GenericPalletError; + /** * Generic pallet error **/ @@ -1881,6 +1891,83 @@ export interface ChainErrors extends GenericChainErrors; }; + /** + * Pallet `EvmForeignAssets`'s errors + **/ + evmForeignAssets: { + AssetAlreadyExists: GenericPalletError; + AssetAlreadyFrozen: GenericPalletError; + AssetDoesNotExist: GenericPalletError; + AssetIdFiltered: GenericPalletError; + AssetNotFrozen: GenericPalletError; + CorruptedStorageOrphanLocation: GenericPalletError; + Erc20ContractCreationFail: GenericPalletError; + EvmCallPauseFail: GenericPalletError; + EvmCallUnpauseFail: GenericPalletError; + EvmInternalError: GenericPalletError; + InvalidSymbol: GenericPalletError; + InvalidTokenName: GenericPalletError; + LocationAlreadyExists: GenericPalletError; + TooManyForeignAssets: GenericPalletError; + + /** + * Generic pallet error + **/ + [error: string]: GenericPalletError; + }; + /** + * Pallet `XcmWeightTrader`'s errors + **/ + xcmWeightTrader: { + /** + * The given asset was already added + **/ + AssetAlreadyAdded: GenericPalletError; + + /** + * The given asset was already paused + **/ + AssetAlreadyPaused: GenericPalletError; + + /** + * The given asset was not found + **/ + AssetNotFound: GenericPalletError; + + /** + * The given asset is not paused + **/ + AssetNotPaused: GenericPalletError; + + /** + * XCM location filtered + **/ + XcmLocationFiltered: GenericPalletError; + + /** + * The relative price cannot be zero + **/ + PriceCannotBeZero: GenericPalletError; + + /** + * Generic pallet error + **/ + [error: string]: GenericPalletError; + }; + /** + * Pallet `EmergencyParaXcm`'s errors + **/ + emergencyParaXcm: { + /** + * The current XCM Mode is not Paused + **/ + NotInPausedMode: GenericPalletError; + + /** + * Generic pallet error + **/ + [error: string]: GenericPalletError; + }; /** * Pallet `PrecompileBenchmarks`'s errors **/ diff --git a/packages/chaintypes/src/moonbeam/events.d.ts b/packages/chaintypes/src/moonbeam/events.d.ts index 7da48c3..c72f3a7 100644 --- a/packages/chaintypes/src/moonbeam/events.d.ts +++ b/packages/chaintypes/src/moonbeam/events.d.ts @@ -2610,12 +2610,7 @@ export interface ChainEvents extends GenericChainEvents; + UnitsPerSecondChanged: GenericPalletEvent; /** * Changed the xcm type mapping for a given asset id @@ -2927,6 +2922,125 @@ export interface ChainEvents extends GenericChainEvents; }; + /** + * Pallet `EvmForeignAssets`'s events + **/ + evmForeignAssets: { + /** + * New asset with the asset manager is registered + **/ + ForeignAssetCreated: GenericPalletEvent< + Rv, + 'EvmForeignAssets', + 'ForeignAssetCreated', + { contractAddress: H160; assetId: bigint; xcmLocation: StagingXcmV4Location } + >; + + /** + * Changed the xcm type mapping for a given asset id + **/ + ForeignAssetXcmLocationChanged: GenericPalletEvent< + Rv, + 'EvmForeignAssets', + 'ForeignAssetXcmLocationChanged', + { assetId: bigint; newXcmLocation: StagingXcmV4Location } + >; + ForeignAssetFrozen: GenericPalletEvent< + Rv, + 'EvmForeignAssets', + 'ForeignAssetFrozen', + { assetId: bigint; xcmLocation: StagingXcmV4Location } + >; + ForeignAssetUnfrozen: GenericPalletEvent< + Rv, + 'EvmForeignAssets', + 'ForeignAssetUnfrozen', + { assetId: bigint; xcmLocation: StagingXcmV4Location } + >; + + /** + * Generic pallet event + **/ + [prop: string]: GenericPalletEvent; + }; + /** + * Pallet `XcmWeightTrader`'s events + **/ + xcmWeightTrader: { + /** + * New supported asset is registered + **/ + SupportedAssetAdded: GenericPalletEvent< + Rv, + 'XcmWeightTrader', + 'SupportedAssetAdded', + { location: StagingXcmV4Location; relativePrice: bigint } + >; + + /** + * Changed the amount of units we are charging per execution second for a given asset + **/ + SupportedAssetEdited: GenericPalletEvent< + Rv, + 'XcmWeightTrader', + 'SupportedAssetEdited', + { location: StagingXcmV4Location; relativePrice: bigint } + >; + + /** + * Pause support for a given asset + **/ + PauseAssetSupport: GenericPalletEvent< + Rv, + 'XcmWeightTrader', + 'PauseAssetSupport', + { location: StagingXcmV4Location } + >; + + /** + * Resume support for a given asset + **/ + ResumeAssetSupport: GenericPalletEvent< + Rv, + 'XcmWeightTrader', + 'ResumeAssetSupport', + { location: StagingXcmV4Location } + >; + + /** + * Supported asset type for fee payment removed + **/ + SupportedAssetRemoved: GenericPalletEvent< + Rv, + 'XcmWeightTrader', + 'SupportedAssetRemoved', + { location: StagingXcmV4Location } + >; + + /** + * Generic pallet event + **/ + [prop: string]: GenericPalletEvent; + }; + /** + * Pallet `EmergencyParaXcm`'s events + **/ + emergencyParaXcm: { + /** + * The XCM incoming execution was Paused + **/ + EnteredPausedXcmMode: GenericPalletEvent; + + /** + * The XCM incoming execution returned to normal operation + **/ + NormalXcmOperationResumed: GenericPalletEvent; + + /** + * Generic pallet event + **/ + [prop: string]: GenericPalletEvent; + }; /** * Pallet `Randomness`'s events **/ diff --git a/packages/chaintypes/src/moonbeam/index.d.ts b/packages/chaintypes/src/moonbeam/index.d.ts index 54705f0..4eff563 100644 --- a/packages/chaintypes/src/moonbeam/index.d.ts +++ b/packages/chaintypes/src/moonbeam/index.d.ts @@ -23,7 +23,7 @@ export interface VersionedMoonbeamApi extends GenericSubs /** * @name: MoonbeamApi - * @specVersion: 3102 + * @specVersion: 3200 **/ export interface MoonbeamApi { legacy: VersionedMoonbeamApi; diff --git a/packages/chaintypes/src/moonbeam/query.d.ts b/packages/chaintypes/src/moonbeam/query.d.ts index e5d1eae..ce21c6d 100644 --- a/packages/chaintypes/src/moonbeam/query.d.ts +++ b/packages/chaintypes/src/moonbeam/query.d.ts @@ -98,6 +98,8 @@ import type { PalletMessageQueueBookState, CumulusPrimitivesCoreAggregateMessageOrigin, PalletMessageQueuePage, + PalletMoonbeamForeignAssetsAssetStatus, + PalletEmergencyParaXcmXcmMode, PalletRandomnessRequestState, PalletRandomnessRandomnessResult, PalletRandomnessRequestType, @@ -2065,27 +2067,6 @@ export interface ChainStorage extends GenericChainStorage MoonbeamRuntimeXcmConfigAssetType >; - /** - * Stores the units per second for local execution for a AssetType. - * This is used to know how to charge for XCM execution in a particular - * asset - * Not all assets might contain units per second, hence the different storage - * - * @param {MoonbeamRuntimeXcmConfigAssetType} arg - * @param {Callback =} callback - **/ - assetTypeUnitsPerSecond: GenericStorageQuery< - Rv, - (arg: MoonbeamRuntimeXcmConfigAssetType) => bigint | undefined, - MoonbeamRuntimeXcmConfigAssetType - >; - - /** - * - * @param {Callback> =} callback - **/ - supportedFeePaymentAssets: GenericStorageQuery Array>; - /** * Generic pallet storage query **/ @@ -2216,6 +2197,85 @@ export interface ChainStorage extends GenericChainStorage **/ [storage: string]: GenericStorageQuery; }; + /** + * Pallet `EvmForeignAssets`'s storage queries + **/ + evmForeignAssets: { + /** + * Mapping from an asset id to a Foreign asset type. + * This is mostly used when receiving transaction specifying an asset directly, + * like transferring an asset from this chain to another. + * + * @param {bigint} arg + * @param {Callback =} callback + **/ + assetsById: GenericStorageQuery StagingXcmV4Location | undefined, bigint>; + + /** + * Counter for the related counted storage map + * + * @param {Callback =} callback + **/ + counterForAssetsById: GenericStorageQuery number>; + + /** + * Reverse mapping of AssetsById. Mapping from a foreign asset to an asset id. + * This is mostly used when receiving a multilocation XCM message to retrieve + * the corresponding asset in which tokens should me minted. + * + * @param {StagingXcmV4Location} arg + * @param {Callback<[bigint, PalletMoonbeamForeignAssetsAssetStatus] | undefined> =} callback + **/ + assetsByLocation: GenericStorageQuery< + Rv, + (arg: StagingXcmV4Location) => [bigint, PalletMoonbeamForeignAssetsAssetStatus] | undefined, + StagingXcmV4Location + >; + + /** + * Generic pallet storage query + **/ + [storage: string]: GenericStorageQuery; + }; + /** + * Pallet `XcmWeightTrader`'s storage queries + **/ + xcmWeightTrader: { + /** + * Stores all supported assets per XCM Location. + * The u128 is the asset price relative to native asset with 18 decimals + * The boolean specify if the support for this asset is active + * + * @param {StagingXcmV4Location} arg + * @param {Callback<[boolean, bigint] | undefined> =} callback + **/ + supportedAssets: GenericStorageQuery< + Rv, + (arg: StagingXcmV4Location) => [boolean, bigint] | undefined, + StagingXcmV4Location + >; + + /** + * Generic pallet storage query + **/ + [storage: string]: GenericStorageQuery; + }; + /** + * Pallet `EmergencyParaXcm`'s storage queries + **/ + emergencyParaXcm: { + /** + * Whether incoming XCM is enabled or paused + * + * @param {Callback =} callback + **/ + mode: GenericStorageQuery PalletEmergencyParaXcmXcmMode>; + + /** + * Generic pallet storage query + **/ + [storage: string]: GenericStorageQuery; + }; /** * Pallet `RelayStorageRoots`'s storage queries **/ diff --git a/packages/chaintypes/src/moonbeam/tx.d.ts b/packages/chaintypes/src/moonbeam/tx.d.ts index 54b860d..b37743d 100644 --- a/packages/chaintypes/src/moonbeam/tx.d.ts +++ b/packages/chaintypes/src/moonbeam/tx.d.ts @@ -3240,6 +3240,24 @@ export interface ChainTx extends GenericChainTx >; + /** + * + * @param {H160} address + **/ + createContractMetadata: GenericTxCall< + Rv, + (address: H160) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'MoonbeamLazyMigrations'; + palletCall: { + name: 'CreateContractMetadata'; + params: { address: H160 }; + }; + } + > + >; + /** * Generic pallet tx call **/ @@ -7226,36 +7244,6 @@ export interface ChainTx extends GenericChainTx >; - /** - * Change the amount of units we are charging per execution second - * for a given ForeignAssetType - * - * @param {MoonbeamRuntimeXcmConfigAssetType} assetType - * @param {bigint} unitsPerSecond - * @param {number} numAssetsWeightHint - **/ - setAssetUnitsPerSecond: GenericTxCall< - Rv, - ( - assetType: MoonbeamRuntimeXcmConfigAssetType, - unitsPerSecond: bigint, - numAssetsWeightHint: number, - ) => ChainSubmittableExtrinsic< - Rv, - { - pallet: 'AssetManager'; - palletCall: { - name: 'SetAssetUnitsPerSecond'; - params: { - assetType: MoonbeamRuntimeXcmConfigAssetType; - unitsPerSecond: bigint; - numAssetsWeightHint: number; - }; - }; - } - > - >; - /** * Change the xcm type mapping for a given assetId * We also change this if the previous units per second where pointing at the old @@ -7283,28 +7271,6 @@ export interface ChainTx extends GenericChainTx >; - /** - * - * @param {MoonbeamRuntimeXcmConfigAssetType} assetType - * @param {number} numAssetsWeightHint - **/ - removeSupportedAsset: GenericTxCall< - Rv, - ( - assetType: MoonbeamRuntimeXcmConfigAssetType, - numAssetsWeightHint: number, - ) => ChainSubmittableExtrinsic< - Rv, - { - pallet: 'AssetManager'; - palletCall: { - name: 'RemoveSupportedAsset'; - params: { assetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number }; - }; - } - > - >; - /** * Remove a given assetId -> assetType association * @@ -8150,6 +8116,269 @@ export interface ChainTx extends GenericChainTx>; }; + /** + * Pallet `EvmForeignAssets`'s transaction calls + **/ + evmForeignAssets: { + /** + * Create new asset with the ForeignAssetCreator + * + * @param {bigint} assetId + * @param {StagingXcmV4Location} xcmLocation + * @param {number} decimals + * @param {BytesLike} symbol + * @param {BytesLike} name + **/ + createForeignAsset: GenericTxCall< + Rv, + ( + assetId: bigint, + xcmLocation: StagingXcmV4Location, + decimals: number, + symbol: BytesLike, + name: BytesLike, + ) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'EvmForeignAssets'; + palletCall: { + name: 'CreateForeignAsset'; + params: { + assetId: bigint; + xcmLocation: StagingXcmV4Location; + decimals: number; + symbol: BytesLike; + name: BytesLike; + }; + }; + } + > + >; + + /** + * Change the xcm type mapping for a given assetId + * We also change this if the previous units per second where pointing at the old + * assetType + * + * @param {bigint} assetId + * @param {StagingXcmV4Location} newXcmLocation + **/ + changeXcmLocation: GenericTxCall< + Rv, + ( + assetId: bigint, + newXcmLocation: StagingXcmV4Location, + ) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'EvmForeignAssets'; + palletCall: { + name: 'ChangeXcmLocation'; + params: { assetId: bigint; newXcmLocation: StagingXcmV4Location }; + }; + } + > + >; + + /** + * Freeze a given foreign assetId + * + * @param {bigint} assetId + * @param {boolean} allowXcmDeposit + **/ + freezeForeignAsset: GenericTxCall< + Rv, + ( + assetId: bigint, + allowXcmDeposit: boolean, + ) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'EvmForeignAssets'; + palletCall: { + name: 'FreezeForeignAsset'; + params: { assetId: bigint; allowXcmDeposit: boolean }; + }; + } + > + >; + + /** + * Unfreeze a given foreign assetId + * + * @param {bigint} assetId + **/ + unfreezeForeignAsset: GenericTxCall< + Rv, + (assetId: bigint) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'EvmForeignAssets'; + palletCall: { + name: 'UnfreezeForeignAsset'; + params: { assetId: bigint }; + }; + } + > + >; + + /** + * Generic pallet tx call + **/ + [callName: string]: GenericTxCall>; + }; + /** + * Pallet `XcmWeightTrader`'s transaction calls + **/ + xcmWeightTrader: { + /** + * + * @param {StagingXcmV4Location} location + * @param {bigint} relativePrice + **/ + addAsset: GenericTxCall< + Rv, + ( + location: StagingXcmV4Location, + relativePrice: bigint, + ) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'XcmWeightTrader'; + palletCall: { + name: 'AddAsset'; + params: { location: StagingXcmV4Location; relativePrice: bigint }; + }; + } + > + >; + + /** + * + * @param {StagingXcmV4Location} location + * @param {bigint} relativePrice + **/ + editAsset: GenericTxCall< + Rv, + ( + location: StagingXcmV4Location, + relativePrice: bigint, + ) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'XcmWeightTrader'; + palletCall: { + name: 'EditAsset'; + params: { location: StagingXcmV4Location; relativePrice: bigint }; + }; + } + > + >; + + /** + * + * @param {StagingXcmV4Location} location + **/ + pauseAssetSupport: GenericTxCall< + Rv, + (location: StagingXcmV4Location) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'XcmWeightTrader'; + palletCall: { + name: 'PauseAssetSupport'; + params: { location: StagingXcmV4Location }; + }; + } + > + >; + + /** + * + * @param {StagingXcmV4Location} location + **/ + resumeAssetSupport: GenericTxCall< + Rv, + (location: StagingXcmV4Location) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'XcmWeightTrader'; + palletCall: { + name: 'ResumeAssetSupport'; + params: { location: StagingXcmV4Location }; + }; + } + > + >; + + /** + * + * @param {StagingXcmV4Location} location + **/ + removeAsset: GenericTxCall< + Rv, + (location: StagingXcmV4Location) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'XcmWeightTrader'; + palletCall: { + name: 'RemoveAsset'; + params: { location: StagingXcmV4Location }; + }; + } + > + >; + + /** + * Generic pallet tx call + **/ + [callName: string]: GenericTxCall>; + }; + /** + * Pallet `EmergencyParaXcm`'s transaction calls + **/ + emergencyParaXcm: { + /** + * Resume `Normal` mode + * + **/ + pausedToNormal: GenericTxCall< + Rv, + () => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'EmergencyParaXcm'; + palletCall: { + name: 'PausedToNormal'; + }; + } + > + >; + + /** + * Authorize a runtime upgrade. Only callable in `Paused` mode + * + * @param {H256} codeHash + **/ + fastAuthorizeUpgrade: GenericTxCall< + Rv, + (codeHash: H256) => ChainSubmittableExtrinsic< + Rv, + { + pallet: 'EmergencyParaXcm'; + palletCall: { + name: 'FastAuthorizeUpgrade'; + params: { codeHash: H256 }; + }; + } + > + >; + + /** + * Generic pallet tx call + **/ + [callName: string]: GenericTxCall>; + }; /** * Pallet `Randomness`'s transaction calls **/ diff --git a/packages/chaintypes/src/moonbeam/types.d.ts b/packages/chaintypes/src/moonbeam/types.d.ts index 5bf974b..d1caf4b 100644 --- a/packages/chaintypes/src/moonbeam/types.d.ts +++ b/packages/chaintypes/src/moonbeam/types.d.ts @@ -87,6 +87,9 @@ export type MoonbeamRuntimeRuntimeEvent = | { pallet: 'XcmTransactor'; palletEvent: PalletXcmTransactorEvent } | { pallet: 'EthereumXcm'; palletEvent: PalletEthereumXcmEvent } | { pallet: 'MessageQueue'; palletEvent: PalletMessageQueueEvent } + | { pallet: 'EvmForeignAssets'; palletEvent: PalletMoonbeamForeignAssetsEvent } + | { pallet: 'XcmWeightTrader'; palletEvent: PalletXcmWeightTraderEvent } + | { pallet: 'EmergencyParaXcm'; palletEvent: PalletEmergencyParaXcmEvent } | { pallet: 'Randomness'; palletEvent: PalletRandomnessEvent }; /** @@ -1305,6 +1308,9 @@ export type MoonbeamRuntimeRuntimeCall = | { pallet: 'XcmTransactor'; palletCall: PalletXcmTransactorCall } | { pallet: 'EthereumXcm'; palletCall: PalletEthereumXcmCall } | { pallet: 'MessageQueue'; palletCall: PalletMessageQueueCall } + | { pallet: 'EvmForeignAssets'; palletCall: PalletMoonbeamForeignAssetsCall } + | { pallet: 'XcmWeightTrader'; palletCall: PalletXcmWeightTraderCall } + | { pallet: 'EmergencyParaXcm'; palletCall: PalletEmergencyParaXcmCall } | { pallet: 'Randomness'; palletCall: PalletRandomnessCall }; export type MoonbeamRuntimeRuntimeCallLike = @@ -1343,6 +1349,9 @@ export type MoonbeamRuntimeRuntimeCallLike = | { pallet: 'XcmTransactor'; palletCall: PalletXcmTransactorCallLike } | { pallet: 'EthereumXcm'; palletCall: PalletEthereumXcmCallLike } | { pallet: 'MessageQueue'; palletCall: PalletMessageQueueCallLike } + | { pallet: 'EvmForeignAssets'; palletCall: PalletMoonbeamForeignAssetsCallLike } + | { pallet: 'XcmWeightTrader'; palletCall: PalletXcmWeightTraderCallLike } + | { pallet: 'EmergencyParaXcm'; palletCall: PalletEmergencyParaXcmCallLike } | { pallet: 'Randomness'; palletCall: PalletRandomnessCallLike }; /** @@ -3778,15 +3787,13 @@ export type PalletMultisigCallLike = /** * Contains a variant per dispatchable extrinsic that this pallet has. **/ -export type PalletMoonbeamLazyMigrationsCall = { - name: 'ClearSuicidedStorage'; - params: { addresses: Array; limit: number }; -}; +export type PalletMoonbeamLazyMigrationsCall = + | { name: 'ClearSuicidedStorage'; params: { addresses: Array; limit: number } } + | { name: 'CreateContractMetadata'; params: { address: H160 } }; -export type PalletMoonbeamLazyMigrationsCallLike = { - name: 'ClearSuicidedStorage'; - params: { addresses: Array; limit: number }; -}; +export type PalletMoonbeamLazyMigrationsCallLike = + | { name: 'ClearSuicidedStorage'; params: { addresses: Array; limit: number } } + | { name: 'CreateContractMetadata'; params: { address: H160 } }; /** * Contains a variant per dispatchable extrinsic that this pallet has. @@ -7850,14 +7857,6 @@ export type PalletAssetManagerCall = isSufficient: boolean; }; } - /** - * Change the amount of units we are charging per execution second - * for a given ForeignAssetType - **/ - | { - name: 'SetAssetUnitsPerSecond'; - params: { assetType: MoonbeamRuntimeXcmConfigAssetType; unitsPerSecond: bigint; numAssetsWeightHint: number }; - } /** * Change the xcm type mapping for a given assetId * We also change this if the previous units per second where pointing at the old @@ -7867,10 +7866,6 @@ export type PalletAssetManagerCall = name: 'ChangeExistingAssetType'; params: { assetId: bigint; newAssetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number }; } - | { - name: 'RemoveSupportedAsset'; - params: { assetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number }; - } /** * Remove a given assetId -> assetType association **/ @@ -7896,14 +7891,6 @@ export type PalletAssetManagerCallLike = isSufficient: boolean; }; } - /** - * Change the amount of units we are charging per execution second - * for a given ForeignAssetType - **/ - | { - name: 'SetAssetUnitsPerSecond'; - params: { assetType: MoonbeamRuntimeXcmConfigAssetType; unitsPerSecond: bigint; numAssetsWeightHint: number }; - } /** * Change the xcm type mapping for a given assetId * We also change this if the previous units per second where pointing at the old @@ -7913,10 +7900,6 @@ export type PalletAssetManagerCallLike = name: 'ChangeExistingAssetType'; params: { assetId: bigint; newAssetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number }; } - | { - name: 'RemoveSupportedAsset'; - params: { assetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number }; - } /** * Remove a given assetId -> assetType association **/ @@ -8700,6 +8683,101 @@ export type CumulusPrimitivesCoreAggregateMessageOrigin = | { type: 'Parent' } | { type: 'Sibling'; value: PolkadotParachainPrimitivesPrimitivesId }; +/** + * Contains a variant per dispatchable extrinsic that this pallet has. + **/ +export type PalletMoonbeamForeignAssetsCall = + /** + * Create new asset with the ForeignAssetCreator + **/ + | { + name: 'CreateForeignAsset'; + params: { assetId: bigint; xcmLocation: StagingXcmV4Location; decimals: number; symbol: Bytes; name: Bytes }; + } + /** + * Change the xcm type mapping for a given assetId + * We also change this if the previous units per second where pointing at the old + * assetType + **/ + | { name: 'ChangeXcmLocation'; params: { assetId: bigint; newXcmLocation: StagingXcmV4Location } } + /** + * Freeze a given foreign assetId + **/ + | { name: 'FreezeForeignAsset'; params: { assetId: bigint; allowXcmDeposit: boolean } } + /** + * Unfreeze a given foreign assetId + **/ + | { name: 'UnfreezeForeignAsset'; params: { assetId: bigint } }; + +export type PalletMoonbeamForeignAssetsCallLike = + /** + * Create new asset with the ForeignAssetCreator + **/ + | { + name: 'CreateForeignAsset'; + params: { + assetId: bigint; + xcmLocation: StagingXcmV4Location; + decimals: number; + symbol: BytesLike; + name: BytesLike; + }; + } + /** + * Change the xcm type mapping for a given assetId + * We also change this if the previous units per second where pointing at the old + * assetType + **/ + | { name: 'ChangeXcmLocation'; params: { assetId: bigint; newXcmLocation: StagingXcmV4Location } } + /** + * Freeze a given foreign assetId + **/ + | { name: 'FreezeForeignAsset'; params: { assetId: bigint; allowXcmDeposit: boolean } } + /** + * Unfreeze a given foreign assetId + **/ + | { name: 'UnfreezeForeignAsset'; params: { assetId: bigint } }; + +/** + * Contains a variant per dispatchable extrinsic that this pallet has. + **/ +export type PalletXcmWeightTraderCall = + | { name: 'AddAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } } + | { name: 'EditAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } } + | { name: 'PauseAssetSupport'; params: { location: StagingXcmV4Location } } + | { name: 'ResumeAssetSupport'; params: { location: StagingXcmV4Location } } + | { name: 'RemoveAsset'; params: { location: StagingXcmV4Location } }; + +export type PalletXcmWeightTraderCallLike = + | { name: 'AddAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } } + | { name: 'EditAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } } + | { name: 'PauseAssetSupport'; params: { location: StagingXcmV4Location } } + | { name: 'ResumeAssetSupport'; params: { location: StagingXcmV4Location } } + | { name: 'RemoveAsset'; params: { location: StagingXcmV4Location } }; + +/** + * Contains a variant per dispatchable extrinsic that this pallet has. + **/ +export type PalletEmergencyParaXcmCall = + /** + * Resume `Normal` mode + **/ + | { name: 'PausedToNormal' } + /** + * Authorize a runtime upgrade. Only callable in `Paused` mode + **/ + | { name: 'FastAuthorizeUpgrade'; params: { codeHash: H256 } }; + +export type PalletEmergencyParaXcmCallLike = + /** + * Resume `Normal` mode + **/ + | { name: 'PausedToNormal' } + /** + * Authorize a runtime upgrade. Only callable in `Paused` mode + **/ + | { name: 'FastAuthorizeUpgrade'; params: { codeHash: H256 } }; + /** * Contains a variant per dispatchable extrinsic that this pallet has. **/ @@ -9269,7 +9347,7 @@ export type PalletAssetManagerEvent = /** * Changed the amount of units we are charging per execution second for a given asset **/ - | { name: 'UnitsPerSecondChanged'; data: { assetType: MoonbeamRuntimeXcmConfigAssetType; unitsPerSecond: bigint } } + | { name: 'UnitsPerSecondChanged' } /** * Changed the xcm type mapping for a given asset id **/ @@ -9489,6 +9567,59 @@ export type FrameSupportMessagesProcessMessageError = | { type: 'Overweight'; value: SpWeightsWeightV2Weight } | { type: 'Yield' }; +/** + * The `Event` enum of this pallet + **/ +export type PalletMoonbeamForeignAssetsEvent = + /** + * New asset with the asset manager is registered + **/ + | { name: 'ForeignAssetCreated'; data: { contractAddress: H160; assetId: bigint; xcmLocation: StagingXcmV4Location } } + /** + * Changed the xcm type mapping for a given asset id + **/ + | { name: 'ForeignAssetXcmLocationChanged'; data: { assetId: bigint; newXcmLocation: StagingXcmV4Location } } + | { name: 'ForeignAssetFrozen'; data: { assetId: bigint; xcmLocation: StagingXcmV4Location } } + | { name: 'ForeignAssetUnfrozen'; data: { assetId: bigint; xcmLocation: StagingXcmV4Location } }; + +/** + * The `Event` enum of this pallet + **/ +export type PalletXcmWeightTraderEvent = + /** + * New supported asset is registered + **/ + | { name: 'SupportedAssetAdded'; data: { location: StagingXcmV4Location; relativePrice: bigint } } + /** + * Changed the amount of units we are charging per execution second for a given asset + **/ + | { name: 'SupportedAssetEdited'; data: { location: StagingXcmV4Location; relativePrice: bigint } } + /** + * Pause support for a given asset + **/ + | { name: 'PauseAssetSupport'; data: { location: StagingXcmV4Location } } + /** + * Resume support for a given asset + **/ + | { name: 'ResumeAssetSupport'; data: { location: StagingXcmV4Location } } + /** + * Supported asset type for fee payment removed + **/ + | { name: 'SupportedAssetRemoved'; data: { location: StagingXcmV4Location } }; + +/** + * The `Event` enum of this pallet + **/ +export type PalletEmergencyParaXcmEvent = + /** + * The XCM incoming execution was Paused + **/ + | 'EnteredPausedXcmMode' + /** + * The XCM incoming execution returned to normal operation + **/ + | 'NormalXcmOperationResumed'; + /** * The `Event` enum of this pallet **/ @@ -10306,7 +10437,15 @@ export type PalletMoonbeamLazyMigrationsError = /** * The contract is not corrupted (Still exist or properly suicided) **/ - | 'ContractNotCorrupted'; + | 'ContractNotCorrupted' + /** + * The contract already have metadata + **/ + | 'ContractMetadataAlreadySet' + /** + * Contract not exist + **/ + | 'ContractNotExist'; export type PalletEvmCodeMetadata = { size: bigint; hash: H256 }; @@ -11473,6 +11612,67 @@ export type PalletMessageQueueError = **/ | 'RecursiveDisallowed'; +export type PalletMoonbeamForeignAssetsAssetStatus = 'Active' | 'FrozenXcmDepositAllowed' | 'FrozenXcmDepositForbidden'; + +/** + * An error that can occur while executing the mapping pallet's logic. + **/ +export type PalletMoonbeamForeignAssetsError = + | 'AssetAlreadyExists' + | 'AssetAlreadyFrozen' + | 'AssetDoesNotExist' + | 'AssetIdFiltered' + | 'AssetNotFrozen' + | 'CorruptedStorageOrphanLocation' + | 'Erc20ContractCreationFail' + | 'EvmCallPauseFail' + | 'EvmCallUnpauseFail' + | 'EvmInternalError' + | 'InvalidSymbol' + | 'InvalidTokenName' + | 'LocationAlreadyExists' + | 'TooManyForeignAssets'; + +/** + * The `Error` enum of this pallet. + **/ +export type PalletXcmWeightTraderError = + /** + * The given asset was already added + **/ + | 'AssetAlreadyAdded' + /** + * The given asset was already paused + **/ + | 'AssetAlreadyPaused' + /** + * The given asset was not found + **/ + | 'AssetNotFound' + /** + * The given asset is not paused + **/ + | 'AssetNotPaused' + /** + * XCM location filtered + **/ + | 'XcmLocationFiltered' + /** + * The relative price cannot be zero + **/ + | 'PriceCannotBeZero'; + +export type PalletEmergencyParaXcmXcmMode = 'Normal' | 'Paused'; + +/** + * An error that can occur while executing this pallet's extrinsics. + **/ +export type PalletEmergencyParaXcmError = + /** + * The current XCM Mode is not Paused + **/ + 'NotInPausedMode'; + /** * The `Error` enum of this pallet. **/ @@ -11531,6 +11731,12 @@ export type FrameSystemExtensionsCheckWeight = {}; export type PalletTransactionPaymentChargeTransactionPayment = bigint; +export type FrameMetadataHashExtensionCheckMetadataHash = { mode: FrameMetadataHashExtensionMode }; + +export type FrameMetadataHashExtensionMode = 'Disabled' | 'Enabled'; + +export type CumulusPrimitivesStorageWeightReclaimStorageWeightReclaim = {}; + export type MoonbeamRuntimeRuntime = {}; export type SpRuntimeTransactionValidityTransactionSource = 'InBlock' | 'Local' | 'External'; @@ -11677,5 +11883,8 @@ export type MoonbeamRuntimeRuntimeError = | { pallet: 'XcmTransactor'; palletError: PalletXcmTransactorError } | { pallet: 'EthereumXcm'; palletError: PalletEthereumXcmError } | { pallet: 'MessageQueue'; palletError: PalletMessageQueueError } + | { pallet: 'EvmForeignAssets'; palletError: PalletMoonbeamForeignAssetsError } + | { pallet: 'XcmWeightTrader'; palletError: PalletXcmWeightTraderError } + | { pallet: 'EmergencyParaXcm'; palletError: PalletEmergencyParaXcmError } | { pallet: 'PrecompileBenchmarks'; palletError: PalletPrecompileBenchmarksError } | { pallet: 'Randomness'; palletError: PalletRandomnessError };