@bopen-io/wallet-toolbox 1.7.18

package/src/storage/methods/listActionsIdb.ts

@@ -0,0 +1,183 @@
+import {
+  Transaction as BsvTransaction,
+  ActionStatus,
+  ListActionsResult,
+  WalletAction,
+  WalletActionOutput,
+  WalletActionInput,
+  Validation
+} from '@bsv/sdk'
+import { StorageIdb } from '../StorageIdb'
+import { getLabelToSpecOp, ListActionsSpecOp } from './ListActionsSpecOp'
+import { AuthId } from '../../sdk/WalletStorage.interfaces'
+import { isListActionsSpecOp, TransactionStatus } from '../../sdk/types'
+import { TableOutputX } from '../schema/tables/TableOutput'
+import { asString } from '../../utility/utilityHelpers.noBuffer'
+
+export async function listActionsIdb(
+  storage: StorageIdb,
+  auth: AuthId,
+  vargs: Validation.ValidListActionsArgs
+): Promise<ListActionsResult> {
+  const limit = vargs.limit
+  const offset = vargs.offset
+
+  const r: ListActionsResult = {
+    totalActions: 0,
+    actions: []
+  }
+
+  let specOp: ListActionsSpecOp | undefined = undefined
+  let specOpLabels: string[] = []
+  let labels: string[] = []
+  for (const label of vargs.labels) {
+    if (isListActionsSpecOp(label)) {
+      specOp = getLabelToSpecOp()[label]
+    } else {
+      labels.push(label)
+    }
+  }
+  if (specOp?.labelsToIntercept !== undefined) {
+    const intercept = specOp.labelsToIntercept!
+    const labels2 = labels
+    labels = []
+    if (intercept.length === 0) {
+      specOpLabels = labels2
+    }
+    for (const label of labels2) {
+      if (intercept.indexOf(label) >= 0) {
+        specOpLabels.push(label)
+      } else {
+        labels.push(label)
+      }
+    }
+  }
+
+  let labelIds: number[] = []
+  if (labels.length > 0) {
+    await storage.filterTxLabels({ partial: { userId: auth.userId, isDeleted: false } }, tl => {
+      if (labels.includes(tl.label)) {
+        labelIds.push(tl.txLabelId)
+      }
+    })
+  }
+
+  const isQueryModeAll = vargs.labelQueryMode === 'all'
+  if (isQueryModeAll && labelIds.length < labels.length)
+    // all the required labels don't exist, impossible to satisfy.
+    return r
+
+  if (!isQueryModeAll && labelIds.length === 0 && labels.length > 0)
+    // any and only non-existing labels, impossible to satisfy.
+    return r
+
+  const stati: TransactionStatus[] = specOp?.setStatusFilter
+    ? specOp.setStatusFilter()
+    : ['completed', 'unprocessed', 'sending', 'unproven', 'unsigned', 'nosend', 'nonfinal']
+
+  const noLabels = labelIds.length === 0
+
+  const txs = await storage.findTransactions(
+    {
+      partial: { userId: auth.userId },
+      status: stati,
+      paged: { limit: vargs.limit, offset: vargs.offset },
+      noRawTx: true
+    },
+    labelIds,
+    isQueryModeAll
+  )
+  if (txs.length === vargs.limit) {
+    r.totalActions = await storage.countTransactions(
+      { partial: { userId: auth.userId }, status: stati },
+      labelIds,
+      isQueryModeAll
+    )
+  } else {
+    r.totalActions = txs.length
+  }
+
+  if (specOp?.postProcess) {
+    await specOp.postProcess(storage, auth, vargs, specOpLabels, txs)
+  }
+
+  for (const tx of txs) {
+    const wtx: WalletAction = {
+      txid: tx.txid || '',
+      satoshis: tx.satoshis || 0,
+      status: <ActionStatus>tx.status!,
+      isOutgoing: !!tx.isOutgoing,
+      description: tx.description || '',
+      version: tx.version || 0,
+      lockTime: tx.lockTime || 0
+    }
+    r.actions.push(wtx)
+  }
+
+  if (vargs.includeLabels || vargs.includeInputs || vargs.includeOutputs) {
+    await Promise.all(
+      txs.map(async (tx, i) => {
+        //let i = -1
+        //for (const tx of txs) {
+        //    i++
+        const action = r.actions[i]
+        if (vargs.includeLabels) {
+          action.labels = (await storage.getLabelsForTransactionId(tx.transactionId)).map(l => l.label)
+        }
+        if (vargs.includeOutputs) {
+          const outputs: TableOutputX[] = await storage.findOutputs({
+            partial: { transactionId: tx.transactionId },
+            noScript: !vargs.includeOutputLockingScripts
+          })
+          action.outputs = []
+          for (const o of outputs) {
+            await storage.extendOutput(o, true, true)
+            const wo: WalletActionOutput = {
+              satoshis: o.satoshis || 0,
+              spendable: !!o.spendable,
+              tags: o.tags?.map(t => t.tag) || [],
+              outputIndex: Number(o.vout),
+              outputDescription: o.outputDescription || '',
+              basket: o.basket?.name || ''
+            }
+            if (vargs.includeOutputLockingScripts) wo.lockingScript = asString(o.lockingScript || [])
+            action.outputs.push(wo)
+          }
+        }
+        if (vargs.includeInputs) {
+          const inputs: TableOutputX[] = await storage.findOutputs({
+            partial: { spentBy: tx.transactionId },
+            noScript: !vargs.includeInputSourceLockingScripts
+          })
+          action.inputs = []
+          if (inputs.length > 0) {
+            const rawTx = await storage.getRawTxOfKnownValidTransaction(tx.txid)
+            let bsvTx: BsvTransaction | undefined = undefined
+            if (rawTx) {
+              bsvTx = BsvTransaction.fromBinary(rawTx)
+            }
+            for (const o of inputs) {
+              await storage.extendOutput(o, true, true)
+              const input = bsvTx?.inputs.find(v => v.sourceTXID === o.txid && v.sourceOutputIndex === o.vout)
+              const wo: WalletActionInput = {
+                sourceOutpoint: `${o.txid}.${o.vout}`,
+                sourceSatoshis: o.satoshis || 0,
+                inputDescription: o.outputDescription || '',
+                sequenceNumber: input?.sequence || 0
+              }
+              action.inputs.push(wo)
+              if (vargs.includeInputSourceLockingScripts) {
+                wo.sourceLockingScript = asString(o.lockingScript || [])
+              }
+              if (vargs.includeInputUnlockingScripts) {
+                wo.unlockingScript = input?.unlockingScript?.toHex()
+              }
+            }
+          }
+        }
+        //}
+      })
+    )
+  }
+  return r
+}

