@bsv/wallet-toolbox 1.1.35 → 1.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.1.35",
+  "version": "1.1.36",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",

package/src/storage/WalletStorageManager.ts

@@ -179,7 +179,7 @@ export class WalletStorageManager implements sdk.WalletStorage {
     let i = -1
     for (const store of this._stores) {
       i++
-      if (!store.isAvailable || !store.settings) {
+      if (!store.isAvailable || !store.settings || !store.user) {
         // Validate all ManagedStorage properties.
         store.settings = await store.storage.makeAvailable()
         const r = await store.storage.findOrInsertUser(this._authId.identityKey)
@@ -633,7 +633,7 @@ export class WalletStorageManager implements sdk.WalletStorage {
 
     log = await this.runAsSync(async sync => {
       const reader = sync
-      const readerSettings = this.getSettings()
+      const readerSettings = reader.getSettings()
 
       log += `syncToWriter from ${readerSettings.storageName} to ${writerSettings.storageName}\n`
 
@@ -697,39 +697,45 @@ export class WalletStorageManager implements sdk.WalletStorage {
 
     let log = `setActive to ${newActive.settings!.storageName}`
 
-    if (newActiveIndex === 0 && this.isActiveEnabled)
+    if (storageIdentityKey === this.getActiveStore() && this.isActiveEnabled)
       /** Setting the current active as the new active is a permitted no-op. */
-      return ` unchanged\n`
+      return log + ` unchanged\n`
 
     log += '\n'
 
     log += await this.runAsSync(async sync => {
       let log = ''
 
-      // Handle case where new active is current active to resolve conflicts.
-      // And where new active is one of the current conflict actives.
-      this._conflictingActives!.push(this._active!)
-      // Remove the new active from conflicting actives and
-      // set new active as the conflicting active that matches the target `storageIdentityKey`
-      this._conflictingActives = this._conflictingActives!.filter(ca => {
-        const isNewActive =
-          ca.settings!.storageIdentityKey === storageIdentityKey
-        if (isNewActive) this._active = ca
-        return !isNewActive
-      })
-
       if (this._conflictingActives!.length > 0) {
-        // Merge state from conflicting actives into `_active`.
+        // Handle case where new active is current active to resolve conflicts.
+        // And where new active is one of the current conflict actives.
+        this._conflictingActives!.push(this._active!)
+        // Remove the new active from conflicting actives and
+        // set new active as the conflicting active that matches the target `storageIdentityKey`
+        this._conflictingActives = this._conflictingActives!.filter(ca => {
+          const isNewActive =
+            ca.settings!.storageIdentityKey === storageIdentityKey
+          return !isNewActive
+        })
+
+        // Merge state from conflicting actives into `newActive`.
         for (const conflict of this._conflictingActives) {
-          const sfr = await this.syncFromReader(
-            identityKey,
-            conflict.storage,
-            newActive.storage
+          const sfr = await this.syncToWriter(
+            { identityKey, userId: newActive.user!.userId, isActive: false },
+            newActive.storage,
+            conflict.storage
           )
           log += sfr.log
         }
       }
 
+      // If there were conflicting actives,
+      // Push state merged from all merged actives into newActive to all stores other than the now single active.
+      // Otherwise,
+      // Push state from current active to all other stores.
+      const backupSource =
+        this._conflictingActives!.length > 0 ? newActive : this._active!
+
       for (const store of this._stores) {
         // Update all store's user records to reflect new active store
         await store.storage.setActive(
@@ -738,12 +744,15 @@ export class WalletStorageManager implements sdk.WalletStorage {
         )
         // Update cached user.activeStorage of all stores
         store.user!.activeStorage = storageIdentityKey
-        // Push state merged from all conflicting actives to all non-active stores.
-        if (store.settings!.storageIdentityKey !== storageIdentityKey) {
+
+        if (
+          store.settings!.storageIdentityKey !==
+          backupSource.settings!.storageIdentityKey
+        ) {
           const stwr = await this.syncToWriter(
             { identityKey, userId: store.user!.userId, isActive: false },
             store.storage,
-            newActive.storage
+            backupSource.storage
           )
           log += stwr.log
         }

package/src/storage/schema/entities/SyncState.ts

@@ -309,7 +309,7 @@ export class EntitySyncState extends EntityBase<TableSyncState> {
   ): sdk.RequestSyncChunkArgs {
     const a: sdk.RequestSyncChunkArgs = {
       identityKey: forIdentityKey,
-      maxRoughSize: maxRoughSize || 20000000,
+      maxRoughSize: maxRoughSize || 10000000,
       maxItems: maxItems || 1000,
       offsets: [],
       since: this.when,

package/test/Wallet/sync/setActive.test.ts

@@ -1,5 +1,7 @@
-import { StorageKnex } from '../../../src'
+import knex from 'knex'
+import { Setup, StorageKnex } from '../../../src'
 import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+import { Database } from 'sqlite3'
 
 describe('setActive tests', () => {
   jest.setTimeout(99999999)
@@ -50,18 +52,96 @@ describe('setActive tests', () => {
     await setup.c.wallet.destroy()
   })
 
-  test('0', async () => {
+  test('0 cycle active over three new sqlite wallets', async () => {
     const s = await _tu.createWalletOnly({
       chain,
       rootKeyHex,
       active: store.a,
       backups: [store.b, store.c]
     })
-    expect(s.storage.isAvailable() === true)
-    expect(s.storage.isActiveEnabled === false)
-    const log = await s.storage.setActive(storeKey.b)
-    console.log(log)
-    expect(s.storage.getActiveStore()).toBe(storeKey.b)
-    expect(s.storage.isActiveEnabled === true)
+    let first: boolean = true
+    for (const active of [storeKey.b, storeKey.c, storeKey.a]) {
+      expect(s.storage.isAvailable() === true)
+      expect(s.storage.isActiveEnabled === !first)
+      const log = await s.storage.setActive(active)
+      console.log(log)
+      expect(s.storage.getActiveStore()).toBe(active)
+      expect(s.storage.isActiveEnabled === true)
+      first = false
+    }
+  })
+
+  test('1 setActive on main storage wallet with local backup', async () => {
+    if (Setup.noEnv('main')) return
+    const env = _tu.getEnv('main')
+    const s = await _tu.createTestWalletWithStorageClient({
+      chain: env.chain,
+      rootKeyHex: env.devKeys[env.identityKey]
+    })
+    const cloudStorageIdentityKey = s.storage.getActiveStore()
+    //const filePath = '/Users/tone/Kz/tone42_backup.sqlite' // env.filePath
+    const filePath = env.filePath
+    if (filePath) {
+      const localStore = (
+        await _tu.createKnexTestWallet({
+          knex: _tu.createLocalSQLite(filePath),
+          databaseName: `sqlite for ${env.identityKey}`,
+          chain: env.chain
+        })
+      ).activeStorage
+      await s.storage.addWalletStorageProvider(localStore)
+      {
+        const log = await s.storage.setActive(cloudStorageIdentityKey)
+        console.log(log)
+      }
+      {
+        const log = await s.storage.setActive(
+          localStore._settings!.storageIdentityKey
+        )
+        console.log(log)
+      }
+      {
+        const log = await s.storage.setActive(cloudStorageIdentityKey)
+        console.log(log)
+      }
+      expect(s.storage.isActiveEnabled)
+    }
+    await s.wallet.destroy()
+  })
+
+  test('2 setActive between two local backups', async () => {
+    if (Setup.noEnv('main')) return
+    const env = _tu.getEnv('main')
+    const s = await _tu.createKnexTestWallet({
+      knex: _tu.createLocalSQLite(env.filePath!),
+      databaseName: `envFilePath for ${env.identityKey}`,
+      chain: env.chain
+    })
+    const envStorageIdentityKey = s.storage.getActiveStore()
+    const filePath = '/Users/tone/Kz/tone42_backup.sqlite'
+    const localStore = (
+      await _tu.createKnexTestWallet({
+        knex: _tu.createLocalSQLite(filePath),
+        databaseName: `sqlite for ${env.identityKey}`,
+        chain: env.chain
+      })
+    ).activeStorage
+    await s.storage.addWalletStorageProvider(localStore)
+    {
+      const log = await s.storage.setActive(envStorageIdentityKey)
+      console.log(log)
+    }
+    {
+      const log = await s.storage.setActive(
+        localStore._settings!.storageIdentityKey
+      )
+      console.log(log)
+    }
+    {
+      const log = await s.storage.setActive(envStorageIdentityKey)
+      console.log(log)
+    }
+    expect(s.storage.isActiveEnabled)
+    await s.wallet.destroy()
   })
 })

package/test/examples/pushdrop.test.ts

@@ -28,11 +28,8 @@ export async function transferPushDrop() {
   // obtain the secrets environment for the testnet network.
   const env = Setup.getEnv('main')
   // setup1 will be the sending wallet using the rootKey associated with identityKey, which is the default.
-  const setup1 = await Setup.createWalletSQLite({
-    env,
-    filePath: env.filePath!,
-    databaseName: 'exists'
-  })
+  const setup1 = await Setup.createWalletClient({ env })
+
   // setup2 will be the receiving wallet using the rootKey associated with identityKey2
   const setup2 = setup1
 
@@ -254,9 +251,7 @@ export async function inputPushDrop(
    */
   const st = car.signableTransaction!
   const beef = Beef.fromBinary(st.tx)
-  const tx = setup.wallet.beef.findAtomicTransaction(
-    beef.txs.slice(-1)[0].txid
-  )!
+  const tx = beef.findAtomicTransaction(beef.txs.slice(-1)[0].txid)!
   tx.inputs[0].unlockingScriptTemplate = unlock
   await tx.sign()
   const unlockingScript = tx.inputs[0].unlockingScript!.toHex()

package/test/utils/TestUtilsWalletStorage.ts

@@ -71,6 +71,10 @@ export interface TuEnv {
   runMySQL: boolean
   runSlowTests: boolean
   logTests: boolean
+  /**
+   * file path to local sqlite file for identityKey
+   */
+  filePath?: string
 }
 
 export abstract class TestUtilsWalletStorage {
@@ -80,6 +84,10 @@ export abstract class TestUtilsWalletStorage {
       (chain === 'main'
         ? process.env.MY_MAIN_IDENTITY
         : process.env.MY_TEST_IDENTITY) || ''
+    const filePath =
+      chain === 'main'
+        ? process.env.MY_MAIN_FILEPATH
+        : process.env.MY_TEST_FILEPATH
     const identityKey2 =
       (chain === 'main'
         ? process.env.MY_MAIN_IDENTITY2
@@ -98,7 +106,8 @@ export abstract class TestUtilsWalletStorage {
       devKeys: JSON.parse(DEV_KEYS) as Record<string, string>,
       runMySQL,
       runSlowTests,
-      logTests
+      logTests,
+      filePath
     }
   }
 

package/test/wallet/sync/Wallet.sync.test.ts

@@ -9,7 +9,7 @@ import {
 import { StorageKnex } from '../../../src/storage/StorageKnex'
 import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
 
-describe.skip('Wallet sync tests', () => {
+describe('Wallet sync tests', () => {
   jest.setTimeout(99999999)
 
   const env = _tu.getEnv('test')
@@ -115,7 +115,11 @@ async function setActiveTwice(
   } = ctx
 
   if (withBackupFirst) {
-    await storageManager.updateBackups()
+    if (storageManager.isActiveEnabled) await storageManager.updateBackups()
+    else
+      await expect(storageManager.updateBackups()).rejects.toThrow(
+        `WalletStorageManager is not accessing user's active storage or there are conflicting active stores configured.`
+      )
   }
 
   const backupIdentityKey = (await backup.makeAvailable()).storageIdentityKey
@@ -123,7 +127,7 @@ async function setActiveTwice(
     .storageIdentityKey
   expect(backupIdentityKey).not.toBe(originalIdentityKey)
 
-  const originalAuth = await storageManager.getAuth()
+  const originalAuth = { ...(await storageManager.getAuth()) }
   expect(originalAuth.userId).toBe(originalUserId)
   const originalTransactions = await original.findTransactions({
     partial: { userId: originalAuth.userId }
@@ -150,8 +154,16 @@ async function setActiveTwice(
     true
   )
 
+  expect(storageManager.getActiveStore()).toBe(originalIdentityKey)
+  expect(storageManager.getActiveUser().activeStorage).toBe(originalIdentityKey)
+
   // sync to backup and make it active.
-  await storageManager.setActive(backupIdentityKey)
+  const log = await storageManager.setActive(backupIdentityKey)
+  console.log(log)
+
+  expect(storageManager.getActiveStore()).toBe(backupIdentityKey)
+  expect(storageManager.getActiveUser().activeStorage).toBe(backupIdentityKey)
+  expect(storageManager.getBackupStores()).toEqual([originalIdentityKey])
 
   let originalUserAfter = verifyTruthy(
     await original.findUserById(originalAuth.userId!)
@@ -173,13 +185,17 @@ async function setActiveTwice(
       output: `${'1'.repeat(64)}.42`
     })
   ).rejects.toThrow('Result must exist and be unique.')
-  if (backupWallet)
+  if (backupWallet) {
+    backupWallet.storage._isAvailable = false
+    backupWallet.storage._active!.user = undefined
+    await backupWallet.storage.makeAvailable()
     await expect(
       backupWallet.relinquishOutput({
         basket: 'xyzzy',
         output: `${'1'.repeat(64)}.42`
       })
     ).rejects.toThrow('Result must exist and be unique.')
+  }
 
   const backupAuth = await storageManager.getAuth()
   const backupTransactions = await backup.findTransactions({
@@ -189,7 +205,10 @@ async function setActiveTwice(
   now = Date.now()
 
   // sync back to original and make it active.
-  await storageManager.setActive(original.getSettings().storageIdentityKey)
+  const log2 = await storageManager.setActive(
+    original.getSettings().storageIdentityKey
+  )
+  console.log(log2)
 
   originalUserAfter = verifyTruthy(
     await original.findUserById(originalAuth.userId!)
@@ -212,13 +231,16 @@ async function setActiveTwice(
     })
   ).rejects.toThrow('Result must exist and be unique.')
   if (backupWallet) {
+    backupWallet.storage._isAvailable = false
+    backupWallet.storage._active!.user = undefined
+    await backupWallet.storage.makeAvailable()
     await expect(
       backupWallet.relinquishOutput({
         basket: 'xyzzy',
         output: `${'1'.repeat(64)}.42`
       })
     ).rejects.toThrow(
-      `WalletStorageManager is not accessing user's active storage.`
+      `WalletStorageManager is not accessing user's active storage or there are conflicting active stores configured.`
     )
   }
 }