@bsv/wallet-toolbox 1.1.0

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

@@ -0,0 +1,226 @@
+import {
+  verifyOne,
+  verifyOneOrNone,
+  verifyTruthy,
+  wait,
+  Wallet,
+  WalletStorageManager
+} from '../../../src/index.client'
+import { StorageKnex } from '../../../src/storage/StorageKnex'
+import { _tu, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+
+describe('Wallet sync tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+
+  beforeAll(async () => {})
+
+  afterAll(async () => {})
+
+  test('0 syncToWriter initial-no changes-1 change', async () => {
+    const {
+      identityKey,
+      storage: storageManager,
+      activeStorage: storage
+    } = await _tu.createLegacyWalletSQLiteCopy('walletSyncTest1aSource')
+    const localSQLiteFile = await _tu.newTmpFile(
+      'walleltSyncTest0tmp.sqlite',
+      true,
+      false,
+      false
+    )
+    const knexSQLite = _tu.createLocalSQLite(localSQLiteFile)
+    const tmpStore = new StorageKnex({
+      ...StorageKnex.defaultOptions(),
+      chain: env.chain,
+      knex: knexSQLite
+    })
+    //await tmpStore.dropAllData()
+    await tmpStore.migrate('walletSyncTest0tmp', '1'.repeat(64))
+    const dstSettings = await tmpStore.makeAvailable()
+
+    const srcSettings = await storage.makeAvailable()
+    const manager = new WalletStorageManager(identityKey, storage, [tmpStore])
+
+    const auth = await manager.getAuth()
+    {
+      const r = await manager.syncToWriter(auth, tmpStore)
+      expect(r.inserts).toBeGreaterThan(1000)
+      expect(r.updates).toBe(0)
+    }
+    {
+      const r = await manager.syncToWriter(auth, tmpStore)
+      expect(r.inserts).toBe(0)
+      expect(r.updates).toBe(0)
+    }
+    {
+      _tu.insertTestOutputBasket(storage, auth.userId)
+      await wait(1000)
+      const r = await manager.syncToWriter(auth, tmpStore)
+      expect(r.inserts).toBe(1)
+      expect(r.updates).toBe(0)
+    }
+    await tmpStore.destroy()
+    await storageManager.destroy()
+  })
+
+  test('1a setActive to backup and back to original without backup first', async () => {
+    // wallet will be the original active wallet, a backup is added, then setActive is used to initiate backup in each direction.
+    const ctx = await _tu.createLegacyWalletSQLiteCopy('walletSyncTest1aSource')
+    const { activeStorage: backup, wallet: backupWallet } =
+      await _tu.createSQLiteTestWallet({
+        databaseName: 'walletSyncTest1aBackup',
+        rootKeyHex: ctx.rootKey.toHex(),
+        dropAll: true
+      })
+    await ctx.storage.addWalletStorageProvider(backup)
+
+    await setActiveTwice(ctx, false, backup, backupWallet)
+
+    await setActiveTwice(ctx, false, backup, backupWallet)
+
+    await ctx.storage.destroy()
+  })
+
+  test('1b setActive to backup and back to original with backup first', async () => {
+    // wallet will be the original active wallet, a backup is added, then setActive is used to initiate backup in each direction.
+    const ctx = await _tu.createLegacyWalletSQLiteCopy('walletSyncTest1bSource')
+    const backup = (
+      await _tu.createSQLiteTestWallet({
+        databaseName: 'walletSyncTest1bBackup',
+        dropAll: true
+      })
+    ).activeStorage
+    await ctx.storage.addWalletStorageProvider(backup)
+
+    await setActiveTwice(ctx, true, backup)
+
+    await setActiveTwice(ctx, true, backup)
+
+    await ctx.storage.destroy()
+  })
+})
+
+async function setActiveTwice(
+  ctx: TestWalletNoSetup,
+  withBackupFirst: boolean,
+  backup: StorageKnex,
+  backupWallet?: Wallet
+) {
+  const {
+    storage: storageManager,
+    activeStorage: original,
+    userId: originalUserId
+  } = ctx
+
+  if (withBackupFirst) {
+    await storageManager.updateBackups()
+  }
+
+  const backupIdentityKey = (await backup.makeAvailable()).storageIdentityKey
+  const originalIdentityKey = (await original.makeAvailable())
+    .storageIdentityKey
+  expect(backupIdentityKey).not.toBe(originalIdentityKey)
+
+  const originalAuth = await storageManager.getAuth()
+  expect(originalAuth.userId).toBe(originalUserId)
+  const originalTransactions = await original.findTransactions({
+    partial: { userId: originalAuth.userId }
+  })
+
+  const originalUserBefore = verifyTruthy(
+    await original.findUserById(originalAuth.userId!)
+  )
+  const backupUserBefore = verifyOneOrNone(
+    await backup.findUsers({
+      partial: { identityKey: originalAuth.identityKey }
+    })
+  )
+
+  expect(
+    originalUserBefore.activeStorage === undefined ||
+      originalUserBefore.activeStorage === originalIdentityKey
+  )
+
+  let now = Date.now()
+
+  expect(originalUserBefore.updated_at.getTime()).toBeLessThan(now)
+  expect(!backupUserBefore || backupUserBefore.updated_at.getTime() < now).toBe(
+    true
+  )
+
+  // sync to backup and make it active.
+  await storageManager.setActive(backupIdentityKey)
+
+  let originalUserAfter = verifyTruthy(
+    await original.findUserById(originalAuth.userId!)
+  )
+  let backupUserAfter = verifyOne(
+    await backup.findUsers({
+      partial: { identityKey: originalAuth.identityKey }
+    })
+  )
+
+  expect(originalUserAfter.updated_at.getTime()).toBeGreaterThanOrEqual(now)
+  expect(backupUserAfter.updated_at.getTime()).toBeGreaterThanOrEqual(now)
+  expect(originalUserAfter.activeStorage).toBe(backupIdentityKey)
+  expect(backupUserAfter.activeStorage).toBe(backupIdentityKey)
+
+  await expect(
+    ctx.wallet.relinquishOutput({
+      basket: 'xyzzy',
+      output: `${'1'.repeat(64)}.42`
+    })
+  ).rejects.toThrow('Result must exist and be unique.')
+  if (backupWallet)
+    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({
+    partial: { userId: backupAuth.userId }
+  })
+
+  now = Date.now()
+
+  // sync back to original and make it active.
+  await storageManager.setActive(original.getSettings().storageIdentityKey)
+
+  originalUserAfter = verifyTruthy(
+    await original.findUserById(originalAuth.userId!)
+  )
+  backupUserAfter = verifyOne(
+    await backup.findUsers({
+      partial: { identityKey: originalAuth.identityKey }
+    })
+  )
+
+  expect(originalUserAfter.updated_at.getTime()).toBeGreaterThanOrEqual(now)
+  expect(backupUserAfter.updated_at.getTime()).toBeGreaterThanOrEqual(now)
+  expect(originalUserAfter.activeStorage).toBe(originalIdentityKey)
+  expect(backupUserAfter.activeStorage).toBe(originalIdentityKey)
+
+  await expect(
+    ctx.wallet.relinquishOutput({
+      basket: 'xyzzy',
+      output: `${'1'.repeat(64)}.42`
+    })
+  ).rejects.toThrow('Result must exist and be unique.')
+  if (backupWallet) {
+    expect(backupWallet?.storage.stores.length === 1)
+    expect(backupWallet?.storage.stores[0] === backup)
+    await expect(
+      backupWallet.relinquishOutput({
+        basket: 'xyzzy',
+        output: `${'1'.repeat(64)}.42`
+      })
+    ).rejects.toThrow(
+      `WalletStorageManager is not accessing user's active storage.`
+    )
+  }
+}

