Bump sdk to v0.20.0

packages/neuron-ui/package.json

@@ -43,7 +43,7 @@
     "last 2 chrome versions"
   ],
   "dependencies": {
-    "@nervosnetwork/ckb-sdk-core": "0.19.1",
+    "@nervosnetwork/ckb-sdk-core": "0.20.0",
     "@uifabric/experiments": "7.10.0",
     "@uifabric/styling": "7.4.0",
     "canvg": "2.0.0",

packages/neuron-wallet/package.json

@@ -34,8 +34,8 @@
     ]
   },
   "dependencies": {
-    "@nervosnetwork/ckb-sdk-core": "0.19.1",
-    "@nervosnetwork/ckb-sdk-utils": "0.19.1",
+    "@nervosnetwork/ckb-sdk-core": "0.20.0",
+    "@nervosnetwork/ckb-sdk-utils": "0.20.0",
     "bn.js": "4.11.8",
     "chalk": "2.4.2",
     "electron-log": "3.0.7",
@@ -51,7 +51,7 @@
     "uuid": "3.3.2"
   },
   "devDependencies": {
-    "@nervosnetwork/ckb-types": "0.19.1",
+    "@nervosnetwork/ckb-types": "0.20.0",
     "@types/electron-devtools-installer": "2.2.0",
     "@types/elliptic": "6.4.8",
     "@types/sqlite3": "3.1.5",

packages/neuron-wallet/src/models/lock-utils.ts

@@ -1,3 +1,4 @@
+import { scriptToHash } from '@nervosnetwork/ckb-sdk-utils'
 import NodeService from 'services/node'
 import { OutPoint, Script, ScriptHashType } from 'types/cell-types'
 import env from 'env'
@@ -65,17 +66,17 @@ export default class LockUtils {
     SystemScriptSubject.next({ codeHash: info.codeHash })
   }
 
-  static computeScriptHash = async (script: Script): Promise<string> => {
+  static computeScriptHash = (script: Script): string => {
     const ckbScript: CKBComponents.Script = ConvertTo.toSdkScript(script)
-    const hash: string = await (core.rpc as any).computeScriptHash(ckbScript)
+    const hash: string = scriptToHash(ckbScript)
     if (!hash.startsWith('0x')) {
       return `0x${hash}`
     }
     return hash
   }
 
   // use SDK lockScriptToHash
-  static lockScriptToHash = async (lock: Script) => {
+  static lockScriptToHash = (lock: Script) => {
     return LockUtils.computeScriptHash(lock)
   }
 
@@ -92,7 +93,7 @@ export default class LockUtils {
 
   static async addressToLockHash(address: string, hashType: ScriptHashType = ScriptHashType.Type): Promise<string> {
     const lock: Script = await this.addressToLockScript(address, hashType)
-    const lockHash: string = await this.lockScriptToHash(lock)
+    const lockHash: string = this.lockScriptToHash(lock)
 
     return lockHash
   }

packages/neuron-wallet/src/services/cells.ts

@@ -83,7 +83,7 @@ export default class CellsService {
     }
 
     const queryParams = {
-      lockHashes: In(lockHashes),
+      lockHash: In(lockHashes),
       status: OutputStatus.Live,
     }
     const skipDataAndType = SkipDataAndType.getInstance().get()

packages/neuron-wallet/src/services/sync/check-and-save/output.ts

@@ -6,20 +6,19 @@ export default class CheckOutput {
 
   constructor(output: Cell) {
     this.output = output
-    // this.calcLockHash()
+    this.calcLockHash()
   }
 
-  public calcLockHash = async (): Promise<Cell> => {
+  public calcLockHash = (): Cell => {
     if (this.output.lockHash) {
       return this.output
     }
 
-    this.output.lockHash = await LockUtils.lockScriptToHash(this.output.lock)
+    this.output.lockHash = LockUtils.lockScriptToHash(this.output.lock)
     return this.output
   }
 
   public checkLockHash = async (lockHashList: string[]): Promise<boolean | undefined> => {
-    await this.calcLockHash()
     return lockHashList.includes(this.output.lockHash!)
   }
 }

packages/neuron-wallet/src/services/tx/transaction-persistor.ts

@@ -185,13 +185,11 @@ export class TransactionPersistor {
     saveType: TxSaveType
   ): Promise<TransactionEntity> => {
     const tx: Transaction = transaction
-    tx.outputs = await Promise.all(
-      tx.outputs!.map(async o => {
-        const output = o
-        output.lockHash = await LockUtils.lockScriptToHash(output.lock!)
-        return output
-      })
-    )
+    tx.outputs = tx.outputs!.map(o => {
+      const output = o
+      output.lockHash = LockUtils.lockScriptToHash(output.lock!)
+      return output
+    })
 
     tx.inputs = await Promise.all(
       tx.inputs!.map(async i => {

packages/neuron-wallet/src/services/wallets.ts

@@ -345,7 +345,10 @@ export default class WalletService {
       fee
     )
 
-    const txHash: string = await (core.rpc as any).computeTransactionHash(ConvertTo.toSdkTxWithoutHash(tx))
+    let txHash: string = core.utils.rawTransactionToHash(ConvertTo.toSdkTxWithoutHash(tx))
+    if (!txHash.startsWith('0x')) {
+      txHash = `0x${txHash}`
+    }
 
     const { inputs } = tx
 

packages/neuron-wallet/src/types/convert-to.ts

@@ -21,7 +21,7 @@ export default class ConvertTo {
     }
   }
 
-  public static toSdkTxWithoutHash = (tx: TransactionWithoutHash): any => {
+  public static toSdkTxWithoutHash = (tx: TransactionWithoutHash): CKBComponents.RawTransaction => {
     const transaction = {
       ...tx,
       inputs: tx.inputs!.map(input => ConvertTo.toSdkInput(input)),

packages/neuron-wallet/tests/models/lock-utils.test.ts

@@ -3,42 +3,41 @@ import LockUtils from '../../src/models/lock-utils'
 
 const systemScript = {
   outPoint: {
-    txHash: '0xc640423e9c8f53855a471c66e3d915fee4f653ac7f7e82033139d25df2ad9aad',
+    txHash: '0x74e34a76d68f5ed864c0ad139a82461ee809e981939cd9cfcd92ac0fdbb1114b',
     index: '0',
   },
-  codeHash: '0x68d5438ac952d2f584abf879527946a537e82c7f3c1cbf6d8ebf9767437d8e88',
+  codeHash: '0x1892ea40d82b53c678ff88312450bbb17e164d7a3e0a90941aa58839f56f8df2',
   hashType: ScriptHashType.Type,
 }
 
 describe('LockUtils Test', () => {
   const bob = {
     lockScript: {
-      codeHash: '0x68d5438ac952d2f584abf879527946a537e82c7f3c1cbf6d8ebf9767437d8e88',
+      codeHash: '0x1892ea40d82b53c678ff88312450bbb17e164d7a3e0a90941aa58839f56f8df2',
       args: ['0x36c329ed630d6ce750712a477543672adab57f4c'],
       hashType: ScriptHashType.Type,
     },
-    lockHash: '0x024b0fd0c4912e98aab6808f6474cacb1969255d526b3cac5d3bdd15962a8818',
+    lockHash: '0xecaeea8c8581d08a3b52980272001dbf203bc6fa2afcabe7cc90cc2afff488ba',
     address: 'ckt1qyqrdsefa43s6m882pcj53m4gdnj4k440axqswmu83',
     blake160: '0x36c329ed630d6ce750712a477543672adab57f4c',
   }
 
-  // const alice = {
-  //   lockScript: {
-  //     codeHash: '0x68d5438ac952d2f584abf879527946a537e82c7f3c1cbf6d8ebf9767437d8e88',
-  //     args: ['0xe2193df51d78411601796b35b17b4f8f2cd85bd0'],
-  //     hashType: ScriptHashType.Type,
-  //   },
-  //   lockHash: '0xf7173d209ce5773a6395735288a53b7182da4a8b0aa4718123208acf37a95196',
-  //   address: 'ckt1qyqwyxfa75whssgkq9ukkdd30d8c7txct0gqfvmy2v',
-  //   blake160: '0xe2193df51d78411601796b35b17b4f8f2cd85bd0',
-  // }
+  const alice = {
+    lockScript: {
+      codeHash: '0x1892ea40d82b53c678ff88312450bbb17e164d7a3e0a90941aa58839f56f8df2',
+      args: ['0xe2193df51d78411601796b35b17b4f8f2cd85bd0'],
+      hashType: ScriptHashType.Type,
+    },
+    lockHash: '0x489306d801d54bee2d8562ae20fdc53635b568f8107bddff15bb357f520cc02c',
+    address: 'ckt1qyqwyxfa75whssgkq9ukkdd30d8c7txct0gqfvmy2v',
+    blake160: '0xe2193df51d78411601796b35b17b4f8f2cd85bd0',
+  }
 
-  // TODO: it need network and node
-  // it('lockScriptToHash', async () => {
-  //   const lockHash: string = await LockUtils.lockScriptToHash(bob.lockScript)
+  it('lockScriptToHash', async () => {
+    const lockHash: string = await LockUtils.lockScriptToHash(bob.lockScript)
 
-  //   expect(lockHash).toEqual(bob.lockHash)
-  // })
+    expect(lockHash).toEqual(bob.lockHash)
+  })
 
   // FIXME: test failed, should fix addressToLockScript
   it('addressToLockScript', async () => {
@@ -51,38 +50,37 @@ describe('LockUtils Test', () => {
     expect(lockScript).toEqual(bob.lockScript)
   })
 
-  // TODO: it need network and node
-  // it('addressToLockHash', async () => {
-  //   const mockContractInfo = jest.fn()
-  //   mockContractInfo.mockReturnValue(systemScript)
-  //   LockUtils.systemScript = mockContractInfo.bind(LockUtils)
+  it('addressToLockHash', async () => {
+    const mockContractInfo = jest.fn()
+    mockContractInfo.mockReturnValue(systemScript)
+    LockUtils.systemScript = mockContractInfo.bind(LockUtils)
 
-  //   const lockHash: string = await LockUtils.addressToLockHash(bob.address)
+    const lockHash: string = await LockUtils.addressToLockHash(bob.address)
 
-  //   expect(lockHash).toEqual(bob.lockHash)
-  // })
+    expect(lockHash).toEqual(bob.lockHash)
+  })
 
-  // it('addressToAllLockHashes', async () => {
-  //   const mockContractInfo = jest.fn()
-  //   mockContractInfo.mockReturnValue(systemScript)
-  //   LockUtils.systemScript = mockContractInfo.bind(LockUtils)
+  it('addressToAllLockHashes', async () => {
+    const mockContractInfo = jest.fn()
+    mockContractInfo.mockReturnValue(systemScript)
+    LockUtils.systemScript = mockContractInfo.bind(LockUtils)
 
-  //   const lockHashes: string[] = await LockUtils.addressToAllLockHashes(bob.address)
+    const lockHashes: string[] = await LockUtils.addressToAllLockHashes(bob.address)
 
-  //   expect(lockHashes).toEqual([bob.lockHash])
-  // })
+    expect(lockHashes).toEqual([bob.lockHash])
+  })
 
-  // it('addressesToAllLockHashes', async () => {
-  //   const mockContractInfo = jest.fn()
-  //   mockContractInfo.mockReturnValue(systemScript)
-  //   LockUtils.systemScript = mockContractInfo.bind(LockUtils)
+  it('addressesToAllLockHashes', async () => {
+    const mockContractInfo = jest.fn()
+    mockContractInfo.mockReturnValue(systemScript)
+    LockUtils.systemScript = mockContractInfo.bind(LockUtils)
 
-  //   const lockHashes: string[] = await LockUtils.addressesToAllLockHashes([bob.address, alice.address])
+    const lockHashes: string[] = await LockUtils.addressesToAllLockHashes([bob.address, alice.address])
 
-  //   const expectedResult = [bob.lockHash, alice.lockHash]
+    const expectedResult = [bob.lockHash, alice.lockHash]
 
-  //   expect(lockHashes).toEqual(expectedResult)
-  // })
+    expect(lockHashes).toEqual(expectedResult)
+  })
 
   it('lockScriptToAddress', async () => {
     const address: string = LockUtils.lockScriptToAddress(bob.lockScript)

packages/neuron-wallet/tests/services/cells.test.ts

@@ -31,31 +31,54 @@ describe('CellsService', () => {
 
   const bob = {
     lockScript: {
-      codeHash: '0x68d5438ac952d2f584abf879527946a537e82c7f3c1cbf6d8ebf9767437d8e88',
+      codeHash: '0x1892ea40d82b53c678ff88312450bbb17e164d7a3e0a90941aa58839f56f8df2',
       args: ['0x36c329ed630d6ce750712a477543672adab57f4c'],
       hashType: ScriptHashType.Type,
     },
-    lockHash: '0x024b0fd0c4912e98aab6808f6474cacb1969255d526b3cac5d3bdd15962a8818',
+    lockHash: '0xecaeea8c8581d08a3b52980272001dbf203bc6fa2afcabe7cc90cc2afff488ba',
     address: 'ckt1qyqrdsefa43s6m882pcj53m4gdnj4k440axqswmu83',
     blake160: '0x36c329ed630d6ce750712a477543672adab57f4c',
   }
 
-  const generateCell = (capacity: string, status: OutputStatus, hasData: boolean, typeScript: Script | null) => {
+  const alice = {
+    lockScript: {
+      codeHash: '0x1892ea40d82b53c678ff88312450bbb17e164d7a3e0a90941aa58839f56f8df2',
+      args: ['0xe2193df51d78411601796b35b17b4f8f2cd85bd0'],
+      hashType: ScriptHashType.Type,
+    },
+    lockHash: '0x489306d801d54bee2d8562ae20fdc53635b568f8107bddff15bb357f520cc02c',
+    address: 'ckt1qyqwyxfa75whssgkq9ukkdd30d8c7txct0gqfvmy2v',
+    blake160: '0xe2193df51d78411601796b35b17b4f8f2cd85bd0',
+  }
+
+  const generateCell = (
+    capacity: string,
+    status: OutputStatus,
+    hasData: boolean,
+    typeScript: Script | null,
+    who: any = bob
+  ) => {
     const output = new OutputEntity()
     output.outPointTxHash = randomHex()
     output.outPointIndex = '0'
     output.capacity = capacity
-    output.lock = bob.lockScript
-    output.lockHash = bob.lockHash
+    output.lock = who.lockScript
+    output.lockHash = who.lockHash
     output.status = status
     output.hasData = hasData
     output.typeScript = typeScript
 
     return output
   }
 
-  const createCell = async (capacity: string, status: OutputStatus, hasData: boolean, typeScript: Script | null) => {
-    const cell = generateCell(capacity, status, hasData, typeScript)
+  const createCell = async (
+    capacity: string,
+    status: OutputStatus,
+    hasData: boolean,
+    typeScript: Script | null,
+    who: any = bob
+  ) => {
+    const cell = generateCell(capacity, status, hasData, typeScript, who)
     await getConnection().manager.save(cell)
     return cell
   }
@@ -89,8 +112,6 @@ describe('CellsService', () => {
     expect(blake160s).toEqual([bob.blake160])
   })
 
-
-
   const lockHashes = [bob.lockHash]
 
   describe('getBalance', () => {
@@ -139,6 +160,22 @@ describe('CellsService', () => {
       const balance: string = await CellsService.getBalance(lockHashes, OutputStatus.Pending, false)
       expect(balance).toEqual('33300')
     })
+
+    it('getBalance with alice', async () => {
+      await createCells()
+      await createCell('2222', OutputStatus.Live, false, null, alice)
+
+      const balance: string = await CellsService.getBalance([alice.lockHash, bob.lockHash], OutputStatus.Live, true)
+      expect(balance).toEqual((100 + 2222).toString())
+    })
+
+    it(`get alice's balance`, async () => {
+      await createCells()
+      await createCell('2222', OutputStatus.Live, false, null, alice)
+
+      const balance: string = await CellsService.getBalance([alice.lockHash], OutputStatus.Live, true)
+      expect(balance).toEqual('2222')
+    })
   })
 
   describe('gatherInputs', () => {
@@ -197,5 +234,30 @@ describe('CellsService', () => {
       }
       expect(error).toBeInstanceOf(CapacityNotEnough)
     })
+
+    it(`bob's and alice's cells`, async () => {
+      SkipDataAndType.getInstance().update(true)
+      await createCells()
+      await createCell(toShannon('5000'), OutputStatus.Live, false, null, alice)
+
+      const result = await CellsService.gatherInputs(toShannon('6000'), [alice.lockHash, bob.lockHash])
+
+      expect(result.capacities).toEqual('600000000000')
+    })
+
+    it(`only bob's cells`, async () => {
+      SkipDataAndType.getInstance().update(true)
+      await createCells()
+      await createCell(toShannon('5000'), OutputStatus.Live, false, null, alice)
+
+      let error
+      try {
+        await CellsService.gatherInputs(toShannon('1001'), [bob.lockHash])
+      } catch (e) {
+        error = e
+      }
+
+      expect(error).toBeInstanceOf(CapacityNotEnough)
+    })
   })
 })