DedotXTelegramGithub
Edit

Supported networks

Supported Networks

Typink comes with built-in support for many well-known Substrate networks, ready to use out of the box. You can also define and register your own custom networks.

Typink supports two types of smart contract platforms:

  • ink! v4/v5 (WASM) - Contracts running on pallet-contracts using WebAssembly

  • ink! v6/Solidity (PolkaVM) - Contracts running on pallet-revive using PolkaVM

Smart Contract Support Overview

Contract Type
Technology
Networks

ink! v4/v5

WASM (pallet-contracts)

alephZero, astar, shiden, popTestnet, alephZeroTestnet, shibuyaTestnet

ink! v6 / Solidity

PolkaVM (pallet-revive)

popTestnet, passetHub, westendAssetHub, kusamaAssetHub

Note: popTestnet supports both contract types.

Well-Known Supported Networks

Mainnet

Typink provides built-in support for the following mainnet networks:

ink! v4/v5 Networks (WASM, pallet-contracts)

  • alephZero - Aleph Zero

  • astar - Astar

  • shiden - Shiden

ink! v6/Solidity Networks (PolkaVM, pallet-revive)

  • kusamaAssetHub - Kusama Asset Hub

Polkadot

  • polkadot - Polkadot Relay Chain

  • polkadotAssetHub - Polkadot Asset Hub

  • polkadotPeople - Polkadot People Chain

Kusama

  • kusama - Kusama Relay Chain

  • kusamaPeople - Kusama People Chain

Other Networks

  • hydration - Hydration

  • basilisk - Basilisk

  • vara - Vara Network

Example Usage:

import {
  alephZero,
  astar,
  kusamaAssetHub,
  polkadot,
  kusama
} from 'typink';

// Example 1: Mix of contract and general Substrate networks
<TypinkProvider
  supportedNetworks={[alephZero, astar, polkadot, kusama]}
  defaultNetworkId={alephZero.id}>
  <MyAppComponent />
</TypinkProvider>

// Example 2: PolkaVM contract network with general Substrate
<TypinkProvider
  supportedNetworks={[kusamaAssetHub, kusama]}
  defaultNetworkId={kusamaAssetHub.id}>
  <MyAppComponent />
</TypinkProvider>

Testnet

Typink provides built-in support for the following testnet networks:

ink! v4/v5 Testnets (WASM, pallet-contracts)

  • popTestnet - POP Network Testnet (supports both WASM and PolkaVM)

  • alephZeroTestnet - Aleph Zero Testnet

  • shibuyaTestnet - Shibuya Testnet

ink! v6/Solidity Testnets (PolkaVM, pallet-revive)

  • popTestnet - POP Network Testnet (supports both WASM and PolkaVM)

  • passetHub - Passet Hub

  • westendAssetHub - Westend Asset Hub

Westend

  • westend - Westend Testnet

  • westendPeople - Westend People Chain

Paseo

  • paseo - Paseo Testnet

  • paseoPeople - Paseo People Chain

  • paseoAssetHub - Paseo Asset Hub

  • paseoHydration - Paseo Hydration

Example Usage:

import {
  popTestnet,
  alephZeroTestnet,
  shibuyaTestnet,
  passetHub,
  westendAssetHub,
  westend,
  paseo
} from 'typink';

// Example 1: ink! v4/v5 (WASM) contract networks
<TypinkProvider
  supportedNetworks={[popTestnet, alephZeroTestnet, shibuyaTestnet]}
  defaultNetworkId={popTestnet.id}>
  <MyAppComponent />
</TypinkProvider>

// Example 2: ink! v6/Solidity (PolkaVM) contract networks
<TypinkProvider
  supportedNetworks={[popTestnet, passetHub, westendAssetHub]}
  defaultNetworkId={popTestnet.id}>
  <MyAppComponent />
</TypinkProvider>

// Example 3: Mix of contract and general Substrate networks
<TypinkProvider
  supportedNetworks={[popTestnet, westend, paseo]}
  defaultNetworkId={popTestnet.id}>
  <MyAppComponent />
</TypinkProvider>

Development

