@bsv/wallet-toolbox 1.1.6 → 1.1.8

package/src/storage/sync/StorageMySQLDojoReader.ts

@@ -12,7 +12,26 @@ import {
   verifyOptionalHexString,
   verifyTruthy
 } from '../../index.all'
-import { table } from '../index.all'
+import {
+  outputColumnsWithoutLockingScript,
+  TableCertificate,
+  TableCertificateField,
+  TableCommission,
+  TableMonitorEvent,
+  TableOutput,
+  TableOutputBasket,
+  TableOutputTag,
+  TableOutputTagMap,
+  TableProvenTx,
+  TableProvenTxReq,
+  TableSettings,
+  TableSyncState,
+  TableTransaction,
+  TableTxLabel,
+  TableTxLabelMap,
+  TableUser,
+  transactionColumnsWithoutRawTx
+} from '../index.all'
 
 import { Knex } from 'knex'
 import { isHexString } from '../../sdk'
@@ -59,9 +78,9 @@ export class StorageMySQLDojoReader extends StorageReader {
     return db
   }
 
-  override async readSettings(trx?: sdk.TrxToken): Promise<table.Settings> {
+  override async readSettings(trx?: sdk.TrxToken): Promise<TableSettings> {
     const d = verifyOne(await this.toDb(trx)('settings'))
-    const r: table.Settings = {
+    const r: TableSettings = {
       created_at: verifyTruthy(d.created_at),
       updated_at: verifyTruthy(d.updated_at),
       storageIdentityKey: verifyHexString(d.dojoIdentityKey),
@@ -100,12 +119,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   async findOutputBaskets(
     args: sdk.FindOutputBasketsArgs
-  ): Promise<table.OutputBasket[]> {
+  ): Promise<TableOutputBasket[]> {
     const q = this.findOutputBasketsQuery(args)
     const ds = await q
-    const rs: table.OutputBasket[] = []
+    const rs: TableOutputBasket[] = []
     for (const d of ds) {
-      const r: table.OutputBasket = {
+      const r: TableOutputBasket = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         basketId: verifyInteger(d.basketId),
@@ -122,12 +141,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   findTxLabelsQuery(args: sdk.FindTxLabelsArgs): Knex.QueryBuilder {
     return this.setupQuery('tx_labels', args)
   }
-  async findTxLabels(args: sdk.FindTxLabelsArgs): Promise<table.TxLabel[]> {
+  async findTxLabels(args: sdk.FindTxLabelsArgs): Promise<TableTxLabel[]> {
     const q = this.findTxLabelsQuery(args)
     const ds = await q
-    const rs: table.TxLabel[] = []
+    const rs: TableTxLabel[] = []
     for (const d of ds) {
-      const r: table.TxLabel = {
+      const r: TableTxLabel = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         txLabelId: verifyInteger(d.txLabelId),
@@ -144,12 +163,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   async findOutputTags(
     args: sdk.FindOutputTagsArgs
-  ): Promise<table.OutputTag[]> {
+  ): Promise<TableOutputTag[]> {
     const q = this.findOutputTagsQuery(args)
     const ds = await q
-    const rs: table.OutputTag[] = []
+    const rs: TableOutputTag[] = []
     for (const d of ds) {
-      const r: table.OutputTag = {
+      const r: TableOutputTag = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         outputTagId: verifyInteger(d.outputTagId),
@@ -178,7 +197,7 @@ export class StorageMySQLDojoReader extends StorageReader {
     const q = this.setupQuery('transactions', args)
     if (args.status && args.status.length > 0) q.whereIn('status', args.status)
     if (args.noRawTx && !count) {
-      const columns = table.transactionColumnsWithoutRawTx.map(
+      const columns = transactionColumnsWithoutRawTx.map(
         c => `transactions.${c}`
       )
       q.select(columns)
@@ -187,12 +206,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   async findTransactions(
     args: sdk.FindTransactionsArgs
-  ): Promise<table.Transaction[]> {
+  ): Promise<TableTransaction[]> {
     const q = this.findTransactionsQuery(args)
     const ds = await q
-    const rs: table.Transaction[] = []
+    const rs: TableTransaction[] = []
     for (const d of ds) {
-      const r: table.Transaction = {
+      const r: TableTransaction = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         transactionId: verifyInteger(d.transactionId),
@@ -223,12 +242,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   async findCommissions(
     args: sdk.FindCommissionsArgs
-  ): Promise<table.Commission[]> {
+  ): Promise<TableCommission[]> {
     const q = this.findCommissionsQuery(args)
     const ds = await q
-    const rs: table.Commission[] = []
+    const rs: TableCommission[] = []
     for (const d of ds) {
-      const r: table.Commission = {
+      const r: TableCommission = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         commissionId: verifyInteger(d.commissionId),
@@ -258,19 +277,17 @@ export class StorageMySQLDojoReader extends StorageReader {
       )
     const q = this.setupQuery('outputs', args)
     if (args.noScript && !count) {
-      const columns = table.outputColumnsWithoutLockingScript.map(
-        c => `outputs.${c}`
-      )
+      const columns = outputColumnsWithoutLockingScript.map(c => `outputs.${c}`)
       q.select(columns)
     }
     return q
   }
-  async findOutputs(args: sdk.FindOutputsArgs): Promise<table.Output[]> {
+  async findOutputs(args: sdk.FindOutputsArgs): Promise<TableOutput[]> {
     const q = this.findOutputsQuery(args)
     const ds = await q
-    const rs: table.Output[] = []
+    const rs: TableOutput[] = []
     for (const d of ds) {
-      const r: table.Output = {
+      const r: TableOutput = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         outputId: verifyInteger(d.outputId),
@@ -315,12 +332,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   async findCertificates(
     args: sdk.FindCertificatesArgs
-  ): Promise<table.Certificate[]> {
+  ): Promise<TableCertificate[]> {
     const q = this.findCertificatesQuery(args)
     const ds = await q
-    const rs: table.Certificate[] = []
+    const rs: TableCertificate[] = []
     for (const d of ds) {
-      const r: table.Certificate = {
+      const r: TableCertificate = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         certificateId: verifyInteger(d.certificateId),
@@ -347,12 +364,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   async findCertificateFields(
     args: sdk.FindCertificateFieldsArgs
-  ): Promise<table.CertificateField[]> {
+  ): Promise<TableCertificateField[]> {
     const q = this.findCertificateFieldsQuery(args)
     const ds = await q
-    const rs: table.CertificateField[] = []
+    const rs: TableCertificateField[] = []
     for (const d of ds) {
-      const r: table.CertificateField = {
+      const r: TableCertificateField = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         userId: verifyInteger(d.userId),
@@ -367,12 +384,12 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   override async findSyncStates(
     args: sdk.FindSyncStatesArgs
-  ): Promise<table.SyncState[]> {
+  ): Promise<TableSyncState[]> {
     const q = this.setupQuery('sync_state', args)
     const ds = await q
-    const rs: table.SyncState[] = []
+    const rs: TableSyncState[] = []
     for (const d of ds) {
-      const r: table.SyncState = {
+      const r: TableSyncState = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         syncStateId: verifyInteger(d.syncStateId),
@@ -394,12 +411,12 @@ export class StorageMySQLDojoReader extends StorageReader {
     }
     return this.validateEntities(rs, undefined, ['init'])
   }
-  override async findUsers(args: sdk.FindUsersArgs): Promise<table.User[]> {
+  override async findUsers(args: sdk.FindUsersArgs): Promise<TableUser[]> {
     const q = this.setupQuery('users', args)
     const ds = await q
-    const rs: table.User[] = []
+    const rs: TableUser[] = []
     for (const d of ds) {
-      const r: table.User = {
+      const r: TableUser = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         userId: verifyId(d.userId),
@@ -433,10 +450,10 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   async getProvenTxsForUser(
     args: sdk.FindForUserSincePagedArgs
-  ): Promise<table.ProvenTx[]> {
+  ): Promise<TableProvenTx[]> {
     const q = this.getProvenTxsForUserQuery(args)
     const ds = await q
-    const rs: table.ProvenTx[] = []
+    const rs: TableProvenTx[] = []
     for (const d of ds) {
       const mp = convertProofToMerklePath(d.txid, {
         index: d.index,
@@ -444,7 +461,7 @@ export class StorageMySQLDojoReader extends StorageReader {
         height: d.height
       })
 
-      const r: table.ProvenTx = {
+      const r: TableProvenTx = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         provenTxId: verifyInteger(d.provenTxId),
@@ -486,12 +503,12 @@ export class StorageMySQLDojoReader extends StorageReader {
 
   async getProvenTxReqsForUser(
     args: sdk.FindForUserSincePagedArgs
-  ): Promise<table.ProvenTxReq[]> {
+  ): Promise<TableProvenTxReq[]> {
     const q = this.getProvenTxReqsForUserQuery(args)
     const ds = await q
-    const rs: table.ProvenTxReq[] = []
+    const rs: TableProvenTxReq[] = []
     for (const d of ds) {
-      const r: table.ProvenTxReq = {
+      const r: TableProvenTxReq = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         provenTxReqId: verifyInteger(d.provenTxReqId),
@@ -534,12 +551,12 @@ export class StorageMySQLDojoReader extends StorageReader {
 
   async getTxLabelMapsForUser(
     args: sdk.FindForUserSincePagedArgs
-  ): Promise<table.TxLabelMap[]> {
+  ): Promise<TableTxLabelMap[]> {
     const q = this.getTxLabelMapsForUserQuery(args)
     const ds = await q
-    const rs: table.TxLabelMap[] = []
+    const rs: TableTxLabelMap[] = []
     for (const d of ds) {
-      const r: table.TxLabelMap = {
+      const r: TableTxLabelMap = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         txLabelId: verifyInteger(d.txLabelId),
@@ -574,12 +591,12 @@ export class StorageMySQLDojoReader extends StorageReader {
 
   async getOutputTagMapsForUser(
     args: sdk.FindForUserSincePagedArgs
-  ): Promise<table.OutputTagMap[]> {
+  ): Promise<TableOutputTagMap[]> {
     const q = this.getOutputTagMapsForUserQuery(args)
     const ds = await q
-    const rs: table.OutputTagMap[] = []
+    const rs: TableOutputTagMap[] = []
     for (const d of ds) {
-      const r: table.OutputTagMap = {
+      const r: TableOutputTagMap = {
         created_at: verifyTruthy(d.created_at),
         updated_at: verifyTruthy(d.updated_at),
         outputId: verifyInteger(d.outputId),
@@ -627,7 +644,7 @@ export class StorageMySQLDojoReader extends StorageReader {
   }
   override findMonitorEvents(
     args: sdk.FindMonitorEventsArgs
-  ): Promise<table.MonitorEvent[]> {
+  ): Promise<TableMonitorEvent[]> {
     throw new Error('Method not implemented.')
   }
   override countMonitorEvents(

package/test/Wallet/certificate/listCertificates.test.ts

@@ -1,7 +1,11 @@
 import { OriginatorDomainNameStringUnder250Bytes } from '@bsv/sdk'
 import { listCertificates } from '../../../src/storage/methods/listCertificates'
 import { StorageProvider } from '../../../src/storage/StorageProvider'
-import { sdk, table } from '../../../src/index.all'
+import {
+  sdk,
+  TableCertificate,
+  TableCertificateField
+} from '../../../src/index.all'
 import { TrxToken } from '../../../src/sdk'
 
 jest.mock('../../../src/storage/StorageProvider')
@@ -78,7 +82,7 @@ describe('listCertificates', () => {
 
   test('should return exactly the number of certificates if they are fewer than the limit', async () => {
     // Suppose we have 2 certificates
-    const fakeCerts: table.Certificate[] = [
+    const fakeCerts: TableCertificate[] = [
       {
         certificateId: 1,
         userId: 123,
@@ -110,7 +114,7 @@ describe('listCertificates', () => {
     ]
 
     // Suppose each cert has some fields
-    const fakeFieldsForCert1: table.CertificateField[] = [
+    const fakeFieldsForCert1: TableCertificateField[] = [
       {
         certificateId: 1,
         userId: 123,
@@ -122,7 +126,7 @@ describe('listCertificates', () => {
       }
     ]
 
-    const fakeFieldsForCert2: table.CertificateField[] = [
+    const fakeFieldsForCert2: TableCertificateField[] = [
       {
         certificateId: 2,
         userId: 123,
@@ -188,7 +192,7 @@ describe('listCertificates', () => {
   test('should call countCertificates when the returned certificates length is equal to limit', async () => {
     // We want exactly 'limit' items returned, so the function calls countCertificates
     vargs.limit = 2 // set limit to 2
-    const fakeCerts: table.Certificate[] = [
+    const fakeCerts: TableCertificate[] = [
       {
         certificateId: 11,
         userId: 123,
@@ -290,7 +294,7 @@ describe('listCertificates', () => {
     // but let's confirm the coverage if the function doesn't rely on partial storage returning partial results.
     vargs.limit = 2
 
-    const cA: table.Certificate = {
+    const cA: TableCertificate = {
       certificateId: 100,
       userId: 123,
       type: 'zzz',
@@ -304,7 +308,7 @@ describe('listCertificates', () => {
       created_at: new Date(),
       updated_at: new Date()
     }
-    const cB: table.Certificate = {
+    const cB: TableCertificate = {
       certificateId: 101,
       userId: 123,
       type: 'yyy',
@@ -318,7 +322,7 @@ describe('listCertificates', () => {
       created_at: new Date(),
       updated_at: new Date()
     }
-    const cC: table.Certificate = {
+    const cC: TableCertificate = {
       certificateId: 102,
       userId: 123,
       type: 'xxx',

package/test/Wallet/live/walletLive.man.test.ts

@@ -14,13 +14,13 @@ import {
   asString,
   StorageKnex,
   sdk,
-  table,
   verifyOne,
   verifyId,
   ScriptTemplateSABPPP,
   randomBytesBase64,
   randomBytes,
-  entity
+  EntityProvenTxReq,
+  TableOutput
 } from '../../../src/index.all'
 import {
   _tu,
@@ -191,6 +191,46 @@ describe('walletLive test', () => {
 `)
   })
 
+  test('5z send a wallet payment from myCtx to second wallet', async () => {
+    const tauriRootKey =
+      '1363ef9b14531a52648e1e7e7f430a10ceda1df8d514a2a75d8404094f14a649'
+    const tauriIdentityKey = PrivateKey.fromHex(tauriRootKey)
+      .toPublicKey()
+      .toString()
+
+    const r = await createWalletPaymentAction({
+      toIdentityKey: tauriIdentityKey,
+      outputSatoshis: 1000 * 1000,
+      keyDeriver: myCtx.keyDeriver,
+      wallet: myCtx.wallet,
+      logResult: true
+    })
+
+    const toCtx = await _tu.createTestWalletWithStorageClient({
+      rootKeyHex: tauriRootKey,
+      chain: env.chain
+    })
+
+    const args: InternalizeActionArgs = {
+      tx: Utils.toArray(r.atomicBEEF, 'hex'),
+      outputs: [
+        {
+          outputIndex: r.vout,
+          protocol: 'wallet payment',
+          paymentRemittance: {
+            derivationPrefix: r.derivationPrefix,
+            derivationSuffix: r.derivationSuffix,
+            senderIdentityKey: r.senderIdentityKey
+          }
+        }
+      ],
+      description: 'from tone wallet'
+    }
+
+    const rw = await toCtx.wallet.internalizeAction(args)
+    expect(rw.accepted).toBe(true)
+  })
+
   test('6 send a wallet payment from myCtx to second wallet', async () => {
     const r = await createWalletPaymentAction({
       toIdentityKey: myIdentityKey2,
@@ -224,7 +264,7 @@ describe('walletLive test', () => {
     const beef = Beef.fromString(r.atomicBEEF)
     const btx = beef.txs.slice(-1)[0]
     const txid = btx.txid
-    const req = await entity.ProvenTxReq.fromStorageTxid(stagingStorage, txid)
+    const req = await EntityProvenTxReq.fromStorageTxid(stagingStorage, txid)
     expect(req?.notify.transactionIds?.length).toBe(2)
   })
 
@@ -344,15 +384,15 @@ ${Utils.toHex(beef.toBinaryAtomic(txid))}
 async function confirmSpendableOutputs(
   storage: StorageKnex,
   services: Services
-): Promise<{ invalidSpendableOutputs: table.Output[] }> {
-  const invalidSpendableOutputs: table.Output[] = []
+): Promise<{ invalidSpendableOutputs: TableOutput[] }> {
+  const invalidSpendableOutputs: TableOutput[] = []
   const users = await storage.findUsers({ partial: {} })
 
   for (const { userId } of users) {
     const defaultBasket = verifyOne(
       await storage.findOutputBaskets({ partial: { userId, name: 'default' } })
     )
-    const where: Partial<table.Output> = {
+    const where: Partial<TableOutput> = {
       userId,
       basketId: defaultBasket.basketId,
       spendable: true

package/test/monitor/Monitor.test.ts

@@ -1,7 +1,7 @@
 import { MerklePath } from '@bsv/sdk'
 import {
   asArray,
-  entity,
+  EntityProvenTxReq,
   sdk,
   verifyOne,
   verifyTruthy,
@@ -165,7 +165,7 @@ describe('Monitor tests', () => {
             (await storage.findProvenTxs({ partial: { txid } })).length
           ).toBe(0)
           const req = verifyTruthy(
-            await entity.ProvenTxReq.fromStorageTxid(storage, txid)
+            await EntityProvenTxReq.fromStorageTxid(storage, txid)
           )
           expect(req.status).toBe('unmined')
         }
@@ -181,7 +181,7 @@ describe('Monitor tests', () => {
           )
           expect(proven.merklePath).toBeTruthy()
           const req = verifyTruthy(
-            await entity.ProvenTxReq.fromStorageTxid(storage, txid)
+            await EntityProvenTxReq.fromStorageTxid(storage, txid)
           )
           expect(req.status).toBe('completed')
           expect(req.provenTxId).toBe(proven.provenTxId)
@@ -227,7 +227,7 @@ describe('Monitor tests', () => {
             (await storage.findProvenTxs({ partial: { txid } })).length
           ).toBe(0)
           const req = verifyTruthy(
-            await entity.ProvenTxReq.fromStorageTxid(storage, txid)
+            await EntityProvenTxReq.fromStorageTxid(storage, txid)
           )
           expect(req.status).toBe('unmined')
           attempts.push(req.attempts)
@@ -246,7 +246,7 @@ describe('Monitor tests', () => {
             (await storage.findProvenTxs({ partial: { txid } })).length
           ).toBe(0)
           const req = verifyTruthy(
-            await entity.ProvenTxReq.fromStorageTxid(storage, txid)
+            await EntityProvenTxReq.fromStorageTxid(storage, txid)
           )
           expect(req.status).toBe('unmined')
           expect(req.attempts).toBeGreaterThanOrEqual(attempts[i])
@@ -462,7 +462,7 @@ describe('Monitor tests', () => {
           )
           expect(req.status).toBe('unsent')
           const notifyIds =
-            new entity.ProvenTxReq(req).notify.transactionIds || []
+            new EntityProvenTxReq(req).notify.transactionIds || []
           for (const transactionId of notifyIds) {
             const tx = verifyTruthy(
               await storage.findTransactionById(transactionId)
@@ -479,9 +479,9 @@ describe('Monitor tests', () => {
             await storage.findProvenTxReqs({ partial: { txid } })
           )
           if (env.logTests)
-            console.log(new entity.ProvenTxReq(req).historyPretty())
+            console.log(new EntityProvenTxReq(req).historyPretty())
           const notifyIds =
-            new entity.ProvenTxReq(req).notify.transactionIds || []
+            new EntityProvenTxReq(req).notify.transactionIds || []
           switch (postBeefMockStatus) {
             case 'success':
               {

package/test/storage/StorageMySQLDojoReader.man.test.ts

@@ -51,7 +51,7 @@ describe('StorageMySQLDojoReader tests', () => {
     const writerSettings = await writer.getSettings()
 
     const identityKey = process.env.MY_TEST_IDENTITY || ''
-    const ss = await entity.SyncState.fromStorage(
+    const ss = await EntitySyncState.fromStorage(
       writer,
       identityKey,
       readerSettings

package/test/storage/insert.test.ts

@@ -4,7 +4,7 @@ import {
   randomBytesHex,
   sdk,
   StorageProvider,
-  table
+  TableCommission
 } from '../../src/index.client'
 import { StorageKnex } from '../../src/storage/StorageKnex'
 
@@ -174,7 +174,7 @@ describe('insert tests', () => {
   test('7 insert Commission', async () => {
     for (const storage of storages) {
       const { tx: t, user } = await _tu.insertTestTransaction(storage)
-      const e: table.Commission = await _tu.insertTestCommission(storage, t)
+      const e: TableCommission = await _tu.insertTestCommission(storage, t)
       const id = e.commissionId
       expect(id).toBeGreaterThan(0)
       e.commissionId = 0