@bennyblader/ddk-rn 1.0.0-rc5 → 1.0.0-rc7

package/README.md

@@ -48,7 +48,7 @@ import {
   acceptOffer,
   signAccept,
   finalizeSign,
-  signContractCet,
+  contractCetTransaction,
 } from '@bennyblader/ddk-rn';
 
 const keys = ContractKeyProvider.fromMnemonic(MNEMONIC, undefined, 'regtest');
@@ -71,15 +71,15 @@ const offer = createOffer({
   contractFlags: 0,
 });
 // …acceptOffer → sign the funding PSBT → signAccept → finalizeSign →
-//   signContractCet / signContractRefund
+//   contractCetTransaction / contractRefundTransaction
 ```
 
-Bytes cross the JSI boundary as `ArrayBuffer` (`ddk-ts` uses `Buffer`).
+Bytes cross the JSI boundary as `Uint8Array`, as they do in `@bennyblader/ddk`.
 
-`example/src/App.tsx` runs the complete flow on device — offline, deterministic,
+`../../examples/react-native/src/App.tsx` runs the complete flow on device — offline, deterministic,
 and asserted by the Maestro E2E.
 
-For complete API documentation, see the [main README](../README.md#-the-contract-api).
+For complete API documentation, see the [main README](../../README.md#-the-contract-api).
 
 ## Development
 
@@ -88,96 +88,35 @@ For complete API documentation, see the [main README](../README.md#-the-contract
 - Node.js >= 20
 - Rust >= 1.70
 - pnpm
-- UniFFI React Native, installed globally at the version pinned in
-  `package.json`: `pnpm add -g uniffi-bindgen-react-native@<version>`
+- UniFFI React Native, installed by the root `pnpm install`.
 - iOS: Xcode 14+, CocoaPods
 - Android: Android Studio, NDK 27.1.12297006
 
-> The `uniffi` crate, this package's `uniffi-bindgen-react-native` dependency,
-> and the globally installed binary must all be the same release — the `just`
-> recipes call the binary on `$PATH`, not the one in `node_modules`. A skew shows
-> up as TypeScript errors like "Expected 2 arguments, but got 1" on every
-> generated `.lower()` call.
+> Keep the Rust UniFFI version and both npm generator pins compatible.
+> Root commands use the workspace-local generator.
 
-### Building from Source
+### Building from source
 
-```bash
-# Install dependencies
-pnpm install
-
-# Generate all bindings and build the native libraries
-just build
-```
-
-### Just Commands
-
-```bash
-# JSI + TurboModule bindings, the iOS XCFramework, and ddk-ts
-just build
-
-# Generate JSI bindings only (TypeScript + C++)
-just uniffi-jsi
-
-# Generate TurboModule specifications
-just uniffi-turbo
-
-# Build the iOS XCFramework (release, stripped)
-just build-ios
+Run from the repository root:
 
-# Build the Android JNI libraries (needs the NDK)
-just build-android
-
-# Setup example app
-just example
-
-# iOS example setup
-just example-ios
-
-# Android example build
-just example-android
-
-# Report the size of every binary destined for the npm package
-just binary-sizes
-
-# Clean all generated files
-just clean
+```sh
+just install
+just generate-react-native
+just build react-native ios
+just build react-native android
+just native example-ios
+just example react-native ios
+just example react-native android
 ```
 
-> Adding a new `#[uniffi::export]` needs `just build-ios`, not just
-> `just uniffi-jsi`. `uniffi-jsi` regenerates the TypeScript and C++, but the C++
-> calls into the XCFramework, which only `build-ios` rebuilds — skip it and the
-> app fails at link with `Undefined symbols … _uniffi_ddk_ffi_fn_func_<name>`.
-> Nothing earlier in the chain catches this.
-
-### Project Structure
-
-```
-ddk-rn/
-├── src/                # Generated TypeScript bindings
-│   ├── index.tsx       # Main entry point (generated)
-│   ├── ddk_ffi.ts      # The API consumers import (generated)
-│   ├── ddk_ffi-ffi.ts  # Native JSI symbol declarations (generated)
-│   └── __tests__/      # Hand-written — the only non-generated code in src/
-├── cpp/                # Generated C++ JSI bindings
-│   ├── ddk_ffi.hpp     # C++ header (generated)
-│   ├── ddk_ffi.cpp     # C++ implementation (generated)
-│   └── *.cpp/.h        # TurboModule files (generated)
-├── ios/                # iOS native module
-│   ├── DdkRn.xcframework/ # Prebuilt iOS framework (generated, shipped)
-│   └── *.h/.mm         # iOS bridge code
-├── android/            # Android native module
-│   └── src/main/
-│       ├── java/       # Kotlin/Java bridge code
-│       └── jniLibs/    # Prebuilt native libraries (generated, shipped)
-├── example/            # Example React Native app + Maestro flows
-├── patches/            # pnpm patch for an unreleased ubrn fix
-├── scripts/            # Package verification
-└── ubrn.config.yaml    # UniFFI React Native configuration
-```
+The package's `src/index.tsx` re-exports `src/generated/`. UniFFI owns everything
+under `src/generated/` and the native adapters in `cpp/`, `ios/` and `android/`.
+The example and Maestro flows live in `../../examples/react-native/`.
 
