feat: assume_valid_target

Author: devchenyan

packages/neuron-wallet/.env

@@ -118,5 +118,4 @@ MULTISIG_CODE_HASH=0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc963
 
 # CKB NODE OPTIONS
 CKB_NODE_ASSUME_VALID_TARGET='0x1381f9e4f70ce521256c4095fa536d11165488171a8a2cbac687f8cf53907afa'
-CKB_NODE_ASSUME_VALID_TARGET_BLOCK_NUMBER=15119157
 CKB_NODE_DATA_SIZE=118

packages/neuron-wallet/src/controllers/sync-api.ts

@@ -1,6 +1,5 @@
 import EventEmiter from 'events'
 import { debounceTime } from 'rxjs/operators'
-import env from '../env'
 import RpcService from '../services/rpc-service'
 import SyncedBlockNumber from '../models/synced-block-number'
 import SyncStateSubject from '../models/subjects/sync-state-subject'
@@ -11,7 +10,6 @@ import { NetworkType } from '../models/network'
 
 const TEN_MINS = 600000
 const MAX_TIP_BLOCK_DELAY = 180000
-const { app } = env
 
 export enum SyncStatus {
   SyncNotStart,
@@ -133,22 +131,16 @@ export default class SyncApiController {
     const currentTimestamp = Date.now()
     const network = NetworksService.getInstance().getCurrent()
     const tipHeader = await new RpcService(network.remote, network.type).getTipHeader()
+    const syncState = await new RpcService(network.remote, network.type).getSyncState()
 
     const { bestKnownBlockNumber, bestKnownBlockTimestamp } = await this.#fetchBestKnownBlockInfo()
     const foundBestKnownBlockNumber = this.#foundBestKnownBlockNumber(bestKnownBlockNumber)
 
     const remainingBlocksToCache = bestKnownBlockNumber - cacheTipNumber
     const remainingBlocksToIndex = bestKnownBlockNumber - indexerTipNumber
-    const setAssumeValidTargetBlockNumber =
-      app.isPackaged &&
-      process.env.CKB_NODE_ASSUME_VALID_TARGET &&
-      process.env.CKB_NODE_ASSUME_VALID_TARGET_BLOCK_NUMBER
-        ? +process.env.CKB_NODE_ASSUME_VALID_TARGET_BLOCK_NUMBER
-        : undefined
+
     const isLookingValidTarget =
-      network.type === NetworkType.Default &&
-      !!setAssumeValidTargetBlockNumber &&
-      bestKnownBlockNumber < setAssumeValidTargetBlockNumber
+      network.type === NetworkType.Default && !syncState.assumeValidTargetReached && syncState.assumeValidTarget
 
     const newSyncState: SyncState = {
       nodeUrl: network.remote,
@@ -162,7 +154,7 @@ export default class SyncApiController {
       estimate: undefined,
       status: SyncStatus.Syncing,
       isLookingValidTarget,
-      validTarget: process.env.CKB_NODE_ASSUME_VALID_TARGET,
+      validTarget: syncState.assumeValidTarget || '0x',
     }
 
     if (foundBestKnownBlockNumber) {

packages/neuron-wallet/src/services/rpc-service.ts

@@ -69,9 +69,14 @@ export default class RpcService {
     })
   }
 
-  public async getSyncState(): Promise<CKBComponents.SyncState> {
+  public async getSyncState(): Promise<
+    CKBComponents.SyncState & {
+      assumeValidTarget: string
+      assumeValidTargetReached: boolean
+    }
+  > {
     const syncState = await this.retry(async () => {
-      return await this.rpc.syncState()
+      return await this.rpc.getSyncState()
     })
     return syncState
   }

packages/neuron-wallet/src/types/rpc.d.ts

@@ -251,6 +251,8 @@ declare namespace RPC {
     txs_fee: string
   }
   export interface SyncState {
+    assume_valid_target: string
+    assume_valid_target_reached: boolean
     best_known_block_number: string
     best_known_block_timestamp: string
     fast_time: string

packages/neuron-wallet/src/utils/ckb-rpc.ts

@@ -118,19 +118,62 @@ const lightRPCProperties: Record<string, Omit<Parameters<CKBRPC['addMethod']>[0]
   },
 }
 
+class Method extends SdkRpcMethod {
+  constructor(node: CKBComponents.Node, options: CKBComponents.Method) {
+    super(node, options, rpcConfig)
+  }
+}
+
 export class FullCKBRPC extends CKBRPC {
+  constructor(url: string, rpcConfig: Partial<RPCConfig>) {
+    super(url, rpcConfig)
+    this.setNode({ url })
+
+    this.getSyncState = new Method(this.node, {
+      name: 'getSyncState',
+      method: 'sync_state',
+      paramsFormatters: [],
+      resultFormatters: (state: {
+        assume_valid_target: string
+        assume_valid_target_reached: boolean
+        best_known_block_number: any
+        best_known_block_timestamp: any
+        fast_time: any
+        ibd: any
+        inflight_blocks_count: any
+        low_time: any
+        normal_time: any
+        orphan_blocks_count: any
+      }) => {
+        if (!state) {
+          return state
+        }
+        return {
+          assumeValidTarget: state.assume_valid_target,
+          assumeValidTargetReached: state.assume_valid_target_reached,
+          bestKnownBlockNumber: state.best_known_block_number,
+          bestKnownBlockTimestamp: state.best_known_block_timestamp,
+          fastTime: state.fast_time,
+          ibd: state.ibd,
+          inflightBlocksCount: state.inflight_blocks_count,
+          lowTime: state.low_time,
+          normalTime: state.normal_time,
+          orphanBlocksCount: state.orphan_blocks_count,
+        }
+      },
+    }).call
+  }
+
   getGenesisBlockHash = async () => {
     return this.getBlockHash('0x0')
   }
 
   getGenesisBlock = async (): Promise<Block> => {
     return this.getBlockByNumber('0x0')
   }
-}
 
-class Method extends SdkRpcMethod {
-  constructor(node: CKBComponents.Node, options: CKBComponents.Method) {
-    super(node, options, rpcConfig)
+  getSyncState = async (): Promise<CKBComponents.SyncState> => {
+    return this.getSyncState()
   }
 }
 
@@ -233,6 +276,14 @@ export class LightRPC extends Base {
     return genesisBlock.header.hash
   }
 
+  getSyncState = async () => {
+    const headerTip = await this.getTipHeader()
+    return {
+      bestKnownBlockNumber: headerTip.number,
+      bestKnownBlockTimestamp: headerTip.timestamp,
+    } as CKBComponents.SyncState
+  }
+
   syncState = async () => {
     const headerTip = await this.getTipHeader()
     return {

packages/neuron-wallet/tests/controllers/sync-api.test.ts

@@ -47,11 +47,6 @@ jest.doMock('models/subjects/networks', () => {
 jest.mock('services/multisig', () => ({
   syncMultisigOutput: () => jest.fn(),
 }))
-jest.mock('env', () => ({
-  app: {
-    isPackaged: true,
-  },
-}))
 
 describe('SyncApiController', () => {
   const emitter = new Emitter()

scripts/update-wallet-env.js

@@ -1,38 +1,9 @@
 const fs = require('node:fs')
 const path = require('node:path')
 
-async function rpcRequest(method, params = []) {
-  const result = await fetch(
-    'https://mainnet.ckb.dev/rpc',
-    {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        id: 0,
-        jsonrpc: '2.0',
-        method,
-        params,
-      }),
-      timeout: 10000,
-    }
-  )
-  return result.json()
-}
-
-const ESTIMATE_BLOCK_COUNT_PER_DAY = 8_000
 const envFilePath = path.resolve(__dirname, '../packages/neuron-wallet/.env')
-const validTargetReg = /(CKB_NODE_ASSUME_VALID_TARGET=)[\S]*/
-const blockNumberReg = /(CKB_NODE_ASSUME_VALID_TARGET_BLOCK_NUMBER=)[\S]*/
 const ckbNodeDataSizeReg = /(CKB_NODE_DATA_SIZE=)[\S]*/
 
-async function getValidTarget() {
-  const tipBlockNumber = (await rpcRequest('get_tip_block_number')).result
-  const validTargetBlockNumber = `0x${(BigInt(tipBlockNumber) - BigInt(ESTIMATE_BLOCK_COUNT_PER_DAY)).toString(16)}`
-  return [validTargetBlockNumber, (await rpcRequest('get_block_hash', [validTargetBlockNumber])).result]
-}
-
 async function getCKBNodeSize() {
   const res = await fetch('https://ckb-node-info.magickbase.com/api')
   const { data_size_g } = await res.json()
@@ -42,14 +13,11 @@ async function getCKBNodeSize() {
 ;(async function () {
   try {
     console.info('start updating env file')
-    const [blockNumber, blockHash] = await getValidTarget()
     const ckbNodeDataSize = await getCKBNodeSize()
     const originEnvContent = fs.readFileSync(envFilePath).toString('utf-8')
     fs.writeFileSync(
       envFilePath,
-      originEnvContent.replace(validTargetReg, `CKB_NODE_ASSUME_VALID_TARGET='${blockHash}'`)
-        .replace(blockNumberReg, `CKB_NODE_ASSUME_VALID_TARGET_BLOCK_NUMBER=${+blockNumber}`)
-        .replace(ckbNodeDataSizeReg, `CKB_NODE_DATA_SIZE=${ckbNodeDataSize}`)
+      originEnvContent.replace(ckbNodeDataSizeReg, `CKB_NODE_DATA_SIZE=${ckbNodeDataSize}`)
     )
     console.info('write success')
   } catch (error) {