winnow

Questions worth working on

Research at
Winnow.

A wallet should be able to explain its foundations.
Research is how we decide what comes next.

How do we recover older wallets? How much cryptographic code do we need to maintain? What changes when another device signs, or when Bitcoin gains a different way to receive payments?

These projects give those questions room to be tested. Each starts with a reason to investigate, records what works, and names the evidence still missing before we make new promises to people using Winnow.

From the blog: Bitcoin Beyond Conspiracy Theories — why we trust standard hashes, and what a wallet must preserve to recover safely.

Research notes · Updated

01 / CRYPTOGRAPHYEarly implementation

A focused Bitcoin library,
written in Swift.

Can we own a narrow implementation of the keys and signatures Winnow needs, and justify the responsibility that comes with it?

Winnow already implements its wallet and Bitcoin transaction logic in Swift. At the revision we inspected, its curve operations use P256K, a Swift interface to C libsecp256k1. We want to investigate a small, independently reusable Swift library for that boundary.

The attraction is being able to follow the types and implementation all the way through: a key, a tweak, a signature, and the mathematics behind them. A focused library could make integration and maintenance easier to understand. Build time, binary size, and performance are questions to measure.

This comes with a substantial cost. libsecp256k1 is an established implementation with extensive testing and deliberate treatment of secret operations. Replacing it transfers that responsibility to us. Swift does not, by itself, establish correct arithmetic, safe nonce handling, or constant-time execution.

What is the minimum?

Schnorr still needs secp256k1. Schnorr is the signature scheme; secp256k1 is the curve used by Bitcoin's BIP340. Winnow also needs key parsing and public-key derivation, BIP32 and Taproot tweaks, and the point and scalar operations used by its existing MuSig2 shared-signing code.

The proposed library owns those operations. Transaction formats, wallet policy, networking, backups, and the interface remain in Winnow. The initial production scope does not call for ECDSA, key recovery, or a general-purpose big-integer API.

Proposed architectureA library with a clear job.
  1. The applicationWinnow

    Wallet policy · transactions · MuSig2 coordination · storage · interface

  2. The independent Swift packageBitcoin keys & Schnorr signatures

    Key validation · derivation tweaks · Taproot · required point and scalar operations

    Internal: fixed-width secp256k1 arithmetic
  3. Supported Apple servicesCryptoKit + Security

    Hashing and HMAC · secure random bytes
    Keychain stays with the consuming app.

An intended boundary. The native curve and signing implementation is still to be built.

Use Apple where it fits. Keep the library independent.

CryptoKit supplies hashes and HMAC; Security supplies secure randomness. Apple's public P-256 APIs use a different curve from Bitcoin's secp256k1. They do not provide a drop-in BIP340 signer. Native Swift here means owning the Bitcoin curve implementation in Swift, while using supported platform services.

We want the package to build and test without Winnow, and to be useful beyond this app. A possible contribution to Apple's Swift Crypto project is one direction to explore. Its current contribution rules require maintainer agreement and a usable BoringSSL implementation for new APIs. A native Swift backend therefore needs an explicit upstream decision. Apple acceptance and future CryptoKit availability are open questions.

The next experiments

  1. Verify public inputs. Execute official valid and invalid signature vectors, test arithmetic boundaries, and compare with the existing backend.
  2. Review secret operations. Add signing only with explicit nonce ownership, failure handling, and review of optimized code and secret lifetimes.
  3. Integrate and measure. Exercise Winnow's wallet and shared-signing flows, then validate signed device builds and internal TestFlight builds using test wallets. Record device performance and dependency changes before deciding on migration.
02 / RECOVERYEarly development

Give an old wallet
a way forward.

Winnow Rescue explores how to move funds from older Bitcoin wallet backups into an account the owner already controls.

A backup can outlive the software that created it. Recovery means understanding its format, finding the right keys and outputs, and showing the owner exactly where the money will go. That work deserves a focused tool with explicit limits for every supported format.

Winnow Rescue is being developed separately, with an embeddable Rust core, a command-line interface, and a desktop graphical interface. Its intended destination is an existing Taproot account. Keeping recovery in its own tool lets it address older wallet formats without adding those formats to the everyday phone wallet.

