From e1be44ad3ea300d04c9a30f6b73163e2e7071487 Mon Sep 17 00:00:00 2001 From: Jaco Greeff Date: Tue, 2 Jun 2020 12:51:30 +0200 Subject: [PATCH] Remove all builtin metadata (#358) --- packages/extension-chains/src/index.ts | 4 ++-- packages/extension-chains/src/kusama.ts | 23 ----------------------- 2 files changed, 2 insertions(+), 25 deletions(-) delete mode 100644 packages/extension-chains/src/kusama.ts diff --git a/packages/extension-chains/src/index.ts b/packages/extension-chains/src/index.ts index 7d6291a0..472b1fe8 100644 --- a/packages/extension-chains/src/index.ts +++ b/packages/extension-chains/src/index.ts @@ -9,10 +9,10 @@ import { Metadata, TypeRegistry } from '@polkadot/types'; // imports chain details, generally metadata. For the generation of these, // inside the api, run `yarn chain:info --ws ` -import kusama from './kusama'; +// import kusama from './kusama'; const definitions = new Map( - [kusama].map((def) => [def.genesisHash, def]) + // [kusama].map((def) => [def.genesisHash, def]) ); const expanded = new Map(); diff --git a/packages/extension-chains/src/kusama.ts b/packages/extension-chains/src/kusama.ts deleted file mode 100644 index 274ef773..00000000 --- a/packages/extension-chains/src/kusama.ts +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright 2019-2020 @polkadot/extension-chains authors & contributors -// This software may be modified and distributed under the terms -// of the Apache-2.0 license. See the LICENSE file for details. - -// Generated via 'yarn run chain:info --ws wss://kusama-rpc.polkadot.io' - -/* eslint-disable sort-keys */ - -export default { - chain: 'Kusama', - genesisHash: '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe', - icon: 'polkadot', - specVersion: 1062, - ss58Format: 2, - tokenDecimals: 12, - tokenSymbol: 'KSM', - types: { - Address: 'AccountId', - Keys: 'SessionKeys5', - LookupSource: 'AccountId' - }, - metaCalls: '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' -};