@bsv/wallet-toolbox 1.1.0

package/src/signer/methods/createAction.ts

@@ -0,0 +1,364 @@
+import {
+  CreateActionResult,
+  SendWithResult,
+  SignActionResult,
+  SignActionSpend
+} from '@bsv/sdk'
+import { Script, Transaction, TransactionInput } from '@bsv/sdk'
+import {
+  asBsvSdkScript,
+  makeAtomicBeef,
+  PendingSignAction,
+  PendingStorageInput,
+  ScriptTemplateSABPPP,
+  sdk,
+  verifyTruthy,
+  Wallet
+} from '../../index.client'
+
+export async function createAction(
+  wallet: Wallet,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidCreateActionArgs
+): Promise<CreateActionResult> {
+  const r: CreateActionResult = {}
+
+  let prior: PendingSignAction | undefined = undefined
+
+  if (vargs.isNewTx) {
+    prior = await createNewTx(wallet, vargs)
+
+    if (vargs.isSignAction) {
+      return makeSignableTransactionResult(prior, wallet, vargs)
+    }
+
+    prior.tx = await completeSignedTransaction(prior, {}, wallet)
+
+    r.txid = prior.tx.id('hex')
+    r.noSendChange = prior.dcr.noSendChangeOutputVouts?.map(
+      vout => `${r.txid}.${vout}`
+    )
+    if (!vargs.options.returnTXIDOnly)
+      r.tx = makeAtomicBeef(prior.tx, prior.dcr.inputBeef!)
+  }
+
+  r.sendWithResults = await processAction(prior, wallet, auth, vargs)
+
+  return r
+}
+
+async function createNewTx(
+  wallet: Wallet,
+  args: sdk.ValidCreateActionArgs
+): Promise<PendingSignAction> {
+  const storageArgs = removeUnlockScripts(args)
+  const dcr = await wallet.storage.createAction(storageArgs)
+
+  const reference = dcr.reference
+
+  const { tx, amount, pdi } = buildSignableTransaction(dcr, args, wallet)
+
+  const prior: PendingSignAction = { reference, dcr, args, amount, tx, pdi }
+
+  return prior
+}
+
+function makeSignableTransactionResult(
+  prior: PendingSignAction,
+  wallet: Wallet,
+  args: sdk.ValidCreateActionArgs
+): CreateActionResult {
+  if (!prior.dcr.inputBeef)
+    throw new sdk.WERR_INTERNAL('prior.dcr.inputBeef must be valid')
+
+  const txid = prior.tx.id('hex')
+
+  const r: CreateActionResult = {
+    noSendChange: args.isNoSend
+      ? prior.dcr.noSendChangeOutputVouts?.map(vout => `${txid}.${vout}`)
+      : undefined,
+    signableTransaction: {
+      reference: prior.dcr.reference,
+      tx: makeAtomicBeef(prior.tx, prior.dcr.inputBeef)
+    }
+  }
+
+  wallet.pendingSignActions[r.signableTransaction!.reference] = prior
+
+  return r
+}
+
+/**
+ * Derive a change output locking script
+ */
+function makeChangeLock(
+  out: sdk.StorageCreateTransactionSdkOutput,
+  dctr: sdk.StorageCreateActionResult,
+  args: sdk.ValidCreateActionArgs,
+  changeKeys: sdk.KeyPair,
+  wallet: Wallet
+): Script {
+  const derivationPrefix = dctr.derivationPrefix
+  const derivationSuffix = verifyTruthy(out.derivationSuffix)
+  const sabppp = new ScriptTemplateSABPPP({
+    derivationPrefix,
+    derivationSuffix,
+    keyDeriver: wallet.keyDeriver
+  })
+  const lockingScript = sabppp.lock(changeKeys.privateKey, changeKeys.publicKey)
+  return lockingScript
+}
+
+export async function completeSignedTransaction(
+  prior: PendingSignAction,
+  spends: Record<number, SignActionSpend>,
+  wallet: Wallet
+): Promise<Transaction> {
+  /////////////////////
+  // Insert the user provided unlocking scripts from "spends" arg
+  /////////////////////
+  for (const [key, spend] of Object.entries(spends)) {
+    const vin = Number(key)
+    const createInput = prior.args.inputs[vin]
+    const input = prior.tx.inputs[vin]
+    if (
+      !createInput ||
+      !input ||
+      createInput.unlockingScript ||
+      !Number.isInteger(createInput.unlockingScriptLength)
+    )
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend does not correspond to prior input with valid unlockingScriptLength.`
+      )
+    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
+      )
+    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
+    if (spend.sequenceNumber !== undefined)
+      input.sequence = spend.sequenceNumber
+  }
+
+  const results = {
+    sdk: <SignActionResult>{}
+  }
+
+  /////////////////////
+  // Insert SABPPP unlock templates for storage signed inputs
+  /////////////////////
+  for (const pdi of prior.pdi) {
+    const sabppp = new ScriptTemplateSABPPP({
+      derivationPrefix: pdi.derivationPrefix,
+      derivationSuffix: pdi.derivationSuffix,
+      keyDeriver: wallet.keyDeriver
+    })
+    const keys = wallet.getClientChangeKeyPair()
+    const lockerPrivKey = keys.privateKey
+    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
+    const sourceSatoshis = pdi.sourceSatoshis
+    const lockingScript = asBsvSdkScript(pdi.lockingScript)
+    const unlockTemplate = sabppp.unlock(
+      lockerPrivKey,
+      unlockerPubKey,
+      sourceSatoshis,
+      lockingScript
+    )
+    const input = prior.tx.inputs[pdi.vin]
+    input.unlockingScriptTemplate = unlockTemplate
+  }
+
+  /////////////////////
+  // Sign storage signed inputs making transaction fully valid.
+  /////////////////////
+  await prior.tx.sign()
+
+  return prior.tx
+}
+function removeUnlockScripts(args: sdk.ValidCreateActionArgs) {
+  let storageArgs = args
+  if (!storageArgs.inputs.every(i => i.unlockingScript === undefined)) {
+    // Never send unlocking scripts to storage, all it needs is the script length.
+    storageArgs = { ...args, inputs: [] }
+    for (const i of args.inputs) {
+      const di: sdk.ValidCreateActionInput = {
+        ...i,
+        unlockingScriptLength:
+          i.unlockingScript !== undefined
+            ? i.unlockingScript.length
+            : i.unlockingScriptLength
+      }
+      delete di.unlockingScript
+      storageArgs.inputs.push(di)
+    }
+  }
+  return storageArgs
+}
+
+export async function processAction(
+  prior: PendingSignAction | undefined,
+  wallet: Wallet,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidProcessActionArgs
+): Promise<SendWithResult[] | undefined> {
+  const args: sdk.StorageProcessActionArgs = {
+    isNewTx: vargs.isNewTx,
+    isSendWith: vargs.isSendWith,
+    isNoSend: vargs.isNoSend,
+    isDelayed: vargs.isDelayed,
+    reference: prior ? prior.reference : undefined,
+    txid: prior ? prior.tx.id('hex') : undefined,
+    rawTx: prior ? prior.tx.toBinary() : undefined,
+    sendWith: vargs.isSendWith ? vargs.options.sendWith : []
+  }
+  const r: sdk.StorageProcessActionResults =
+    await wallet.storage.processAction(args)
+
+  return r.sendWithResults
+}
+
+function buildSignableTransaction(
+  dctr: sdk.StorageCreateActionResult,
+  args: sdk.ValidCreateActionArgs,
+  wallet: Wallet
+): {
+  tx: Transaction
+  amount: number
+  pdi: PendingStorageInput[]
+  log: string
+} {
+  const changeKeys = wallet.getClientChangeKeyPair()
+
+  const { inputs: storageInputs, outputs: storageOutputs } = dctr
+
+  const tx = new Transaction(args.version, [], [], args.lockTime)
+
+  // The order of outputs in storageOutputs is always:
+  // CreateActionArgs.outputs in the original order
+  // Commission output
+  // Change outputs
+  // The Vout values will be randomized if args.options.randomizeOutputs is true. Default is true.
+  const voutToIndex = Array<number>(storageOutputs.length)
+  for (let vout = 0; vout < storageOutputs.length; vout++) {
+    const i = storageOutputs.findIndex(o => o.vout === vout)
+    if (i < 0)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'output.vout',
+        `sequential. ${vout} is missing`
+      )
+    voutToIndex[vout] = i
+  }
+
+  //////////////
+  // Add OUTPUTS
+  /////////////
+  for (let vout = 0; vout < storageOutputs.length; vout++) {
+    const i = voutToIndex[vout]
+    const out = storageOutputs[i]
+    if (vout !== out.vout)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'output.vout',
+        `equal to array index. ${out.vout} !== ${vout}`
+      )
+
+    const change = out.providedBy === 'storage' && out.purpose === 'change'
+
+    const lockingScript = change
+      ? makeChangeLock(out, dctr, args, changeKeys, wallet)
+      : asBsvSdkScript(out.lockingScript)
+
+    const output = {
+      satoshis: out.satoshis,
+      lockingScript,
+      change
+    }
+    tx.addOutput(output)
+  }
+
+  //////////////
+  // Merge and sort INPUTS info by vin order.
+  /////////////
+  const inputs: {
+    argsInput: sdk.ValidCreateActionInput | undefined
+    storageInput: sdk.StorageCreateTransactionSdkInput
+  }[] = []
+  for (const storageInput of storageInputs) {
+    const argsInput =
+      storageInput.vin !== undefined && storageInput.vin < args.inputs.length
+        ? args.inputs[storageInput.vin]
+        : undefined
+    inputs.push({ argsInput, storageInput })
+  }
+  inputs.sort((a, b) =>
+    a.storageInput.vin! < b.storageInput.vin!
+      ? -1
+      : a.storageInput.vin! === b.storageInput.vin!
+        ? 0
+        : 1
+  )
+
+  const pendingStorageInputs: PendingStorageInput[] = []
+
+  //////////////
+  // Add INPUTS
+  /////////////
+  let totalChangeInputs = 0
+  for (const { storageInput, argsInput } of inputs) {
+    // Two types of inputs are handled: user specified wth/without unlockingScript and storage specified using SABPPP template.
+    if (argsInput) {
+      // Type 1: User supplied input, with or without an explicit unlockingScript.
+      // If without, signAction must be used to provide the actual unlockScript.
+      const hasUnlock = typeof argsInput.unlockingScript === 'string'
+      const unlock = hasUnlock
+        ? asBsvSdkScript(argsInput.unlockingScript!)
+        : new Script()
+      const inputToAdd: TransactionInput = {
+        sourceTXID: argsInput.outpoint.txid,
+        sourceOutputIndex: argsInput.outpoint.vout,
+        unlockingScript: unlock,
+        sequence: argsInput.sequenceNumber
+      }
+      tx.addInput(inputToAdd)
+    } else {
+      // Type2: SABPPP protocol inputs which are signed using ScriptTemplateSABPPP.
+      if (storageInput.type !== 'P2PKH')
+        throw new sdk.WERR_INVALID_PARAMETER(
+          'type',
+          `vin ${storageInput.vin}, "${storageInput.type}" is not a supported unlocking script type.`
+        )
+
+      pendingStorageInputs.push({
+        vin: tx.inputs.length,
+        derivationPrefix: verifyTruthy(storageInput.derivationPrefix),
+        derivationSuffix: verifyTruthy(storageInput.derivationSuffix),
+        unlockerPubKey: storageInput.senderIdentityKey,
+        sourceSatoshis: storageInput.sourceSatoshis,
+        lockingScript: storageInput.sourceLockingScript
+      })
+
+      const inputToAdd: TransactionInput = {
+        sourceTXID: storageInput.sourceTxid,
+        sourceOutputIndex: storageInput.sourceVout,
+        unlockingScript: new Script(),
+        sequence: 0xffffffff
+      }
+      tx.addInput(inputToAdd)
+      totalChangeInputs += verifyTruthy(storageInput.sourceSatoshis)
+    }
+  }
+
+  // The amount is the total of non-foreign inputs minus change outputs
+  // Note that the amount can be negative when we are redeeming more inputs than we are spending
+  const totalChangeOutputs = storageOutputs
+    .filter(x => x.purpose === 'change')
+    .reduce((acc, el) => acc + el.satoshis, 0)
+  const amount = totalChangeInputs - totalChangeOutputs
+
+  return {
+    tx,
+    amount,
+    pdi: pendingStorageInputs,
+    log: ''
+  }
+}

package/src/signer/methods/internalizeAction.ts

@@ -0,0 +1,142 @@
+import {
+  Beef,
+  InternalizeActionArgs,
+  InternalizeActionResult,
+  InternalizeOutput,
+  P2PKH,
+  WalletProtocol
+} from '@bsv/sdk'
+import { sdk, Wallet } from '../../index.client'
+
+/**
+ * Internalize Action allows a wallet to take ownership of outputs in a pre-existing transaction.
+ * The transaction may, or may not already be known to both the storage and user.
+ *
+ * Two types of outputs are handled: "wallet payments" and "basket insertions".
+ *
+ * A "basket insertion" output is considered a custom output and has no effect on the wallet's "balance".
+ *
+ * A "wallet payment" adds an outputs value to the wallet's change "balance". These outputs are assigned to the "default" basket.
+ *
+ * Processing starts with simple validation and then checks for a pre-existing transaction.
+ * If the transaction is already known to the user, then the outputs are reviewed against the existing outputs treatment,
+ * and merge rules are added to the arguments passed to the storage layer.
+ * The existing transaction must be in the 'unproven' or 'completed' status. Any other status is an error.
+ *
+ * When the transaction already exists, the description is updated. The isOutgoing sense is not changed.
+ *
+ * "basket insertion" Merge Rules:
+ * 1. The "default" basket may not be specified as the insertion basket.
+ * 2. A change output in the "default" basket may not be target of an insertion into a different basket.
+ * 3. These baskets do not affect the wallet's balance and are typed "custom".
+ *
+ * "wallet payment" Merge Rules:
+ * 1. Targetting an existing change "default" basket output results in a no-op. No error. No alterations made.
+ * 2. Targetting a previously "custom" non-change output converts it into a change output. This alters the transaction's `amount`, and the wallet balance.
+ *
+ */
+export async function internalizeAction(
+  wallet: Wallet,
+  auth: sdk.AuthId,
+  args: InternalizeActionArgs
+): Promise<InternalizeActionResult> {
+  const vargs = sdk.validateInternalizeActionArgs(args)
+
+  const { ab, tx, txid } = await validateAtomicBeef()
+  const brc29ProtocolID: WalletProtocol = [2, '3241645161d8']
+
+  for (const o of vargs.outputs) {
+    if (o.outputIndex < 0 || o.outputIndex >= tx.outputs.length)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'outputIndex',
+        `a valid output index in range 0 to ${tx.outputs.length - 1}`
+      )
+    switch (o.protocol) {
+      case 'basket insertion':
+        setupBasketInsertionForOutput(o, vargs)
+        break
+      case 'wallet payment':
+        setupWalletPaymentForOutput(o, vargs)
+        break
+      default:
+        throw new sdk.WERR_INTERNAL(`unexpected protocol ${o.protocol}`)
+    }
+  }
+
+  const r: InternalizeActionResult =
+    await wallet.storage.internalizeAction(args)
+
+  return r
+
+  function setupWalletPaymentForOutput(
+    o: InternalizeOutput,
+    dargs: sdk.ValidInternalizeActionArgs
+  ) {
+    const p = o.paymentRemittance
+    const output = tx.outputs[o.outputIndex]
+    if (!p)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'paymentRemitance',
+        `valid for protocol ${o.protocol}`
+      )
+
+    const keyID = `${p.derivationPrefix} ${p.derivationSuffix}`
+
+    const privKey = wallet.keyDeriver!.derivePrivateKey(
+      brc29ProtocolID,
+      keyID,
+      p.senderIdentityKey
+    )
+    const expectedLockScript = new P2PKH().lock(privKey.toAddress())
+    if (output.lockingScript.toHex() !== expectedLockScript.toHex())
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'paymentRemitance',
+        `locked by script conforming to BRC-29`
+      )
+  }
+
+  function setupBasketInsertionForOutput(
+    o: InternalizeOutput,
+    dargs: sdk.ValidInternalizeActionArgs
+  ) {
+    /*
+    No additional validations...
+    */
+  }
+
+  async function validateAtomicBeef() {
+    const ab = Beef.fromBinary(vargs.tx)
+
+    // TODO: Add support for known txids...
+
+    const txValid = await ab.verify(
+      await wallet.getServices().getChainTracker(),
+      false
+    )
+    if (!txValid || !ab.atomicTxid)
+      throw new sdk.WERR_INVALID_PARAMETER('tx', 'valid AtomicBEEF')
+    const txid = ab.atomicTxid
+    const btx = ab.findTxid(txid)
+    if (!btx)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'tx',
+        `valid AtomicBEEF with newest txid of ${txid}`
+      )
+    const tx = btx.tx
+
+    /*
+    for (const i of tx.inputs) {
+      if (!i.sourceTXID)
+        throw new sdk.WERR_INTERNAL('beef Transactions must have sourceTXIDs')
+      if (!i.sourceTransaction) {
+        const btx = ab.findTxid(i.sourceTXID)
+        if (!btx)
+          throw new sdk.WERR_INVALID_PARAMETER('tx', `valid AtomicBEEF and contain input transaction with txid ${i.sourceTXID}`);
+        i.sourceTransaction = btx.tx
+      }
+    }
+    */
+
+    return { ab, tx, txid }
+  }
+}

package/src/signer/methods/proveCertificate.ts

@@ -0,0 +1,51 @@
+import { CompletedProtoWallet, ProveCertificateResult } from '@bsv/sdk'
+import { sdk, Wallet } from '../../index.client'
+import { CertOpsWallet } from '../../sdk'
+
+export async function proveCertificate(
+  wallet: Wallet,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidProveCertificateArgs
+): Promise<ProveCertificateResult> {
+  const lcargs: sdk.ValidListCertificatesArgs = {
+    partial: {
+      type: vargs.type,
+      serialNumber: vargs.serialNumber,
+      certifier: vargs.certifier,
+      subject: vargs.subject,
+      revocationOutpoint: vargs.revocationOutpoint,
+      signature: vargs.signature
+    },
+    certifiers: [],
+    types: [],
+    limit: 2,
+    offset: 0,
+    privileged: false
+  }
+
+  const lcr = await wallet.storage.listCertificates(lcargs)
+  if (lcr.certificates.length != 1)
+    throw new sdk.WERR_INVALID_PARAMETER('args', `a unique certificate match`)
+  const storageCert = lcr.certificates[0]
+  let proveWallet: CertOpsWallet = wallet
+  if (storageCert.subject != wallet.identityKey) {
+    // Certificate must have been issued to privileged identity
+    if (!wallet.privilegedKeyManager)
+      throw new sdk.WERR_INVALID_OPERATION(
+        'Wallet is not privileged. proveCertificate fails.'
+      )
+    proveWallet = wallet.privilegedKeyManager
+  }
+  const co = await sdk.CertOps.fromCounterparty(proveWallet, {
+    certificate: { ...storageCert },
+    keyring: storageCert.keyring!,
+    counterparty: storageCert.verifier || storageCert.subject
+  })
+  const e = await co.exportForCounterparty(vargs.verifier, vargs.fieldsToReveal)
+  const pr: ProveCertificateResult = {
+    certificate: e.certificate,
+    verifier: e.counterparty,
+    keyringForVerifier: e.keyring
+  }
+  return pr
+}

package/src/signer/methods/signAction.ts

@@ -0,0 +1,121 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import {
+  Beef,
+  Transaction as BsvTransaction,
+  SignActionResult,
+  SignActionSpend
+} from '@bsv/sdk'
+import {
+  asBsvSdkScript,
+  PendingSignAction,
+  ScriptTemplateSABPPP,
+  sdk,
+  Wallet
+} from '../../index.client'
+import { processAction } from './createAction'
+
+export async function signAction(
+  wallet: Wallet,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidSignActionArgs
+): Promise<SignActionResult> {
+  const prior = wallet.pendingSignActions[vargs.reference]
+  if (!prior)
+    throw new sdk.WERR_NOT_IMPLEMENTED(
+      'recovery of out-of-session signAction reference data is not yet implemented.'
+    )
+  if (!prior.dcr.inputBeef)
+    throw new sdk.WERR_INTERNAL('prior.dcr.inputBeef must be valid')
+
+  prior.tx = await completeSignedTransaction(prior, vargs.spends, wallet)
+
+  const sendWithResults = await processAction(prior, wallet, auth, vargs)
+
+  const r: SignActionResult = {
+    txid: prior.tx.id('hex'),
+    tx: vargs.options.returnTXIDOnly
+      ? undefined
+      : makeAtomicBeef(prior.tx, prior.dcr.inputBeef),
+    sendWithResults
+  }
+
+  return r
+}
+
+export function makeAtomicBeef(
+  tx: BsvTransaction,
+  beef: number[] | Beef
+): number[] {
+  if (Array.isArray(beef)) beef = Beef.fromBinary(beef)
+  beef.mergeTransaction(tx)
+  return beef.toBinaryAtomic(tx.id('hex'))
+}
+
+export async function completeSignedTransaction(
+  prior: PendingSignAction,
+  spends: Record<number, SignActionSpend>,
+  wallet: Wallet
+): Promise<BsvTransaction> {
+  /////////////////////
+  // Insert the user provided unlocking scripts from "spends" arg
+  /////////////////////
+  for (const [key, spend] of Object.entries(spends)) {
+    const vin = Number(key)
+    const createInput = prior.args.inputs[vin]
+    const input = prior.tx.inputs[vin]
+    if (
+      !createInput ||
+      !input ||
+      createInput.unlockingScript ||
+      !Number.isInteger(createInput.unlockingScriptLength)
+    )
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend does not correspond to prior input with valid unlockingScriptLength.`
+      )
+    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
+      )
+    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
+    if (spend.sequenceNumber !== undefined)
+      input.sequence = spend.sequenceNumber
+  }
+
+  const results = {
+    sdk: <SignActionResult>{}
+  }
+
+  /////////////////////
+  // Insert SABPPP unlock templates for wallet signed inputs
+  /////////////////////
+  for (const pdi of prior.pdi) {
+    const sabppp = new ScriptTemplateSABPPP({
+      derivationPrefix: pdi.derivationPrefix,
+      derivationSuffix: pdi.derivationSuffix,
+      keyDeriver: wallet.keyDeriver
+    })
+    const keys = wallet.getClientChangeKeyPair()
+    const lockerPrivKey = keys.privateKey
+    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
+    const sourceSatoshis = pdi.sourceSatoshis
+    const lockingScript = asBsvSdkScript(pdi.lockingScript)
+    const unlockTemplate = sabppp.unlock(
+      lockerPrivKey,
+      unlockerPubKey,
+      sourceSatoshis,
+      lockingScript
+    )
+    const input = prior.tx.inputs[pdi.vin]
+    input.unlockingScriptTemplate = unlockTemplate
+  }
+
+  /////////////////////
+  // Sign wallet signed inputs making transaction fully valid.
+  /////////////////////
+  await prior.tx.sign()
+
+  return prior.tx
+}

package/src/storage/README.md

@@ -0,0 +1,14 @@
+# WalletStorage
+
+Provides access to persistent storage in support of Wallet.interfaces.
+
+This includes:
+
+- Direct storage on a variety of databases.
+- Remoted storage to service providers for backup and mobile support.
+- Synchronization between multiple stores.
+- Import from legacy stores.
+- Support single user, multi-read/single write, full multi-user modes.
+
+
+