Files
extension/packages/extension-chains/src/kusama.ts
T

23 lines
104 KiB
TypeScript

// 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: 1055,
ss58Format: 2,
tokenDecimals: 12,
tokenSymbol: 'KSM',
types: {
Address: 'AccountId',
Keys: 'SessionKeys5'
},
metaCalls: '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'
};