diff --git a/packages/neuron-wallet/src/database/address/dao.ts b/packages/neuron-wallet/src/database/address/dao.ts
index 0d2a72b363..3b6c295b2c 100644
--- a/packages/neuron-wallet/src/database/address/dao.ts
+++ b/packages/neuron-wallet/src/database/address/dao.ts
@@ -7,6 +7,7 @@ import { TransactionStatus } from 'types/cell-types'
 import { OutputStatus } from 'services/tx/params'
 import AddressEntity, { AddressVersion } from './entities/address'
 import { getConnection } from './ormconfig'
+import NodeService from 'services/node'
 
 export interface Address {
   walletId: string
@@ -54,7 +55,10 @@ export default class AddressDao {
   // so the final balance is (liveBalance + sentBalance - pendingBalance)
   // balance is the balance of the cells those who don't hold data or type script
   // totalBalance means balance of all cells, including those who hold data and type script
-  public static updateTxCountAndBalance = async (address: string): Promise<AddressEntity[]> => {
+  public static updateTxCountAndBalance = async (
+    address: string,
+    url: string = NodeService.getInstance().core.rpc.node.url
+  ): Promise<AddressEntity[]> => {
     const addressEntities = await getConnection()
       .getRepository(AddressEntity)
       .find({
@@ -64,12 +68,12 @@ export default class AddressDao {
     const txCount: number = await TransactionsService.getCountByAddressAndStatus(address, [
       TransactionStatus.Pending,
       TransactionStatus.Success,
-    ])
+    ], url)
     const entities = await Promise.all(
       addressEntities.map(async entity => {
         const addressEntity = entity
         addressEntity.txCount = txCount
-        const lockHashes: string[] = await LockUtils.addressToAllLockHashes(addressEntity.address)
+        const lockHashes: string[] = await LockUtils.addressToAllLockHashes(addressEntity.address, url)
         addressEntity.liveBalance = await CellsService.getBalance(lockHashes, OutputStatus.Live, true)
         addressEntity.sentBalance = await CellsService.getBalance(lockHashes, OutputStatus.Sent, true)
         addressEntity.pendingBalance = await CellsService.getBalance(lockHashes, OutputStatus.Pending, true)
diff --git a/packages/neuron-wallet/src/listeners/address.ts b/packages/neuron-wallet/src/listeners/address.ts
index 1a1e91424e..6b3994240e 100644
--- a/packages/neuron-wallet/src/listeners/address.ts
+++ b/packages/neuron-wallet/src/listeners/address.ts
@@ -1,7 +1,7 @@
 import { remote } from 'electron'
 import { ReplaySubject } from 'rxjs'
 import { bufferTime } from 'rxjs/operators'
-import AddressesUsedSubject from 'models/subjects/addresses-used-subject'
+import AddressesUsedSubject, { AddressesWithURL } from 'models/subjects/addresses-used-subject'
 import AddressService from 'services/addresses'
 import WalletService from 'services/wallets'
 import { AccountExtendedPublicKey } from 'models/keys/key'
@@ -12,17 +12,21 @@ const addressesUsedSubject = isRenderer
   : AddressesUsedSubject.getSubject()
 
 // pipe not working directly
-const bridge = new ReplaySubject<string[]>(1000)
-addressesUsedSubject.subscribe((addresses: string[]) => {
-  bridge.next(addresses)
+const bridge = new ReplaySubject<AddressesWithURL>(1000)
+addressesUsedSubject.subscribe((params: AddressesWithURL) => {
+  bridge.next(params)
 })
 
 // update txCount when addresses used
 export const register = () => {
-  bridge.pipe(bufferTime(1000)).subscribe(async (addressesList: string[][]) => {
-    const addresses = addressesList.reduce((acc, val) => acc.concat(val), [])
+  bridge.pipe(bufferTime(1000)).subscribe(async (addressesList: AddressesWithURL[]) => {
+    if (addressesList.length === 0) {
+      return
+    }
+    const addresses = addressesList.map(list => list.addresses).reduce((acc, val) => acc.concat(val), [])
+    const url: string = addressesList[addressesList.length - 1].url
     const uniqueAddresses = [...new Set(addresses)]
-    const addrs = await AddressService.updateTxCountAndBalances(uniqueAddresses)
+    const addrs = await AddressService.updateTxCountAndBalances(uniqueAddresses, url)
     const walletIds: string[] = addrs.map(addr => addr.walletId).filter((value, idx, a) => a.indexOf(value) === idx)
     await Promise.all(
       walletIds.map(async id => {
diff --git a/packages/neuron-wallet/src/listeners/tx-status.ts b/packages/neuron-wallet/src/listeners/tx-status.ts
index aaf1cb4e28..3f9be3f9e8 100644
--- a/packages/neuron-wallet/src/listeners/tx-status.ts
+++ b/packages/neuron-wallet/src/listeners/tx-status.ts
@@ -61,7 +61,11 @@ const trackingStatus = async () => {
   if (failedTxs.length) {
     const blake160s = await FailedTransaction.updateFailedTxs(failedTxs.map(tx => tx.hash))
     const usedAddresses = blake160s.map(blake160 => LockUtils.blake160ToAddress(blake160))
-    AddressesUsedSubject.getSubject().next(usedAddresses)
+    const { core } = nodeService
+    AddressesUsedSubject.getSubject().next({
+      addresses: usedAddresses,
+      url: core.rpc.node.url,
+    })
   }
 
   if (successTxs.length > 0) {
diff --git a/packages/neuron-wallet/src/models/lock-utils.ts b/packages/neuron-wallet/src/models/lock-utils.ts
index 6ac0094768..13165a5c02 100644
--- a/packages/neuron-wallet/src/models/lock-utils.ts
+++ b/packages/neuron-wallet/src/models/lock-utils.ts
@@ -1,11 +1,16 @@
-import { scriptToHash } from '@nervosnetwork/ckb-sdk-utils'
+import {
+  scriptToHash,
+  AddressPrefix,
+  bech32Address,
+  AddressType,
+  parseAddress
+} from '@nervosnetwork/ckb-sdk-utils'
 import NodeService from 'services/node'
 import { OutPoint, Script, ScriptHashType } from 'types/cell-types'
 import env from 'env'
 import ConvertTo from 'types/convert-to'
 import { SystemScriptSubject } from 'models/subjects/system-script'
-
-const { core } = NodeService.getInstance()
+import Core from '@nervosnetwork/ckb-sdk-core'
 
 export interface SystemScript {
   codeHash: string
@@ -28,11 +33,15 @@ export default class LockUtils {
   @subscribed
   static systemScriptInfo: SystemScript | undefined
 
-  static async systemScript(): Promise<SystemScript> {
-    if (this.systemScriptInfo) {
+  static previousURL: string | undefined
+
+  static async systemScript(nodeURL: string = NodeService.getInstance().core.rpc.node.url): Promise<SystemScript> {
+    if (this.systemScriptInfo && nodeURL === LockUtils.previousURL) {
       return this.systemScriptInfo
     }
 
+    const core = new Core(nodeURL)
+
     const systemCell = await core.loadSecp256k1Dep()
     let { codeHash } = systemCell
     const { outPoint, hashType } = systemCell
@@ -57,6 +66,7 @@ export default class LockUtils {
     }
 
     this.systemScriptInfo = systemScriptInfo
+    LockUtils.previousURL = nodeURL
 
     return systemScriptInfo
   }
@@ -80,8 +90,12 @@ export default class LockUtils {
     return LockUtils.computeScriptHash(lock)
   }
 
-  static async addressToLockScript(address: string, hashType: ScriptHashType = ScriptHashType.Type): Promise<Script> {
-    const systemScript = await this.systemScript()
+  static async addressToLockScript(
+    address: string,
+    hashType: ScriptHashType = ScriptHashType.Type,
+    nodeURL: string = NodeService.getInstance().core.rpc.node.url
+  ): Promise<Script> {
+    const systemScript = await this.systemScript(nodeURL)
 
     const lock: Script = {
       codeHash: systemScript.codeHash,
@@ -91,22 +105,32 @@ export default class LockUtils {
     return lock
   }
 
-  static async addressToLockHash(address: string, hashType: ScriptHashType = ScriptHashType.Type): Promise<string> {
-    const lock: Script = await this.addressToLockScript(address, hashType)
+  static async addressToLockHash(
+    address: string,
+    hashType: ScriptHashType = ScriptHashType.Type,
+    nodeURL: string = NodeService.getInstance().core.rpc.node.url
+  ): Promise<string> {
+    const lock: Script = await this.addressToLockScript(address, hashType, nodeURL)
     const lockHash: string = this.lockScriptToHash(lock)
 
     return lockHash
   }
 
-  static async addressToAllLockHashes(address: string): Promise<string[]> {
-    const dataLockHash = await LockUtils.addressToLockHash(address)
+  static async addressToAllLockHashes(
+    address: string,
+    nodeURL: string = NodeService.getInstance().core.rpc.node.url
+  ): Promise<string[]> {
+    const dataLockHash = await LockUtils.addressToLockHash(address, ScriptHashType.Type, nodeURL)
     return [dataLockHash]
   }
 
-  static async addressesToAllLockHashes(addresses: string[]): Promise<string[]> {
+  static async addressesToAllLockHashes(
+    addresses: string[],
+    nodeURL: string = NodeService.getInstance().core.rpc.node.url
+  ): Promise<string[]> {
     const lockHashes: string[] = (await Promise.all(
       addresses.map(async addr => {
-        return LockUtils.addressToAllLockHashes(addr)
+        return LockUtils.addressToAllLockHashes(addr, nodeURL)
       })
     )).reduce((acc, val) => acc.concat(val), [])
     return lockHashes
@@ -118,16 +142,16 @@ export default class LockUtils {
   }
 
   static blake160ToAddress(blake160: string): string {
-    const prefix = env.testnet ? core.utils.AddressPrefix.Testnet : core.utils.AddressPrefix.Mainnet
-    return core.utils.bech32Address(blake160, {
+    const prefix = env.testnet ? AddressPrefix.Testnet : AddressPrefix.Mainnet
+    return bech32Address(blake160, {
       prefix,
-      type: core.utils.AddressType.HashIdx,
+      type: AddressType.HashIdx,
       codeHashIndex: '0x00',
     })
   }
 
   static addressToBlake160(address: string): string {
-    const result: string = core.utils.parseAddress(address, 'hex') as string
+    const result: string = parseAddress(address, 'hex') as string
     const hrp: string = `0100`
     let blake160: string = result.slice(hrp.length + 2, result.length)
     if (!blake160.startsWith('0x')) {
diff --git a/packages/neuron-wallet/src/models/subjects/addresses-used-subject.ts b/packages/neuron-wallet/src/models/subjects/addresses-used-subject.ts
index 005b102551..99b06f4588 100644
--- a/packages/neuron-wallet/src/models/subjects/addresses-used-subject.ts
+++ b/packages/neuron-wallet/src/models/subjects/addresses-used-subject.ts
@@ -1,14 +1,19 @@
 import { ReplaySubject } from 'rxjs'
 
+export interface AddressesWithURL {
+  addresses: string[]
+  url: string
+}
+
 // subscribe this Subject to monitor which addresses are used
 export class AddressesUsedSubject {
-  static subject = new ReplaySubject<string[]>(100)
+  static subject = new ReplaySubject<AddressesWithURL>(100)
 
   static getSubject() {
     return this.subject
   }
 
-  static setSubject(subject: ReplaySubject<string[]>) {
+  static setSubject(subject: ReplaySubject<AddressesWithURL>) {
     this.subject = subject
   }
 }
diff --git a/packages/neuron-wallet/src/services/addresses.ts b/packages/neuron-wallet/src/services/addresses.ts
index cb1ebe0dcf..691aa25430 100644
--- a/packages/neuron-wallet/src/services/addresses.ts
+++ b/packages/neuron-wallet/src/services/addresses.ts
@@ -6,6 +6,7 @@ import AddressDao, { Address as AddressInterface } from 'database/address/dao'
 import env from 'env'
 import AddressEntity, { AddressVersion } from 'database/address/entities/address'
 import AddressCreatedSubject from 'models/subjects/address-created-subject'
+import NodeService from './node'
 
 const MAX_ADDRESS_COUNT = 30
 
@@ -96,10 +97,13 @@ export default class AddressService {
 
   /* eslint no-await-in-loop: "off" */
   /* eslint no-restricted-syntax: "off" */
-  public static updateTxCountAndBalances = async (addresses: string[]) => {
+  public static updateTxCountAndBalances = async (
+    addresses: string[],
+    url: string = NodeService.getInstance().core.rpc.node.url
+  ) => {
     let addrs: AddressEntity[] = []
     for (const address of addresses) {
-      const ads = await AddressDao.updateTxCountAndBalance(address)
+      const ads = await AddressDao.updateTxCountAndBalance(address, url)
       addrs = addrs.concat(ads)
     }
     return addrs
diff --git a/packages/neuron-wallet/src/services/indexer/queue.ts b/packages/neuron-wallet/src/services/indexer/queue.ts
index 2bdc71f6c4..cbd0487059 100644
--- a/packages/neuron-wallet/src/services/indexer/queue.ts
+++ b/packages/neuron-wallet/src/services/indexer/queue.ts
@@ -45,9 +45,12 @@ export default class IndexerQueue {
 
   private latestCreatedBy: TxUniqueFlagCache = new TxUniqueFlagCache(100)
 
+  private url: string
+
   constructor(url: string, lockHashInfos: LockHashInfo[], tipNumberSubject: Subject<string | undefined>) {
     // this.lockHashes = lockHashes
     this.lockHashInfos = lockHashInfos
+    this.url = url
     this.indexerRPC = new IndexerRPC(url)
     this.getBlocksService = new GetBlocks(url)
     this.blockNumberService = new BlockNumber()
@@ -190,7 +193,10 @@ export default class IndexerQueue {
           }
           if (type === TxPointType.CreatedBy && this.latestCreatedBy.includes(txUniqueFlag)) {
             const address = LockUtils.lockScriptToAddress(transaction.outputs![parseInt(txPoint.index, 16)].lock)
-            AddressesUsedSubject.getSubject().next([address])
+            AddressesUsedSubject.getSubject().next({
+              addresses: [address],
+              url: this.url,
+            })
             return
           }
 
@@ -229,7 +235,10 @@ export default class IndexerQueue {
             }
           }
           if (address) {
-            AddressesUsedSubject.getSubject().next([address])
+            AddressesUsedSubject.getSubject().next({
+              addresses: [address],
+              url: this.url,
+            })
           }
         }
       }
diff --git a/packages/neuron-wallet/src/services/sync/check-and-save/index.ts b/packages/neuron-wallet/src/services/sync/check-and-save/index.ts
index ed8c495b4c..6c7319b40b 100644
--- a/packages/neuron-wallet/src/services/sync/check-and-save/index.ts
+++ b/packages/neuron-wallet/src/services/sync/check-and-save/index.ts
@@ -4,17 +4,19 @@ import CheckTx from './tx'
 export default class CheckAndSave {
   private block: Block
   private lockHashes: string[]
+  private url: string
 
-  constructor(block: Block, lockHashes: string[]) {
+  constructor(block: Block, lockHashes: string[], url: string) {
     this.block = block
     this.lockHashes = lockHashes
+    this.url = url
   }
 
   public process = async (): Promise<boolean[]> => {
     const txs = this.block.transactions
     let result: boolean[] = []
     for (const tx of txs) {
-      const checkTx = new CheckTx(tx)
+      const checkTx = new CheckTx(tx, this.url)
       const checkResult = await checkTx.checkAndSave(this.lockHashes)
       result.push(checkResult)
     }
diff --git a/packages/neuron-wallet/src/services/sync/check-and-save/tx.ts b/packages/neuron-wallet/src/services/sync/check-and-save/tx.ts
index 4b7d46fe1a..537f236017 100644
--- a/packages/neuron-wallet/src/services/sync/check-and-save/tx.ts
+++ b/packages/neuron-wallet/src/services/sync/check-and-save/tx.ts
@@ -6,14 +6,22 @@ import { TransactionPersistor } from 'services/tx'
 import LockUtils from 'models/lock-utils'
 import CheckOutput from './output'
 import { addressesUsedSubject as addressesUsedSubjectParam } from '../renderer-params'
+import { AddressesWithURL } from 'models/subjects/addresses-used-subject'
 
 export default class CheckTx {
   private tx: Transaction
-  private addressesUsedSubject: Subject<string[]>
+  private addressesUsedSubject: Subject<AddressesWithURL>
+  private url: string
 
-  constructor(tx: Transaction, addressesUsedSubject: Subject<string[]> = addressesUsedSubjectParam) {
+  constructor(
+    tx: Transaction,
+    url: string,
+    addressesUsedSubject: Subject<AddressesWithURL> = addressesUsedSubjectParam,
+  ) {
     this.tx = tx
     this.addressesUsedSubject = addressesUsedSubject
+
+    this.url = url
   }
 
   public check = async (lockHashes: string[]): Promise<string[]> => {
@@ -33,7 +41,10 @@ export default class CheckTx {
     const addresses = await this.check(lockHashes)
     if (addresses.length > 0) {
       await TransactionPersistor.saveFetchTx(this.tx)
-      this.addressesUsedSubject.next(addresses)
+      this.addressesUsedSubject.next({
+        addresses,
+        url: this.url,
+      })
       return true
     }
     return false
diff --git a/packages/neuron-wallet/src/services/sync/get-blocks.ts b/packages/neuron-wallet/src/services/sync/get-blocks.ts
index bc9115447c..cc162cc3f4 100644
--- a/packages/neuron-wallet/src/services/sync/get-blocks.ts
+++ b/packages/neuron-wallet/src/services/sync/get-blocks.ts
@@ -14,10 +14,12 @@ export default class GetBlocks {
   private retryTime: number
   private retryInterval: number
   private core: Core
+  private url: string
 
   constructor(url: string, retryTime: number = 3, retryInterval: number = 100) {
     this.retryTime = retryTime
     this.retryInterval = retryInterval
+    this.url = url
     this.core = generateCore(url)
   }
 
@@ -39,7 +41,7 @@ export default class GetBlocks {
   public checkAndSave = async (blocks: Block[], lockHashes: string[]): Promise<void> => {
     for (const block of blocks) {
       for (const tx of block.transactions) {
-        const checkTx = new CheckTx(tx)
+        const checkTx = new CheckTx(tx, this.url)
         const addresses = await checkTx.check(lockHashes)
         if (addresses.length > 0) {
           for (const input of tx.inputs!) {
@@ -51,7 +53,10 @@ export default class GetBlocks {
             input.capacity = previousOutput.capacity
           }
           await TransactionPersistor.saveFetchTx(tx)
-          addressesUsedSubject.next(addresses)
+          addressesUsedSubject.next({
+            addresses,
+            url: this.url,
+          })
         }
       }
     }
diff --git a/packages/neuron-wallet/src/services/tx/transaction-service.ts b/packages/neuron-wallet/src/services/tx/transaction-service.ts
index ebe924e05c..07ad7cb7ab 100644
--- a/packages/neuron-wallet/src/services/tx/transaction-service.ts
+++ b/packages/neuron-wallet/src/services/tx/transaction-service.ts
@@ -4,6 +4,7 @@ import { Transaction, TransactionWithoutHash, TransactionStatus } from 'types/ce
 import TransactionEntity from 'database/chain/entities/transaction'
 import LockUtils from 'models/lock-utils'
 import { CONNECTION_NOT_FOUND_NAME } from 'database/chain/ormconfig'
+import NodeService from 'services/node'
 
 export interface TransactionsByAddressesParam {
   pageNo: number
@@ -300,8 +301,12 @@ export class TransactionsService {
     return count
   }
 
-  public static getCountByAddressAndStatus = async (address: string, status: TransactionStatus[]): Promise<number> => {
-    const lockHashes: string[] = await LockUtils.addressToAllLockHashes(address)
+  public static getCountByAddressAndStatus = async (
+    address: string,
+    status: TransactionStatus[],
+    url: string = NodeService.getInstance().core.rpc.node.url
+  ): Promise<number> => {
+    const lockHashes: string[] = await LockUtils.addressToAllLockHashes(address, url)
     return TransactionsService.getCountByLockHashesAndStatus(lockHashes, status)
   }
 
diff --git a/packages/neuron-wallet/src/services/wallets.ts b/packages/neuron-wallet/src/services/wallets.ts
index e6b475f018..c125ac2447 100644
--- a/packages/neuron-wallet/src/services/wallets.ts
+++ b/packages/neuron-wallet/src/services/wallets.ts
@@ -403,7 +403,10 @@ export default class WalletService {
     // update addresses txCount and balance
     const blake160s = TransactionsService.blake160sOfTx(tx)
     const usedAddresses = blake160s.map(blake160 => LockUtils.blake160ToAddress(blake160))
-    AddressesUsedSubject.getSubject().next(usedAddresses)
+    AddressesUsedSubject.getSubject().next({
+      addresses: usedAddresses,
+      url: core.rpc.node.url,
+    })
 
     return txHash
   }
diff --git a/packages/neuron-wallet/src/startup/sync-block-task/create.ts b/packages/neuron-wallet/src/startup/sync-block-task/create.ts
index 6e7103815e..868566404c 100644
--- a/packages/neuron-wallet/src/startup/sync-block-task/create.ts
+++ b/packages/neuron-wallet/src/startup/sync-block-task/create.ts
@@ -6,23 +6,38 @@ import { NetworkWithID } from 'types/network'
 import env from 'env'
 import AddressService from 'services/addresses'
 import genesisBlockHash from './genesis'
-import initDatabase from './init-database'
+import InitDatabase from './init-database'
 
 export { genesisBlockHash }
 
-const updateAllAddressesTxCount = async () => {
+const updateAllAddressesTxCount = async (url: string) => {
   const addresses = (await AddressService.allAddresses()).map(addr => addr.address)
-  await AddressService.updateTxCountAndBalances(addresses)
+  await AddressService.updateTxCountAndBalances(addresses, url)
 }
 
-export const databaseInitSubject = new ReplaySubject(1)
+export interface DatabaseInitParams {
+  network: NetworkWithID
+  genesisBlockHash: string
+}
+
+export const databaseInitSubject = new ReplaySubject<DatabaseInitParams>(1)
+
 networkSwitchSubject.subscribe(async (network: NetworkWithID | undefined) => {
   if (network) {
     // TODO: only switch if genesisHash is different
-    await initDatabase()
-    databaseInitSubject.next(network)
-    // re init txCount in addresses if switch network
-    await updateAllAddressesTxCount()
+
+    await InitDatabase.getInstance().stopAndWait()
+    const genesisBlockHash = await InitDatabase.getInstance().init(network.remote)
+
+    if (genesisBlockHash !== 'killed') {
+      const databaseInitParams: DatabaseInitParams = {
+        network,
+        genesisBlockHash,
+      }
+      databaseInitSubject.next(databaseInitParams)
+      // re init txCount in addresses if switch network
+      await updateAllAddressesTxCount(network.remote)
+    }
   }
 })
 
diff --git a/packages/neuron-wallet/src/startup/sync-block-task/genesis.ts b/packages/neuron-wallet/src/startup/sync-block-task/genesis.ts
index be2a275fa1..a7009b05a5 100644
--- a/packages/neuron-wallet/src/startup/sync-block-task/genesis.ts
+++ b/packages/neuron-wallet/src/startup/sync-block-task/genesis.ts
@@ -1,9 +1,8 @@
+import Core from '@nervosnetwork/ckb-sdk-core'
 import Utils from 'services/sync/utils'
-import NodeService from 'services/node'
 
-const { core } = NodeService.getInstance()
-
-export const genesisBlockHash = async () => {
+export const genesisBlockHash = async (url: string) => {
+  const core = new Core(url)
   const hash: string = await Utils.retry(3, 100, async () => {
     const h: string = await core.rpc.getBlockHash('0x0')
     return h
diff --git a/packages/neuron-wallet/src/startup/sync-block-task/indexer.ts b/packages/neuron-wallet/src/startup/sync-block-task/indexer.ts
index f97e028d74..dcfe03641f 100644
--- a/packages/neuron-wallet/src/startup/sync-block-task/indexer.ts
+++ b/packages/neuron-wallet/src/startup/sync-block-task/indexer.ts
@@ -4,30 +4,30 @@ import LockUtils from 'models/lock-utils'
 import IndexerQueue, { LockHashInfo } from 'services/indexer/queue'
 import { Address } from 'database/address/dao'
 
-import { initDatabase } from './init-database'
+import initConnection from 'database/chain/ormconfig'
 
 const { nodeService, addressCreatedSubject, walletCreatedSubject } = remote.require('./startup/sync-block-task/params')
 
 // maybe should call this every time when new address generated
 // load all addresses and convert to lockHashes
-export const loadAddressesAndConvert = async (): Promise<string[]> => {
+export const loadAddressesAndConvert = async (nodeURL: string): Promise<string[]> => {
   const addresses: string[] = (await AddressService.allAddresses()).map(addr => addr.address)
-  const lockHashes: string[] = await LockUtils.addressesToAllLockHashes(addresses)
+  const lockHashes: string[] = await LockUtils.addressesToAllLockHashes(addresses, nodeURL)
   return lockHashes
 }
 
 // call this after network switched
 let indexerQueue: IndexerQueue | undefined
-export const switchNetwork = async (nodeURL: string) => {
+export const switchNetwork = async (nodeURL: string, genesisBlockHash: string) => {
   // stop all blocks service
   if (indexerQueue) {
     await indexerQueue.stopAndWait()
   }
 
   // disconnect old connection and connect to new database
-  await initDatabase()
+  await initConnection(genesisBlockHash)
   // load lockHashes
-  const lockHashes: string[] = await loadAddressesAndConvert()
+  const lockHashes: string[] = await loadAddressesAndConvert(nodeURL)
   const lockHashInfos: LockHashInfo[] = lockHashes.map(lockHash => {
     return {
       lockHash,
@@ -42,7 +42,7 @@ export const switchNetwork = async (nodeURL: string) => {
     if (indexerQueue) {
       const infos: LockHashInfo[] = (await Promise.all(
         addresses.map(async addr => {
-          const hashes: string[] = await LockUtils.addressToAllLockHashes(addr.address)
+          const hashes: string[] = await LockUtils.addressToAllLockHashes(addr.address, nodeURL)
           // undefined means true
           const isImporting: boolean = addr.isImporting !== false
           return hashes.map(h => {
diff --git a/packages/neuron-wallet/src/startup/sync-block-task/init-database.ts b/packages/neuron-wallet/src/startup/sync-block-task/init-database.ts
index 635fd1df81..e9d2079387 100644
--- a/packages/neuron-wallet/src/startup/sync-block-task/init-database.ts
+++ b/packages/neuron-wallet/src/startup/sync-block-task/init-database.ts
@@ -5,28 +5,91 @@ import LockUtils from 'models/lock-utils'
 import logger from 'utils/logger'
 import genesisBlockHash from './genesis'
 
-export const initDatabase = async () => {
-  try {
-    const hash = await genesisBlockHash()
-    await initConnection(hash)
-
-    try {
-      const systemScriptInfo = await LockUtils.systemScript()
-      updateMetaInfo({ genesisBlockHash: hash, systemScriptInfo })
-    } catch (err) {
-      logger.error('update systemScriptInfo failed:', err)
+// only used by main process
+export class InitDatabase {
+  private static instance: InitDatabase
+
+  public static getInstance = () => {
+    if (!InitDatabase.instance) {
+      InitDatabase.instance = new InitDatabase()
+    }
+    return InitDatabase.instance
+  }
+
+  private stopped: boolean = false
+  // private nodeURL: string
+  private inProcess: boolean = false
+
+  private success: boolean = false
+
+  public id: number = +new Date()
+
+  private static previous: InitDatabase | undefined
+
+  private killed: boolean = false
+
+  public init = async (url: string): Promise<string> => {
+    if (InitDatabase.previous) {
+      await InitDatabase.previous.stopAndWait()
+    }
+
+    this.inProcess = true
+
+    let hash: string | undefined
+    while (!this.stopped && !this.success) {
+      try {
+        hash = await genesisBlockHash(url)
+        await initConnection(hash)
+
+        try {
+          const systemScriptInfo = await LockUtils.systemScript(url)
+          updateMetaInfo({ genesisBlockHash: hash, systemScriptInfo })
+        } catch (err) {
+          logger.error('update systemScriptInfo failed:', err)
+        }
+
+        this.success = true
+      } catch (err) {
+        logger.debug('initDatabase error:', err)
+        try {
+          const metaInfo = getMetaInfo()
+          await initConnection(metaInfo.genesisBlockHash)
+          LockUtils.setSystemScript(metaInfo.systemScriptInfo)
+          hash = metaInfo.genesisBlockHash
+          this.success = true
+        } catch (error) {
+          Utils.sleep(5000)
+        }
+      }
     }
-  } catch (err) {
-    logger.debug('initDatabase error:', err)
-    try {
-      const metaInfo = getMetaInfo()
-      await initConnection(metaInfo.genesisBlockHash)
-      LockUtils.setSystemScript(metaInfo.systemScriptInfo)
-    } catch (error) {
-      Utils.sleep(1000)
-      await initDatabase()
+
+    this.inProcess = false
+
+    if (this.killed) {
+      return 'killed'
     }
+
+    return hash!
+  }
+
+  public stopAndWait = async (timeout: number = 10000) => {
+    this.killed = true
+    this.stopped = true
+
+    const startAt: number = +new Date()
+    while (this.inProcess) {
+      const now: number = +new Date()
+      if (now - startAt > timeout) {
+        return
+      }
+      await Utils.sleep(100)
+    }
+
+    this.killed = false
+    this.stopped = false
+    this.success = false
+    this.inProcess = false
   }
 }
 
-export default initDatabase
+export default InitDatabase
diff --git a/packages/neuron-wallet/src/startup/sync-block-task/sync.ts b/packages/neuron-wallet/src/startup/sync-block-task/sync.ts
index b6dd49929d..14c274bfb4 100644
--- a/packages/neuron-wallet/src/startup/sync-block-task/sync.ts
+++ b/packages/neuron-wallet/src/startup/sync-block-task/sync.ts
@@ -4,7 +4,7 @@ import LockUtils from 'models/lock-utils'
 import BlockListener from 'services/sync/block-listener'
 import { Address } from 'database/address/dao'
 
-import { initDatabase } from './init-database'
+import initConnection from 'database/chain/ormconfig'
 
 const { nodeService, addressCreatedSubject, walletCreatedSubject } = remote.require('./startup/sync-block-task/params')
 
@@ -18,24 +18,24 @@ export interface LockHashInfo {
 
 // maybe should call this every time when new address generated
 // load all addresses and convert to lockHashes
-export const loadAddressesAndConvert = async (): Promise<string[]> => {
+export const loadAddressesAndConvert = async (nodeURL: string): Promise<string[]> => {
   const addresses: string[] = (await AddressService.allAddresses()).map(addr => addr.address)
-  const lockHashes: string[] = await LockUtils.addressesToAllLockHashes(addresses)
+  const lockHashes: string[] = await LockUtils.addressesToAllLockHashes(addresses, nodeURL)
   return lockHashes
 }
 
 // call this after network switched
 let blockListener: BlockListener | undefined
-export const switchNetwork = async (url: string) => {
+export const switchNetwork = async (url: string, genesisBlockHash: string) => {
   // stop all blocks service
   if (blockListener) {
     await blockListener.stopAndWait()
   }
 
   // disconnect old connection and connect to new database
-  await initDatabase()
+  await initConnection(genesisBlockHash)
   // load lockHashes
-  const lockHashes: string[] = await loadAddressesAndConvert()
+  const lockHashes: string[] = await loadAddressesAndConvert(url)
   // start sync blocks service
   blockListener = new BlockListener(url, lockHashes, nodeService.tipNumberSubject)
 
@@ -69,7 +69,7 @@ export const switchNetwork = async (url: string) => {
       await blockListener.stopAndWait()
     }
     // wait former queue to be drained
-    const hashes: string[] = await loadAddressesAndConvert()
+    const hashes: string[] = await loadAddressesAndConvert(url)
     blockListener = new BlockListener(url, hashes, nodeService.tipNumberSubject)
     await blockListener.start(true)
   }
diff --git a/packages/neuron-wallet/src/startup/sync-block-task/task.ts b/packages/neuron-wallet/src/startup/sync-block-task/task.ts
index c48c13d6d2..8e38ec0836 100644
--- a/packages/neuron-wallet/src/startup/sync-block-task/task.ts
+++ b/packages/neuron-wallet/src/startup/sync-block-task/task.ts
@@ -1,7 +1,6 @@
 import { remote } from 'electron'
 import { initConnection as initAddressConnection } from 'database/address/ormconfig'
 import AddressesUsedSubject from 'models/subjects/addresses-used-subject'
-import { NetworkWithID } from 'types/network'
 import { register as registerTxStatusListener } from 'listeners/tx-status'
 import { register as registerAddressListener } from 'listeners/address'
 import IndexerRPC from 'services/indexer/indexer-rpc'
@@ -9,6 +8,7 @@ import Utils from 'services/sync/utils'
 
 import { switchNetwork as syncSwitchNetwork } from './sync'
 import { switchNetwork as indexerSwitchNetwork } from './indexer'
+import { DatabaseInitParams } from './create'
 
 // register to listen address updates
 registerAddressListener()
@@ -32,13 +32,14 @@ export const testIndexer = async (url: string): Promise<boolean> => {
 
 export const run = async () => {
   await initAddressConnection()
-  databaseInitSubject.subscribe(async (network: NetworkWithID | undefined) => {
-    if (network) {
+  databaseInitSubject.subscribe(async (params: DatabaseInitParams) => {
+    const { network, genesisBlockHash } = params
+    if (network && genesisBlockHash.startsWith('0x')) {
       const indexerEnabled = await testIndexer(network.remote)
       if (indexerEnabled) {
-        await indexerSwitchNetwork(network.remote)
+        await indexerSwitchNetwork(network.remote, genesisBlockHash)
       } else {
-        await syncSwitchNetwork(network.remote)
+        await syncSwitchNetwork(network.remote, genesisBlockHash)
       }
     }
   })