package/src/storage/methods/listActionsKnex.ts

@@ -0,0 +1,226 @@
+import {
+  Transaction as BsvTransaction,
+  ActionStatus,
+  ListActionsResult,
+  WalletAction,
+  WalletActionOutput,
+  WalletActionInput,
+  Validation
+} from '@bsv/sdk'
+import { StorageKnex } from '../StorageKnex'
+import { getLabelToSpecOp, ListActionsSpecOp } from './ListActionsSpecOp'
+import { AuthId } from '../../sdk/WalletStorage.interfaces'
+import { isListActionsSpecOp } from '../../sdk/types'
+import { TableTxLabel } from '../schema/tables/TableTxLabel'
+import { TableTransaction } from '../schema/tables/TableTransaction'
+import { verifyOne } from '../../utility/utilityHelpers'
+import { TableOutputX } from '../schema/tables/TableOutput'
+import { asString } from '../../utility/utilityHelpers.noBuffer'
+
+export async function listActions(
+  storage: StorageKnex,
+  auth: AuthId,
+  vargs: Validation.ValidListActionsArgs
+): Promise<ListActionsResult> {
+  const limit = vargs.limit
+  const offset = vargs.offset
+
+  const k = storage.toDb(undefined)
+
+  const r: ListActionsResult = {
+    totalActions: 0,
+    actions: []
+  }
+
+  let specOp: ListActionsSpecOp | undefined = undefined
+  let specOpLabels: string[] = []
+  let labels: string[] = []
+  for (const label of vargs.labels) {
+    if (isListActionsSpecOp(label)) {
+      specOp = getLabelToSpecOp()[label]
+    } else {
+      labels.push(label)
+    }
+  }
+  if (specOp?.labelsToIntercept !== undefined) {
+    const intercept = specOp.labelsToIntercept!
+    const labels2 = labels
+    labels = []
+    if (intercept.length === 0) {
+      specOpLabels = labels2
+    }
+    for (const label of labels2) {
+      if (intercept.indexOf(label) >= 0) {
+        specOpLabels.push(label)
+      } else {
+        labels.push(label)
+      }
+    }
+  }
+
+  let labelIds: number[] = []
+  if (labels.length > 0) {
+    const q = k<TableTxLabel>('tx_labels')
+      .where({
+        userId: auth.userId,
+        isDeleted: false
+      })
+      .whereNotNull('txLabelId')
+      .whereIn('label', labels)
+      .select('txLabelId')
+    const r = await q
+    labelIds = r.map(r => r.txLabelId!)
+  }
+
+  const isQueryModeAll = vargs.labelQueryMode === 'all'
+  if (isQueryModeAll && labelIds.length < labels.length)
+    // all the required labels don't exist, impossible to satisfy.
+    return r
+
+  if (!isQueryModeAll && labelIds.length === 0 && labels.length > 0)
+    // any and only non-existing labels, impossible to satisfy.
+    return r
+
+  const columns: string[] = [
+    'transactionId',
+    'reference',
+    'txid',
+    'satoshis',
+    'status',
+    'isOutgoing',
+    'description',
+    'version',
+    'lockTime'
+  ]
+
+  const stati: string[] = specOp?.setStatusFilter
+    ? specOp.setStatusFilter()
+    : ['completed', 'unprocessed', 'sending', 'unproven', 'unsigned', 'nosend', 'nonfinal']
+
+  const noLabels = labelIds.length === 0
+
+  const makeWithLabelsQueries = () => {
+    const cteq = k.raw(`
+            SELECT ${columns.map(c => 't.' + c).join(',')}, 
+                    (SELECT COUNT(*) 
+                    FROM tx_labels_map AS m 
+                    WHERE m.transactionId = t.transactionId 
+                    AND m.txLabelId IN (${labelIds.join(',')}) 
+                    ) AS lc
+            FROM transactions AS t
+            WHERE t.userId = ${auth.userId}
+            AND t.status in (${stati.map(s => `'${s}'`).join(',')})
+            `)
+
+    const q = k.with('tlc', cteq)
+    q.from('tlc')
+    if (isQueryModeAll) q.where('lc', labelIds.length)
+    else q.where('lc', '>', 0)
+    const qcount = q.clone()
+    q.select(columns)
+    qcount.count('transactionId as total')
+    return { q, qcount }
+  }
+
+  const makeWithoutLabelsQueries = () => {
+    const q = k('transactions').where('userId', auth.userId).whereIn('status', stati)
+    const qcount = q.clone().count('transactionId as total')
+    return { q, qcount }
+  }
+
+  const { q, qcount } = noLabels ? makeWithoutLabelsQueries() : makeWithLabelsQueries()
+
+  q.limit(limit).offset(offset).orderBy('transactionId', 'asc')
+
+  const txs: Partial<TableTransaction>[] = await q
+
+  if (specOp?.postProcess) {
+    await specOp.postProcess(storage, auth, vargs, specOpLabels, txs)
+  }
+
+  if (!limit || txs.length < limit) r.totalActions = txs.length
+  else {
+    const total = verifyOne(await qcount)['total']
+    r.totalActions = Number(total)
+  }
+
+  for (const tx of txs) {
+    const wtx: WalletAction = {
+      txid: tx.txid || '',
+      satoshis: tx.satoshis || 0,
+      status: <ActionStatus>tx.status!,
+      isOutgoing: !!tx.isOutgoing,
+      description: tx.description || '',
+      version: tx.version || 0,
+      lockTime: tx.lockTime || 0
+    }
+    r.actions.push(wtx)
+  }
+
+  if (vargs.includeLabels || vargs.includeInputs || vargs.includeOutputs) {
+    await Promise.all(
+      txs.map(async (tx, i) => {
+        //let i = -1
+        //for (const tx of txs) {
+        //    i++
+        const action = r.actions[i]
+        if (vargs.includeLabels) {
+          action.labels = (await storage.getLabelsForTransactionId(tx.transactionId)).map(l => l.label)
+        }
+        if (vargs.includeOutputs) {
+          const outputs: TableOutputX[] = await storage.findOutputs({
+            partial: { transactionId: tx.transactionId },
+            noScript: !vargs.includeOutputLockingScripts
+          })
+          action.outputs = []
+          for (const o of outputs) {
+            await storage.extendOutput(o, true, true)
+            const wo: WalletActionOutput = {
+              satoshis: o.satoshis || 0,
+              spendable: !!o.spendable,
+              tags: o.tags?.map(t => t.tag) || [],
+              outputIndex: Number(o.vout),
+              outputDescription: o.outputDescription || '',
+              basket: o.basket?.name || ''
+            }
+            if (vargs.includeOutputLockingScripts) wo.lockingScript = asString(o.lockingScript || [])
+            action.outputs.push(wo)
+          }
+        }
+        if (vargs.includeInputs) {
+          const inputs: TableOutputX[] = await storage.findOutputs({
+            partial: { spentBy: tx.transactionId },
+            noScript: !vargs.includeInputSourceLockingScripts
+          })
+          action.inputs = []
+          if (inputs.length > 0) {
+            const rawTx = await storage.getRawTxOfKnownValidTransaction(tx.txid)
+            let bsvTx: BsvTransaction | undefined = undefined
+            if (rawTx) {
+              bsvTx = BsvTransaction.fromBinary(rawTx)
+            }
+            for (const o of inputs) {
+              await storage.extendOutput(o, true, true)
+              const input = bsvTx?.inputs.find(v => v.sourceTXID === o.txid && v.sourceOutputIndex === o.vout)
+              const wo: WalletActionInput = {
+                sourceOutpoint: `${o.txid}.${o.vout}`,
+                sourceSatoshis: o.satoshis || 0,
+                inputDescription: o.outputDescription || '',
+                sequenceNumber: input?.sequence || 0
+              }
+              action.inputs.push(wo)
+              if (vargs.includeInputSourceLockingScripts) {
+                wo.sourceLockingScript = asString(o.lockingScript || [])
+              }
+              if (vargs.includeInputUnlockingScripts) {
+                wo.unlockingScript = input?.unlockingScript?.toHex()
+              }
+            }
+          }
+        }
+        //}
+      })
+    )
+  }
+  return r
+}

