@subwallet/extension-base 1.3.45-1 → 1.3.47-0

package/utils/account/common.js

@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
-import { _chainInfoToChainType, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
+import { _chainInfoToChainType, _getChainSubstrateAddressPrefix, _getSubstrateGenesisHash, _isChainBitcoinCompatible, _isChainCardanoCompatible, _isChainEvmCompatible, _isChainTonCompatible, _isSubstrateEvmCompatibleChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { AccountChainType } from '@subwallet/extension-base/types';
-import { getAccountChainTypeFromKeypairType } from '@subwallet/extension-base/utils';
+import { getAccountChainTypeFromKeypairType, pairToAccount } from '@subwallet/extension-base/utils';
 import { decodeAddress, encodeAddress, getKeypairTypeByAddress, isAddress, isBitcoinAddress, isCardanoAddress, isTonAddress } from '@subwallet/keyring';
 import { getBitcoinAddressInfo } from '@subwallet/keyring/utils/address/validate';
+import { keyring } from '@subwallet/ui-keyring';
 import { ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
 export function isAccountAll(address) {
   return address === ALL_ACCOUNT_KEY;
@@ -123,4 +124,92 @@ export const modifyAccountName = (type, name, modify) => {
       break;
   }
   return network ? [name, network].join(' - ') : name;
+};
+
+/**
+ * @function getAccountJsonByAddress
+ * @desc Get account info by address
+ * <p>
+ *   Note: Use on the background only
+ * </p>
+ * @param {string} address - Address
+ * @returns {AccountJson|null}  - Account info or null if not found
+ */
+export const getAccountJsonByAddress = address => {
+  try {
+    const pair = keyring.getPair(address);
+    if (pair) {
+      return pairToAccount(pair);
+    } else {
+      return null;
+    }
+  } catch (e) {
+    console.warn(e);
+    return null;
+  }
+};
+
+/** Filter addresses to subscribe by chain info */
+export const filterAddressByChainInfo = (addresses, chainInfo) => {
+  const {
+    _bitcoin,
+    bitcoin,
+    cardano,
+    evm,
+    substrate,
+    ton
+  } = getAddressesByChainTypeMap(addresses, chainInfo);
+  if (_isChainEvmCompatible(chainInfo)) {
+    const [fetchList, unFetchList] = processEvmAndSubstrateAddresses(evm, chainInfo);
+    return [fetchList, [...unFetchList, ...bitcoin, ...ton, ...substrate, ...cardano, ..._bitcoin].flat()];
+  } else if (_isChainBitcoinCompatible(chainInfo)) {
+    return [bitcoin, [...evm, ...substrate, ...ton, ...cardano, ..._bitcoin].flat()];
+  } else if (_isChainTonCompatible(chainInfo)) {
+    return [ton, [...bitcoin, ...evm, ...substrate, ...cardano, ..._bitcoin].flat()];
+  } else if (_isChainCardanoCompatible(chainInfo)) {
+    return [cardano, [...bitcoin, ...evm, ...substrate, ...ton, ..._bitcoin].flat()];
+  } else {
+    const [fetchList, unFetchList] = processEvmAndSubstrateAddresses(substrate, chainInfo);
+    return [fetchList, [...unFetchList, ...bitcoin, ...evm, ...ton, ...cardano, ..._bitcoin].flat()];
+  }
+};
+const processEvmAndSubstrateAddresses = (addressList, chainInfo) => {
+  const fetchList = [];
+  const unFetchList = [];
+  const isEvm = isEthereumAddress(addressList[0]);
+  addressList.forEach(address => {
+    const account = getAccountJsonByAddress(address);
+    if (account) {
+      if (account.isHardware) {
+        if (isEvm) {
+          if (account.isGeneric && account.isSubstrateECDSA) {
+            if (_isSubstrateEvmCompatibleChain(chainInfo)) {
+              fetchList.push(address);
+            } else {
+              unFetchList.push(address);
+            }
+          } else {
+            fetchList.push(address);
+          }
+        } else {
+          if (account.isGeneric) {
+            fetchList.push(address);
+          } else {
+            const availGen = account.availableGenesisHashes || [];
+            const gen = _getSubstrateGenesisHash(chainInfo);
+            if (availGen.includes(gen)) {
+              fetchList.push(address);
+            } else {
+              unFetchList.push(address);
+            }
+          }
+        }
+      } else {
+        fetchList.push(address);
+      }
+    } else {
+      fetchList.push(address);
+    }
+  });
+  return [fetchList, unFetchList];
 };

package/utils/account/transform.js

@@ -62,6 +62,9 @@ export const getAccountSignMode = (address, _meta) => {
       if (meta.isExternal) {
         if (meta.isHardware) {
           if (meta.isGeneric) {
+            if (meta.isSubstrateECDSA) {
+              return AccountSignMode.ECDSA_SUBSTRATE_LEDGER;
+            }
             return AccountSignMode.GENERIC_LEDGER;
           } else {
             return AccountSignMode.LEGACY_LEDGER;
@@ -233,6 +236,11 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
       result.push(...CLAIM_AVAIL_BRIDGE);
     }
     return result;
+  } else if (signMode === AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
+    // Only for account substrate with ECDSA scheme format
+    const result = [];
+    result.push(...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ExtrinsicType.TRANSFER_XCM, ExtrinsicType.SWAP, ExtrinsicType.CROWDLOAN);
+    return result;
   }
   return [];
 };
@@ -352,6 +360,7 @@ export const convertAccountProxyType = accountSignMode => {
   switch (accountSignMode) {
     case AccountSignMode.GENERIC_LEDGER:
     case AccountSignMode.LEGACY_LEDGER:
+    case AccountSignMode.ECDSA_SUBSTRATE_LEDGER:
       return AccountProxyType.LEDGER;
     case AccountSignMode.QR:
       return AccountProxyType.QR;
@@ -460,6 +469,7 @@ export const _combineAccounts = (accounts, modifyPairs, accountProxies) => {
       switch (account.signMode) {
         case AccountSignMode.GENERIC_LEDGER:
         case AccountSignMode.LEGACY_LEDGER:
+        case AccountSignMode.ECDSA_SUBSTRATE_LEDGER:
           specialChain = account.specialChain;
           break;
       }

package/utils/asset.d.ts

@@ -1,3 +1,4 @@
-import { _AssetType, _ChainAsset } from '@subwallet/chain-list/types';
+import { _AssetType, _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 export declare const filterAssetsByChainAndType: (chainAssetMap: Record<string, _ChainAsset>, chain: string, assetTypes: _AssetType[]) => Record<string, _ChainAsset>;
 export declare const filterAlphaAssetsByChain: (chainAssetMap: Record<string, _ChainAsset>, chain: string) => Record<string, _ChainAsset>;
+export declare const isSubstrateEcdsaLedgerAssetSupported: (chainsAsset: _ChainAsset, chainInfo: _ChainInfo) => boolean;

package/utils/asset.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _AssetType } from '@subwallet/chain-list/types';
-import { _getAssetNetuid } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetNetuid, _getContractAddressOfToken, _isNativeToken, _isSubstrateEvmCompatibleChain } from '@subwallet/extension-base/services/chain-service/utils';
 export const filterAssetsByChainAndType = (chainAssetMap, chain, assetTypes) => {
   const result = {};
   Object.values(chainAssetMap).forEach(assetInfo => {
@@ -23,4 +23,10 @@ export const filterAlphaAssetsByChain = (chainAssetMap, chain) => {
     }
   });
   return result;
+};
+export const isSubstrateEcdsaLedgerAssetSupported = (chainsAsset, chainInfo) => {
+  if (!_isSubstrateEvmCompatibleChain(chainInfo)) {
+    return false;
+  }
+  return _isNativeToken(chainsAsset) || !_getContractAddressOfToken(chainsAsset);
 };

package/utils/gear/combine.d.ts

@@ -1,3 +1,4 @@
+import { GearApi } from '@gear-js/api';
 import { ApiPromise } from '@polkadot/api';
 import { GRC20 } from './grc20';
 import { VFT } from './vft';
@@ -7,4 +8,4 @@ export declare const DEFAULT_GEAR_ADDRESS: {
 };
 export declare const GEAR_DEFAULT_ADDRESS = "5EYCAe5ijiYfAXEth5DGRKiKuVjTXQKr877tUPz6eLz2t9aG";
 export declare function getGRC20ContractPromise(apiPromise: ApiPromise, contractAddress: string): GRC20;
-export declare function getVFTContractPromise(apiPromise: ApiPromise, contractAddress: string): VFT;
+export declare function getVFTContractPromise(api: GearApi, contractAddress?: string): VFT;

package/utils/gear/combine.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { GRC20 } from "./grc20.js";
-import { VFT } from "./vft.js";
+import { sailsCache, VFT } from "./vft.js";
 export const DEFAULT_GEAR_ADDRESS = {
   ALICE: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
   BOB: '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty'
@@ -12,7 +12,7 @@ export function getGRC20ContractPromise(apiPromise, contractAddress) {
   const gearApi = apiPromise;
   return new GRC20(gearApi, contractAddress);
 }
-export function getVFTContractPromise(apiPromise, contractAddress) {
-  const gearApi = apiPromise;
-  return new VFT(gearApi, contractAddress);
+export function getVFTContractPromise(api, contractAddress = '0x') {
+  const sails = sailsCache.get();
+  return new VFT(api, contractAddress, sails);
 }

package/utils/gear/vft.d.ts

@@ -1,19 +1,20 @@
 /// <reference types="node" />
 import { GearApi } from '@gear-js/api';
-import { ActorId, TransactionBuilder } from 'sails-js';
-import { TypeRegistry } from '@polkadot/types';
+import { ActorId, Sails, TransactionBuilder } from 'sails-js';
 export declare class VFT {
-    api: GearApi;
+    readonly api: GearApi;
     programId: `0x${string}`;
-    readonly registry: TypeRegistry;
     readonly service: VftService;
-    constructor(api: GearApi, programId?: `0x${string}`);
-    newCtorFromCode(code: Uint8Array | Buffer, name: string, symbol: string, decimals: number): TransactionBuilder<null>;
-    newCtorFromCodeId(codeId: `0x${string}`, name: string, symbol: string, decimals: number): TransactionBuilder<null>;
+    readonly sails: Sails;
+    constructor(api: GearApi, programId: `0x${string}`, sails: Sails);
+    newCtorFromCode(code: Uint8Array | Buffer, name: string, symbol: string, decimals: number): TransactionBuilder<any>;
+    newCtorFromCodeId(codeId: `0x${string}`, name: string, symbol: string, decimals: number): TransactionBuilder<any>;
 }
 export declare class VftService {
     private _program;
     constructor(_program: VFT);
+    private get functions();
+    private get queries();
     approve(spender: ActorId, value: number | string | bigint): TransactionBuilder<boolean>;
     transfer(to: ActorId, value: number | string | bigint): TransactionBuilder<boolean>;
     transferFrom(from: ActorId, to: ActorId, value: number | string | bigint): TransactionBuilder<boolean>;
@@ -26,11 +27,21 @@ export declare class VftService {
     subscribeToApprovalEvent(callback: (data: {
         owner: ActorId;
         spender: ActorId;
-        value: number | string | bigint;
+        value: bigint;
     }) => void | Promise<void>): Promise<() => void>;
     subscribeToTransferEvent(callback: (data: {
         from: ActorId;
         to: ActorId;
-        value: number | string | bigint;
+        value: bigint;
     }) => void | Promise<void>): Promise<() => void>;
 }
+declare class SailsCache {
+    private static instance;
+    private sail;
+    private constructor();
+    static getInstance(): SailsCache;
+    init(): Promise<void>;
+    get(): Sails;
+}
+export declare const sailsCache: SailsCache;
+export {};

package/utils/gear/vft.js

@@ -1,28 +1,26 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { decodeAddress } from '@gear-js/api';
-import { getFnNamePrefix, getServiceNamePrefix, TransactionBuilder, ZERO_ADDRESS } from 'sails-js';
-import { TypeRegistry } from '@polkadot/types';
+import { Sails } from 'sails-js';
+import { SailsIdlParser } from 'sails-js-parser';
 export class VFT {
-  constructor(api, programId = '0x') {
+  constructor(api, programId = '0x', sails) {
     this.api = api;
     this.programId = programId;
-    const types = {};
-    this.registry = new TypeRegistry();
-    this.registry.setKnownTypes({
-      types
-    });
-    this.registry.register(types);
+    this.sails = sails;
+    this.sails.setApi(api);
+    this.sails.setProgramId(programId);
     this.service = new VftService(this);
   }
   newCtorFromCode(code, name, symbol, decimals) {
-    const builder = new TransactionBuilder(this.api, this.registry, 'upload_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', code);
+    const ctor = this.sails.ctors.New;
+    const builder = ctor.fromCode(code, name, symbol, decimals);
     this.programId = builder.programId;
     return builder;
   }
   newCtorFromCodeId(codeId, name, symbol, decimals) {
-    const builder = new TransactionBuilder(this.api, this.registry, 'create_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', codeId);
+    const ctor = this.sails.ctors.New;
+    const builder = ctor.fromCodeId(codeId, name, symbol, decimals);
     this.programId = builder.programId;
     return builder;
   }
@@ -31,132 +29,103 @@ export class VftService {
   constructor(_program) {
     this._program = _program;
   }
+  get functions() {
+    return this._program.sails.services.Vft.functions;
+  }
+  get queries() {
+    return this._program.sails.services.Vft.queries;
+  }
   approve(spender, value) {
-    if (!this._program.programId) {
-      throw new Error('Program ID is not set');
-    }
-    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'Approve', spender, value], '(String, String, [u8;32], U256)', 'bool', this._program.programId);
+    return this.functions.Approve(spender, value);
   }
   transfer(to, value) {
-    if (!this._program.programId) {
-      throw new Error('Program ID is not set');
-    }
-    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'Transfer', to, value], '(String, String, [u8;32], U256)', 'bool', this._program.programId);
+    return this.functions.Transfer(to, value);
   }
   transferFrom(from, to, value) {
-    if (!this._program.programId) {
-      throw new Error('Program ID is not set');
+    return this.functions.TransferFrom(from, to, value);
+  }
+  allowance(owner, spender, originAddress, value, atBlock) {
+    return this.queries.Allowance(originAddress, BigInt(value || 0), atBlock, owner, spender);
+  }
+  balanceOf(account, originAddress, value, atBlock) {
+    return this.queries.BalanceOf(originAddress, BigInt(value || 0), atBlock, account);
+  }
+  decimals(originAddress, value, atBlock) {
+    return this.queries.Decimals(originAddress, BigInt(value || 0), atBlock);
+  }
+  name(originAddress, value, atBlock) {
+    return this.queries.Name(originAddress, BigInt(value || 0), atBlock);
+  }
+  symbol(originAddress, value, atBlock) {
+    return this.queries.Symbol(originAddress, BigInt(value || 0), atBlock);
+  }
+  totalSupply(originAddress, value, atBlock) {
+    return this.queries.TotalSupply(originAddress, BigInt(value || 0), atBlock);
+  }
+  async subscribeToApprovalEvent(callback) {
+    return this._program.sails.services.Vft.events.Approval.subscribe(callback);
+  }
+  async subscribeToTransferEvent(callback) {
+    return this._program.sails.services.Vft.events.Transfer.subscribe(callback);
+  }
+}
+
+// Cache sai
+const vftIdl = `
+constructor {
+  New : (name: str, symbol: str, decimals: u8);
+};
+
+service Vft {
+  Approve : (spender: actor_id, value: u256) -> bool;
+  Transfer : (to: actor_id, value: u256) -> bool;
+  TransferFrom : (from: actor_id, to: actor_id, value: u256) -> bool;
+
+  query Allowance : (owner: actor_id, spender: actor_id) -> u256;
+  query BalanceOf : (account: actor_id) -> u256;
+  query Decimals : () -> u8;
+  query Name : () -> str;
+  query Symbol : () -> str;
+  query TotalSupply : () -> u256;
+
+  events {
+    Approval: struct {
+      owner: actor_id,
+      spender: actor_id,
+      value: u256,
+    };
+    Transfer: struct {
+      from: actor_id,
+      to: actor_id,
+      value: u256,
+    };
+  }
+};
+`;
+class SailsCache {
+  static instance = null;
+  sail = null;
+
+  // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function
+  constructor() {}
+  static getInstance() {
+    if (!SailsCache.instance) {
+      SailsCache.instance = new SailsCache();
     }
-    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'TransferFrom', from, to, value], '(String, String, [u8;32], [u8;32], U256)', 'bool', this._program.programId);
-  }
-  async allowance(owner, spender, originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String, [u8;32], [u8;32])', ['Vft', 'Allowance', owner, spender]).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
-    return result[2].toBigInt();
-  }
-  async balanceOf(account, originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String, [u8;32])', ['Vft', 'BalanceOf', account]).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
-    return result[2].toBigInt();
-  }
-  async decimals(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Decimals']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, u8)', reply.payload);
-    return result[2].toNumber();
-  }
-  async name(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Name']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, String)', reply.payload);
-    return result[2].toString();
-  }
-  async symbol(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Symbol']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, String)', reply.payload);
-    return result[2].toString();
-  }
-  async totalSupply(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'TotalSupply']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
-    return result[2].toBigInt();
-  }
-  subscribeToApprovalEvent(callback) {
-    return this._program.api.gearEvents.subscribeToGearEvent('UserMessageSent', ({
-      data: {
-        message
-      }
-    }) => {
-      if (!message.source.eq(this._program.programId) || !message.destination.eq(ZERO_ADDRESS)) {
-        return;
-      }
-      const payload = message.payload.toHex();
-      if (getServiceNamePrefix(payload) === 'Vft' && getFnNamePrefix(payload) === 'Approval') {
-        // eslint-disable-next-line node/no-callback-literal,@typescript-eslint/no-floating-promises
-        callback(this._program.registry.createType('(String, String, {"owner":"[u8;32]","spender":"[u8;32]","value":"U256"})', message.payload)[2].toJSON());
-      }
-    });
-  }
-  subscribeToTransferEvent(callback) {
-    return this._program.api.gearEvents.subscribeToGearEvent('UserMessageSent', ({
-      data: {
-        message
-      }
-    }) => {
-      if (!message.source.eq(this._program.programId) || !message.destination.eq(ZERO_ADDRESS)) {
-        return;
-      }
-      const payload = message.payload.toHex();
-      if (getServiceNamePrefix(payload) === 'Service' && getFnNamePrefix(payload) === 'Transfer') {
-        // eslint-disable-next-line node/no-callback-literal,@typescript-eslint/no-floating-promises
-        callback(this._program.registry.createType('(String, String, {"from":"[u8;32]","to":"[u8;32]","value":"U256"})', message.payload)[2].toJSON());
-      }
-    });
-  }
-}
+    return SailsCache.instance;
+  }
+  async init() {
+    if (!this.sail) {
+      const parser = await SailsIdlParser.new();
+      const sails = new Sails(parser);
+      this.sail = sails.parseIdl(vftIdl);
+    }
+  }
+  get() {
+    if (!this.sail) {
+      throw new Error('Sails is not init yet');
+    }
+    return this.sail;
+  }
+}
+export const sailsCache = SailsCache.getInstance();