-Everything in `src/` except `src/__tests__/` is generated — don't hand-edit it,
-and don't "fix" lint errors inside it (those files are in `eslintIgnore` for
-exactly that reason).
+Native build and device-test recipes live in this package's `justfile`.
+`just native --list` from the repository root lists the individual steps.
+Rebuild native libraries after changing Rust exports, as generating TypeScript
+alone does not update the linked native symbols.
 
 ### Testing
 
@@ -192,8 +131,8 @@ bindings can't execute under Node, so it asserts instead that generation was
 complete — every function, record, and constructor present in both the
 TypeScript surface and the native symbol layer. It catches the classic
 regression where `ddk-ffi` changed but `ddk-rn` wasn't regenerated. Runtime
-behavior is covered by the shared Rust (`ddk-ffi` unit tests and the `ddk-ts`
-suite exercise the same functions).
+behavior is covered by the shared Rust (`ddk-ffi` unit tests and the `ddk`
+suites exercise the same functions).
 
 ### End-to-end, on a device
 
@@ -204,12 +143,12 @@ launching.
 
 | command | needs | time |
 |---|---|---|
-| `just e2e-flows` | nothing — no device, no app | ~15s |
-| `just e2e-ios-test` | the app already installed | ~10s |
-| `just e2e-ios` | full: build + install + run | ~5-10m |
+| `just native e2e-flows` | nothing — no device, no app | ~15s |
+| `just native e2e-ios-test` | the app already installed | ~10s |
+| `just native e2e-ios` | full: build + install + run | ~5-10m |
 
-Android needs a one-time `just e2e-android-setup` (~1.5GB) to create the
-emulator and AVD, then `just e2e-android`.
+Android needs a one-time `just native e2e-android-setup` (~1.5GB) to create the
+emulator and AVD, then `just native e2e-android`.
 
 While editing a flow, stay in `e2e-ios-test`; only rebuild when the app itself
 changes (JS, Rust, or the generated bindings).
@@ -235,10 +174,10 @@ apps actually build with.
 
 ```bash
 # Install iOS dependencies with new architecture
-just example-ios
+just example react-native ios
 
 # Run the app
-cd example
+cd ../../examples/react-native
 npx react-native run-ios
 ```
 
@@ -246,16 +185,16 @@ npx react-native run-ios
 
 ```bash
 # Build Android app
-just example-android
+just example react-native android
 
 # Run the app
-cd example
+cd ../../examples/react-native
 npx react-native run-android
 ```
 
 ### Release Process
 
-`ddk-ts` and `ddk-rn` are versioned and released together, from the repo root:
+`ddk` and `ddk-rn` are versioned and released together, from the repo root:
 
 ```bash
 just release 0.5.0
@@ -264,7 +203,7 @@ just release 0.5.0
 This will:
 
 1. Check the working directory is clean
-2. Set the version in `ddk-ts/package.json`, `ddk-rn/package.json` and `ddk-ffi/Cargo.toml`
+2. Set the version in `packages/node-browser/package.json`, `packages/react-native/package.json` and `ffi/Cargo.toml`
 3. Commit, tag as `v0.5.0` and push
 
 Publishing happens in CI — pushing the tag is what publishes. The iOS
@@ -284,11 +223,10 @@ All bindings are generated from the compiled `ddk-ffi` library, whose Rust
 source — annotated with UniFFI proc-macros, with no `.udl` file — is the single
 source of truth for the interface.
 
-`@bennyblader/ddk-ts` is hand-written NAPI over the same crates and is kept in
-parity by CI. Two differences to know: bytes are `ArrayBuffer` here and `Buffer`
-there, and a dozen transaction operations are methods on a record here
-(`TxOutput.isDust`, `Transaction.signCet`, …) but free functions there. See the
-[comparison table](../README.md#where-the-two-packages-differ).
+`@bennyblader/ddk` (Node and browsers) is generated from the same library by the
+same bindgen, so it has the same names, the same argument lists and the same
+`Uint8Array` byte type. The one difference: its browser build needs
+`await init()` before the first call.
 
 ### Known Issues
 
@@ -303,7 +241,7 @@ there, and a dozen transaction operations are methods on a record here
 If you encounter build issues on iOS:
 
 ```bash
-cd example/ios
+cd ../../examples/react-native/ios
 pod deintegrate
 pod install
 ```
@@ -313,7 +251,7 @@ pod install
 Clean and rebuild Android:
 
 ```bash
-cd example/android
+cd ../../examples/react-native/android
 ./gradlew clean
 ./gradlew build
 ```
@@ -323,13 +261,13 @@ cd example/android
 If bindings are missing, regenerate them:
 
 ```bash
-just clean
-just build
+pnpm --dir packages/react-native clean
+just build react-native ios
 ```
 
 ### A modified `android/build.gradle` after building
 
-`just build-android <abi>` narrows `abiFilters` to the ABIs you passed and wipes
+`just native build-android <abi>` narrows `abiFilters` to the ABIs you passed and wipes
 `jniLibs/` for the rest. Never commit that — a single-ABI `build.gradle` ships an
 app that only runs on one architecture:
 

package/android/build.gradle

@@ -133,7 +133,6 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "net.java.dev.jna:jna:5.17.0@aar"
 }
 
 if (isNewArchitectureEnabled()) {