package/src/storage/methods/listCertificates.ts

@@ -0,0 +1,73 @@
+import { ListCertificatesResult, OriginatorDomainNameStringUnder250Bytes, Validation } from '@bsv/sdk'
+import { StorageProvider, TableCertificate } from '../index.client'
+import { AuthId, FindCertificatesArgs } from '../../sdk/WalletStorage.interfaces'
+import { Paged } from '../../sdk/types'
+
+export async function listCertificates(
+  storage: StorageProvider,
+  auth: AuthId,
+  vargs: Validation.ValidListCertificatesArgs,
+  originator?: OriginatorDomainNameStringUnder250Bytes
+): Promise<ListCertificatesResult> {
+  const paged: Paged = { limit: vargs.limit, offset: vargs.offset }
+
+  const partial: Partial<TableCertificate> = {
+    userId: auth.userId,
+    isDeleted: false
+  }
+
+  if (vargs.partial) {
+    const vp = vargs.partial
+    if (vp.type) partial['type'] = vp.type
+    if (vp.subject) partial['subject'] = vp.subject
+    if (vp.serialNumber) partial['serialNumber'] = vp.serialNumber
+    if (vp.certifier) partial['certifier'] = vp.certifier
+    if (vp.revocationOutpoint) partial['revocationOutpoint'] = vp.revocationOutpoint
+    if (vp.signature) partial['signature'] = vp.signature
+  }
+
+  const r = await storage.transaction(async trx => {
+    const findCertsArgs: FindCertificatesArgs = {
+      partial,
+      certifiers: vargs.certifiers,
+      types: vargs.types,
+      paged,
+      trx
+    }
+    const certs = await storage.findCertificates(findCertsArgs)
+    const certsWithFields = await Promise.all(
+      certs.map(async cert => {
+        const fields = await storage.findCertificateFields({
+          partial: { certificateId: cert.certificateId, userId: auth.userId },
+          trx
+        })
+        return {
+          ...cert,
+          fields: Object.fromEntries(fields.map(f => [f.fieldName, f.fieldValue])),
+          masterKeyring: Object.fromEntries(fields.map(f => [f.fieldName, f.masterKey]))
+        }
+      })
+    )
+    const r: ListCertificatesResult = {
+      totalCertificates: 0,
+      certificates: certsWithFields.map(cwf => ({
+        type: cwf.type,
+        subject: cwf.subject,
+        serialNumber: cwf.serialNumber,
+        certifier: cwf.certifier,
+        revocationOutpoint: cwf.revocationOutpoint,
+        signature: cwf.signature,
+        fields: cwf.fields,
+        verifier: cwf.verifier,
+        keyring: cwf.masterKeyring
+      }))
+    }
+    if (r.certificates.length < paged.limit) r.totalCertificates = r.certificates.length
+    else {
+      r.totalCertificates = await storage.countCertificates(findCertsArgs)
+    }
+    return r
+  })
+
+  return r
+}

