@bopen-io/wallet-toolbox 1.7.18

package/src/storage/remoting/StorageServer.ts

@@ -0,0 +1,291 @@
+/**
+ * StorageServer.ts
+ *
+ * A server-side class that "has a" local WalletStorage (like a StorageKnex instance),
+ * and exposes it via a JSON-RPC POST endpoint using Express.
+ */
+
+import { MakeWalletLogger, WalletInterface, WalletLoggerInterface } from '@bsv/sdk'
+import express, { Request, Response } from 'express'
+import { AuthMiddlewareOptions, createAuthMiddleware } from '@bsv/auth-express-middleware'
+import { createPaymentMiddleware } from '@bsv/payment-express-middleware'
+import { Wallet } from '../../Wallet'
+import { StorageProvider } from '../StorageProvider'
+import { WERR_UNAUTHORIZED } from '../../sdk/WERR_errors'
+import { SyncChunk } from '../../sdk/WalletStorage.interfaces'
+import { EntityTimeStamp } from '../../sdk/types'
+import { WalletError } from '../../sdk/WalletError'
+import { logWalletError } from '../../WalletLogger'
+
+export interface WalletStorageServerOptions {
+  port: number
+  wallet: Wallet
+  monetize: boolean
+  calculateRequestPrice?: (req: Request) => number | Promise<number>
+  adminIdentityKeys?: string[]
+  makeLogger?: MakeWalletLogger
+}
+
+export class StorageServer {
+  private app = express()
+  private port: number
+  private storage: StorageProvider
+  private wallet: Wallet
+  private monetize: boolean
+  private calculateRequestPrice?: (req: Request) => number | Promise<number>
+  private adminIdentityKeys?: string[]
+  private makeLogger?: MakeWalletLogger
+
+  constructor(storage: StorageProvider, options: WalletStorageServerOptions) {
+    this.storage = storage
+    this.port = options.port
+    this.wallet = options.wallet
+    this.monetize = options.monetize
+    this.calculateRequestPrice = options.calculateRequestPrice
+    this.adminIdentityKeys = options.adminIdentityKeys
+    this.makeLogger = options.makeLogger
+
+    this.setupRoutes()
+  }
+
+  private setupRoutes(): void {
+    this.app.use(express.json({ limit: '30mb' }))
+
+    // This allows the API to be used everywhere when CORS is enforced
+    this.app.use((req, res, next) => {
+      res.header('Access-Control-Allow-Origin', '*')
+      res.header('Access-Control-Allow-Headers', '*')
+      res.header('Access-Control-Allow-Methods', '*')
+      res.header('Access-Control-Expose-Headers', '*')
+      res.header('Access-Control-Allow-Private-Network', 'true')
+      if (req.method === 'OPTIONS') {
+        // Handle CORS preflight requests to allow cross-origin POST/PUT requests
+        res.sendStatus(200)
+      } else {
+        next()
+      }
+    })
+
+    this.app.get(`/robots.txt`, (req: Request, res: Response) => {
+      res.type('text/plain')
+      res.send(`User-agent: *\nDisallow: /`)
+    })
+
+    this.app.get(`/`, (req: Request, res: Response) => {
+      res.type('text/plain')
+      res.send(`BRC-100 ${this.wallet.chain}Net Storage Provider.`)
+    })
+
+    const options: AuthMiddlewareOptions = {
+      wallet: this.wallet as WalletInterface
+    }
+    this.app.use(createAuthMiddleware(options))
+    if (this.monetize) {
+      this.app.use(
+        createPaymentMiddleware({
+          wallet: this.wallet,
+          calculateRequestPrice: this.calculateRequestPrice || (() => 100)
+        })
+      )
+    }
+
+    // A single POST endpoint for JSON-RPC:
+    this.app.post('/', async (req: Request, res: Response) => {
+      let { jsonrpc, method, params, id } = req.body
+
+      // Basic JSON-RPC protocol checks:
+      if (jsonrpc !== '2.0' || !method || typeof method !== 'string') {
+        return res.status(400).json({ error: { code: -32600, message: 'Invalid Request' } })
+      }
+
+      try {
+        // Dispatch the method call:
+        if (typeof (this as any)[method] === 'function') {
+          // if you wanted to handle certain methods on the server class itself
+          // e.g. this['someServerMethod'](params)
+          throw new Error('Server method dispatch not used in this approach.')
+        } else if (typeof (this.storage as any)[method] === 'function') {
+          // method is on the walletStorage:
+          // Find user
+          switch (method) {
+            case 'destroy': {
+              console.log(`StorageServer: method=${method} IGNORED`)
+              return res.json({ jsonrpc: '2.0', result: undefined, id })
+            }
+            case 'getSettings':
+              {
+                /** */
+              }
+              break
+            case 'findOrInsertUser':
+              {
+                if (params[0] !== req.auth.identityKey)
+                  throw new WERR_UNAUTHORIZED('function may only access authenticated user.')
+              }
+              break
+            case 'adminStats':
+              {
+                // TODO: add check for admin user
+                if (params[0] !== req.auth.identityKey)
+                  throw new WERR_UNAUTHORIZED('function may only access authenticated admin user.')
+                if (!this.adminIdentityKeys || !this.adminIdentityKeys.includes(req.auth.identityKey))
+                  throw new WERR_UNAUTHORIZED('function may only be accessed by admin user.')
+              }
+              break
+            case 'processSyncChunk':
+              {
+                await this.validateParam0(params, req)
+                //const args: RequestSyncChunkArgs = params[0]
+                const r: SyncChunk = params[1]
+                if (r.certificateFields) r.certificateFields = this.validateEntities(r.certificateFields)
+                if (r.certificates) r.certificates = this.validateEntities(r.certificates)
+                if (r.commissions) r.commissions = this.validateEntities(r.commissions)
+                if (r.outputBaskets) r.outputBaskets = this.validateEntities(r.outputBaskets)
+                if (r.outputTagMaps) r.outputTagMaps = this.validateEntities(r.outputTagMaps)
+                if (r.outputTags) r.outputTags = this.validateEntities(r.outputTags)
+                if (r.outputs) r.outputs = this.validateEntities(r.outputs)
+                if (r.provenTxReqs) r.provenTxReqs = this.validateEntities(r.provenTxReqs)
+                if (r.provenTxs) r.provenTxs = this.validateEntities(r.provenTxs)
+                if (r.transactions) r.transactions = this.validateEntities(r.transactions)
+                if (r.txLabelMaps) r.txLabelMaps = this.validateEntities(r.txLabelMaps)
+                if (r.txLabels) r.txLabels = this.validateEntities(r.txLabels)
+                if (r.user) r.user = this.validateEntity(r.user)
+              }
+              break
+            default:
+              {
+                await this.validateParam0(params, req)
+              }
+              break
+          }
+
+          // If makeLogger is valid, setup and potentially initialize to return data
+          let logger: WalletLoggerInterface | undefined
+          if (this.makeLogger && typeof params[1] === 'object') {
+            logger = this.makeLogger(params[1]['logger'])
+            params[1]['logger'] = logger
+            logger.group(`StorageSever ${method}`)
+            const userId = params[0]?.['userId']
+            const identityKey = params[0]?.['identityKey']
+            if (userId) logger.log(`userId: ${userId}`)
+            if (identityKey) logger.log(`identityKey: ${identityKey}`)
+          }
+
+          try {
+            const result = await (this.storage as any)[method](...(params || []))
+
+            if (logger) {
+              logger.groupEnd()
+              logger.flush?.()
+              if (logger.isOrigin) {
+                // Potentially only flush if isOrigin...
+              } else if (logger.logs && typeof result === 'object') {
+                // If not the start of logging, return logged data with result.
+                result['log'] = { logs: logger.logs }
+              }
+            }
+
+            return res.json({ jsonrpc: '2.0', result, id })
+          } catch (eu: unknown) {
+            logWalletError(eu, logger, 'error executing requested method')
+            logger?.flush?.()
+            throw eu
+          }
+        } else {
+          // Unknown method
+          return res.status(400).json({
+            jsonrpc: '2.0',
+            error: { code: -32601, message: `Method not found: ${method}` },
+            id
+          })
+        }
+      } catch (error: unknown) {
+        /**
+         * Catch any thrown errors from the local walletStorage method.
+         *
+         * Convert errors to standard JSON object format that can be converted
+         * back to WalletError derived objects on the client side and re-thrown.
+         *
+         * Uses WalletError.fromJson(<error object>) on the client side to re-create
+         * an error object of the right class and properties.
+         */
+        const json = WalletError.unknownToJson(error)
+        return res.status(200).json({
+          jsonrpc: '2.0',
+          error: JSON.parse(json),
+          id
+        })
+      }
+    })
+  }
+
+  private async validateParam0(params: any, req: Request): Promise<void> {
+    if (typeof params[0] !== 'object' || !params[0]) {
+      params = [{}]
+    }
+    if (params[0]['identityKey'] && params[0]['identityKey'] !== req.auth.identityKey)
+      throw new WERR_UNAUTHORIZED('identityKey does not match authentiation')
+    console.log('looking up user with identityKey:', req.auth.identityKey)
+    const { user, isNew } = await this.storage.findOrInsertUser(req.auth.identityKey)
+    params[0].reqAuthUserId = user.userId
+    if (params[0]['identityKey']) params[0].userId = user.userId
+  }
+
+  server: any
+
+  public start(): void {
+    this.server = this.app.listen(this.port, () => {
+      console.log(`WalletStorageServer listening at http://localhost:${this.port}`)
+    })
+  }
+
+  public async close(): Promise<void> {
+    if (this.server) {
+      await this.server.close(() => {
+        console.log('WalletStorageServer closed')
+      })
+    }
+  }
+
+  validateDate(date: Date | string | number): Date {
+    let r: Date
+    if (date instanceof Date) r = date
+    else r = new Date(date)
+    return r
+  }
+
+  /**
+   * Helper to force uniform behavior across database engines.
+   * Use to process all individual records with time stamps retreived from database.
+   */
+  validateEntity<T extends EntityTimeStamp>(entity: T, dateFields?: string[]): T {
+    entity.created_at = this.validateDate(entity.created_at)
+    entity.updated_at = this.validateDate(entity.updated_at)
+    if (dateFields) {
+      for (const df of dateFields) {
+        if (entity[df]) entity[df] = this.validateDate(entity[df])
+      }
+    }
+    for (const key of Object.keys(entity)) {
+      const val = entity[key]
+      if (val === null) {
+        entity[key] = undefined
+      } else if (Buffer.isBuffer(val)) {
+        entity[key] = Array.from(val)
+      }
+    }
+    return entity
+  }
+
+  /**
+   * Helper to force uniform behavior across database engines.
+   * Use to process all arrays of records with time stamps retreived from database.
+   * @returns input `entities` array with contained values validated.
+   */
+  validateEntities<T extends EntityTimeStamp>(entities: T[], dateFields?: string[]): T[] {
+    for (let i = 0; i < entities.length; i++) {
+      entities[i] = this.validateEntity(entities[i], dateFields)
+    }
+    return entities
+  }
+}