package/ts2md.json

@@ -0,0 +1,32 @@
+{
+  "options": [
+    {
+      "inputFilename": "src/index.ts",
+      "outputFilename": "docs/monitor.md",
+      "firstHeadingLevel": 1,
+      "filenameSubString": "monitor"
+    },
+    {
+      "inputFilename": "src/index.ts",
+      "outputFilename": "docs/services.md",
+      "firstHeadingLevel": 1,
+      "filenameSubString": "services"
+    },
+    {
+      "inputFilename": "src/index.ts",
+      "outputFilename": "docs/storage.md",
+      "firstHeadingLevel": 1,
+      "filenameSubString": "storage"
+    },
+    {
+      "inputFilename": "src/index.client.ts",
+      "outputFilename": "docs/client.md",
+      "firstHeadingLevel": 1
+    },
+    {
+      "inputFilename": "src/Wallet.ts",
+      "outputFilename": "docs/wallet.md",
+      "firstHeadingLevel": 1
+    }
+  ]
+}

package/tsconfig.all.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "rootDir": ".", // Include both src and test directories
+    "outDir": "./out",
+    "target": "es2018",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "allowJs": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noImplicitAny": false,
+    "declaration": true,
+    "declarationMap": true,
+    "composite": true,
+    "noImplicitOverride": true
+  },
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ], // Include test files
+  "exclude": [
+    "node_modules",
+    "out",
+    "out-client"
+  ]
+}

package/tsconfig.client.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "rootDir": ".", // Include both src and test directories
+    "outDir": "./client/out",
+    "target": "es2018",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "allowJs": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noImplicitAny": false,
+    "declaration": true,
+    "declarationMap": true,
+    "noImplicitOverride": true
+  },
+  "files": [
+    "src/index.client.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "files": [],
+    "compilerOptions": {
+        "esModuleInterop": true
+    },
+    "references": [
+        {
+            "path": "tsconfig.all.json"
+        },
+        {
+            "path": "tsconfig.client.json"
+        }
+    ]
+}

package/unlock-migrations.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Script to unlock the SQLite database for Knex migrations
+
+# Variables
+DB_FILE="test/data/tmp/updatetest.sqlite"
+KNEXFILE="knexfile.js"
+
+# Check if the SQLite database file exists
+if [ -f "$DB_FILE" ]; then
+  echo "Database file found: $DB_FILE"
+else
+  echo "Error: Database file $DB_FILE not found."
+  exit 1
+fi
+
+# Check if knexfile.js exists
+if [ -f "$KNEXFILE" ]; then
+  echo "Knex configuration file found: $KNEXFILE"
+else
+  echo "Error: Knex configuration file $KNEXFILE not found."
+  exit 1
+fi
+
+# Unlock the migrations
+echo "Attempting to unlock the database migrations..."
+npx knex migrate:unlock --env development
+
+# Check if the unlock was successful
+if [ $? -eq 0 ]; then
+  echo "Database migrations unlocked successfully."
+else
+  echo "Error: Failed to unlock the database migrations."
+  exit 1
+fi
+
+# Optional: Verify the migration status
+echo "Verifying migration status..."
+npx knex migrate:status --env development
+
+# End of script