package/src/storage/methods/listOutputsIdb.ts

@@ -0,0 +1,203 @@
+import { Beef, ListOutputsResult, OriginatorDomainNameStringUnder250Bytes, WalletOutput, Validation } from '@bsv/sdk'
+import { getBasketToSpecOp, ListOutputsSpecOp } from './ListOutputsSpecOp'
+import { StorageIdb } from '../StorageIdb'
+import { AuthId, FindOutputsArgs } from '../../sdk/WalletStorage.interfaces'
+import { verifyId } from '../../utility/utilityHelpers'
+import { WERR_NOT_IMPLEMENTED } from '../../sdk/WERR_errors'
+import { TableOutputBasket } from '../schema/tables/TableOutputBasket'
+import { TransactionStatus } from '../../sdk/types'
+import { asString } from '../../utility/utilityHelpers.noBuffer'
+
+export async function listOutputsIdb(
+  storage: StorageIdb,
+  auth: AuthId,
+  vargs: Validation.ValidListOutputsArgs,
+  originator?: OriginatorDomainNameStringUnder250Bytes
+): Promise<ListOutputsResult> {
+  const userId = verifyId(auth.userId)
+  const limit = vargs.limit
+  const offset = vargs.offset
+  if (offset < 0) throw new WERR_NOT_IMPLEMENTED('Negative offset not supported in IndexedDB')
+
+  const r: ListOutputsResult = {
+    totalOutputs: 0,
+    outputs: []
+  }
+
+  /*
+        ListOutputsArgs {
+            basket: BasketStringUnder300Bytes
+
+            tags?: OutputTagStringUnder300Bytes[]
+            tagQueryMode?: 'all' | 'any' // default any
+
+            limit?: PositiveIntegerDefault10Max10000
+            offset?: PositiveIntegerOrZero
+        }
+    */
+
+  let specOp: ListOutputsSpecOp | undefined = undefined
+  let basketId: number | undefined = undefined
+  const basketsById: Record<number, TableOutputBasket> = {}
+  if (vargs.basket) {
+    let b = vargs.basket
+    specOp = getBasketToSpecOp()[b]
+    b = specOp ? (specOp.useBasket ? specOp.useBasket : '') : b
+    if (b) {
+      const baskets = await storage.findOutputBaskets({
+        partial: { userId, name: b }
+      })
+      if (baskets.length !== 1) {
+        // If basket does not exist, result is no outputs.
+        return r
+      }
+      const basket = baskets[0]
+      basketId = basket.basketId!
+      basketsById[basketId!] = basket
+    }
+  }
+
+  let tags = [...vargs.tags]
+  const specOpTags: string[] = []
+  if (specOp && specOp.tagsParamsCount) {
+    specOpTags.push(...tags.splice(0, Math.min(tags.length, specOp.tagsParamsCount)))
+  }
+  if (specOp && specOp.tagsToIntercept) {
+    // Pull out tags used by current specOp
+    const ts = tags
+    tags = []
+    for (const t of ts) {
+      if (specOp.tagsToIntercept.length === 0 || specOp.tagsToIntercept.indexOf(t) >= 0) {
+        specOpTags.push(t)
+        if (t === 'all') {
+          basketId = undefined
+        }
+      } else {
+        tags.push(t)
+      }
+    }
+  }
+
+  if (specOp && specOp.resultFromTags) {
+    const r = await specOp.resultFromTags(storage, auth, vargs, specOpTags)
+    return r
+  }
+
+  let tagIds: number[] = []
+  if (tags && tags.length > 0) {
+    await storage.filterOutputTags({ partial: { userId, isDeleted: false } }, ot => {
+      if (tags.includes(ot.tag)) {
+        tagIds.push(ot.outputTagId)
+      }
+    })
+  }
+
+  const isQueryModeAll = vargs.tagQueryMode === 'all'
+  if (isQueryModeAll && tagIds.length < tags.length)
+    // all the required tags don't exist, impossible to satisfy.
+    return r
+
+  if (!isQueryModeAll && tagIds.length === 0 && tags.length > 0)
+    // any and only non-existing labels, impossible to satisfy.
+    return r
+
+  const noTags = tagIds.length === 0
+  const includeSpent = false
+
+  const stati: TransactionStatus[] = ['completed', 'unproven', 'nosend']
+
+  const args: FindOutputsArgs = {
+    partial: {
+      userId,
+      basketId,
+      spendable: !includeSpent ? true : undefined
+    },
+    txStatus: stati,
+    noScript: true
+  }
+  if (!specOp || !specOp.ignoreLimit) args.paged = { limit, offset }
+
+  let outputs = await storage.findOutputs(args, tagIds, isQueryModeAll)
+  if (outputs.length === vargs.limit) {
+    args.paged = undefined
+    r.totalOutputs = await storage.countOutputs(args, tagIds, isQueryModeAll)
+  } else {
+    r.totalOutputs = outputs.length
+  }
+
+  if (specOp) {
+    if (specOp.filterOutputs) outputs = await specOp.filterOutputs(storage, auth, vargs, specOpTags, outputs)
+    if (specOp.resultFromOutputs) {
+      const r = await specOp.resultFromOutputs(storage, auth, vargs, specOpTags, outputs)
+      return r
+    }
+  }
+
+  /*
+        ListOutputsArgs {
+            include?: 'locking scripts' | 'entire transactions'
+            includeCustomInstructions?: BooleanDefaultFalse
+            includeTags?: BooleanDefaultFalse
+            includeLabels?: BooleanDefaultFalse
+        }
+
+        ListOutputsResult {
+            totalOutputs: PositiveIntegerOrZero
+            BEEF?: BEEF
+            outputs: Array<WalletOutput>
+        }
+
+        WalletOutput {
+            satoshis: SatoshiValue
+            spendable: boolean
+            outpoint: OutpointString
+
+            customInstructions?: string
+            lockingScript?: HexString
+            tags?: OutputTagStringUnder300Bytes[]
+            labels?: LabelStringUnder300Bytes[]
+        }
+    */
+
+  const labelsByTxid: Record<string, string[]> = {}
+
+  const beef = new Beef()
+
+  for (const o of outputs) {
+    const wo: WalletOutput = {
+      satoshis: Number(o.satoshis),
+      spendable: !!o.spendable,
+      outpoint: `${o.txid}.${o.vout}`
+    }
+    r.outputs.push(wo)
+    //if (vargs.includeBasket && o.basketId) {
+    //    if (!basketsById[o.basketId]) {
+    //        basketsById[o.basketId] = verifyTruthy(await dsk.findOutputBasketId(o.basketId!, trx))
+    //    }
+    //    wo.basket = basketsById[o.basketId].name
+    //}
+    if (vargs.includeCustomInstructions && o.customInstructions) wo.customInstructions = o.customInstructions
+    if (vargs.includeLabels && o.txid) {
+      if (labelsByTxid[o.txid] === undefined) {
+        labelsByTxid[o.txid] = (await storage.getLabelsForTransactionId(o.transactionId)).map(l => l.label)
+      }
+      wo.labels = labelsByTxid[o.txid]
+    }
+    if (vargs.includeTags) {
+      wo.tags = (await storage.getTagsForOutputId(o.outputId)).map(t => t.tag)
+    }
+    if (vargs.includeLockingScripts) {
+      await storage.validateOutputScript(o)
+      if (o.lockingScript) wo.lockingScript = asString(o.lockingScript)
+    }
+    if (vargs.includeTransactions && !beef.findTxid(o.txid!)) {
+      await storage.getValidBeefForKnownTxid(o.txid!, beef, undefined, vargs.knownTxids)
+    }
+  }
+
+  if (vargs.includeTransactions) {
+    r.BEEF = beef.toBinary()
+  }
+
+  return r
+}