package/utils/staticData/assetHubStaking.json

@@ -0,0 +1 @@
+{}

package/utils/staticData/index.d.ts

@@ -11,6 +11,7 @@ export declare const remindNotificationTime: Record<NotificationActionType, numb
 export declare const blockedActions: Record<string, EnvConfig>;
 export declare const oldChainPrefix: Record<string, EnvConfig>;
 export declare const paraSpellChainMap: Record<string, EnvConfig>;
+export declare const assetHubStakingMap: Record<string, EnvConfig>;
 export declare enum StaticKey {
     BUY_SERVICE_INFOS = "buy-service-infos",
     CHAINS = "chains",
@@ -23,7 +24,8 @@ export declare enum StaticKey {
     REMIND_NOTIFICATION_TIME = "remind-notification-time",
     BLOCKED_ACTIONS = "blocked-actions",
     OLD_CHAIN_PREFIX = "old-chain-prefix",
-    PARASPELL_CHAIN_MAP = "paraspell-chain-map"
+    PARASPELL_CHAIN_MAP = "paraspell-chain-map",
+    ASSET_HUB_STAKING_MAP = "asset-hub-staking-map"
 }
 export declare const staticData: {
     chains: import("@subwallet/chain-list/types")._ChainInfo[];
@@ -38,4 +40,5 @@ export declare const staticData: {
     "blocked-actions": Record<string, EnvConfig>;
     "old-chain-prefix": Record<string, EnvConfig>;
     "paraspell-chain-map": Record<string, EnvConfig>;
+    "asset-hub-staking-map": Record<string, EnvConfig>;
 };

package/utils/staticData/index.js

@@ -25,6 +25,8 @@ export const blockedActions = require("./blockedActions.json");
 export const oldChainPrefix = require("./oldChainPrefix.json");
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
 export const paraSpellChainMap = require("./paraSpellChainMap.json");
+// eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
+export const assetHubStakingMap = require("./assetHubStaking.json");
 export let StaticKey;
 (function (StaticKey) {
   StaticKey["BUY_SERVICE_INFOS"] = "buy-service-infos";
@@ -39,6 +41,7 @@ export let StaticKey;
   StaticKey["BLOCKED_ACTIONS"] = "blocked-actions";
   StaticKey["OLD_CHAIN_PREFIX"] = "old-chain-prefix";
   StaticKey["PARASPELL_CHAIN_MAP"] = "paraspell-chain-map";
+  StaticKey["ASSET_HUB_STAKING_MAP"] = "asset-hub-staking-map";
 })(StaticKey || (StaticKey = {}));
 export const staticData = {
   [StaticKey.CHAINS]: Object.values(ChainInfoMap),
@@ -52,5 +55,6 @@ export const staticData = {
   [StaticKey.REMIND_NOTIFICATION_TIME]: remindNotificationTime,
   [StaticKey.BLOCKED_ACTIONS]: blockedActions,
   [StaticKey.OLD_CHAIN_PREFIX]: oldChainPrefix,
-  [StaticKey.PARASPELL_CHAIN_MAP]: paraSpellChainMap
+  [StaticKey.PARASPELL_CHAIN_MAP]: paraSpellChainMap,
+  [StaticKey.ASSET_HUB_STAKING_MAP]: assetHubStakingMap
 };