The next experiment

Take one precisely defined wallet format through a reproducible test-coin recovery: discover the funds, review the destination and fee, sign, and verify the resulting payment. Test damaged backups, wrong passwords, and interrupted scans before widening support.

Follow Winnow Rescue

03 / BITCOIN SCRIPTSProtocol research

Understand a different
way to commit.

Pay-to-Merkle-Root asks what changes when an output commits directly to a tree of spending scripts.

BIP360 proposes P2MR: script-tree spending without Taproot's key-path spend. We want to understand the consequences for wallet policy, backups, interoperability, and an eventual opt-in migration.

Removing the exposed output key addresses one part of the long-term public-key exposure problem. It does not replace the signatures inside the scripts with post-quantum signatures. That distinction matters when explaining what the proposal could protect.

The next experiment

Build an isolated experiment with explicit network rules. Check address construction and spending against independent implementations, then exercise backup, restoration, and migration. Record which rules the test network actually enforces.

Read the P2MR proposal Current wallet boundary

04 / SIGNING DEVICESCompatibility research

Work with the hardware
people already own.

Can Winnow coordinate payments with an independent signing device, while keeping approval and recovery understandable?

A separate signer can give a wallet a different boundary for key custody. That only helps if the phone and device agree on the account, receiving addresses, spending policy, and transaction being approved. We are researching compatibility with existing hardware wallets.

The full flow matters: what the device can display and verify, how signing messages travel, how shared-signing nonces are used once, and what happens when approval fails. Recovery must cover a lost phone, a replaced signer, and the backups needed to reconstruct the same policy.

The next experiment

Choose a specific hardware model and firmware, then demonstrate receiving, approving, signing, and restoring a test wallet. Publish the coordinator revision, transport, supported policy, and display limitations. Exercise refusal, disconnection, retries, and replacement before claiming compatibility.

05 / PAYMENT PRIVACYProtocol research

Receive repeatedly.
Reveal less.

Can reusable payment information fit a wallet that discovers its own payments on a phone?

BIP352 Silent Payments lets a recipient publish reusable payment information while senders derive separate on-chain output keys. The motivation is to make repeated receiving more practical without putting the same receiving address into every payment.

The tradeoff is discovery. A recipient needs to identify payments intended for them using transaction input information and their scanning key. For Winnow, the research question includes how that work fits its direct-to-peer design, the cost of restoring a wallet, and what the phone must download and compute. Ordinary compact filters alone do not provide everything needed for discovery.

Silent Payments also needs secret scalar multiplication with public points for a shared-secret calculation (ECDH). That would expand the native Swift library beyond the minimum required by current Winnow. We will evaluate that addition explicitly.

The next experiment

Start with specification vectors and a test-coin exchange with an independent implementation. Measure the data, time, and energy needed to find and restore payments on an iPhone. Test interrupted scans and chain reorganizations. Make the scanning-key, spending-key, and label recovery requirements explicit, and evaluate any server assistance by what it learns about the recipient.

Read BIP352

A question shared by every project

What must survive
the lost device?

A recovery strategy must account for signing authority, coin discovery, spending policy, and any state required to sign safely. Winnow's emphasis on local discovery and Rescue's broader recovery task require separate privacy evaluations: asking a server about wallet-specific scripts or combining coins in a sweep can disclose relationships.

Hash-based signatures make this distinction especially important. SPHINCS+-based SLH-DSA is stateless, but a wallet still needs recoverable keys and account information. Stateful schemes such as XMSS and LMS also require a reliable record of used one-time signing keys. Restoring an old backup can roll that record backward; a chain rescan cannot reveal every signature exported before the device was lost.

These are research questions, not supported post-quantum recovery flows in Winnow or Rescue. The next experiment should specify what is backed up, what can be reconstructed, who learns about the wallet during recovery, and what makes signing safe after restoration.

Read the hash security and recovery explainer

The standard for every project

Let the evidence
set the pace.

Keep the source inspectable. Name the revision and environment behind a result. Test recovery and failure as deliberately as a successful payment. Measure the costs. A useful research result can be a working implementation, a smaller scope, or a well-supported decision to keep the existing approach.

Read the Winnow roadmap