Coin control

package.json

@@ -38,7 +38,7 @@
     "dash-core-p2p": "https://github.com/pshenmic/dash-core-p2p#7c40475607faf2b9a68d2f897a862b8e249cb2cc",
     "crypto-toothpick": "https://github.com/owl352/crypto-toothpick#900da4edf5df12eef28cfcb38059c4b69c8f4f77",
     "dash-core-sdk": "1.1.3-dev.6",
-    "dash-platform-sdk": "1.5.0-dev.9",
+    "dash-platform-sdk": "1.5.0-dev.10",
     "dash-ui-kit": "1.0.94",
     "electron-log": "^5.4.4",
     "knex": "^3.1.0",

src/main/migrations/0019_shielded_note_nullifier.ts

@@ -0,0 +1,19 @@
+import type {Knex} from 'knex'
+
+// A note's nullifier is derived from the seed, so only a sync can compute it.
+// Persisting it lets a locked wallet ask the chain whether its notes are still
+// spendable — decoding a note needs the seed, checking one does not.
+//
+// Nullable: rows written before this ran have none until the next sync.
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('shielded_notes', table => {
+    table.binary('nullifier').nullable()
+  })
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('shielded_notes', table => {
+    table.dropColumn('nullifier')
+  })
+}

src/main/platform/PlatformService.ts

@@ -19,6 +19,7 @@ import {identityInfos} from './operations/identity/infos'
 import {identityScan} from './operations/identity/scan'
 import {identityNonce} from './operations/identity/nonce'
 import {identityWithdrawal} from './operations/identity/withdrawal'
+import {checkNullifiers} from './operations/shielded/reads/checkNullifiers'
 import {encryptedNotes} from './operations/shielded/reads/encryptedNotes'
 import {notesCount} from './operations/shielded/reads/notesCount'
 import {poolInfo} from './operations/shielded/reads/poolInfo'
@@ -217,6 +218,7 @@ export class PlatformService {
       case 'poolInfo': return poolInfo(ctx)
       case 'notesCount': return notesCount(ctx)
       case 'encryptedNotes': return encryptedNotes(request.payload, ctx)
+      case 'checkNullifiers': return checkNullifiers(request.payload, ctx)
     }
   }
 

src/main/platform/constants.ts

@@ -24,6 +24,10 @@ export const FEE_QUOTE_PUBLIC_KEY = Uint8Array.from(
 // bincode encoding of PlatformAddress::P2pkh: one variant byte, then the hash.
 export const PLATFORM_ADDRESS_BYTES = 21
 
+// Drive caps a proved query at max_returned_elements, and rejects the request
+// rather than truncating it. Versioned, so it can move under a protocol bump.
+export const PROVED_QUERY_LIMIT = 100
+
 export const KEY_SPECS: Array<{purpose: 'AUTHENTICATION' | 'TRANSFER'; securityLevel: 'MASTER' | 'HIGH' | 'CRITICAL'}> = [
   {purpose: 'AUTHENTICATION', securityLevel: 'MASTER'},
   {purpose: 'AUTHENTICATION', securityLevel: 'HIGH'},
@@ -79,6 +83,7 @@ export function laneFor(request: PlatformRequestMessage): string | null {
     case 'poolInfo':
     case 'notesCount':
     case 'encryptedNotes':
+    case 'checkNullifiers':
       return null
   }
 }

src/main/platform/operations/address/createIdentity.ts

@@ -2,7 +2,7 @@ import {IdentityCreateFromAddressesTransitionWASM, IdentityPublicKeyInCreationWA
 import {PlatformOperations} from '../../types/messages'
 import {OperationContext, OperationError} from '../types'
 import {broadcast} from '../broadcast'
-import {DEDUCT_FROM_FIRST, signInputs, toInputAddresses} from './signInputs'
+import {signInputs, toFeeStrategy, toInputAddresses} from './signInputs'
 import {KEY_SPECS} from '../../constants'
 
 type Payload = PlatformOperations['identityCreateFromAddresses']['payload']
@@ -32,7 +32,7 @@ export async function identityCreateFromAddresses(payload: Payload, ctx: Operati
     publicKeys: keys.map(key =>
       new IdentityPublicKeyInCreationWASM(key.keyId, key.spec.purpose, key.spec.securityLevel, 'ECDSA_SECP256K1', false, key.publicKey)),
     inputs: toInputAddresses(inputs),
-    feeStrategy: DEDUCT_FROM_FIRST,
+    feeStrategy: toFeeStrategy(payload.feeStrategy),
     inputWitness: [],
     userFeeIncrease: 0,
   })

src/main/platform/operations/address/infos.ts

@@ -1,26 +1,31 @@
 import {PlatformOperations} from '../../types/messages'
 import {OperationContext} from '../types'
+import {PROVED_QUERY_LIMIT} from '../../constants'
 
 type Payload = PlatformOperations['addressInfos']['payload']
 type Result = PlatformOperations['addressInfos']['result']
 
-// One proof-verified batch, no per-address fallback: the proof either covers
-// the whole query or the call throws, so an address absent from the answer is
+// Proof-verified batches, no per-address fallback: each page's proof either
+// covers that page or the call throws, so an address absent from the answer is
 // absent from state — never an address we failed to ask about (finding R-4).
+// Drive rejects a page over the cap rather than truncating it, so a wallet past
+// one page can only be asked a page at a time.
 export async function addressInfos(payload: Payload, ctx: OperationContext): Promise<Result> {
   const {addresses} = payload
   if (addresses.length === 0) return {infos: []}
 
   const {sdk, network} = ctx
-  const batch = await sdk.platformAddresses.getAddressesInfos(addresses)
-
-  return {
-    infos: batch
+  const infos: Result['infos'] = []
+  for (let start = 0; start < addresses.length; start += PROVED_QUERY_LIMIT) {
+    const batch = await sdk.platformAddresses.getAddressesInfos(addresses.slice(start, start + PROVED_QUERY_LIMIT))
+    infos.push(...batch
       .filter(info => info.address != null)
       .map(info => ({
         address: info.address.toBech32m(network),
         balance: info.balance,
         nonce: info.nonce,
-      })),
+      })))
   }
