@bopen-io/wallet-toolbox 1.7.18

package/src/sdk/__test/WalletError.test.ts

@@ -0,0 +1,318 @@
+import { WalletError } from '../WalletError'
+import { WalletErrorFromJson } from '../WalletErrorFromJson'
+import {
+  WERR_NOT_IMPLEMENTED,
+  WERR_INTERNAL,
+  WERR_INVALID_PARAMETER,
+  WERR_REVIEW_ACTIONS,
+  WERR_INSUFFICIENT_FUNDS,
+  WERR_BROADCAST_UNAVAILABLE,
+  WERR_NETWORK_CHAIN,
+  WERR_INVALID_OPERATION,
+  WERR_MISSING_PARAMETER,
+  WERR_BAD_REQUEST,
+  WERR_UNAUTHORIZED,
+  WERR_NOT_ACTIVE,
+  WERR_INVALID_PUBLIC_KEY
+} from '../WERR_errors'
+
+// Mock WalletStorage interface
+const mockWalletStorage = {
+  createAction: jest.fn().mockImplementation((args: any) => {
+    throw new WERR_REVIEW_ACTIONS(
+      [{ txid: 'txid123', status: 'doubleSpend', competingTxs: ['txid456'], competingBeef: [0, 1, 2, 3] }],
+      [{ txid: 'txid123', status: 'failed' }],
+      'txid123',
+      [5, 6, 7, 8],
+      ['00'.repeat(32) + '.0']
+    )
+  })
+}
+
+describe('WalletError tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 - WERR_REVIEW_ACTIONS from createAction failure', async () => {
+    try {
+      await mockWalletStorage.createAction({ someArgs: 'test' })
+    } catch (err) {
+      const werr = WalletError.fromUnknown(err)
+      expect(werr.name).toBe('WERR_REVIEW_ACTIONS')
+      expect(werr.message).toBe('Undelayed createAction or signAction results require review.')
+
+      const json = WalletError.unknownToJson(werr)
+      const werr2 = WalletErrorFromJson(JSON.parse(json))
+      expect(werr2 instanceof WERR_REVIEW_ACTIONS).toBe(true)
+      const werr3 = werr2 as WERR_REVIEW_ACTIONS
+      expect(werr3.txid).toBe('txid123')
+      expect(werr3.reviewActionResults).toEqual([
+        { txid: 'txid123', status: 'doubleSpend', competingTxs: ['txid456'], competingBeef: [0, 1, 2, 3] }
+      ])
+      expect(werr3.sendWithResults).toEqual([{ txid: 'txid123', status: 'failed' }])
+      expect(werr3.noSendChange).toEqual(['00'.repeat(32) + '.0'])
+    }
+  })
+
+  test('1 - WERR_NOT_IMPLEMENTED basic test', async () => {
+    const werr = new WERR_NOT_IMPLEMENTED('Custom not implemented message')
+    expect(werr.name).toBe('WERR_NOT_IMPLEMENTED')
+    expect(werr.message).toBe('Custom not implemented message')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_NOT_IMPLEMENTED')
+    expect(werr2.message).toBe('Custom not implemented message')
+  })
+
+  test('2 - WERR_INTERNAL with default message', async () => {
+    const werr = new WERR_INTERNAL()
+    expect(werr.name).toBe('WERR_INTERNAL')
+    expect(werr.message).toBe('An internal error has occurred.')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INTERNAL')
+    expect(werr2.message).toBe('An internal error has occurred.')
+  })
+
+  test('3 - WERR_INVALID_PARAMETER with custom parameter', async () => {
+    const werr = new WERR_INVALID_PARAMETER('amount', 'positive')
+    expect(werr.name).toBe('WERR_INVALID_PARAMETER')
+    expect(werr.message).toBe('The amount parameter must be positive')
+    expect(werr.parameter).toBe('amount')
+
+    const json = werr.toJson()
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INVALID_PARAMETER')
+    expect(werr2.message).toBe('The amount parameter must be positive')
+    expect((werr2 as WERR_INVALID_PARAMETER).parameter).toBe('amount')
+  })
+
+  test('4 - WERR_INSUFFICIENT_FUNDS with numeric values', async () => {
+    const werr = new WERR_INSUFFICIENT_FUNDS(1000, 500)
+    expect(werr.name).toBe('WERR_INSUFFICIENT_FUNDS')
+    expect(werr.message).toContain('500 more satoshis are needed')
+    expect(werr.message).toContain('for a total of 1000')
+    expect(werr.totalSatoshisNeeded).toBe(1000)
+    expect(werr.moreSatoshisNeeded).toBe(500)
+
+    const json = werr.toJson()
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INSUFFICIENT_FUNDS')
+    expect((werr2 as WERR_INSUFFICIENT_FUNDS).totalSatoshisNeeded).toBe(1000)
+    expect((werr2 as WERR_INSUFFICIENT_FUNDS).moreSatoshisNeeded).toBe(500)
+  })
+
+  test('5 - WERR_BROADCAST_UNAVAILABLE test', async () => {
+    const werr = new WERR_BROADCAST_UNAVAILABLE('Network issue')
+    expect(werr.name).toBe('WERR_BROADCAST_UNAVAILABLE')
+    expect(werr.message).toBe('Unable to broadcast transaction at this time.')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_BROADCAST_UNAVAILABLE')
+    expect(werr2.message).toBe('Unable to broadcast transaction at this time.')
+  })
+
+  test('6 - WERR_NETWORK_CHAIN test', async () => {
+    const werr = new WERR_NETWORK_CHAIN('Chain mismatch')
+    expect(werr.name).toBe('WERR_NETWORK_CHAIN')
+    expect(werr.message).toBe('Chain mismatch')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_NETWORK_CHAIN')
+    expect(werr2.message).toBe('Chain mismatch')
+  })
+
+  test('7 - WalletError.fromUnknown with plain Error', async () => {
+    const err = new Error('Test error')
+    const werr = WalletError.fromUnknown(err)
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('Test error')
+  })
+
+  test('8 - WalletError.unknownToJson with unknown object', async () => {
+    const obj = { custom: 'data', code: 404 }
+    const json = WalletError.unknownToJson(obj)
+    const werr = WalletErrorFromJson(JSON.parse(json))
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('[object Object]')
+  })
+
+  test('9 - WERR_INVALID_OPERATION basic test', async () => {
+    const werr = new WERR_INVALID_OPERATION('Custom invalid operation message')
+    expect(werr.name).toBe('WERR_INVALID_OPERATION')
+    expect(werr.message).toBe('Custom invalid operation message')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INVALID_OPERATION')
+    expect(werr2.message).toBe('Custom invalid operation message')
+  })
+
+  test('10 - WERR_MISSING_PARAMETER with parameter', async () => {
+    const werr = new WERR_MISSING_PARAMETER('requiredField')
+    expect(werr.name).toBe('WERR_MISSING_PARAMETER')
+    expect(werr.message).toBe('The required requiredField parameter is missing.')
+    expect(werr.parameter).toBe('requiredField')
+
+    const json = werr.toJson()
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_MISSING_PARAMETER')
+    expect(werr2.message).toBe('The required requiredField parameter is missing.')
+    expect((werr2 as WERR_MISSING_PARAMETER).parameter).toBe('requiredField')
+  })
+
+  test('11 - WERR_BAD_REQUEST with custom message', async () => {
+    const werr = new WERR_BAD_REQUEST('Invalid request data')
+    expect(werr.name).toBe('WERR_BAD_REQUEST')
+    expect(werr.message).toBe('Invalid request data')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_BAD_REQUEST')
+    expect(werr2.message).toBe('Invalid request data')
+  })
+
+  test('12 - WERR_UNAUTHORIZED with default message', async () => {
+    const werr = new WERR_UNAUTHORIZED()
+    expect(werr.name).toBe('WERR_UNAUTHORIZED')
+    expect(werr.message).toBe('Access is denied due to an authorization error.')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_UNAUTHORIZED')
+    expect(werr2.message).toBe('Access is denied due to an authorization error.')
+  })
+
+  test('13 - WERR_NOT_ACTIVE with default message', async () => {
+    const werr = new WERR_NOT_ACTIVE()
+    expect(werr.name).toBe('WERR_NOT_ACTIVE')
+    expect(werr.message).toBe(
+      `WalletStorageManager is not accessing user's active storage or there are conflicting active stores configured.`
+    )
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_NOT_ACTIVE')
+    expect(werr2.message).toBe(
+      `WalletStorageManager is not accessing user's active storage or there are conflicting active stores configured.`
+    )
+  })
+
+  test('14 - WERR_INVALID_PUBLIC_KEY with key and mainnet network', async () => {
+    const werr = new WERR_INVALID_PUBLIC_KEY('invalidkey123', 'mainnet')
+    expect(werr.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr.message).toBe('The provided public key "invalidkey123" is invalid or malformed.')
+    expect((werr as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+
+    const json = WalletError.unknownToJson(werr)
+    const parsedJson = JSON.parse(json)
+    const werr2 = WalletErrorFromJson(parsedJson)
+    expect(werr2.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr2.message).toBe('The provided public key "invalidkey123" is invalid or malformed.')
+    expect((werr2 as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+  })
+
+  test('15 - WERR_INVALID_PUBLIC_KEY with key and testnet network', async () => {
+    const werr = new WERR_INVALID_PUBLIC_KEY('invalidkey123', 'testnet')
+    expect(werr.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr.message).toBe('The provided public key is invalid or malformed.')
+    expect((werr as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+
+    const json = WalletError.unknownToJson(werr)
+    const parsedJson = JSON.parse(json)
+    const werr2 = WalletErrorFromJson(parsedJson)
+    expect(werr2.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr2.message).toBe('The provided public key is invalid or malformed.')
+    expect((werr2 as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+  })
+
+  test('16 - WalletError basic constructor with details and stack', async () => {
+    const customStack = 'custom stack trace'
+    const werr = new WalletError('WERR_TEST', 'Test message', customStack, { detail1: 'value1', detail2: 'value2' })
+    expect(werr.isError).toBe(true)
+    expect(werr.name).toBe('WERR_TEST')
+    expect(werr.message).toBe('Test message')
+    expect(werr.stack).toBe(customStack)
+    expect(werr.details).toEqual({ detail1: 'value1', detail2: 'value2' })
+    expect(werr.code).toBe('WERR_TEST')
+    expect(werr.description).toBe('Test message')
+
+    werr.code = 'WERR_NEW_CODE'
+    werr.description = 'New description'
+    expect(werr.name).toBe('WERR_NEW_CODE')
+    expect(werr.message).toBe('New description')
+  })
+
+  test('17 - WalletError.fromUnknown with string', async () => {
+    const werr = WalletError.fromUnknown('String error message')
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('String error message')
+  })
+
+  test('18 - WalletError.fromUnknown with number', async () => {
+    const werr = WalletError.fromUnknown(404)
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('404')
+  })
+
+  test('19 - WalletError.fromUnknown with custom object', async () => {
+    const obj = { code: 'ERR_404', message: 'Not found', status: 404 }
+    const werr = WalletError.fromUnknown(obj)
+    expect(werr.name).toBe('ERR_404')
+    expect(werr.message).toBe('Not found')
+  })
+
+  test('20 - WalletError.fromUnknown with nested walletError', async () => {
+    const innerErr = new WERR_INTERNAL('Inner error')
+    const outerObj = { message: 'Outer error', walletError: innerErr }
+    const werr = WalletError.fromUnknown(outerObj)
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('Outer error')
+    expect((werr as any).walletError).toBeInstanceOf(WERR_INTERNAL)
+    expect((werr as any).walletError.message).toBe('Inner error')
+  })
+
+  test('21 - WalletError.fromUnknown with SQL details', async () => {
+    const err = { name: 'DBError', message: 'Query failed', sql: 'SELECT * FROM table', sqlMessage: 'Syntax error' }
+    const werr = WalletError.fromUnknown(err)
+    expect(werr.name).toBe('DBError')
+    expect(werr.message).toBe('Query failed')
+    expect(werr.details).toEqual({ sql: 'SELECT * FROM table', sqlMessage: 'Syntax error' })
+  })
+
+  test('22 - WalletError.unknownToJson with WalletError', async () => {
+    const werr = new WalletError('WERR_TEST', 'Test message')
+    const json = WalletError.unknownToJson(werr)
+    const parsed = JSON.parse(json)
+    expect(parsed.name).toBe('WERR_TEST')
+    expect(parsed.message).toBe('Test message')
+  })
+
+  test('23 - WalletError.unknownToJson with standard Error', async () => {
+    const err = new Error('Standard error')
+    const json = WalletError.unknownToJson(err)
+    const werr = WalletErrorFromJson(JSON.parse(json))
+    expect(werr.name).toBe('Error')
+    expect(werr.message).toBe('Standard error')
+  })
+
+  test('24 - WalletError.unknownToJson with string', async () => {
+    const json = WalletError.unknownToJson('String error')
+    const werr = WalletErrorFromJson(JSON.parse(json))
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('String error')
+  })
+
+  test('25 - WalletError asStatus method', async () => {
+    const werr = new WalletError('WERR_TEST', 'Test description')
+    const status = werr.asStatus()
+    expect(status).toEqual({
+      status: 'error',
+      code: 'WERR_TEST',
+      description: 'Test description'
+    })
+  })
+})

package/src/sdk/__test/validationHelpers.test.ts

@@ -0,0 +1,21 @@
+import { Utils, Validation as V } from '@bsv/sdk'
+describe('validationHelpers tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 validateBase64String', async () => {
+    const validB64 = 'SGVsbG8gV29ybGQh' // "Hello World!"
+
+    const s = V.validateBase64String(validB64, 'testParam', 1, 20)
+    expect(s).toBe(validB64)
+
+    {
+      const invalidB64 = 'SGVsbG8g29ybGQh'
+      expect(() => V.validateBase64String(invalidB64, 'testParam', 1, 20)).toThrow()
+    }
+
+    {
+      const invalidB64 = 'SGVsbG8gV29ybGQh='
+      expect(() => V.validateBase64String(invalidB64, 'testParam', 1, 20)).toThrow()
+    }
+  })
+})

package/src/sdk/index.ts

@@ -0,0 +1,10 @@
+export * from './WalletError'
+export * from './WalletErrorFromJson'
+export * from './WalletSigner.interfaces'
+export * from './WalletStorage.interfaces'
+export * from './WERR_errors'
+export { Validation } from '@bsv/sdk'
+export * from './CertOpsWallet'
+export * from './types'
+export * from './WalletServices.interfaces'
+export * from './PrivilegedKeyManager'

package/src/sdk/types.ts

@@ -0,0 +1,226 @@
+import { Transaction, UnlockingScript } from '@bsv/sdk'
+
+/**
+ * Identifies a unique transaction output by its `txid` and index `vout`
+ */
+export interface OutPoint {
+  /**
+   * Transaction double sha256 hash as big endian hex string
+   */
+  txid: string
+  /**
+   * zero based output index within the transaction
+   */
+  vout: number
+}
+
+export type Chain = 'main' | 'test'
+
+/**
+ * Initial status (attempts === 0):
+ *
+ * nosend: transaction was marked 'noSend'. It is complete and signed. It may be sent by an external party. Proof should be sought as if 'unmined'. No error if it remains unknown by network.
+ *
+ * unprocessed: indicates req is about to be posted to network by non-acceptDelayedBroadcast application code, after posting status is normally advanced to 'sending'
+ *
+ * unsent: rawTx has not yet been sent to the network for processing. req is queued for delayed processing.
+ *
+ * sending: At least one attempt to send rawTx to transaction processors has occured without confirmation of acceptance.
+ *
+ * unknown: rawTx status is unknown but is believed to have been previously sent to the network.
+ *
+ * Attempts > 0 status, processing:
+ *
+ * unknown: Last status update received did not recognize txid or wasn't understood.
+ *
+ * nonfinal: rawTx has an un-expired nLockTime and is eligible for continuous updating by new transactions with additional outputs and incrementing sequence numbers.
+ *
+ * unmined: Last attempt has txid waiting to be mined, possibly just sent without callback
+ *
+ * callback: Waiting for proof confirmation callback from transaction processor.
+ *
+ * unconfirmed: Potential proof has not been confirmed by chaintracks
+ *
+ * Terminal status:
+ *
+ * doubleSpend: Transaction spends same input as another transaction.
+ *
+ * invalid: rawTx is structuraly invalid or was rejected by the network. Will never be re-attempted or completed.
+ *
+ * completed: proven_txs record added, and notifications are complete.
+ *
+ * unfail: asigned to force review of a currently invalid ProvenTxReq.
+ */
+export type ProvenTxReqStatus =
+  | 'sending'
+  | 'unsent'
+  | 'nosend'
+  | 'unknown'
+  | 'nonfinal'
+  | 'unprocessed'
+  | 'unmined'
+  | 'callback'
+  | 'unconfirmed'
+  | 'completed'
+  | 'invalid'
+  | 'doubleSpend'
+  | 'unfail'
+
+export const ProvenTxReqTerminalStatus: ProvenTxReqStatus[] = ['completed', 'invalid', 'doubleSpend']
+
+export const ProvenTxReqNonTerminalStatus: ProvenTxReqStatus[] = [
+  'sending',
+  'unsent',
+  'nosend',
+  'unknown',
+  'nonfinal',
+  'unprocessed',
+  'unmined',
+  'callback',
+  'unconfirmed'
+]
+
+export type TransactionStatus =
+  | 'completed'
+  | 'failed'
+  | 'unprocessed'
+  | 'sending'
+  | 'unproven'
+  | 'unsigned'
+  | 'nosend'
+  | 'nonfinal'
+  | 'unfail'
+
+export interface Paged {
+  limit: number
+  offset?: number
+}
+
+export interface KeyPair {
+  privateKey: string
+  publicKey: string
+}
+
+export interface StorageIdentity {
+  /**
+   * The identity key (public key) assigned to this storage
+   */
+  storageIdentityKey: string
+  /**
+   * The human readable name assigned to this storage.
+   */
+  storageName: string
+}
+
+export interface EntityTimeStamp {
+  created_at: Date
+  updated_at: Date
+}
+
+export interface ScriptTemplateUnlock {
+  sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+  estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
+}
+
+export interface WalletBalance {
+  total: number
+  utxos: { satoshis: number; outpoint: string }[]
+}
+
+export type ReqHistoryNote = {
+  when?: string
+  what: string
+  [key: string]: boolean | string | number | undefined
+}
+
+/**
+ * The transaction status that a client will receive when subscribing to transaction updates in the Monitor.
+ */
+export interface ProvenTransactionStatus {
+  txid: string
+  txIndex: number
+  blockHeight: number
+  blockHash: string
+  merklePath: number[]
+  merkleRoot: string
+}
+
+/**
+ * `listOutputs` special operation basket name value.
+ *
+ * Returns wallet's current change balance in the `totalOutputs` result property.
+ * The `outputs` result property will always be an empty array.
+ */
+export const specOpWalletBalance = '893b7646de0e1c9f741bd6e9169b76a8847ae34adef7bef1e6a285371206d2e8'
+
+/**
+ * `listOutputs` special operation basket name value.
+ *
+ * Returns currently spendable wallet change outputs that fail to validate as unspent transaction outputs.
+ *
+ * Optional tag value 'release'. If present, updates invalid change outputs to not spendable.
+ *
+ * Optional tag value 'all'. If present, processes all spendable true outputs, independent of baskets, but basket must be defined.
+ */
+export const specOpInvalidChange = '5a76fd430a311f8bc0553859061710a4475c19fed46e2ff95969aa918e612e57'
+
+/**
+ * `listOutputs` special operation basket name value.
+ *
+ * Updates the wallet's automatic change management parameters.
+ *
+ * Tag at index 0 is the new desired number of spendable change outputs to maintain.
+ *
+ * Tag at index 1 is the new target for minimum satoshis when creating new change outputs.
+ */
+export const specOpSetWalletChangeParams = 'a4979d28ced8581e9c1c92f1001cc7cb3aabf8ea32e10888ad898f0a509a3929'
+
+/**
+ * @param basket Output basket name value.
+ * @returns true iff the `basket` name is a reserved `listOutputs` special operation identifier.
+ */
+export function isListOutputsSpecOp(basket: string): boolean {
+  return [specOpWalletBalance, specOpInvalidChange, specOpSetWalletChangeParams].indexOf(basket) >= 0
+}
+
+/**
+ * `listActions` special operation label name value.
+ *
+ * Processes only actions currently with status 'nosend'
+ *
+ * Optional label value 'abort'. If present, runs abortAction on all the actions returned.
+ */
+export const specOpNoSendActions = 'ac6b20a3bb320adafecd637b25c84b792ad828d3aa510d05dc841481f664277d'
+
+/**
+ * `listActions` special operation label name value.
+ *
+ * Processes only actions currently with status 'failed'
+ *
+ * Optional label value 'unfail'. If present, sets status to 'unfail', which queues them for attempted recovery by the Monitor.
+ */
+export const specOpFailedActions = '97d4eb1e49215e3374cc2c1939a7c43a55e95c7427bf2d45ed63e3b4e0c88153'
+
+/**
+ * @param label Action / Transaction label name value.
+ * @returns true iff the `label` name is a reserved `listActions` special operation identifier.
+ */
+export function isListActionsSpecOp(label: string): boolean {
+  return [specOpNoSendActions, specOpFailedActions].indexOf(label) >= 0
+}
+
+/**
+ * `createAction` special operation label name value.
+ *
+ * Causes WERR_REVIEW_ACTIONS throw with dummy properties.
+ *
+ */
+export const specOpThrowReviewActions = 'a496e747fc3ad5fabdd4ae8f91184e71f87539bd3d962aa2548942faaaf0047a'
+
+/**
+ * @param label Action / Transaction label name value.
+ * @returns true iff the `label` name is a reserved `createAction` special operation identifier.
+ */
+export function isCreateActionSpecOp(label: string): boolean {
+  return [specOpThrowReviewActions].indexOf(label) >= 0
+}

package/src/services/README.md

@@ -0,0 +1,11 @@
+# External Data Services Necessary to Wallet Operations
+
+The principal purpsose of these services is to insulate the rest of the code from the APIs of external service providers.
+
+These services include:
+
+- Posting BEEFs to transaction processors.
+- Maintaining a local trusted block header database and answering merkleproof queries.
+- Obtaining real time exchange rates.
+- Raw transaction lookup by txid.
+- UTXO status verification by lockingScript hash.