For local development with a Substrate node:

  • development - Local Development Network (ws://127.0.0.1:9944)

Example Usage:

import { development } from 'typink';

<TypinkProvider
  supportedNetworks={[development]}
  defaultNetworkId={development.id}>
  <MyAppComponent />
</TypinkProvider>

Define & Register Custom Network Info

You can define a new network info following the NetworkInfo interface:

type NetworkId = string;

enum NetworkType {
  DEVNET = 'devnet',
  TESTNET = 'testnet',
  MAINNET = 'mainnet',
}

enum JsonRpcApi {
  LEGACY = 'legacy',
  NEW = 'new',
}

interface NetworkInfo {
  id: NetworkId;
  type?: NetworkType;                    // default to mainnet
  name: string;
  logo: string;
  providers: string[];
  symbol: string;
  decimals: number;
  subscanUrl?: string;
  pjsUrl?: string;
  faucetUrl?: string;
  jsonRpcApi?: JsonRpcApi;              // default to new
  chainSpec?: () => Promise<string>;     // for light client support
  relayChain?: NetworkInfo;              // for parachains using light client
}

Basic Custom Network Example

For a basic custom network:

import { NetworkInfo, NetworkType } from 'typink';

const myNetwork: NetworkInfo = {
  id: 'my_network',
  type: NetworkType.MAINNET,
  name: 'My Network',
  logo: 'https://path/to/your/network/logo.png',
  providers: ['wss://mynetwork.dev'],
  symbol: 'MYN',
  decimals: 12,
};

Custom Network with Light Client Support

To add light client support to your custom network:

import { NetworkInfo, NetworkType } from 'typink';

const myNetwork: NetworkInfo = {
  id: 'my_network',
  type: NetworkType.MAINNET,
  name: 'My Network',
  logo: 'https://path/to/your/network/logo.png',
  providers: ['wss://mynetwork.dev'],
  symbol: 'MYN',
  decimals: 12,
  chainSpec: async () => {
    // Option 1: Use known chain from @substrate/connect-known-chains
    return (await import('@substrate/connect-known-chains/polkadot')).chainSpec;

    // Option 2: Fetch from URL
    // const response = await fetch('https://example.com/chainspec.json');
    // return await response.text();

    // Option 3: Inline chain spec
    // return '{"name":"MyChain","id":"my_chain",...}';
  },
};

Custom Parachain with Light Client Support

For parachains, you must specify the relay chain:

import { NetworkInfo, NetworkType, polkadot } from 'typink';

const myParachain: NetworkInfo = {
  id: 'my_parachain',
  type: NetworkType.MAINNET,
  name: 'My Parachain',
  logo: 'https://path/to/your/parachain/logo.png',
  providers: ['wss://myparachain.dev'],
  symbol: 'MPC',
  decimals: 12,
  chainSpec: async () => {
    const response = await fetch('https://myparachain.dev/chainspec.json');
    return await response.text();
  },
  relayChain: polkadot, // Reference to the relay chain NetworkInfo
};

Register Custom Network

Once defined, register your custom network with Typink:

<TypinkProvider
  supportedNetworks={[myNetwork]}
  defaultNetworkId={myNetwork.id}>
  <MyAppComponent />
</TypinkProvider>

You can also combine custom networks with built-in networks:

import { popTestnet, alephZero } from 'typink';

<TypinkProvider
  supportedNetworks={[myNetwork, popTestnet, alephZero]}
  defaultNetworkId={myNetwork.id}>
  <MyAppComponent />
</TypinkProvider>

Network Properties

Required Properties

  • id - Unique network identifier

  • name - Human-readable network name

  • logo - URL to network logo

  • providers - Array of RPC endpoint URLs

  • symbol - Native token symbol

  • decimals - Native token decimals

Optional Properties

  • type - Network type (mainnet, testnet, devnet)

  • subscanUrl - Subscan explorer URL

  • pjsUrl - Polkadot.js Apps URL

  • faucetUrl - Faucet URL for testnets

  • jsonRpcApi - RPC API version (new or legacy)

  • chainSpec - Chain specification for light client support

  • relayChain - Parent relay chain for parachains (required for parachain light clients)

PreviousMigrate from existing dappNextcreate-typink CLI

Last updated

Was this helpful?