package/src/storage/remoting/__test/StorageClient.test.ts

@@ -0,0 +1,113 @@
+import { CreateActionArgs, WalletLoggerInterface } from '@bsv/sdk'
+import { _tu, TestWalletNoSetup, TestWalletOnly } from '../../../../test/utils/TestUtilsWalletStorage'
+import { wait } from '../../../utility/utilityHelpers'
+import { WalletLogger } from '../../../WalletLogger'
+import { StorageServer, WalletStorageServerOptions } from '../StorageServer'
+import { StorageClient } from '../StorageClient'
+
+describe('StorageClient tests', () => {
+  jest.setTimeout(99999999)
+
+  let server: { setup: TestWalletNoSetup; server: StorageServer }
+
+  let client: TestWalletOnly
+
+  beforeAll(async () => {
+    server = await createStorageServer()
+
+    client = await _tu.createTestWalletWithStorageClient({
+      rootKeyHex: server.setup.rootKey.toHex(),
+      endpointUrl: 'http://localhost:8042',
+      chain: server.setup.chain
+    })
+  })
+
+  afterAll(async () => {
+    await client.wallet.destroy()
+    await server.server.close()
+    await server.setup.wallet.destroy()
+  })
+
+  test('0 repeatable createAction', async () => {
+    const storageClient = client.storage.getActive() as StorageClient
+    const u = await storageClient.findOrInsertUser(server.setup.identityKey)
+    expect(u).toBeTruthy()
+  })
+
+  test('1 repeatable createAction', async () => {
+    const wallet = client.wallet
+    //wallet.makeLogger = () => console
+    wallet.makeLogger = () => new WalletLogger()
+    wallet.randomVals = [0.1, 0.2, 0.3, 0.7, 0.8, 0.9]
+    const root = '02135476'
+    const kp = _tu.getKeyPair(root.repeat(8))
+    const createArgs: CreateActionArgs = {
+      description: `repeatable`,
+      outputs: [
+        {
+          satoshis: 45,
+          lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
+          outputDescription: 'pay echo'
+        }
+      ],
+      options: {
+        randomizeOutputs: false,
+        signAndProcess: true,
+        noSend: true
+      }
+    }
+
+    const cr = await wallet.createAction(createArgs)
+    expect(cr.txid === '4f428a93c43c2d120204ecdc06f7916be8a5f4542cc8839a0fd79bd1b44582f3')
+  })
+
+  test('1a error createAction', async () => {
+    if (_tu.noEnv('main')) return
+
+    const wallet = client.wallet
+    //wallet.makeLogger = () => console
+    wallet.makeLogger = () => new WalletLogger()
+    wallet.randomVals = [0.1, 0.2, 0.3, 0.7, 0.8, 0.9]
+    const root = '02135476'
+    const kp = _tu.getKeyPair(root.repeat(8))
+    const createArgs: CreateActionArgs = {
+      description: `error`,
+      outputs: [
+        {
+          satoshis: 45,
+          lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
+          outputDescription: 'pay echo'
+        }
+      ],
+      options: {
+        randomizeOutputs: false,
+        signAndProcess: true,
+        noSend: false,
+        acceptDelayedBroadcast: false
+      }
+    }
+
+    const cr = await wallet.createAction(createArgs)
+    expect(cr.txid === '4f428a93c43c2d120204ecdc06f7916be8a5f4542cc8839a0fd79bd1b44582f3')
+  })
+})
+
+async function createStorageServer(): Promise<{ setup: TestWalletNoSetup; server: StorageServer }> {
+  const setup = await _tu.createLegacyWalletSQLiteCopy('StorageClientTest')
+
+  const options: WalletStorageServerOptions = {
+    port: Number(8042),
+    wallet: setup.wallet,
+    monetize: false,
+    adminIdentityKeys: [],
+    calculateRequestPrice: async () => {
+      return 0 // Monetize your server here! Price is in satoshis.
+    },
+    makeLogger: (log?: string | WalletLoggerInterface) => new WalletLogger(log)
+  }
+  const server = new StorageServer(setup.activeStorage, options)
+
+  server.start()
+
+  return { setup, server }
+}