+
+  return {infos}
 }

src/main/platform/operations/address/signInputs.ts

@@ -3,13 +3,22 @@ import {AddressWitnessWASM, InputAddressWASM, AddressFundsFeeStrategyStepWASM} f
 import {Network} from '../../../src/types/Network'
 import {PLATFORM_ACCOUNT} from '../../../src/constants/addresses'
 import {AddressInput} from '../../types/messages'
+import {FeeStrategyStep} from '../../../src/types/PlatformTransfer'
 
-// Fees come out of the first input for every address-funded transition.
+// What a quote charges, and the wallet's default: the fee comes out of the
+// first input. A priced transition has no strategy of its own to carry.
 export const DEDUCT_FROM_FIRST = [AddressFundsFeeStrategyStepWASM.DeductFromInput(0)]
 
 export const toInputAddresses = (inputs: AddressInput[]): InputAddressWASM[] =>
   inputs.map(input => new InputAddressWASM(input.platformAddress, input.nonce + 1, input.credits))
 
+// Both indexes are positions in the inputs and outputs as this transition
+// submits them, which main resolved them against.
+export const toFeeStrategy = (steps: FeeStrategyStep[]): AddressFundsFeeStrategyStepWASM[] =>
+  steps.map(step => step.kind === 'deductFromInput'
+    ? AddressFundsFeeStrategyStepWASM.DeductFromInput(step.index)
+    : AddressFundsFeeStrategyStepWASM.ReduceOutput(step.index))
+
 export async function signInputs(
   sdk: DashPlatformSDK,
   signable: Uint8Array,

src/main/platform/operations/address/topUpIdentity.ts

@@ -2,7 +2,7 @@ import {IdentityTopUpFromAddressesTransitionWASM} from 'dash-platform-sdk/types.
 import {PlatformOperations} from '../../types/messages'
 import {OperationContext} from '../types'
 import {broadcast} from '../broadcast'
-import {DEDUCT_FROM_FIRST, signInputs, toInputAddresses} from './signInputs'
+import {signInputs, toFeeStrategy, toInputAddresses} from './signInputs'
 
 type Payload = PlatformOperations['identityTopUpFromAddresses']['payload']
 type Result = PlatformOperations['identityTopUpFromAddresses']['result']
@@ -15,7 +15,7 @@ export async function identityTopUpFromAddresses(payload: Payload, ctx: Operatio
   const unsigned = sdk.platformAddresses.createStateTransition('identityTopUpFromAddresses', {
     identityId: identifier,
     inputs: toInputAddresses(inputs),
-    feeStrategy: DEDUCT_FROM_FIRST,
+    feeStrategy: toFeeStrategy(payload.feeStrategy),
     inputWitness: [],
     userFeeIncrease: 0,
   })

src/main/platform/operations/address/transfer.ts

@@ -2,30 +2,32 @@ import {AddressFundsTransferTransitionWASM, OutputAddressWASM} from 'dash-platfo
 import {PlatformOperations} from '../../types/messages'
 import {OperationContext, OperationError} from '../types'
 import {broadcast} from '../broadcast'
-import {DEDUCT_FROM_FIRST, signInputs, toInputAddresses} from './signInputs'
+import {signInputs, toFeeStrategy, toInputAddresses} from './signInputs'
 
 type Payload = PlatformOperations['addressTransfer']['payload']
 type Result = PlatformOperations['addressTransfer']['result']
 
 export async function addressTransfer(payload: Payload, ctx: OperationContext): Promise<Result> {
   const {sdk, network} = ctx
-  const {seed, input, recipient, amountCredits} = payload
+  const {seed, inputs, recipients} = payload
 
-  if (recipient === input.platformAddress) {
-    throw new OperationError('Recipient must be different from the source address', 'internal')
+  // Consensus refuses an output address that is also an input.
+  const paid = new Set(recipients.map(recipient => recipient.address))
+  if (inputs.some(input => paid.has(input.platformAddress))) {
+    throw new OperationError('A recipient cannot also be one of the addresses funding this transfer', 'internal')
   }
 
   ctx.progress('signing', 0, 0)
   const unsigned = sdk.platformAddresses.createStateTransition('addressFundsTransfer', {
-    inputs: toInputAddresses([input]),
-    feeStrategy: DEDUCT_FROM_FIRST,
+    inputs: toInputAddresses(inputs),
+    feeStrategy: toFeeStrategy(payload.feeStrategy),
     userFeeIncrease: 0,
     inputWitness: [],
-    outputs: [new OutputAddressWASM(recipient, amountCredits)],
+    outputs: recipients.map(recipient => new OutputAddressWASM(recipient.address, recipient.amountCredits)),
   })
 
   const transition = AddressFundsTransferTransitionWASM.fromStateTransition(unsigned)
-  transition.inputWitness = await signInputs(sdk, unsigned.getSignableBytes(), [input], seed, network)
+  transition.inputWitness = await signInputs(sdk, unsigned.getSignableBytes(), inputs, seed, network)
 
   return {stHash: await broadcast(sdk, transition.toStateTransition(), ctx)}
 }

src/main/platform/operations/address/withdrawal.ts

@@ -3,7 +3,7 @@ import {coreAddressToScript} from '../../../src/utils/coreScript'
 import {PlatformOperations} from '../../types/messages'
 import {OperationContext} from '../types'
 import {broadcast} from '../broadcast'
-import {DEDUCT_FROM_FIRST, signInputs, toInputAddresses} from './signInputs'
+import {signInputs, toFeeStrategy, toInputAddresses} from './signInputs'
 
 type Payload = PlatformOperations['addressWithdrawal']['payload']
 type Result = PlatformOperations['addressWithdrawal']['result']
@@ -15,7 +15,7 @@ export async function addressWithdrawal(payload: Payload, ctx: OperationContext)
   ctx.progress('signing', 0, 0)
   const unsigned = sdk.platformAddresses.createStateTransition('addressCreditWithdrawal', {
     inputs: toInputAddresses(inputs),
-    feeStrategy: DEDUCT_FROM_FIRST,
+    feeStrategy: toFeeStrategy(payload.feeStrategy),
     inputWitness: [],
     userFeeIncrease: 0,
     coreFeePerByte,

src/main/platform/operations/fee.ts

@@ -24,19 +24,23 @@ import {OperationContext} from './types'
 import {buildAssetLockProof} from './assetLockProof'
 import {DEDUCT_FROM_FIRST} from './address/signInputs'
 import {minimumFee} from './shielded/spend/fee'
-import {MAX_SPEND_NOTES, MIN_BUNDLE_ACTIONS} from './shielded/constants'
-import {IDENTITY_KEY_DEFINITIONS, SHIELD_FUNDING_FEE_RESERVE_CREDITS} from '../../src/constants/credits'
+import {
+  IDENTITY_KEY_DEFINITIONS,
+  MAX_BUNDLE_ACTIONS,
+  MIN_BUNDLE_ACTIONS,
+  SHIELD_FUNDING_FEE_RESERVE_CREDITS,
+} from '../../src/constants/credits'
 
 type Payload = PlatformOperations['transitionFee']['payload']
 type Result = PlatformOperations['transitionFee']['result']
 type CurvePayload = PlatformOperations['spendFeeCurve']['payload']
 type CurveResult = PlatformOperations['spendFeeCurve']['result']
 
-// A spend's fee and its note count define each other, so the caller needs the
-// whole curve to resolve them rather than one point on it.
+// Notes spent and addresses paid both land on the action count, and the fee
+// follows only that, so one curve over every action count answers for both.
 export function spendFeeCurve(payload: CurvePayload): CurveResult {
   return {
-    feeCredits: Array.from({length: MAX_SPEND_NOTES}, (_, index) => minimumFee(payload.kind, index + 1)),
+    feeCredits: Array.from({length: MAX_BUNDLE_ACTIONS}, (_, index) => minimumFee(payload.kind, index + 1)),
   }
 }
 
@@ -56,8 +60,10 @@ export function transitionFee(payload: Payload, ctx: OperationContext): Result {
 
 function protocolFee(operation: TransitionFeeOperation, params: FeeQuoteParams, ctx: OperationContext): bigint {
   switch (operation) {
+    // Consensus meters an input like an output, one address balance write each,
+    // so every address touched is priced at the output rate, plus one for base.
     case 'addressFundsTransfer':
-      return AddressFundsTransferTransitionWASM.estimateMinFee(params.inputCount, paid(params).length)
+      return AddressFundsTransferTransitionWASM.estimateMinFee(0, params.inputCount + paid(params).length + 1)
 
     // What a withdrawal does not spend stays on the address, so no change output.
     case 'addressWithdrawal':

src/main/platform/operations/shielded/checkSpent.ts

@@ -2,6 +2,7 @@ import {DashPlatformSDK} from 'dash-platform-sdk'
 import {RecoveredNoteWASM} from 'pshenmic-dpp'
 
 import {CheckedNote} from '../../types/service'
+import {nullifierStatuses} from './reads/nullifierStatuses'
 
 const hex = (bytes: Uint8Array): string => Buffer.from(bytes).toString('hex')
 
@@ -14,7 +15,7 @@ export async function checkSpent(
 ): Promise<CheckedNote[]> {
   if (recovered.length === 0) return []
 
-  const statuses = await sdk.shielded.getShieldedNullifiers(recovered.map(note => note.nullifier))
+  const statuses = await nullifierStatuses(sdk, recovered.map(note => note.nullifier))
   const byNullifier = new Map(statuses.map(status => [hex(status.nullifier), status.isSpent]))
 
   return recovered.map(recoveredNote => ({recoveredNote, spent: byNullifier.get(hex(recoveredNote.nullifier)) === true}))

src/main/platform/operations/shielded/constants.ts

@@ -1,9 +1 @@
 export const SHIELD_FUNDING_DUMMY_OUTPUTS = 1
-
-// Platform caps state transitions at ~20KB and the Halo2 proof grows with the
-// number of Orchard actions.
-export const MAX_SPEND_NOTES = 6
-
-// An Orchard bundle carries at least two actions, so a single-note spend is
-// still charged for two.
-export const MIN_BUNDLE_ACTIONS = 2

src/main/platform/operations/shielded/reads/checkNullifiers.ts

@@ -0,0 +1,15 @@
+import {PlatformOperations} from '../../../types/messages'
+import {OperationContext} from '../../types'
+import {nullifierStatuses} from './nullifierStatuses'
+
+type Payload = PlatformOperations['checkNullifiers']['payload']
+type Result = PlatformOperations['checkNullifiers']['result']
+
+// Matched by nullifier rather than array position: the response order is not
+// contractual.
+export async function checkNullifiers(payload: Payload, ctx: OperationContext): Promise<Result> {
+  if (payload.nullifiers.length === 0) return {spent: []}
+
+  const statuses = await nullifierStatuses(ctx.sdk, payload.nullifiers)
+  return {spent: statuses.filter(status => status.isSpent).map(status => status.nullifier)}
+}

src/main/platform/operations/shielded/reads/nullifierStatuses.ts

@@ -0,0 +1,17 @@
+import {DashPlatformSDK} from 'dash-platform-sdk'
+import {ShieldedNullifierStatus} from 'dash-platform-sdk/types.js'
+import {PROVED_QUERY_LIMIT} from '../../../constants'
+
+// Drive refuses an oversized query outright rather than truncating it, so a
+// wallet past one page can only be asked about a page at a time.
+export async function nullifierStatuses(
+  sdk: DashPlatformSDK,
+  nullifiers: Uint8Array[],
+): Promise<ShieldedNullifierStatus[]> {
+  const statuses: ShieldedNullifierStatus[] = []
+  for (let start = 0; start < nullifiers.length; start += PROVED_QUERY_LIMIT) {
+    const page = nullifiers.slice(start, start + PROVED_QUERY_LIMIT)
+    statuses.push(...await sdk.shielded.getShieldedNullifiers(page))
+  }
+  return statuses
+}