@bennyblader/ddk-rn 0.4.0 → 1.0.0-rc2

package/src/ddk_ffi.ts

@@ -10,21 +10,30 @@ import {
   type UniffiForeignFutureDroppedCallbackStruct,
 } from './ddk_ffi-ffi';
 import {
+  type FfiConverter,
   type UniffiByteArray,
+  type UniffiGcObject,
+  type UniffiHandle,
+  type UniffiObjectFactory,
   AbstractFfiConverterByteArray,
   FfiConverterArray,
-  FfiConverterArrayBuffer,
   FfiConverterBool,
   FfiConverterInt32,
+  FfiConverterObject,
   FfiConverterOptional,
+  FfiConverterUInt16,
   FfiConverterUInt32,
   FfiConverterUInt64,
   FfiConverterUInt8,
+  FfiConverterUint8Array,
   RustBuffer,
+  UniffiAbstractObject,
   UniffiEnum,
   UniffiError,
   UniffiInternalError,
   UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
   uniffiCreateFfiConverterString,
   uniffiCreateRecord,
   uniffiTypeNameSymbol,
@@ -41,13 +50,153 @@ const uniffiIsDebug =
 
 // Public interface members begin here.
 
+/**
+ * Accepts an offer. The accepting party's funding secret key is derived inside
+ * Rust from `keys` + `new_temporary_contract_id` and never crosses the boundary;
+ * it must match `params.party.funding_pubkey` (derive both from the same provider).
+ */
+export function acceptOffer(
+  offer: Uint8Array,
+  params: AcceptOfferParams,
+  keys: ContractKeyProviderLike,
+  newTemporaryContractId: Uint8Array
+): AcceptResult /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterTypeAcceptResult.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_accept_offer(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterTypeAcceptOfferParams.lower(
+            params,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterTypeContractKeyProvider.lower(
+            keys,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            newTemporaryContractId,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * The 32-byte chain hash for a network (`bitcoin` / `testnet` / `signet` /
+ * `regtest`). Use it for [`CreateOfferParams::chain_hash`].
+ */
+export function chainHashFromNetwork(network: string): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_chain_hash_from_network(
+          FfiConverterString.lower(network, nativeModule().rustbuffer_alloc),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * The 32-byte contract id derived from the offer and accept messages — the
+ * stable id of the funded contract. Use it to key stored contracts.
+ */
+export function computeContractId(
+  offer: Uint8Array,
+  accept: Uint8Array
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_compute_contract_id(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Derives the offer/accept payouts for every outcome of a contract from its
+ * wire-encoded `ContractInfo`, for building a payout table to show users.
+ *
+ * Handles both enum contracts (each row a labeled outcome) and numeric-outcome
+ * contracts (each row an inclusive outcome range that shares a single payout,
+ * as determined by the payout function and rounding intervals). Disjoint
+ * contracts contribute the rows of each of their sub-contracts.
+ */
+export function contractInfoPayouts(
+  contractInfo: Uint8Array
+): ContractPayouts /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterTypeContractPayouts.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_contract_info_payouts(
+          FfiConverterUint8Array.lower(
+            contractInfo,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
 export function convertMnemonicToSeed(
   mnemonic: string,
   passphrase: string | undefined
-): ArrayBuffer /*throws*/ {
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
@@ -125,8 +274,8 @@ export function createCet(
 
 export function createCetAdaptorPointsFromOracleInfo(
   oracleInfo: Array<OracleInfo>,
-  msgs: Array<Array<Array<ArrayBuffer>>>
-): Array<ArrayBuffer> /*throws*/ {
+  msgs: Array<Array<Array<Uint8Array>>>
+): Array<Uint8Array> /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
       return FfiConverterSequenceBytes.lift(__rb);
@@ -159,10 +308,10 @@ export function createCetAdaptorPointsFromOracleInfo(
 export function createCetAdaptorSigsFromOracleInfo(
   cets: Array<Transaction>,
   oracleInfo: Array<OracleInfo>,
-  fundingSecretKey: ArrayBuffer,
-  fundingScriptPubkey: ArrayBuffer,
+  fundingSecretKey: Uint8Array,
+  fundingScriptPubkey: Uint8Array,
   fundOutputValue: bigint,
-  msgs: Array<Array<Array<ArrayBuffer>>>
+  msgs: Array<Array<Array<Uint8Array>>>
 ): Array<AdaptorSignature> /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
@@ -185,11 +334,11 @@ export function createCetAdaptorSigsFromOracleInfo(
             oracleInfo,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             fundingSecretKey,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             fundingScriptPubkey,
             nativeModule().rustbuffer_alloc
           ),
@@ -214,9 +363,9 @@ export function createCetAdaptorSigsFromOracleInfo(
  */
 export function createCetAdaptorSigsFromPoints(
   cets: Array<Transaction>,
-  adaptorPoints: Array<ArrayBuffer>,
-  fundingSecretKey: ArrayBuffer,
-  fundingScriptPubkey: ArrayBuffer,
+  adaptorPoints: Array<Uint8Array>,
+  fundingSecretKey: Uint8Array,
+  fundingScriptPubkey: Uint8Array,
   fundOutputValue: bigint
 ): Array<AdaptorSignature> /*throws*/ {
   return ((__rb: Uint8Array) => {
@@ -240,11 +389,11 @@ export function createCetAdaptorSigsFromPoints(
             adaptorPoints,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             fundingSecretKey,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             fundingScriptPubkey,
             nativeModule().rustbuffer_alloc
           ),
@@ -266,8 +415,8 @@ export function createCetAdaptorSigsFromPoints(
 export function createCets(
   fundTxId: string,
   fundVout: number,
-  localFinalScriptPubkey: ArrayBuffer,
-  remoteFinalScriptPubkey: ArrayBuffer,
+  localFinalScriptPubkey: Uint8Array,
+  remoteFinalScriptPubkey: Uint8Array,
   outcomes: Array<Payout>,
   lockTime: number,
   localSerialId: bigint,
@@ -288,11 +437,11 @@ export function createCets(
         return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_cets(
           FfiConverterString.lower(fundTxId, nativeModule().rustbuffer_alloc),
           FfiConverterUInt32.lower(fundVout, nativeModule().rustbuffer_alloc),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             localFinalScriptPubkey,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             remoteFinalScriptPubkey,
             nativeModule().rustbuffer_alloc
           ),
@@ -317,6 +466,61 @@ export function createCets(
   );
 }
 
+/**
+ * Rebuilds the splice `FundingInput` (wire-encoded) that spends a previous
+ * contract's 2-of-2 funding output, from that contract's offer and accept
+ * messages. Only the offering party contributes a splice input; place the
+ * result in the offering party's `funding_inputs`. `max_witness_len` must be
+ * greater than 108 — use [`dlc_input_max_witness_len`].
+ */
+export function createDlcSpliceInput(
+  prevOffer: Uint8Array,
+  prevAccept: Uint8Array,
+  localParty: Party,
+  inputSerialId: bigint | undefined,
+  maxWitnessLen: number
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_dlc_splice_input(
+          FfiConverterUint8Array.lower(
+            prevOffer,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            prevAccept,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterTypeParty.lower(
+            localParty,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterOptionalUInt64.lower(
+            inputSerialId,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUInt16.lower(
+            maxWitnessLen,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
 /**
  * Create complete DLC transactions
  */
@@ -390,12 +594,12 @@ export function createDlcTransactions(
  * Input: 78-byte encoded xpriv, Output: 78-byte encoded xpriv
  */
 export function createExtkeyFromParentPath(
-  extkey: ArrayBuffer,
+  extkey: Uint8Array,
   path: string
-): ArrayBuffer /*throws*/ {
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
@@ -406,10 +610,7 @@ export function createExtkeyFromParentPath(
       ),
       /*caller:*/ (callStatus) => {
         return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_extkey_from_parent_path(
-          FfiConverterArrayBuffer.lower(
-            extkey,
-            nativeModule().rustbuffer_alloc
-          ),
+          FfiConverterUint8Array.lower(extkey, nativeModule().rustbuffer_alloc),
           FfiConverterString.lower(path, nativeModule().rustbuffer_alloc),
           callStatus
         );
@@ -424,12 +625,12 @@ export function createExtkeyFromParentPath(
  * Returns 78-byte encoded xpriv
  */
 export function createExtkeyFromSeed(
-  seed: ArrayBuffer,
+  seed: Uint8Array,
   network: string
-): ArrayBuffer /*throws*/ {
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
@@ -440,7 +641,7 @@ export function createExtkeyFromSeed(
       ),
       /*caller:*/ (callStatus) => {
         return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_extkey_from_seed(
-          FfiConverterArrayBuffer.lower(seed, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(seed, nativeModule().rustbuffer_alloc),
           FfiConverterString.lower(network, nativeModule().rustbuffer_alloc),
           callStatus
         );
@@ -454,12 +655,12 @@ export function createExtkeyFromSeed(
  * Create a funding script pubkey for DLC transactions
  */
 export function createFundTxLockingScript(
-  localFundPubkey: ArrayBuffer,
-  remoteFundPubkey: ArrayBuffer
-): ArrayBuffer /*throws*/ {
+  localFundPubkey: Uint8Array,
+  remoteFundPubkey: Uint8Array
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
@@ -470,11 +671,11 @@ export function createFundTxLockingScript(
       ),
       /*caller:*/ (callStatus) => {
         return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_fund_tx_locking_script(
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             localFundPubkey,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             remoteFundPubkey,
             nativeModule().rustbuffer_alloc
           ),
@@ -486,12 +687,71 @@ export function createFundTxLockingScript(
   );
 }
 
+/**
+ * Rebuilds the BIP-174 funding PSBT from the offer and accept messages.
+ */
+export function createFundingPsbt(
+  offer: Uint8Array,
+  accept: Uint8Array
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_funding_psbt(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Creates an offer. Returns the wire-encoded `OfferDlc` to send to the accepting party.
+ */
+export function createOffer(params: CreateOfferParams): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_offer(
+          FfiConverterTypeCreateOfferParams.lower(
+            params,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
 /**
  * Create a refund transaction
  */
 export function createRefundTransaction(
-  localFinalScriptPubkey: ArrayBuffer,
-  remoteFinalScriptPubkey: ArrayBuffer,
+  localFinalScriptPubkey: Uint8Array,
+  remoteFinalScriptPubkey: Uint8Array,
   localAmount: bigint,
   remoteAmount: bigint,
   lockTime: number,
@@ -511,11 +771,11 @@ export function createRefundTransaction(
       ),
       /*caller:*/ (callStatus) => {
         return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_refund_transaction(
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             localFinalScriptPubkey,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             remoteFinalScriptPubkey,
             nativeModule().rustbuffer_alloc
           ),
@@ -611,14 +871,14 @@ export function createSplicedDlcTransactions(
  * This function handles both seeds (64 bytes) and xprivs (78 bytes) which is confusing
  */
 export function createXprivFromParentPath(
-  seedOrXpriv: ArrayBuffer,
+  seedOrXpriv: Uint8Array,
   baseDerivationPath: string,
   network: string,
   path: string
-): ArrayBuffer /*throws*/ {
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
@@ -629,7 +889,7 @@ export function createXprivFromParentPath(
       ),
       /*caller:*/ (callStatus) => {
         return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_create_xpriv_from_parent_path(
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             seedOrXpriv,
             nativeModule().rustbuffer_alloc
           ),
@@ -647,13 +907,59 @@ export function createXprivFromParentPath(
   );
 }
 
+/**
+ * The required `max_witness_len` for a DLC (splice) funding input (220).
+ */
+export function dlcInputMaxWitnessLen(): number {
+  return FfiConverterUInt16.lift(
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_dlc_input_max_witness_len(
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Rebuilds the unsigned funding, CET, and refund transactions from the messages.
+ */
+export function dlcTransactionsFromMessages(
+  offer: Uint8Array,
+  accept: Uint8Array
+): DlcTransactions /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterTypeDlcTransactions.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_dlc_transactions_from_messages(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
 export function extractEcdsaSignatureFromOracleSignatures(
-  oracleSignatures: Array<ArrayBuffer>,
-  adaptorSignature: ArrayBuffer
-): ArrayBuffer /*throws*/ {
+  oracleSignatures: Array<Uint8Array>,
+  adaptorSignature: Uint8Array
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
@@ -668,7 +974,7 @@ export function extractEcdsaSignatureFromOracleSignatures(
             oracleSignatures,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(
             adaptorSignature,
             nativeModule().rustbuffer_alloc
           ),
@@ -681,31 +987,35 @@ export function extractEcdsaSignatureFromOracleSignatures(
 }
 
 /**
- * Extract public key from extended key (private or public)
- * Input: 78-byte encoded xpriv/xpub, Output: 33-byte compressed public key
+ * The accepting party verifies the sign message and completes the funding
+ * transaction. Returns the Bitcoin consensus-serialized signed transaction.
  */
-export function getPubkeyFromExtkey(
-  extkey: ArrayBuffer,
-  network: string
-): ArrayBuffer /*throws*/ {
+export function finalizeSign(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  sign: Uint8Array,
+  signedFundingPsbt: Uint8Array
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
   })(
     uniffiCaller.rustCallWithError(
-      /*liftError:*/ FfiConverterTypeDLCError.lift.bind(
-        FfiConverterTypeDLCError
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
       ),
       /*caller:*/ (callStatus) => {
-        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_get_pubkey_from_extkey(
-          FfiConverterArrayBuffer.lower(
-            extkey,
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_finalize_sign(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(sign, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(
+            signedFundingPsbt,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterString.lower(network, nativeModule().rustbuffer_alloc),
           callStatus
         );
       },
@@ -715,15 +1025,44 @@ export function getPubkeyFromExtkey(
 }
 
 /**
- * Get total input virtual size for fee calculation
+ * Like [`finalize_sign`], but additionally completes the 2-of-2 witness for any
+ * splice (DLC) funding input using this (accepting) party's prior funding keys,
+ * re-derived inside Rust from `keys`.
  */
-export function getTotalInputVsize(inputs: Array<TxInputInfo>): number {
-  return FfiConverterUInt32.lift(
-    uniffiCaller.rustCall(
+export function finalizeSignSpliced(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  sign: Uint8Array,
+  signedFundingPsbt: Uint8Array,
+  keys: ContractKeyProviderLike,
+  spliceKeys: Array<SpliceKeyRef>
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
       /*caller:*/ (callStatus) => {
-        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_get_total_input_vsize(
-          FfiConverterSequenceTypeTxInputInfo.lower(
-            inputs,
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_finalize_sign_spliced(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(sign, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(
+            signedFundingPsbt,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterTypeContractKeyProvider.lower(
+            keys,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterSequenceTypeSpliceKeyRef.lower(
+            spliceKeys,
             nativeModule().rustbuffer_alloc
           ),
           callStatus
@@ -735,16 +1074,77 @@ export function getTotalInputVsize(inputs: Array<TxInputInfo>): number {
 }
 
 /**
- * Convert extended private key to extended public key
- * Input: 78-byte encoded xpriv, Output: 78-byte encoded xpub
+ * Builds a wire-encoded `FundingInput` from a wallet UTXO, ready to place in a
+ * party's `funding_inputs`.
+ *
+ * - `previous_transaction`: the full consensus-serialized transaction that
+ * created the UTXO being spent.
+ * - `vout`: the output index of the UTXO within that transaction.
+ * - `input_serial_id`: orders the input in the funding transaction; randomly
+ * generated when `None`.
+ * - `sequence`: the input sequence (usually `0xffffffff`).
+ * - `max_witness_len`: the input's maximum witness length (e.g. 108 for
+ * P2WPKH).
+ * - `redeem_script`: the redeem script for a P2SH input, or empty for others.
  */
-export function getXpubFromXpriv(
-  xpriv: ArrayBuffer,
+export function fundingInput(
+  previousTransaction: Uint8Array,
+  vout: number,
+  inputSerialId: bigint | undefined,
+  sequence: number,
+  maxWitnessLen: number,
+  redeemScript: Uint8Array
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_funding_input(
+          FfiConverterUint8Array.lower(
+            previousTransaction,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUInt32.lower(vout, nativeModule().rustbuffer_alloc),
+          FfiConverterOptionalUInt64.lower(
+            inputSerialId,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUInt32.lower(sequence, nativeModule().rustbuffer_alloc),
+          FfiConverterUInt16.lower(
+            maxWitnessLen,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            redeemScript,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Extract public key from extended key (private or public)
+ * Input: 78-byte encoded xpriv/xpub, Output: 33-byte compressed public key
+ */
+export function getPubkeyFromExtkey(
+  extkey: Uint8Array,
   network: string
-): ArrayBuffer /*throws*/ {
+): Uint8Array /*throws*/ {
   return ((__rb: Uint8Array) => {
     try {
-      return FfiConverterArrayBuffer.lift(__rb);
+      return FfiConverterUint8Array.lift(__rb);
     } finally {
       nativeModule().rustbuffer_free(__rb);
     }
@@ -754,8 +1154,8 @@ export function getXpubFromXpriv(
         FfiConverterTypeDLCError
       ),
       /*caller:*/ (callStatus) => {
-        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_get_xpub_from_xpriv(
-          FfiConverterArrayBuffer.lower(xpriv, nativeModule().rustbuffer_alloc),
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_get_pubkey_from_extkey(
+          FfiConverterUint8Array.lower(extkey, nativeModule().rustbuffer_alloc),
           FfiConverterString.lower(network, nativeModule().rustbuffer_alloc),
           callStatus
         );
@@ -765,14 +1165,414 @@ export function getXpubFromXpriv(
   );
 }
 
-export function verifyCetAdaptorSigsFromOracleInfo(
-  adaptorSigs: Array<AdaptorSignature>,
-  cets: Array<Transaction>,
+/**
+ * Get total input virtual size for fee calculation
+ */
+export function getTotalInputVsize(inputs: Array<TxInputInfo>): number {
+  return FfiConverterUInt32.lift(
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_get_total_input_vsize(
+          FfiConverterSequenceTypeTxInputInfo.lower(
+            inputs,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Convert extended private key to extended public key
+ * Input: 78-byte encoded xpriv, Output: 78-byte encoded xpub
+ */
+export function getXpubFromXpriv(
+  xpriv: Uint8Array,
+  network: string
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeDLCError.lift.bind(
+        FfiConverterTypeDLCError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_get_xpub_from_xpriv(
+          FfiConverterUint8Array.lower(xpriv, nativeModule().rustbuffer_alloc),
+          FfiConverterString.lower(network, nativeModule().rustbuffer_alloc),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * The offering party verifies the accept message and produces its `SignDlc`.
+ * The offer party's funding secret key is derived from `keys` +
+ * `temporary_contract_id` (the new contract's id).
+ */
+export function signAccept(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  keys: ContractKeyProviderLike,
+  temporaryContractId: Uint8Array,
+  signedFundingPsbt: Uint8Array
+): SignResult /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterTypeSignResult.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_sign_accept(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          FfiConverterTypeContractKeyProvider.lower(
+            keys,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            temporaryContractId,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            signedFundingPsbt,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Like [`sign_accept`], but additionally co-signs any splice (DLC) funding
+ * inputs. For each splice input, `splice_keys` names the previous contract; the
+ * prior funding secret key is re-derived inside Rust from `keys`.
+ */
+export function signAcceptSpliced(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  keys: ContractKeyProviderLike,
+  temporaryContractId: Uint8Array,
+  signedFundingPsbt: Uint8Array,
+  spliceKeys: Array<SpliceKeyRef>
+): SignResult /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterTypeSignResult.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_sign_accept_spliced(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          FfiConverterTypeContractKeyProvider.lower(
+            keys,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            temporaryContractId,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            signedFundingPsbt,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterSequenceTypeSpliceKeyRef.lower(
+            spliceKeys,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Signs the CET matching a set of oracle attestations, returning the Bitcoin
+ * consensus-serialized transaction. It pays each party the attested outcome's
+ * payout and is ready to broadcast — no network access happens here.
+ *
+ * The settling party's funding secret key is derived inside Rust from `keys` +
+ * `temporary_contract_id` — the settling party's OWN temporary id (the offer's
+ * for the offering party, the `new_temporary_contract_id` passed to
+ * `accept_offer` for the accepting party). The key also identifies which side
+ * is settling, so there is no party argument to get wrong. Either party can
+ * settle alone: the counterparty's half of the 2-of-2 comes from decrypting its
+ * CET adaptor signature with the oracle signatures.
+ *
+ * Each entry in `attestations` pairs a wire-encoded `OracleAttestation` with
+ * the index of its oracle in the announcements of the contract info it settles.
+ * Attestations are verified against the announcements they claim to come from,
+ * so a forged or misindexed one cannot produce a CET
+ * ([`ContractError::InvalidAttestation`]). When no contract outcome matches the
+ * attested outcomes, [`ContractError::NoMatchingOutcome`] is returned — which
+ * is also what an attestation for an unrelated event looks like.
+ */
+export function signContractCet(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  sign: Uint8Array,
+  keys: ContractKeyProviderLike,
+  temporaryContractId: Uint8Array,
+  attestations: Array<OracleAttestationRef>
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_sign_contract_cet(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(sign, nativeModule().rustbuffer_alloc),
+          FfiConverterTypeContractKeyProvider.lower(
+            keys,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            temporaryContractId,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterSequenceTypeOracleAttestationRef.lower(
+            attestations,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Signs the refund transaction, returning the Bitcoin consensus-serialized
+ * transaction. It returns each party its own collateral and can only be
+ * broadcast once the offer's `refund_locktime` has passed — enforcing that is
+ * the chain's job, not this function's.
+ *
+ * As with [`sign_contract_cet`], `temporary_contract_id` is the settling
+ * party's own temporary id and identifies which side is settling. Both parties
+ * signed the refund during the offer/accept exchange, so this only adds this
+ * party's half; the counterparty's stored signature is verified first.
+ */
+export function signContractRefund(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  sign: Uint8Array,
+  keys: ContractKeyProviderLike,
+  temporaryContractId: Uint8Array
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_sign_contract_refund(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(sign, nativeModule().rustbuffer_alloc),
+          FfiConverterTypeContractKeyProvider.lower(
+            keys,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterUint8Array.lower(
+            temporaryContractId,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Signs a party's own funding inputs on the funding PSBT using a private output
+ * descriptor (e.g. bdk's `wpkh(...)` with an xprv), returning the updated PSBT.
+ * Each entry in `inputs` names one of this party's funding inputs (by serial
+ * id) and the descriptor wildcard index that derives its key. Supports `wpkh()`
+ * and `sh(wpkh())`, with or without a wildcard.
+ */
+export function signFundingPsbtWithDescriptor(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  fundingPsbt: Uint8Array,
+  descriptor: string,
+  inputs: Array<DescriptorInput>
+): Uint8Array /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterUint8Array.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+        FfiConverterTypeContractError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_ddk_ffi_fn_func_sign_funding_psbt_with_descriptor(
+          FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(
+            fundingPsbt,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterString.lower(descriptor, nativeModule().rustbuffer_alloc),
+          FfiConverterSequenceTypeDescriptorInput.lower(
+            inputs,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Validates an accept message against its offer: the acceptor's CET adaptor
+ * signatures and refund signature must be valid for the contract the two
+ * messages describe. This is the same check `sign_accept` runs internally,
+ * exposed so a stored/received `AcceptDlc` can be verified on its own.
+ */
+export function validateAccept(
+  offer: Uint8Array,
+  accept: Uint8Array
+): void /*throws*/ {
+  uniffiCaller.rustCallWithError(
+    /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+      FfiConverterTypeContractError
+    ),
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_ddk_ffi_fn_func_validate_accept(
+        FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+        FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * Validates an offer's protocol version, funding inputs, fee rate, collateral,
+ * and oracle timeouts.
+ *
+ * The lifecycle functions already validate internally (`accept_offer` validates
+ * the offer, `sign_accept` validates the accept, `finalize_sign` validates the
+ * sign); these `validate_*` functions expose the same checks standalone, so a
+ * consumer can independently verify a stored or received message at any time —
+ * e.g. before persisting it, or when loading it back later.
+ */
+export function validateOffer(
+  offer: Uint8Array,
+  minTimeoutInterval: number,
+  maxTimeoutInterval: number
+): void /*throws*/ {
+  uniffiCaller.rustCallWithError(
+    /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+      FfiConverterTypeContractError
+    ),
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_ddk_ffi_fn_func_validate_offer(
+        FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+        FfiConverterUInt32.lower(
+          minTimeoutInterval,
+          nativeModule().rustbuffer_alloc
+        ),
+        FfiConverterUInt32.lower(
+          maxTimeoutInterval,
+          nativeModule().rustbuffer_alloc
+        ),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * Validates a sign message against its offer and accept: the offerer's CET
+ * adaptor signatures and refund signature must be valid. This is the same
+ * check `finalize_sign` runs internally, exposed so a stored/received `SignDlc`
+ * can be verified on its own.
+ */
+export function validateSign(
+  offer: Uint8Array,
+  accept: Uint8Array,
+  sign: Uint8Array
+): void /*throws*/ {
+  uniffiCaller.rustCallWithError(
+    /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+      FfiConverterTypeContractError
+    ),
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_ddk_ffi_fn_func_validate_sign(
+        FfiConverterUint8Array.lower(offer, nativeModule().rustbuffer_alloc),
+        FfiConverterUint8Array.lower(accept, nativeModule().rustbuffer_alloc),
+        FfiConverterUint8Array.lower(sign, nativeModule().rustbuffer_alloc),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+export function verifyCetAdaptorSigsFromOracleInfo(
+  adaptorSigs: Array<AdaptorSignature>,
+  cets: Array<Transaction>,
   oracleInfos: Array<OracleInfo>,
-  pubkey: ArrayBuffer,
-  fundingScriptPubkey: ArrayBuffer,
+  pubkey: Uint8Array,
+  fundingScriptPubkey: Uint8Array,
   totalCollateral: bigint,
-  msgs: Array<Array<Array<ArrayBuffer>>>
+  msgs: Array<Array<Array<Uint8Array>>>
 ): boolean {
   return FfiConverterBool.lift(
     uniffiCaller.rustCall(
@@ -790,11 +1590,8 @@ export function verifyCetAdaptorSigsFromOracleInfo(
             oracleInfos,
             nativeModule().rustbuffer_alloc
           ),
-          FfiConverterArrayBuffer.lower(
-            pubkey,
-            nativeModule().rustbuffer_alloc
-          ),
-          FfiConverterArrayBuffer.lower(
+          FfiConverterUint8Array.lower(pubkey, nativeModule().rustbuffer_alloc),
+          FfiConverterUint8Array.lower(
             fundingScriptPubkey,
             nativeModule().rustbuffer_alloc
           ),
@@ -831,93 +1628,143 @@ export function version(): string {
   );
 }
 
-export type AdaptorSignature = {
-  signature: ArrayBuffer;
-  proof: ArrayBuffer;
+/**
+ * One party's Bitcoin-level contract data (mirrors [`ddk::contract::PartyParams`]).
+ */
+export type ContractPartyParams = {
+  /**
+   * The 33-byte compressed DLC funding public key.
+   */
+  fundingPubkey: Uint8Array;
+  /**
+   * The wallet UTXOs this party contributes, each a wire-encoded `FundingInput`.
+   */
+  fundingInputs: Array<Uint8Array>;
+  /**
+   * The script pubkey (raw bytes) CET and refund payouts are sent to.
+   */
+  payoutSpk: Uint8Array;
+  /**
+   * Serial id ordering the payout output; randomly generated when `None`.
+   */
+  payoutSerialId?: bigint;
+  /**
+   * The script pubkey (raw bytes) funding change is sent to.
+   */
+  changeSpk: Uint8Array;
+  /**
+   * Serial id ordering the change output; randomly generated when `None`.
+   */
+  changeSerialId?: bigint;
 };
 
 /**
- * Generated factory for {@link AdaptorSignature} record objects.
+ * Generated factory for {@link ContractPartyParams} record objects.
  */
-export const AdaptorSignature = (() => {
+export const ContractPartyParams = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<AdaptorSignature, ReturnType<typeof defaults>>(
+    return uniffiCreateRecord<ContractPartyParams, ReturnType<typeof defaults>>(
       defaults
     );
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<AdaptorSignature>,
-    verifyFromOracleInfo(
-      self_: AdaptorSignature,
-      cet: Transaction,
-      oracleInfos: Array<OracleInfo>,
-      pubkey: ArrayBuffer,
-      fundingScriptPubkey: ArrayBuffer,
-      totalCollateral: bigint,
-      msgs: Array<Array<ArrayBuffer>>
-    ): boolean {
-      return FfiConverterBool.lift(
-        uniffiCaller.rustCall(
-          /*caller:*/ (callStatus) => {
-            return nativeModule().ubrn_uniffi_ddk_ffi_fn_method_adaptorsignature_verify_from_oracle_info(
-              FfiConverterTypeAdaptorSignature.lower(
-                self_,
-                nativeModule().rustbuffer_alloc
-              ),
-              FfiConverterTypeTransaction.lower(
-                cet,
-                nativeModule().rustbuffer_alloc
-              ),
-              FfiConverterSequenceTypeOracleInfo.lower(
-                oracleInfos,
-                nativeModule().rustbuffer_alloc
-              ),
-              FfiConverterArrayBuffer.lower(
-                pubkey,
-                nativeModule().rustbuffer_alloc
-              ),
-              FfiConverterArrayBuffer.lower(
-                fundingScriptPubkey,
-                nativeModule().rustbuffer_alloc
-              ),
-              FfiConverterUInt64.lower(
-                totalCollateral,
-                nativeModule().rustbuffer_alloc
-              ),
-              FfiConverterSequenceSequenceBytes.lower(
-                msgs,
-                nativeModule().rustbuffer_alloc
-              ),
-              callStatus
-            );
-          },
-          /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
-        )
+    defaults: () => Object.freeze(defaults()) as Partial<ContractPartyParams>,
+  });
+})();
+
+const FfiConverterTypeContractPartyParams = (() => {
+  type TypeName = ContractPartyParams;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        fundingPubkey: FfiConverterUint8Array.read(from),
+        fundingInputs: FfiConverterSequenceBytes.read(from),
+        payoutSpk: FfiConverterUint8Array.read(from),
+        payoutSerialId: FfiConverterOptionalUInt64.read(from),
+        changeSpk: FfiConverterUint8Array.read(from),
+        changeSerialId: FfiConverterOptionalUInt64.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUint8Array.write(value.fundingPubkey, into);
+      FfiConverterSequenceBytes.write(value.fundingInputs, into);
+      FfiConverterUint8Array.write(value.payoutSpk, into);
+      FfiConverterOptionalUInt64.write(value.payoutSerialId, into);
+      FfiConverterUint8Array.write(value.changeSpk, into);
+      FfiConverterOptionalUInt64.write(value.changeSerialId, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUint8Array.allocationSize(value.fundingPubkey) +
+        FfiConverterSequenceBytes.allocationSize(value.fundingInputs) +
+        FfiConverterUint8Array.allocationSize(value.payoutSpk) +
+        FfiConverterOptionalUInt64.allocationSize(value.payoutSerialId) +
+        FfiConverterUint8Array.allocationSize(value.changeSpk) +
+        FfiConverterOptionalUInt64.allocationSize(value.changeSerialId)
       );
-    },
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Parameters for [`accept_offer`] (mirrors [`ddk::contract::AcceptOfferParams`]).
+ */
+export type AcceptOfferParams = {
+  /**
+   * The accepting party's Bitcoin-level contract data.
+   */
+  party: ContractPartyParams;
+  /**
+   * The minimum accepted interval between oracle maturity and the refund locktime.
+   */
+  minTimeoutInterval: number;
+  /**
+   * The maximum accepted interval between oracle maturity and the refund locktime.
+   */
+  maxTimeoutInterval: number;
+};
+
+/**
+ * Generated factory for {@link AcceptOfferParams} record objects.
+ */
+export const AcceptOfferParams = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<AcceptOfferParams, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<AcceptOfferParams>,
   });
 })();
 
-const FfiConverterTypeAdaptorSignature = (() => {
-  type TypeName = AdaptorSignature;
+const FfiConverterTypeAcceptOfferParams = (() => {
+  type TypeName = AcceptOfferParams;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        signature: FfiConverterArrayBuffer.read(from),
-        proof: FfiConverterArrayBuffer.read(from),
+        party: FfiConverterTypeContractPartyParams.read(from),
+        minTimeoutInterval: FfiConverterUInt32.read(from),
+        maxTimeoutInterval: FfiConverterUInt32.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterArrayBuffer.write(value.signature, into);
-      FfiConverterArrayBuffer.write(value.proof, into);
+      FfiConverterTypeContractPartyParams.write(value.party, into);
+      FfiConverterUInt32.write(value.minTimeoutInterval, into);
+      FfiConverterUInt32.write(value.maxTimeoutInterval, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterArrayBuffer.allocationSize(value.signature) +
-        FfiConverterArrayBuffer.allocationSize(value.proof)
+        FfiConverterTypeContractPartyParams.allocationSize(value.party) +
+        FfiConverterUInt32.allocationSize(value.minTimeoutInterval) +
+        FfiConverterUInt32.allocationSize(value.maxTimeoutInterval)
       );
     }
   }
@@ -986,97 +1833,55 @@ const stringConverter = (() => {
 })();
 const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
 
-/**
- * Debug info for CET adaptor signature inputs.
- *
- * Contains all the values that go into creating an adaptor signature,
- * useful for comparing with external signers during debugging.
- *
- * This struct is intentionally always available (not feature-gated)
- * to support production debugging scenarios.
- */
-export type CetAdaptorSignatureDebugInfo = {
-  /**
-   * The sighash (32 bytes) - this is the message that gets signed
-   */
-  sighash: ArrayBuffer;
-  /**
-   * The adaptor point (33 bytes compressed public key)
-   */
-  adaptorPoint: ArrayBuffer;
-  /**
-   * Input index (always 0 for CETs)
-   */
-  inputIndex: number;
-  /**
-   * The funding script pubkey used for sighash
-   */
-  scriptPubkey: ArrayBuffer;
-  /**
-   * The fund output value used for sighash
-   */
-  value: bigint;
-  /**
-   * The CET txid
-   */
-  cetTxid: string;
-  /**
-   * Raw CET bytes for verification
-   */
-  cetRaw: ArrayBuffer;
+export type TxInput = {
+  txid: string;
+  vout: number;
+  scriptSig: Uint8Array;
+  sequence: number;
+  witness: Array<Uint8Array>;
 };
 
 /**
- * Generated factory for {@link CetAdaptorSignatureDebugInfo} record objects.
+ * Generated factory for {@link TxInput} record objects.
  */
-export const CetAdaptorSignatureDebugInfo = (() => {
+export const TxInput = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<
-      CetAdaptorSignatureDebugInfo,
-      ReturnType<typeof defaults>
-    >(defaults);
+    return uniffiCreateRecord<TxInput, ReturnType<typeof defaults>>(defaults);
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () =>
-      Object.freeze(defaults()) as Partial<CetAdaptorSignatureDebugInfo>,
+    defaults: () => Object.freeze(defaults()) as Partial<TxInput>,
   });
 })();
 
-const FfiConverterTypeCetAdaptorSignatureDebugInfo = (() => {
-  type TypeName = CetAdaptorSignatureDebugInfo;
+const FfiConverterTypeTxInput = (() => {
+  type TypeName = TxInput;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        sighash: FfiConverterArrayBuffer.read(from),
-        adaptorPoint: FfiConverterArrayBuffer.read(from),
-        inputIndex: FfiConverterUInt32.read(from),
-        scriptPubkey: FfiConverterArrayBuffer.read(from),
-        value: FfiConverterUInt64.read(from),
-        cetTxid: FfiConverterString.read(from),
-        cetRaw: FfiConverterArrayBuffer.read(from),
+        txid: FfiConverterString.read(from),
+        vout: FfiConverterUInt32.read(from),
+        scriptSig: FfiConverterUint8Array.read(from),
+        sequence: FfiConverterUInt32.read(from),
+        witness: FfiConverterSequenceBytes.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterArrayBuffer.write(value.sighash, into);
-      FfiConverterArrayBuffer.write(value.adaptorPoint, into);
-      FfiConverterUInt32.write(value.inputIndex, into);
-      FfiConverterArrayBuffer.write(value.scriptPubkey, into);
-      FfiConverterUInt64.write(value.value, into);
-      FfiConverterString.write(value.cetTxid, into);
-      FfiConverterArrayBuffer.write(value.cetRaw, into);
+      FfiConverterString.write(value.txid, into);
+      FfiConverterUInt32.write(value.vout, into);
+      FfiConverterUint8Array.write(value.scriptSig, into);
+      FfiConverterUInt32.write(value.sequence, into);
+      FfiConverterSequenceBytes.write(value.witness, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterArrayBuffer.allocationSize(value.sighash) +
-        FfiConverterArrayBuffer.allocationSize(value.adaptorPoint) +
-        FfiConverterUInt32.allocationSize(value.inputIndex) +
-        FfiConverterArrayBuffer.allocationSize(value.scriptPubkey) +
-        FfiConverterUInt64.allocationSize(value.value) +
-        FfiConverterString.allocationSize(value.cetTxid) +
-        FfiConverterArrayBuffer.allocationSize(value.cetRaw)
+        FfiConverterString.allocationSize(value.txid) +
+        FfiConverterUInt32.allocationSize(value.vout) +
+        FfiConverterUint8Array.allocationSize(value.scriptSig) +
+        FfiConverterUInt32.allocationSize(value.sequence) +
+        FfiConverterSequenceBytes.allocationSize(value.witness)
       );
     }
   }
@@ -1085,7 +1890,7 @@ const FfiConverterTypeCetAdaptorSignatureDebugInfo = (() => {
 
 export type TxOutput = {
   value: bigint;
-  scriptPubkey: ArrayBuffer;
+  scriptPubkey: Uint8Array;
 };
 
 /**
@@ -1125,121 +1930,17 @@ const FfiConverterTypeTxOutput = (() => {
     read(from: RustBuffer): TypeName {
       return {
         value: FfiConverterUInt64.read(from),
-        scriptPubkey: FfiConverterArrayBuffer.read(from),
+        scriptPubkey: FfiConverterUint8Array.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
       FfiConverterUInt64.write(value.value, into);
-      FfiConverterArrayBuffer.write(value.scriptPubkey, into);
+      FfiConverterUint8Array.write(value.scriptPubkey, into);
     }
     allocationSize(value: TypeName): number {
       return (
         FfiConverterUInt64.allocationSize(value.value) +
-        FfiConverterArrayBuffer.allocationSize(value.scriptPubkey)
-      );
-    }
-  }
-  return new FFIConverter();
-})();
-
-export type ChangeOutputAndFees = {
-  changeOutput: TxOutput;
-  fundFee: bigint;
-  cetFee: bigint;
-};
-
-/**
- * Generated factory for {@link ChangeOutputAndFees} record objects.
- */
-export const ChangeOutputAndFees = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord<ChangeOutputAndFees, ReturnType<typeof defaults>>(
-      defaults
-    );
-  })();
-  return Object.freeze({
-    create,
-    new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<ChangeOutputAndFees>,
-  });
-})();
-
-const FfiConverterTypeChangeOutputAndFees = (() => {
-  type TypeName = ChangeOutputAndFees;
-  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-    read(from: RustBuffer): TypeName {
-      return {
-        changeOutput: FfiConverterTypeTxOutput.read(from),
-        fundFee: FfiConverterUInt64.read(from),
-        cetFee: FfiConverterUInt64.read(from),
-      };
-    }
-    write(value: TypeName, into: RustBuffer): void {
-      FfiConverterTypeTxOutput.write(value.changeOutput, into);
-      FfiConverterUInt64.write(value.fundFee, into);
-      FfiConverterUInt64.write(value.cetFee, into);
-    }
-    allocationSize(value: TypeName): number {
-      return (
-        FfiConverterTypeTxOutput.allocationSize(value.changeOutput) +
-        FfiConverterUInt64.allocationSize(value.fundFee) +
-        FfiConverterUInt64.allocationSize(value.cetFee)
-      );
-    }
-  }
-  return new FFIConverter();
-})();
-
-export type TxInput = {
-  txid: string;
-  vout: number;
-  scriptSig: ArrayBuffer;
-  sequence: number;
-  witness: Array<ArrayBuffer>;
-};
-
-/**
- * Generated factory for {@link TxInput} record objects.
- */
-export const TxInput = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord<TxInput, ReturnType<typeof defaults>>(defaults);
-  })();
-  return Object.freeze({
-    create,
-    new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<TxInput>,
-  });
-})();
-
-const FfiConverterTypeTxInput = (() => {
-  type TypeName = TxInput;
-  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-    read(from: RustBuffer): TypeName {
-      return {
-        txid: FfiConverterString.read(from),
-        vout: FfiConverterUInt32.read(from),
-        scriptSig: FfiConverterArrayBuffer.read(from),
-        sequence: FfiConverterUInt32.read(from),
-        witness: FfiConverterSequenceBytes.read(from),
-      };
-    }
-    write(value: TypeName, into: RustBuffer): void {
-      FfiConverterString.write(value.txid, into);
-      FfiConverterUInt32.write(value.vout, into);
-      FfiConverterArrayBuffer.write(value.scriptSig, into);
-      FfiConverterUInt32.write(value.sequence, into);
-      FfiConverterSequenceBytes.write(value.witness, into);
-    }
-    allocationSize(value: TypeName): number {
-      return (
-        FfiConverterString.allocationSize(value.txid) +
-        FfiConverterUInt32.allocationSize(value.vout) +
-        FfiConverterArrayBuffer.allocationSize(value.scriptSig) +
-        FfiConverterUInt32.allocationSize(value.sequence) +
-        FfiConverterSequenceBytes.allocationSize(value.witness)
+        FfiConverterUint8Array.allocationSize(value.scriptPubkey)
       );
     }
   }
@@ -1251,7 +1952,7 @@ export type Transaction = {
   lockTime: number;
   inputs: Array<TxInput>;
   outputs: Array<TxOutput>;
-  rawBytes: ArrayBuffer;
+  rawBytes: Uint8Array;
 };
 
 /**
@@ -1270,8 +1971,8 @@ export const Transaction = (() => {
     defaults: () => Object.freeze(defaults()) as Partial<Transaction>,
     addSignature(
       self_: Transaction,
-      signature: ArrayBuffer,
-      pubkey: ArrayBuffer,
+      signature: Uint8Array,
+      pubkey: Uint8Array,
       inputIndex: number
     ): Transaction {
       return ((__rb: Uint8Array) => {
@@ -1291,11 +1992,11 @@ export const Transaction = (() => {
                 self_,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 signature,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 pubkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1313,10 +2014,10 @@ export const Transaction = (() => {
     cetAdaptorSignatureFromOracleInfo(
       self_: Transaction,
       oracleInfo: OracleInfo,
-      fundingSk: ArrayBuffer,
-      fundingScriptPubkey: ArrayBuffer,
+      fundingSk: Uint8Array,
+      fundingScriptPubkey: Uint8Array,
       totalCollateral: bigint,
-      msgs: Array<ArrayBuffer>
+      msgs: Array<Uint8Array>
     ): AdaptorSignature {
       return ((__rb: Uint8Array) => {
         try {
@@ -1339,11 +2040,11 @@ export const Transaction = (() => {
                 oracleInfo,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 fundingSk,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 fundingScriptPubkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1365,9 +2066,9 @@ export const Transaction = (() => {
     cetAdaptorSignatureInputs(
       self_: Transaction,
       oracleInfo: Array<OracleInfo>,
-      fundingScriptPubkey: ArrayBuffer,
+      fundingScriptPubkey: Uint8Array,
       fundOutputValue: bigint,
-      msgs: Array<Array<ArrayBuffer>>
+      msgs: Array<Array<Uint8Array>>
     ): CetAdaptorSignatureDebugInfo {
       return ((__rb: Uint8Array) => {
         try {
@@ -1390,7 +2091,7 @@ export const Transaction = (() => {
                 oracleInfo,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 fundingScriptPubkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1411,12 +2112,12 @@ export const Transaction = (() => {
     },
     cetSighash(
       self_: Transaction,
-      fundingScriptPubkey: ArrayBuffer,
+      fundingScriptPubkey: Uint8Array,
       fundOutputValue: bigint
-    ): ArrayBuffer {
+    ): Uint8Array {
       return ((__rb: Uint8Array) => {
         try {
-          return FfiConverterArrayBuffer.lift(__rb);
+          return FfiConverterUint8Array.lift(__rb);
         } finally {
           nativeModule().rustbuffer_free(__rb);
         }
@@ -1431,7 +2132,7 @@ export const Transaction = (() => {
                 self_,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 fundingScriptPubkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1448,14 +2149,14 @@ export const Transaction = (() => {
     },
     rawFundingInputSignature(
       self_: Transaction,
-      privkey: ArrayBuffer,
+      privkey: Uint8Array,
       prevTxId: string,
       prevTxVout: number,
       value: bigint
-    ): ArrayBuffer {
+    ): Uint8Array {
       return ((__rb: Uint8Array) => {
         try {
-          return FfiConverterArrayBuffer.lift(__rb);
+          return FfiConverterUint8Array.lift(__rb);
         } finally {
           nativeModule().rustbuffer_free(__rb);
         }
@@ -1470,7 +2171,7 @@ export const Transaction = (() => {
                 self_,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 privkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1492,11 +2193,11 @@ export const Transaction = (() => {
     },
     signCet(
       self_: Transaction,
-      adaptorSignature: ArrayBuffer,
-      oracleSignatures: Array<ArrayBuffer>,
-      fundingSecretKey: ArrayBuffer,
-      otherPubkey: ArrayBuffer,
-      fundingScriptPubkey: ArrayBuffer,
+      adaptorSignature: Uint8Array,
+      oracleSignatures: Array<Uint8Array>,
+      fundingSecretKey: Uint8Array,
+      otherPubkey: Uint8Array,
+      fundingScriptPubkey: Uint8Array,
       fundOutputValue: bigint
     ): Transaction {
       return ((__rb: Uint8Array) => {
@@ -1516,7 +2217,7 @@ export const Transaction = (() => {
                 self_,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 adaptorSignature,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1524,15 +2225,15 @@ export const Transaction = (() => {
                 oracleSignatures,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 fundingSecretKey,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 otherPubkey,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 fundingScriptPubkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1549,7 +2250,7 @@ export const Transaction = (() => {
     },
     signFundInput(
       self_: Transaction,
-      privkey: ArrayBuffer,
+      privkey: Uint8Array,
       prevTxId: string,
       prevTxVout: number,
       value: bigint
@@ -1571,7 +2272,7 @@ export const Transaction = (() => {
                 self_,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 privkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1594,8 +2295,8 @@ export const Transaction = (() => {
     signMultiSigInput(
       self_: Transaction,
       dlcInput: DlcInputInfo,
-      localPrivkey: ArrayBuffer,
-      remoteSignature: ArrayBuffer
+      localPrivkey: Uint8Array,
+      remoteSignature: Uint8Array
     ): Transaction {
       return ((__rb: Uint8Array) => {
         try {
@@ -1618,11 +2319,11 @@ export const Transaction = (() => {
                 dlcInput,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 localPrivkey,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 remoteSignature,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1635,8 +2336,8 @@ export const Transaction = (() => {
     },
     verifyFundSignature(
       self_: Transaction,
-      signature: ArrayBuffer,
-      pubkey: ArrayBuffer,
+      signature: Uint8Array,
+      pubkey: Uint8Array,
       txid: string,
       vout: number,
       inputAmount: bigint
@@ -1652,11 +2353,11 @@ export const Transaction = (() => {
                 self_,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 signature,
                 nativeModule().rustbuffer_alloc
               ),
-              FfiConverterArrayBuffer.lower(
+              FfiConverterUint8Array.lower(
                 pubkey,
                 nativeModule().rustbuffer_alloc
               ),
@@ -1685,7 +2386,7 @@ const FfiConverterTypeTransaction = (() => {
         lockTime: FfiConverterUInt32.read(from),
         inputs: FfiConverterSequenceTypeTxInput.read(from),
         outputs: FfiConverterSequenceTypeTxOutput.read(from),
-        rawBytes: FfiConverterArrayBuffer.read(from),
+        rawBytes: FfiConverterUint8Array.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
@@ -1693,7 +2394,7 @@ const FfiConverterTypeTransaction = (() => {
       FfiConverterUInt32.write(value.lockTime, into);
       FfiConverterSequenceTypeTxInput.write(value.inputs, into);
       FfiConverterSequenceTypeTxOutput.write(value.outputs, into);
-      FfiConverterArrayBuffer.write(value.rawBytes, into);
+      FfiConverterUint8Array.write(value.rawBytes, into);
     }
     allocationSize(value: TypeName): number {
       return (
@@ -1701,385 +2402,2127 @@ const FfiConverterTypeTransaction = (() => {
         FfiConverterUInt32.allocationSize(value.lockTime) +
         FfiConverterSequenceTypeTxInput.allocationSize(value.inputs) +
         FfiConverterSequenceTypeTxOutput.allocationSize(value.outputs) +
-        FfiConverterArrayBuffer.allocationSize(value.rawBytes)
+        FfiConverterUint8Array.allocationSize(value.rawBytes)
       );
     }
   }
   return new FFIConverter();
 })();
 
-export type DlcInputInfo = {
-  fundTx: Transaction;
-  fundVout: number;
-  localFundPubkey: ArrayBuffer;
-  remoteFundPubkey: ArrayBuffer;
-  fundAmount: bigint;
-  maxWitnessLen: number;
-  inputSerialId: bigint;
-  contractId: ArrayBuffer;
+export type DlcTransactions = {
+  fund: Transaction;
+  cets: Array<Transaction>;
+  refund: Transaction;
+  fundingScriptPubkey: Uint8Array;
 };
 
 /**
- * Generated factory for {@link DlcInputInfo} record objects.
+ * Generated factory for {@link DlcTransactions} record objects.
  */
-export const DlcInputInfo = (() => {
+export const DlcTransactions = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<DlcInputInfo, ReturnType<typeof defaults>>(
+    return uniffiCreateRecord<DlcTransactions, ReturnType<typeof defaults>>(
       defaults
     );
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<DlcInputInfo>,
+    defaults: () => Object.freeze(defaults()) as Partial<DlcTransactions>,
   });
 })();
 
-const FfiConverterTypeDlcInputInfo = (() => {
-  type TypeName = DlcInputInfo;
+const FfiConverterTypeDlcTransactions = (() => {
+  type TypeName = DlcTransactions;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        fundTx: FfiConverterTypeTransaction.read(from),
-        fundVout: FfiConverterUInt32.read(from),
-        localFundPubkey: FfiConverterArrayBuffer.read(from),
-        remoteFundPubkey: FfiConverterArrayBuffer.read(from),
-        fundAmount: FfiConverterUInt64.read(from),
-        maxWitnessLen: FfiConverterUInt32.read(from),
-        inputSerialId: FfiConverterUInt64.read(from),
-        contractId: FfiConverterArrayBuffer.read(from),
+        fund: FfiConverterTypeTransaction.read(from),
+        cets: FfiConverterSequenceTypeTransaction.read(from),
+        refund: FfiConverterTypeTransaction.read(from),
+        fundingScriptPubkey: FfiConverterUint8Array.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterTypeTransaction.write(value.fundTx, into);
-      FfiConverterUInt32.write(value.fundVout, into);
-      FfiConverterArrayBuffer.write(value.localFundPubkey, into);
-      FfiConverterArrayBuffer.write(value.remoteFundPubkey, into);
-      FfiConverterUInt64.write(value.fundAmount, into);
-      FfiConverterUInt32.write(value.maxWitnessLen, into);
-      FfiConverterUInt64.write(value.inputSerialId, into);
-      FfiConverterArrayBuffer.write(value.contractId, into);
-    }
-    allocationSize(value: TypeName): number {
+      FfiConverterTypeTransaction.write(value.fund, into);
+      FfiConverterSequenceTypeTransaction.write(value.cets, into);
+      FfiConverterTypeTransaction.write(value.refund, into);
+      FfiConverterUint8Array.write(value.fundingScriptPubkey, into);
+    }
+    allocationSize(value: TypeName): number {
       return (
-        FfiConverterTypeTransaction.allocationSize(value.fundTx) +
-        FfiConverterUInt32.allocationSize(value.fundVout) +
-        FfiConverterArrayBuffer.allocationSize(value.localFundPubkey) +
-        FfiConverterArrayBuffer.allocationSize(value.remoteFundPubkey) +
-        FfiConverterUInt64.allocationSize(value.fundAmount) +
-        FfiConverterUInt32.allocationSize(value.maxWitnessLen) +
-        FfiConverterUInt64.allocationSize(value.inputSerialId) +
-        FfiConverterArrayBuffer.allocationSize(value.contractId)
+        FfiConverterTypeTransaction.allocationSize(value.fund) +
+        FfiConverterSequenceTypeTransaction.allocationSize(value.cets) +
+        FfiConverterTypeTransaction.allocationSize(value.refund) +
+        FfiConverterUint8Array.allocationSize(value.fundingScriptPubkey)
       );
     }
   }
   return new FFIConverter();
 })();
 
-export type DlcTransactions = {
-  fund: Transaction;
-  cets: Array<Transaction>;
-  refund: Transaction;
-  fundingScriptPubkey: ArrayBuffer;
+/**
+ * The result of [`accept_offer`].
+ */
+export type AcceptResult = {
+  /**
+   * The wire-encoded `AcceptDlc` message to send to the offering party.
+   */
+  accept: Uint8Array;
+  /**
+   * The unsigned funding, CET, and refund transactions.
+   */
+  transactions: DlcTransactions;
+  /**
+   * The BIP-174 funding PSBT ready to be signed by either party's funding source.
+   */
+  fundingPsbt: Uint8Array;
 };
 
 /**
- * Generated factory for {@link DlcTransactions} record objects.
+ * Generated factory for {@link AcceptResult} record objects.
  */
-export const DlcTransactions = (() => {
+export const AcceptResult = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<DlcTransactions, ReturnType<typeof defaults>>(
+    return uniffiCreateRecord<AcceptResult, ReturnType<typeof defaults>>(
       defaults
     );
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<DlcTransactions>,
+    defaults: () => Object.freeze(defaults()) as Partial<AcceptResult>,
   });
 })();
 
-const FfiConverterTypeDlcTransactions = (() => {
-  type TypeName = DlcTransactions;
+const FfiConverterTypeAcceptResult = (() => {
+  type TypeName = AcceptResult;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        fund: FfiConverterTypeTransaction.read(from),
-        cets: FfiConverterSequenceTypeTransaction.read(from),
-        refund: FfiConverterTypeTransaction.read(from),
-        fundingScriptPubkey: FfiConverterArrayBuffer.read(from),
+        accept: FfiConverterUint8Array.read(from),
+        transactions: FfiConverterTypeDlcTransactions.read(from),
+        fundingPsbt: FfiConverterUint8Array.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterTypeTransaction.write(value.fund, into);
-      FfiConverterSequenceTypeTransaction.write(value.cets, into);
-      FfiConverterTypeTransaction.write(value.refund, into);
-      FfiConverterArrayBuffer.write(value.fundingScriptPubkey, into);
+      FfiConverterUint8Array.write(value.accept, into);
+      FfiConverterTypeDlcTransactions.write(value.transactions, into);
+      FfiConverterUint8Array.write(value.fundingPsbt, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterTypeTransaction.allocationSize(value.fund) +
-        FfiConverterSequenceTypeTransaction.allocationSize(value.cets) +
-        FfiConverterTypeTransaction.allocationSize(value.refund) +
-        FfiConverterArrayBuffer.allocationSize(value.fundingScriptPubkey)
+        FfiConverterUint8Array.allocationSize(value.accept) +
+        FfiConverterTypeDlcTransactions.allocationSize(value.transactions) +
+        FfiConverterUint8Array.allocationSize(value.fundingPsbt)
       );
     }
   }
   return new FFIConverter();
 })();
 
-export type OracleInfo = {
-  publicKey: ArrayBuffer;
-  nonces: Array<ArrayBuffer>;
+export type AdaptorSignature = {
+  signature: Uint8Array;
+  proof: Uint8Array;
 };
 
 /**
- * Generated factory for {@link OracleInfo} record objects.
+ * Generated factory for {@link AdaptorSignature} record objects.
  */
-export const OracleInfo = (() => {
+export const AdaptorSignature = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<OracleInfo, ReturnType<typeof defaults>>(
+    return uniffiCreateRecord<AdaptorSignature, ReturnType<typeof defaults>>(
       defaults
     );
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<OracleInfo>,
+    defaults: () => Object.freeze(defaults()) as Partial<AdaptorSignature>,
+    verifyFromOracleInfo(
+      self_: AdaptorSignature,
+      cet: Transaction,
+      oracleInfos: Array<OracleInfo>,
+      pubkey: Uint8Array,
+      fundingScriptPubkey: Uint8Array,
+      totalCollateral: bigint,
+      msgs: Array<Array<Uint8Array>>
+    ): boolean {
+      return FfiConverterBool.lift(
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_ddk_ffi_fn_method_adaptorsignature_verify_from_oracle_info(
+              FfiConverterTypeAdaptorSignature.lower(
+                self_,
+                nativeModule().rustbuffer_alloc
+              ),
+              FfiConverterTypeTransaction.lower(
+                cet,
+                nativeModule().rustbuffer_alloc
+              ),
+              FfiConverterSequenceTypeOracleInfo.lower(
+                oracleInfos,
+                nativeModule().rustbuffer_alloc
+              ),
+              FfiConverterUint8Array.lower(
+                pubkey,
+                nativeModule().rustbuffer_alloc
+              ),
+              FfiConverterUint8Array.lower(
+                fundingScriptPubkey,
+                nativeModule().rustbuffer_alloc
+              ),
+              FfiConverterUInt64.lower(
+                totalCollateral,
+                nativeModule().rustbuffer_alloc
+              ),
+              FfiConverterSequenceSequenceBytes.lower(
+                msgs,
+                nativeModule().rustbuffer_alloc
+              ),
+              callStatus
+            );
+          },
+          /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+        )
+      );
+    },
   });
 })();
 
-const FfiConverterTypeOracleInfo = (() => {
-  type TypeName = OracleInfo;
+const FfiConverterTypeAdaptorSignature = (() => {
+  type TypeName = AdaptorSignature;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        publicKey: FfiConverterArrayBuffer.read(from),
-        nonces: FfiConverterSequenceBytes.read(from),
+        signature: FfiConverterUint8Array.read(from),
+        proof: FfiConverterUint8Array.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterArrayBuffer.write(value.publicKey, into);
-      FfiConverterSequenceBytes.write(value.nonces, into);
+      FfiConverterUint8Array.write(value.signature, into);
+      FfiConverterUint8Array.write(value.proof, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterArrayBuffer.allocationSize(value.publicKey) +
-        FfiConverterSequenceBytes.allocationSize(value.nonces)
+        FfiConverterUint8Array.allocationSize(value.signature) +
+        FfiConverterUint8Array.allocationSize(value.proof)
       );
     }
   }
   return new FFIConverter();
 })();
 
-export type TxInputInfo = {
-  txid: string;
-  vout: number;
-  scriptSig: ArrayBuffer;
-  maxWitnessLength: number;
-  serialId: bigint;
+/**
+ * Debug info for CET adaptor signature inputs.
+ *
+ * Contains all the values that go into creating an adaptor signature,
+ * useful for comparing with external signers during debugging.
+ *
+ * This struct is intentionally always available (not feature-gated)
+ * to support production debugging scenarios.
+ */
+export type CetAdaptorSignatureDebugInfo = {
+  /**
+   * The sighash (32 bytes) - this is the message that gets signed
+   */
+  sighash: Uint8Array;
+  /**
+   * The adaptor point (33 bytes compressed public key)
+   */
+  adaptorPoint: Uint8Array;
+  /**
+   * Input index (always 0 for CETs)
+   */
+  inputIndex: number;
+  /**
+   * The funding script pubkey used for sighash
+   */
+  scriptPubkey: Uint8Array;
+  /**
+   * The fund output value used for sighash
+   */
+  value: bigint;
+  /**
+   * The CET txid
+   */
+  cetTxid: string;
+  /**
+   * Raw CET bytes for verification
+   */
+  cetRaw: Uint8Array;
 };
 
 /**
- * Generated factory for {@link TxInputInfo} record objects.
+ * Generated factory for {@link CetAdaptorSignatureDebugInfo} record objects.
  */
-export const TxInputInfo = (() => {
+export const CetAdaptorSignatureDebugInfo = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<TxInputInfo, ReturnType<typeof defaults>>(
-      defaults
-    );
+    return uniffiCreateRecord<
+      CetAdaptorSignatureDebugInfo,
+      ReturnType<typeof defaults>
+    >(defaults);
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<TxInputInfo>,
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<CetAdaptorSignatureDebugInfo>,
   });
 })();
 
-const FfiConverterTypeTxInputInfo = (() => {
-  type TypeName = TxInputInfo;
+const FfiConverterTypeCetAdaptorSignatureDebugInfo = (() => {
+  type TypeName = CetAdaptorSignatureDebugInfo;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        txid: FfiConverterString.read(from),
-        vout: FfiConverterUInt32.read(from),
-        scriptSig: FfiConverterArrayBuffer.read(from),
-        maxWitnessLength: FfiConverterUInt32.read(from),
-        serialId: FfiConverterUInt64.read(from),
+        sighash: FfiConverterUint8Array.read(from),
+        adaptorPoint: FfiConverterUint8Array.read(from),
+        inputIndex: FfiConverterUInt32.read(from),
+        scriptPubkey: FfiConverterUint8Array.read(from),
+        value: FfiConverterUInt64.read(from),
+        cetTxid: FfiConverterString.read(from),
+        cetRaw: FfiConverterUint8Array.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterString.write(value.txid, into);
-      FfiConverterUInt32.write(value.vout, into);
-      FfiConverterArrayBuffer.write(value.scriptSig, into);
-      FfiConverterUInt32.write(value.maxWitnessLength, into);
-      FfiConverterUInt64.write(value.serialId, into);
+      FfiConverterUint8Array.write(value.sighash, into);
+      FfiConverterUint8Array.write(value.adaptorPoint, into);
+      FfiConverterUInt32.write(value.inputIndex, into);
+      FfiConverterUint8Array.write(value.scriptPubkey, into);
+      FfiConverterUInt64.write(value.value, into);
+      FfiConverterString.write(value.cetTxid, into);
+      FfiConverterUint8Array.write(value.cetRaw, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterString.allocationSize(value.txid) +
-        FfiConverterUInt32.allocationSize(value.vout) +
-        FfiConverterArrayBuffer.allocationSize(value.scriptSig) +
-        FfiConverterUInt32.allocationSize(value.maxWitnessLength) +
-        FfiConverterUInt64.allocationSize(value.serialId)
+        FfiConverterUint8Array.allocationSize(value.sighash) +
+        FfiConverterUint8Array.allocationSize(value.adaptorPoint) +
+        FfiConverterUInt32.allocationSize(value.inputIndex) +
+        FfiConverterUint8Array.allocationSize(value.scriptPubkey) +
+        FfiConverterUInt64.allocationSize(value.value) +
+        FfiConverterString.allocationSize(value.cetTxid) +
+        FfiConverterUint8Array.allocationSize(value.cetRaw)
       );
     }
   }
   return new FFIConverter();
 })();
 
-export type PartyParams = {
-  fundPubkey: ArrayBuffer;
-  changeScriptPubkey: ArrayBuffer;
-  changeSerialId: bigint;
-  payoutScriptPubkey: ArrayBuffer;
-  payoutSerialId: bigint;
-  inputs: Array<TxInputInfo>;
-  inputAmount: bigint;
-  collateral: bigint;
-  dlcInputs: Array<DlcInputInfo>;
+export type ChangeOutputAndFees = {
+  changeOutput: TxOutput;
+  fundFee: bigint;
+  cetFee: bigint;
 };
 
 /**
- * Generated factory for {@link PartyParams} record objects.
+ * Generated factory for {@link ChangeOutputAndFees} record objects.
  */
-export const PartyParams = (() => {
+export const ChangeOutputAndFees = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<PartyParams, ReturnType<typeof defaults>>(
+    return uniffiCreateRecord<ChangeOutputAndFees, ReturnType<typeof defaults>>(
       defaults
     );
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<PartyParams>,
-    changeOutputAndFees(
-      self_: PartyParams,
-      feeRate: bigint
-    ): ChangeOutputAndFees {
-      return ((__rb: Uint8Array) => {
-        try {
-          return FfiConverterTypeChangeOutputAndFees.lift(__rb);
-        } finally {
-          nativeModule().rustbuffer_free(__rb);
-        }
-      })(
-        uniffiCaller.rustCallWithError(
-          /*liftError:*/ FfiConverterTypeDLCError.lift.bind(
-            FfiConverterTypeDLCError
-          ),
-          /*caller:*/ (callStatus) => {
-            return nativeModule().ubrn_uniffi_ddk_ffi_fn_method_partyparams_change_output_and_fees(
-              FfiConverterTypePartyParams.lower(
-                self_,
-                nativeModule().rustbuffer_alloc
-              ),
-              FfiConverterUInt64.lower(
-                feeRate,
-                nativeModule().rustbuffer_alloc
-              ),
-              callStatus
-            );
-          },
-          /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
-        )
-      );
-    },
+    defaults: () => Object.freeze(defaults()) as Partial<ChangeOutputAndFees>,
   });
 })();
 
-const FfiConverterTypePartyParams = (() => {
-  type TypeName = PartyParams;
+const FfiConverterTypeChangeOutputAndFees = (() => {
+  type TypeName = ChangeOutputAndFees;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        fundPubkey: FfiConverterArrayBuffer.read(from),
-        changeScriptPubkey: FfiConverterArrayBuffer.read(from),
-        changeSerialId: FfiConverterUInt64.read(from),
-        payoutScriptPubkey: FfiConverterArrayBuffer.read(from),
-        payoutSerialId: FfiConverterUInt64.read(from),
-        inputs: FfiConverterSequenceTypeTxInputInfo.read(from),
-        inputAmount: FfiConverterUInt64.read(from),
-        collateral: FfiConverterUInt64.read(from),
-        dlcInputs: FfiConverterSequenceTypeDlcInputInfo.read(from),
+        changeOutput: FfiConverterTypeTxOutput.read(from),
+        fundFee: FfiConverterUInt64.read(from),
+        cetFee: FfiConverterUInt64.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterArrayBuffer.write(value.fundPubkey, into);
-      FfiConverterArrayBuffer.write(value.changeScriptPubkey, into);
-      FfiConverterUInt64.write(value.changeSerialId, into);
-      FfiConverterArrayBuffer.write(value.payoutScriptPubkey, into);
-      FfiConverterUInt64.write(value.payoutSerialId, into);
-      FfiConverterSequenceTypeTxInputInfo.write(value.inputs, into);
-      FfiConverterUInt64.write(value.inputAmount, into);
-      FfiConverterUInt64.write(value.collateral, into);
-      FfiConverterSequenceTypeDlcInputInfo.write(value.dlcInputs, into);
+      FfiConverterTypeTxOutput.write(value.changeOutput, into);
+      FfiConverterUInt64.write(value.fundFee, into);
+      FfiConverterUInt64.write(value.cetFee, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterArrayBuffer.allocationSize(value.fundPubkey) +
-        FfiConverterArrayBuffer.allocationSize(value.changeScriptPubkey) +
-        FfiConverterUInt64.allocationSize(value.changeSerialId) +
-        FfiConverterArrayBuffer.allocationSize(value.payoutScriptPubkey) +
-        FfiConverterUInt64.allocationSize(value.payoutSerialId) +
-        FfiConverterSequenceTypeTxInputInfo.allocationSize(value.inputs) +
-        FfiConverterUInt64.allocationSize(value.inputAmount) +
-        FfiConverterUInt64.allocationSize(value.collateral) +
-        FfiConverterSequenceTypeDlcInputInfo.allocationSize(value.dlcInputs)
+        FfiConverterTypeTxOutput.allocationSize(value.changeOutput) +
+        FfiConverterUInt64.allocationSize(value.fundFee) +
+        FfiConverterUInt64.allocationSize(value.cetFee)
       );
     }
   }
   return new FFIConverter();
 })();
 
-export type Payout = {
-  offer: bigint;
-  accept: bigint;
+/**
+ * One row of a contract's payout table.
+ *
+ * Enum-contract rows carry an `outcome` label; numeric-contract rows carry an
+ * inclusive `[range_start, range_end]` of outcome values that share the payout.
+ */
+export type PayoutRow = {
+  /**
+   * The outcome label (enum contracts only; `None` for numeric).
+   */
+  outcome?: string;
+  /**
+   * Inclusive start of the outcome range (numeric contracts only; `None` for enum).
+   */
+  rangeStart?: bigint;
+  /**
+   * Inclusive end of the outcome range (numeric contracts only; `None` for enum).
+   */
+  rangeEnd?: bigint;
+  /**
+   * The payout to the offering party, in satoshis.
+   */
+  offerPayoutSats: bigint;
+  /**
+   * The payout to the accepting party, in satoshis.
+   */
+  acceptPayoutSats: bigint;
 };
 
 /**
- * Generated factory for {@link Payout} record objects.
+ * Generated factory for {@link PayoutRow} record objects.
  */
-export const Payout = (() => {
+export const PayoutRow = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<Payout, ReturnType<typeof defaults>>(defaults);
+    return uniffiCreateRecord<PayoutRow, ReturnType<typeof defaults>>(defaults);
   })();
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()) as Partial<Payout>,
+    defaults: () => Object.freeze(defaults()) as Partial<PayoutRow>,
   });
 })();
 
-const FfiConverterTypePayout = (() => {
-  type TypeName = Payout;
+const FfiConverterTypePayoutRow = (() => {
+  type TypeName = PayoutRow;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        offer: FfiConverterUInt64.read(from),
-        accept: FfiConverterUInt64.read(from),
+        outcome: FfiConverterOptionalString.read(from),
+        rangeStart: FfiConverterOptionalUInt64.read(from),
+        rangeEnd: FfiConverterOptionalUInt64.read(from),
+        offerPayoutSats: FfiConverterUInt64.read(from),
+        acceptPayoutSats: FfiConverterUInt64.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterUInt64.write(value.offer, into);
-      FfiConverterUInt64.write(value.accept, into);
+      FfiConverterOptionalString.write(value.outcome, into);
+      FfiConverterOptionalUInt64.write(value.rangeStart, into);
+      FfiConverterOptionalUInt64.write(value.rangeEnd, into);
+      FfiConverterUInt64.write(value.offerPayoutSats, into);
+      FfiConverterUInt64.write(value.acceptPayoutSats, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterUInt64.allocationSize(value.offer) +
-        FfiConverterUInt64.allocationSize(value.accept)
+        FfiConverterOptionalString.allocationSize(value.outcome) +
+        FfiConverterOptionalUInt64.allocationSize(value.rangeStart) +
+        FfiConverterOptionalUInt64.allocationSize(value.rangeEnd) +
+        FfiConverterUInt64.allocationSize(value.offerPayoutSats) +
+        FfiConverterUInt64.allocationSize(value.acceptPayoutSats)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * A contract's payouts, derived from its `ContractInfo`, for display as a table.
+ */
+export type ContractPayouts = {
+  /**
+   * Total collateral (offer + accept), in satoshis.
+   */
+  totalCollateralSats: bigint;
+  /**
+   * `true` for enum contracts (rows are labeled outcomes); `false` for numeric
+   * contracts (rows are outcome ranges).
+   */
+  isEnum: boolean;
+  /**
+   * The payout rows, in outcome order.
+   */
+  rows: Array<PayoutRow>;
+};
+
+/**
+ * Generated factory for {@link ContractPayouts} record objects.
+ */
+export const ContractPayouts = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ContractPayouts, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<ContractPayouts>,
+  });
+})();
+
+const FfiConverterTypeContractPayouts = (() => {
+  type TypeName = ContractPayouts;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        totalCollateralSats: FfiConverterUInt64.read(from),
+        isEnum: FfiConverterBool.read(from),
+        rows: FfiConverterSequenceTypePayoutRow.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt64.write(value.totalCollateralSats, into);
+      FfiConverterBool.write(value.isEnum, into);
+      FfiConverterSequenceTypePayoutRow.write(value.rows, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt64.allocationSize(value.totalCollateralSats) +
+        FfiConverterBool.allocationSize(value.isEnum) +
+        FfiConverterSequenceTypePayoutRow.allocationSize(value.rows)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Parameters for [`create_offer`] (mirrors [`ddk::contract::CreateOfferParams`]).
+ */
+export type CreateOfferParams = {
+  /**
+   * The 32-byte chain hash the contract settles on.
+   */
+  chainHash: Uint8Array;
+  /**
+   * The 32-byte temporary contract id; randomly generated when `None`.
+   */
+  temporaryContractId?: Uint8Array;
+  /**
+   * The contract payout and oracle information, wire-encoded `ContractInfo`.
+   */
+  contractInfo: Uint8Array;
+  /**
+   * The collateral, in satoshis, contributed by the offering party.
+   */
+  offerCollateralSats: bigint;
+  /**
+   * The offering party's Bitcoin-level contract data.
+   */
+  party: ContractPartyParams;
+  /**
+   * Serial id ordering the funding output; randomly generated when `None`.
+   */
+  fundOutputSerialId?: bigint;
+  /**
+   * The fee rate, in satoshis per virtual byte.
+   */
+  feeRatePerVb: bigint;
+  /**
+   * The earliest time CETs can be broadcast.
+   */
+  cetLocktime: number;
+  /**
+   * The time after which the refund transaction can be broadcast.
+   */
+  refundLocktime: number;
+  /**
+   * Contract feature flags. Use `0` unless a protocol extension requires otherwise.
+   */
+  contractFlags: number;
+};
+
+/**
+ * Generated factory for {@link CreateOfferParams} record objects.
+ */
+export const CreateOfferParams = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<CreateOfferParams, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<CreateOfferParams>,
+  });
+})();
+
+const FfiConverterTypeCreateOfferParams = (() => {
+  type TypeName = CreateOfferParams;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        chainHash: FfiConverterUint8Array.read(from),
+        temporaryContractId: FfiConverterOptionalBytes.read(from),
+        contractInfo: FfiConverterUint8Array.read(from),
+        offerCollateralSats: FfiConverterUInt64.read(from),
+        party: FfiConverterTypeContractPartyParams.read(from),
+        fundOutputSerialId: FfiConverterOptionalUInt64.read(from),
+        feeRatePerVb: FfiConverterUInt64.read(from),
+        cetLocktime: FfiConverterUInt32.read(from),
+        refundLocktime: FfiConverterUInt32.read(from),
+        contractFlags: FfiConverterUInt8.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUint8Array.write(value.chainHash, into);
+      FfiConverterOptionalBytes.write(value.temporaryContractId, into);
+      FfiConverterUint8Array.write(value.contractInfo, into);
+      FfiConverterUInt64.write(value.offerCollateralSats, into);
+      FfiConverterTypeContractPartyParams.write(value.party, into);
+      FfiConverterOptionalUInt64.write(value.fundOutputSerialId, into);
+      FfiConverterUInt64.write(value.feeRatePerVb, into);
+      FfiConverterUInt32.write(value.cetLocktime, into);
+      FfiConverterUInt32.write(value.refundLocktime, into);
+      FfiConverterUInt8.write(value.contractFlags, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUint8Array.allocationSize(value.chainHash) +
+        FfiConverterOptionalBytes.allocationSize(value.temporaryContractId) +
+        FfiConverterUint8Array.allocationSize(value.contractInfo) +
+        FfiConverterUInt64.allocationSize(value.offerCollateralSats) +
+        FfiConverterTypeContractPartyParams.allocationSize(value.party) +
+        FfiConverterOptionalUInt64.allocationSize(value.fundOutputSerialId) +
+        FfiConverterUInt64.allocationSize(value.feeRatePerVb) +
+        FfiConverterUInt32.allocationSize(value.cetLocktime) +
+        FfiConverterUInt32.allocationSize(value.refundLocktime) +
+        FfiConverterUInt8.allocationSize(value.contractFlags)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Identifies a funding input and the descriptor wildcard index that derives its
+ * key, for [`sign_funding_psbt_with_descriptor`].
+ */
+export type DescriptorInput = {
+  /**
+   * The serial id of the funding input to sign.
+   */
+  inputSerialId: bigint;
+  /**
+   * The descriptor wildcard derivation index of the input's script (ignored
+   * for descriptors without a wildcard).
+   */
+  derivationIndex: number;
+};
+
+/**
+ * Generated factory for {@link DescriptorInput} record objects.
+ */
+export const DescriptorInput = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<DescriptorInput, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<DescriptorInput>,
+  });
+})();
+
+const FfiConverterTypeDescriptorInput = (() => {
+  type TypeName = DescriptorInput;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        inputSerialId: FfiConverterUInt64.read(from),
+        derivationIndex: FfiConverterUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt64.write(value.inputSerialId, into);
+      FfiConverterUInt32.write(value.derivationIndex, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt64.allocationSize(value.inputSerialId) +
+        FfiConverterUInt32.allocationSize(value.derivationIndex)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type DlcInputInfo = {
+  fundTx: Transaction;
+  fundVout: number;
+  localFundPubkey: Uint8Array;
+  remoteFundPubkey: Uint8Array;
+  fundAmount: bigint;
+  maxWitnessLen: number;
+  inputSerialId: bigint;
+  contractId: Uint8Array;
+};
+
+/**
+ * Generated factory for {@link DlcInputInfo} record objects.
+ */
+export const DlcInputInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<DlcInputInfo, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<DlcInputInfo>,
+  });
+})();
+
+const FfiConverterTypeDlcInputInfo = (() => {
+  type TypeName = DlcInputInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        fundTx: FfiConverterTypeTransaction.read(from),
+        fundVout: FfiConverterUInt32.read(from),
+        localFundPubkey: FfiConverterUint8Array.read(from),
+        remoteFundPubkey: FfiConverterUint8Array.read(from),
+        fundAmount: FfiConverterUInt64.read(from),
+        maxWitnessLen: FfiConverterUInt32.read(from),
+        inputSerialId: FfiConverterUInt64.read(from),
+        contractId: FfiConverterUint8Array.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeTransaction.write(value.fundTx, into);
+      FfiConverterUInt32.write(value.fundVout, into);
+      FfiConverterUint8Array.write(value.localFundPubkey, into);
+      FfiConverterUint8Array.write(value.remoteFundPubkey, into);
+      FfiConverterUInt64.write(value.fundAmount, into);
+      FfiConverterUInt32.write(value.maxWitnessLen, into);
+      FfiConverterUInt64.write(value.inputSerialId, into);
+      FfiConverterUint8Array.write(value.contractId, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeTransaction.allocationSize(value.fundTx) +
+        FfiConverterUInt32.allocationSize(value.fundVout) +
+        FfiConverterUint8Array.allocationSize(value.localFundPubkey) +
+        FfiConverterUint8Array.allocationSize(value.remoteFundPubkey) +
+        FfiConverterUInt64.allocationSize(value.fundAmount) +
+        FfiConverterUInt32.allocationSize(value.maxWitnessLen) +
+        FfiConverterUInt64.allocationSize(value.inputSerialId) +
+        FfiConverterUint8Array.allocationSize(value.contractId)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * An oracle attestation paired with the position of the oracle that produced it
+ * in the contract's announcements, for [`sign_contract_cet`].
+ */
+export type OracleAttestationRef = {
+  /**
+   * The index of the attesting oracle in the contract info's announcements.
+   */
+  oracleIndex: number;
+  /**
+   * The wire-encoded `OracleAttestation`.
+   */
+  attestation: Uint8Array;
+};
+
+/**
+ * Generated factory for {@link OracleAttestationRef} record objects.
+ */
+export const OracleAttestationRef = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      OracleAttestationRef,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<OracleAttestationRef>,
+  });
+})();
+
+const FfiConverterTypeOracleAttestationRef = (() => {
+  type TypeName = OracleAttestationRef;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        oracleIndex: FfiConverterUInt32.read(from),
+        attestation: FfiConverterUint8Array.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.oracleIndex, into);
+      FfiConverterUint8Array.write(value.attestation, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.oracleIndex) +
+        FfiConverterUint8Array.allocationSize(value.attestation)
       );
     }
   }
   return new FFIConverter();
 })();
 
+export type OracleInfo = {
+  publicKey: Uint8Array;
+  nonces: Array<Uint8Array>;
+};
+
+/**
+ * Generated factory for {@link OracleInfo} record objects.
+ */
+export const OracleInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<OracleInfo, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<OracleInfo>,
+  });
+})();
+
+const FfiConverterTypeOracleInfo = (() => {
+  type TypeName = OracleInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        publicKey: FfiConverterUint8Array.read(from),
+        nonces: FfiConverterSequenceBytes.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUint8Array.write(value.publicKey, into);
+      FfiConverterSequenceBytes.write(value.nonces, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUint8Array.allocationSize(value.publicKey) +
+        FfiConverterSequenceBytes.allocationSize(value.nonces)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type TxInputInfo = {
+  txid: string;
+  vout: number;
+  scriptSig: Uint8Array;
+  maxWitnessLength: number;
+  serialId: bigint;
+};
+
+/**
+ * Generated factory for {@link TxInputInfo} record objects.
+ */
+export const TxInputInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<TxInputInfo, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<TxInputInfo>,
+  });
+})();
+
+const FfiConverterTypeTxInputInfo = (() => {
+  type TypeName = TxInputInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        txid: FfiConverterString.read(from),
+        vout: FfiConverterUInt32.read(from),
+        scriptSig: FfiConverterUint8Array.read(from),
+        maxWitnessLength: FfiConverterUInt32.read(from),
+        serialId: FfiConverterUInt64.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.txid, into);
+      FfiConverterUInt32.write(value.vout, into);
+      FfiConverterUint8Array.write(value.scriptSig, into);
+      FfiConverterUInt32.write(value.maxWitnessLength, into);
+      FfiConverterUInt64.write(value.serialId, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.txid) +
+        FfiConverterUInt32.allocationSize(value.vout) +
+        FfiConverterUint8Array.allocationSize(value.scriptSig) +
+        FfiConverterUInt32.allocationSize(value.maxWitnessLength) +
+        FfiConverterUInt64.allocationSize(value.serialId)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type PartyParams = {
+  fundPubkey: Uint8Array;
+  changeScriptPubkey: Uint8Array;
+  changeSerialId: bigint;
+  payoutScriptPubkey: Uint8Array;
+  payoutSerialId: bigint;
+  inputs: Array<TxInputInfo>;
+  inputAmount: bigint;
+  collateral: bigint;
+  dlcInputs: Array<DlcInputInfo>;
+};
+
+/**
+ * Generated factory for {@link PartyParams} record objects.
+ */
+export const PartyParams = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<PartyParams, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<PartyParams>,
+    changeOutputAndFees(
+      self_: PartyParams,
+      feeRate: bigint
+    ): ChangeOutputAndFees {
+      return ((__rb: Uint8Array) => {
+        try {
+          return FfiConverterTypeChangeOutputAndFees.lift(__rb);
+        } finally {
+          nativeModule().rustbuffer_free(__rb);
+        }
+      })(
+        uniffiCaller.rustCallWithError(
+          /*liftError:*/ FfiConverterTypeDLCError.lift.bind(
+            FfiConverterTypeDLCError
+          ),
+          /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_ddk_ffi_fn_method_partyparams_change_output_and_fees(
+              FfiConverterTypePartyParams.lower(
+                self_,
+                nativeModule().rustbuffer_alloc
+              ),
+              FfiConverterUInt64.lower(
+                feeRate,
+                nativeModule().rustbuffer_alloc
+              ),
+              callStatus
+            );
+          },
+          /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+        )
+      );
+    },
+  });
+})();
+
+const FfiConverterTypePartyParams = (() => {
+  type TypeName = PartyParams;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        fundPubkey: FfiConverterUint8Array.read(from),
+        changeScriptPubkey: FfiConverterUint8Array.read(from),
+        changeSerialId: FfiConverterUInt64.read(from),
+        payoutScriptPubkey: FfiConverterUint8Array.read(from),
+        payoutSerialId: FfiConverterUInt64.read(from),
+        inputs: FfiConverterSequenceTypeTxInputInfo.read(from),
+        inputAmount: FfiConverterUInt64.read(from),
+        collateral: FfiConverterUInt64.read(from),
+        dlcInputs: FfiConverterSequenceTypeDlcInputInfo.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUint8Array.write(value.fundPubkey, into);
+      FfiConverterUint8Array.write(value.changeScriptPubkey, into);
+      FfiConverterUInt64.write(value.changeSerialId, into);
+      FfiConverterUint8Array.write(value.payoutScriptPubkey, into);
+      FfiConverterUInt64.write(value.payoutSerialId, into);
+      FfiConverterSequenceTypeTxInputInfo.write(value.inputs, into);
+      FfiConverterUInt64.write(value.inputAmount, into);
+      FfiConverterUInt64.write(value.collateral, into);
+      FfiConverterSequenceTypeDlcInputInfo.write(value.dlcInputs, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUint8Array.allocationSize(value.fundPubkey) +
+        FfiConverterUint8Array.allocationSize(value.changeScriptPubkey) +
+        FfiConverterUInt64.allocationSize(value.changeSerialId) +
+        FfiConverterUint8Array.allocationSize(value.payoutScriptPubkey) +
+        FfiConverterUInt64.allocationSize(value.payoutSerialId) +
+        FfiConverterSequenceTypeTxInputInfo.allocationSize(value.inputs) +
+        FfiConverterUInt64.allocationSize(value.inputAmount) +
+        FfiConverterUInt64.allocationSize(value.collateral) +
+        FfiConverterSequenceTypeDlcInputInfo.allocationSize(value.dlcInputs)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type Payout = {
+  offer: bigint;
+  accept: bigint;
+};
+
+/**
+ * Generated factory for {@link Payout} record objects.
+ */
+export const Payout = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<Payout, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<Payout>,
+  });
+})();
+
+const FfiConverterTypePayout = (() => {
+  type TypeName = Payout;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        offer: FfiConverterUInt64.read(from),
+        accept: FfiConverterUInt64.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt64.write(value.offer, into);
+      FfiConverterUInt64.write(value.accept, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt64.allocationSize(value.offer) +
+        FfiConverterUInt64.allocationSize(value.accept)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * The result of [`sign_accept`] / [`sign_accept_spliced`].
+ */
+export type SignResult = {
+  /**
+   * The wire-encoded `SignDlc` message to send to the accepting party.
+   */
+  sign: Uint8Array;
+  /**
+   * The unsigned funding, CET, and refund transactions.
+   */
+  transactions: DlcTransactions;
+};
+
+/**
+ * Generated factory for {@link SignResult} record objects.
+ */
+export const SignResult = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SignResult, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<SignResult>,
+  });
+})();
+
+const FfiConverterTypeSignResult = (() => {
+  type TypeName = SignResult;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        sign: FfiConverterUint8Array.read(from),
+        transactions: FfiConverterTypeDlcTransactions.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUint8Array.write(value.sign, into);
+      FfiConverterTypeDlcTransactions.write(value.transactions, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUint8Array.allocationSize(value.sign) +
+        FfiConverterTypeDlcTransactions.allocationSize(value.transactions)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * References a splice (DLC) funding input and the previous contract whose
+ * 2-of-2 output it spends, so the provider can re-derive the signing key.
+ */
+export type SpliceKeyRef = {
+  /**
+   * The serial id of the DLC (splice) funding input this key signs.
+   */
+  inputSerialId: bigint;
+  /**
+   * The 32-byte temporary id of the previous contract being spliced from.
+   */
+  priorTemporaryContractId: Uint8Array;
+};
+
+/**
+ * Generated factory for {@link SpliceKeyRef} record objects.
+ */
+export const SpliceKeyRef = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SpliceKeyRef, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<SpliceKeyRef>,
+  });
+})();
+
+const FfiConverterTypeSpliceKeyRef = (() => {
+  type TypeName = SpliceKeyRef;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        inputSerialId: FfiConverterUInt64.read(from),
+        priorTemporaryContractId: FfiConverterUint8Array.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt64.write(value.inputSerialId, into);
+      FfiConverterUint8Array.write(value.priorTemporaryContractId, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt64.allocationSize(value.inputSerialId) +
+        FfiConverterUint8Array.allocationSize(value.priorTemporaryContractId)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Error type: ContractError
+export enum ContractError_Tags {
+  InvalidOffer = 'InvalidOffer',
+  InvalidAccept = 'InvalidAccept',
+  InvalidSign = 'InvalidSign',
+  InvalidFundingInput = 'InvalidFundingInput',
+  PsbtMismatch = 'PsbtMismatch',
+  MissingFinalizedInput = 'MissingFinalizedInput',
+  UnsupportedScriptType = 'UnsupportedScriptType',
+  InvalidAttestation = 'InvalidAttestation',
+  NoMatchingOutcome = 'NoMatchingOutcome',
+  Descriptor = 'Descriptor',
+  Wallet = 'Wallet',
+  Bip32 = 'Bip32',
+  Dlc = 'Dlc',
+  Key = 'Key',
+  Serialization = 'Serialization',
+  InvalidNetwork = 'InvalidNetwork',
+  InvalidLength = 'InvalidLength',
+}
+/**
+ * Errors returned by the stateless contract API.
+ *
+ * Mirrors [`ddk::contract::ContractError`] as a uniffi error so the typed
+ * variants survive across the binding boundary. Variants carry plain strings.
+ */
+export const ContractError = (() => {
+  type InvalidOffer__interface = {
+    tag: ContractError_Tags.InvalidOffer;
+    inner: Readonly<{ message: string }>;
+  };
+  class InvalidOffer_ extends UniffiError implements InvalidOffer__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.InvalidOffer;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'InvalidOffer');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): InvalidOffer_ {
+      return new InvalidOffer_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidOffer_ {
+      return obj.tag === ContractError_Tags.InvalidOffer;
+    }
+    static hasInner(obj: any): obj is InvalidOffer_ {
+      return InvalidOffer_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidOffer_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidAccept__interface = {
+    tag: ContractError_Tags.InvalidAccept;
+    inner: Readonly<{ message: string }>;
+  };
+  class InvalidAccept_ extends UniffiError implements InvalidAccept__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.InvalidAccept;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'InvalidAccept');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): InvalidAccept_ {
+      return new InvalidAccept_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidAccept_ {
+      return obj.tag === ContractError_Tags.InvalidAccept;
+    }
+    static hasInner(obj: any): obj is InvalidAccept_ {
+      return InvalidAccept_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidAccept_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidSign__interface = {
+    tag: ContractError_Tags.InvalidSign;
+    inner: Readonly<{ message: string }>;
+  };
+  class InvalidSign_ extends UniffiError implements InvalidSign__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.InvalidSign;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'InvalidSign');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): InvalidSign_ {
+      return new InvalidSign_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidSign_ {
+      return obj.tag === ContractError_Tags.InvalidSign;
+    }
+    static hasInner(obj: any): obj is InvalidSign_ {
+      return InvalidSign_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidSign_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidFundingInput__interface = {
+    tag: ContractError_Tags.InvalidFundingInput;
+    inner: Readonly<{ message: string }>;
+  };
+  class InvalidFundingInput_
+    extends UniffiError
+    implements InvalidFundingInput__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.InvalidFundingInput;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'InvalidFundingInput');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): InvalidFundingInput_ {
+      return new InvalidFundingInput_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidFundingInput_ {
+      return obj.tag === ContractError_Tags.InvalidFundingInput;
+    }
+    static hasInner(obj: any): obj is InvalidFundingInput_ {
+      return InvalidFundingInput_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidFundingInput_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type PsbtMismatch__interface = {
+    tag: ContractError_Tags.PsbtMismatch;
+    inner: Readonly<{ message: string }>;
+  };
+  class PsbtMismatch_ extends UniffiError implements PsbtMismatch__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.PsbtMismatch;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'PsbtMismatch');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): PsbtMismatch_ {
+      return new PsbtMismatch_(inner);
+    }
+
+    static instanceOf(obj: any): obj is PsbtMismatch_ {
+      return obj.tag === ContractError_Tags.PsbtMismatch;
+    }
+    static hasInner(obj: any): obj is PsbtMismatch_ {
+      return PsbtMismatch_.instanceOf(obj);
+    }
+
+    static getInner(obj: PsbtMismatch_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type MissingFinalizedInput__interface = {
+    tag: ContractError_Tags.MissingFinalizedInput;
+    inner: Readonly<{ inputIndex: number }>;
+  };
+  class MissingFinalizedInput_
+    extends UniffiError
+    implements MissingFinalizedInput__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.MissingFinalizedInput;
+    readonly inner: Readonly<{ inputIndex: number }>;
+    constructor(inner: { inputIndex: number }) {
+      super('ContractError', 'MissingFinalizedInput');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { inputIndex: number }): MissingFinalizedInput_ {
+      return new MissingFinalizedInput_(inner);
+    }
+
+    static instanceOf(obj: any): obj is MissingFinalizedInput_ {
+      return obj.tag === ContractError_Tags.MissingFinalizedInput;
+    }
+    static hasInner(obj: any): obj is MissingFinalizedInput_ {
+      return MissingFinalizedInput_.instanceOf(obj);
+    }
+
+    static getInner(
+      obj: MissingFinalizedInput_
+    ): Readonly<{ inputIndex: number }> {
+      return obj.inner;
+    }
+  }
+
+  type UnsupportedScriptType__interface = {
+    tag: ContractError_Tags.UnsupportedScriptType;
+    inner: Readonly<{ inputIndex: number }>;
+  };
+  class UnsupportedScriptType_
+    extends UniffiError
+    implements UnsupportedScriptType__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.UnsupportedScriptType;
+    readonly inner: Readonly<{ inputIndex: number }>;
+    constructor(inner: { inputIndex: number }) {
+      super('ContractError', 'UnsupportedScriptType');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { inputIndex: number }): UnsupportedScriptType_ {
+      return new UnsupportedScriptType_(inner);
+    }
+
+    static instanceOf(obj: any): obj is UnsupportedScriptType_ {
+      return obj.tag === ContractError_Tags.UnsupportedScriptType;
+    }
+    static hasInner(obj: any): obj is UnsupportedScriptType_ {
+      return UnsupportedScriptType_.instanceOf(obj);
+    }
+
+    static getInner(
+      obj: UnsupportedScriptType_
+    ): Readonly<{ inputIndex: number }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidAttestation__interface = {
+    tag: ContractError_Tags.InvalidAttestation;
+    inner: Readonly<{ message: string }>;
+  };
+  class InvalidAttestation_
+    extends UniffiError
+    implements InvalidAttestation__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.InvalidAttestation;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'InvalidAttestation');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): InvalidAttestation_ {
+      return new InvalidAttestation_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidAttestation_ {
+      return obj.tag === ContractError_Tags.InvalidAttestation;
+    }
+    static hasInner(obj: any): obj is InvalidAttestation_ {
+      return InvalidAttestation_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidAttestation_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type NoMatchingOutcome__interface = {
+    tag: ContractError_Tags.NoMatchingOutcome;
+  };
+  class NoMatchingOutcome_
+    extends UniffiError
+    implements NoMatchingOutcome__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.NoMatchingOutcome;
+    constructor() {
+      super('ContractError', 'NoMatchingOutcome');
+    }
+
+    static new(): NoMatchingOutcome_ {
+      return new NoMatchingOutcome_();
+    }
+
+    static instanceOf(obj: any): obj is NoMatchingOutcome_ {
+      return obj.tag === ContractError_Tags.NoMatchingOutcome;
+    }
+    static hasInner(obj: any): obj is NoMatchingOutcome_ {
+      return false;
+    }
+  }
+
+  type Descriptor__interface = {
+    tag: ContractError_Tags.Descriptor;
+    inner: Readonly<{ message: string }>;
+  };
+  class Descriptor_ extends UniffiError implements Descriptor__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.Descriptor;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'Descriptor');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): Descriptor_ {
+      return new Descriptor_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Descriptor_ {
+      return obj.tag === ContractError_Tags.Descriptor;
+    }
+    static hasInner(obj: any): obj is Descriptor_ {
+      return Descriptor_.instanceOf(obj);
+    }
+
+    static getInner(obj: Descriptor_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Wallet__interface = {
+    tag: ContractError_Tags.Wallet;
+    inner: Readonly<{ message: string }>;
+  };
+  class Wallet_ extends UniffiError implements Wallet__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.Wallet;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'Wallet');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): Wallet_ {
+      return new Wallet_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Wallet_ {
+      return obj.tag === ContractError_Tags.Wallet;
+    }
+    static hasInner(obj: any): obj is Wallet_ {
+      return Wallet_.instanceOf(obj);
+    }
+
+    static getInner(obj: Wallet_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Bip32__interface = {
+    tag: ContractError_Tags.Bip32;
+    inner: Readonly<{ message: string }>;
+  };
+  class Bip32_ extends UniffiError implements Bip32__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.Bip32;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'Bip32');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): Bip32_ {
+      return new Bip32_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Bip32_ {
+      return obj.tag === ContractError_Tags.Bip32;
+    }
+    static hasInner(obj: any): obj is Bip32_ {
+      return Bip32_.instanceOf(obj);
+    }
+
+    static getInner(obj: Bip32_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Dlc__interface = {
+    tag: ContractError_Tags.Dlc;
+    inner: Readonly<{ message: string }>;
+  };
+  class Dlc_ extends UniffiError implements Dlc__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.Dlc;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'Dlc');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): Dlc_ {
+      return new Dlc_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Dlc_ {
+      return obj.tag === ContractError_Tags.Dlc;
+    }
+    static hasInner(obj: any): obj is Dlc_ {
+      return Dlc_.instanceOf(obj);
+    }
+
+    static getInner(obj: Dlc_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Key__interface = {
+    tag: ContractError_Tags.Key;
+    inner: Readonly<{ message: string }>;
+  };
+  class Key_ extends UniffiError implements Key__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.Key;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'Key');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): Key_ {
+      return new Key_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Key_ {
+      return obj.tag === ContractError_Tags.Key;
+    }
+    static hasInner(obj: any): obj is Key_ {
+      return Key_.instanceOf(obj);
+    }
+
+    static getInner(obj: Key_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Serialization__interface = {
+    tag: ContractError_Tags.Serialization;
+    inner: Readonly<{ message: string }>;
+  };
+  /**
+   * A message or PSBT could not be (de)serialized at the FFI boundary.
+   */
+  class Serialization_ extends UniffiError implements Serialization__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.Serialization;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'Serialization');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): Serialization_ {
+      return new Serialization_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Serialization_ {
+      return obj.tag === ContractError_Tags.Serialization;
+    }
+    static hasInner(obj: any): obj is Serialization_ {
+      return Serialization_.instanceOf(obj);
+    }
+
+    static getInner(obj: Serialization_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidNetwork__interface = {
+    tag: ContractError_Tags.InvalidNetwork;
+    inner: Readonly<{ message: string }>;
+  };
+  /**
+   * The network string was not one of bitcoin/testnet/signet/regtest.
+   */
+  class InvalidNetwork_
+    extends UniffiError
+    implements InvalidNetwork__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.InvalidNetwork;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('ContractError', 'InvalidNetwork');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { message: string }): InvalidNetwork_ {
+      return new InvalidNetwork_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidNetwork_ {
+      return obj.tag === ContractError_Tags.InvalidNetwork;
+    }
+    static hasInner(obj: any): obj is InvalidNetwork_ {
+      return InvalidNetwork_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidNetwork_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidLength__interface = {
+    tag: ContractError_Tags.InvalidLength;
+    inner: Readonly<{ field: string; expected: number; actual: number }>;
+  };
+  /**
+   * A byte argument had the wrong length (e.g. a 32-byte id).
+   */
+  class InvalidLength_ extends UniffiError implements InvalidLength__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ContractError';
+    readonly tag = ContractError_Tags.InvalidLength;
+    readonly inner: Readonly<{
+      field: string;
+      expected: number;
+      actual: number;
+    }>;
+    constructor(inner: { field: string; expected: number; actual: number }) {
+      super('ContractError', 'InvalidLength');
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: {
+      field: string;
+      expected: number;
+      actual: number;
+    }): InvalidLength_ {
+      return new InvalidLength_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidLength_ {
+      return obj.tag === ContractError_Tags.InvalidLength;
+    }
+    static hasInner(obj: any): obj is InvalidLength_ {
+      return InvalidLength_.instanceOf(obj);
+    }
+
+    static getInner(
+      obj: InvalidLength_
+    ): Readonly<{ field: string; expected: number; actual: number }> {
+      return obj.inner;
+    }
+  }
+
+  function instanceOf(obj: any): obj is ContractError {
+    return obj[uniffiTypeNameSymbol] === 'ContractError';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    InvalidOffer: InvalidOffer_,
+    InvalidAccept: InvalidAccept_,
+    InvalidSign: InvalidSign_,
+    InvalidFundingInput: InvalidFundingInput_,
+    PsbtMismatch: PsbtMismatch_,
+    MissingFinalizedInput: MissingFinalizedInput_,
+    UnsupportedScriptType: UnsupportedScriptType_,
+    InvalidAttestation: InvalidAttestation_,
+    NoMatchingOutcome: NoMatchingOutcome_,
+    Descriptor: Descriptor_,
+    Wallet: Wallet_,
+    Bip32: Bip32_,
+    Dlc: Dlc_,
+    Key: Key_,
+    Serialization: Serialization_,
+    InvalidNetwork: InvalidNetwork_,
+    InvalidLength: InvalidLength_,
+  });
+})();
+/**
+ * Errors returned by the stateless contract API.
+ *
+ * Mirrors [`ddk::contract::ContractError`] as a uniffi error so the typed
+ * variants survive across the binding boundary. Variants carry plain strings.
+ */
+export type ContractError = InstanceType<
+  (typeof ContractError)[
+    | 'InvalidOffer'
+    | 'InvalidAccept'
+    | 'InvalidSign'
+    | 'InvalidFundingInput'
+    | 'PsbtMismatch'
+    | 'MissingFinalizedInput'
+    | 'UnsupportedScriptType'
+    | 'InvalidAttestation'
+    | 'NoMatchingOutcome'
+    | 'Descriptor'
+    | 'Wallet'
+    | 'Bip32'
+    | 'Dlc'
+    | 'Key'
+    | 'Serialization'
+    | 'InvalidNetwork'
+    | 'InvalidLength']
+>;
+
+// FfiConverter for enum ContractError
+const FfiConverterTypeContractError = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ContractError;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new ContractError.InvalidOffer({
+            message: FfiConverterString.read(from),
+          });
+        case 2:
+          return new ContractError.InvalidAccept({
+            message: FfiConverterString.read(from),
+          });
+        case 3:
+          return new ContractError.InvalidSign({
+            message: FfiConverterString.read(from),
+          });
+        case 4:
+          return new ContractError.InvalidFundingInput({
+            message: FfiConverterString.read(from),
+          });
+        case 5:
+          return new ContractError.PsbtMismatch({
+            message: FfiConverterString.read(from),
+          });
+        case 6:
+          return new ContractError.MissingFinalizedInput({
+            inputIndex: FfiConverterUInt32.read(from),
+          });
+        case 7:
+          return new ContractError.UnsupportedScriptType({
+            inputIndex: FfiConverterUInt32.read(from),
+          });
+        case 8:
+          return new ContractError.InvalidAttestation({
+            message: FfiConverterString.read(from),
+          });
+        case 9:
+          return new ContractError.NoMatchingOutcome();
+        case 10:
+          return new ContractError.Descriptor({
+            message: FfiConverterString.read(from),
+          });
+        case 11:
+          return new ContractError.Wallet({
+            message: FfiConverterString.read(from),
+          });
+        case 12:
+          return new ContractError.Bip32({
+            message: FfiConverterString.read(from),
+          });
+        case 13:
+          return new ContractError.Dlc({
+            message: FfiConverterString.read(from),
+          });
+        case 14:
+          return new ContractError.Key({
+            message: FfiConverterString.read(from),
+          });
+        case 15:
+          return new ContractError.Serialization({
+            message: FfiConverterString.read(from),
+          });
+        case 16:
+          return new ContractError.InvalidNetwork({
+            message: FfiConverterString.read(from),
+          });
+        case 17:
+          return new ContractError.InvalidLength({
+            field: FfiConverterString.read(from),
+            expected: FfiConverterUInt32.read(from),
+            actual: FfiConverterUInt32.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case ContractError_Tags.InvalidOffer: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.InvalidAccept: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.InvalidSign: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.InvalidFundingInput: {
+          ordinalConverter.write(4, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.PsbtMismatch: {
+          ordinalConverter.write(5, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.MissingFinalizedInput: {
+          ordinalConverter.write(6, into);
+          const inner = value.inner;
+          FfiConverterUInt32.write(inner.inputIndex, into);
+          return;
+        }
+        case ContractError_Tags.UnsupportedScriptType: {
+          ordinalConverter.write(7, into);
+          const inner = value.inner;
+          FfiConverterUInt32.write(inner.inputIndex, into);
+          return;
+        }
+        case ContractError_Tags.InvalidAttestation: {
+          ordinalConverter.write(8, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.NoMatchingOutcome: {
+          ordinalConverter.write(9, into);
+          return;
+        }
+        case ContractError_Tags.Descriptor: {
+          ordinalConverter.write(10, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.Wallet: {
+          ordinalConverter.write(11, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.Bip32: {
+          ordinalConverter.write(12, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.Dlc: {
+          ordinalConverter.write(13, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.Key: {
+          ordinalConverter.write(14, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.Serialization: {
+          ordinalConverter.write(15, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.InvalidNetwork: {
+          ordinalConverter.write(16, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case ContractError_Tags.InvalidLength: {
+          ordinalConverter.write(17, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.field, into);
+          FfiConverterUInt32.write(inner.expected, into);
+          FfiConverterUInt32.write(inner.actual, into);
+          return;
+        }
+        default:
+          // Throwing from here means that ContractError_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case ContractError_Tags.InvalidOffer: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.InvalidAccept: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.InvalidSign: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.InvalidFundingInput: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(4);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.PsbtMismatch: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(5);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.MissingFinalizedInput: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(6);
+          size += FfiConverterUInt32.allocationSize(inner.inputIndex);
+          return size;
+        }
+        case ContractError_Tags.UnsupportedScriptType: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(7);
+          size += FfiConverterUInt32.allocationSize(inner.inputIndex);
+          return size;
+        }
+        case ContractError_Tags.InvalidAttestation: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(8);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.NoMatchingOutcome: {
+          return ordinalConverter.allocationSize(9);
+        }
+        case ContractError_Tags.Descriptor: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(10);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.Wallet: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(11);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.Bip32: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(12);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.Dlc: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(13);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.Key: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(14);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.Serialization: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(15);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.InvalidNetwork: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(16);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case ContractError_Tags.InvalidLength: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(17);
+          size += FfiConverterString.allocationSize(inner.field);
+          size += FfiConverterUInt32.allocationSize(inner.expected);
+          size += FfiConverterUInt32.allocationSize(inner.actual);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 export enum ExtendedKey {
   InvalidMnemonic,
   InvalidXpriv,
@@ -2617,11 +5060,315 @@ const FfiConverterTypeDLCError = (() => {
   return new FFIConverter();
 })();
 
-// FfiConverter for Array<ArrayBuffer>
-const FfiConverterSequenceBytes = new FfiConverterArray(
-  FfiConverterArrayBuffer
+/**
+ * Identifies which party's funding inputs an operation applies to.
+ */
+export enum Party {
+  /**
+   * The party that created the offer.
+   */
+  Offer,
+  /**
+   * The party that accepted the offer.
+   */
+  Accept,
+}
+
+const FfiConverterTypeParty = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = Party;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return Party.Offer;
+        case 2:
+          return Party.Accept;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case Party.Offer:
+          return ordinalConverter.write(1, into);
+        case Party.Accept:
+          return ordinalConverter.write(2, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Deterministically derives DLC contract funding keys from a master extended
+ * private key. Secret keys never leave this object.
+ *
+ * Construct one from whatever key material the consumer holds, then call
+ * [`ContractKeyProvider::funding_pubkey`] to obtain the public key to publish
+ * in an offer/accept message.
+ */
+export interface ContractKeyProviderLike {
+  /**
+   * The 33-byte compressed funding public key for a contract, from its
+   * 32-byte temporary id. Publish this in the offer or accept message.
+   */
+  fundingPubkey(temporaryContractId: Uint8Array) /*throws*/ : Uint8Array;
+}
+/**
+ * @deprecated Use `ContractKeyProviderLike` instead.
+ */
+export type ContractKeyProviderInterface = ContractKeyProviderLike;
+
+/**
+ * Deterministically derives DLC contract funding keys from a master extended
+ * private key. Secret keys never leave this object.
+ *
+ * Construct one from whatever key material the consumer holds, then call
+ * [`ContractKeyProvider::funding_pubkey`] to obtain the public key to publish
+ * in an offer/accept message.
+ */
+export class ContractKeyProvider
+  extends UniffiAbstractObject
+  implements ContractKeyProviderLike
+{
+  readonly [uniffiTypeNameSymbol] = 'ContractKeyProvider';
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  // No primary constructor declared for this class.
+  private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] =
+      uniffiTypeContractKeyProviderObjectFactory.bless(pointer);
+  }
+
+  /**
+   * Builds a provider from an output descriptor that carries an extended
+   * private key (e.g. `wpkh(xprv.../84h/1h/0h/0/*)`). Watch-only descriptors
+   * are rejected; the descriptor's own path/wildcard is not applied to
+   * contract-key derivation.
+   */
+  static fromDescriptor(
+    descriptor: string
+  ): ContractKeyProviderLike /*throws*/ {
+    return FfiConverterTypeContractKeyProvider.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+          FfiConverterTypeContractError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_ddk_ffi_fn_constructor_contractkeyprovider_from_descriptor(
+            FfiConverterString.lower(
+              descriptor,
+              nativeModule().rustbuffer_alloc
+            ),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+      )
+    );
+  }
+
+  /**
+   * Builds a provider from a BIP39 mnemonic (with optional passphrase).
+   */
+  static fromMnemonic(
+    mnemonic: string,
+    passphrase: string | undefined,
+    network: string
+  ): ContractKeyProviderLike /*throws*/ {
+    return FfiConverterTypeContractKeyProvider.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+          FfiConverterTypeContractError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_ddk_ffi_fn_constructor_contractkeyprovider_from_mnemonic(
+            FfiConverterString.lower(mnemonic, nativeModule().rustbuffer_alloc),
+            FfiConverterOptionalString.lower(
+              passphrase,
+              nativeModule().rustbuffer_alloc
+            ),
+            FfiConverterString.lower(network, nativeModule().rustbuffer_alloc),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+      )
+    );
+  }
+
+  /**
+   * Builds a provider from a raw seed (for example the 64 bytes produced by
+   * `convert_mnemonic_to_seed`).
+   */
+  static fromSeed(
+    seed: Uint8Array,
+    network: string
+  ): ContractKeyProviderLike /*throws*/ {
+    return FfiConverterTypeContractKeyProvider.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+          FfiConverterTypeContractError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_ddk_ffi_fn_constructor_contractkeyprovider_from_seed(
+            FfiConverterUint8Array.lower(seed, nativeModule().rustbuffer_alloc),
+            FfiConverterString.lower(network, nativeModule().rustbuffer_alloc),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+      )
+    );
+  }
+
+  /**
+   * Builds a provider from a 78-byte encoded master extended private key
+   * (the encoding produced by `create_extkey_from_seed`).
+   */
+  static fromXprv(xprv: Uint8Array): ContractKeyProviderLike /*throws*/ {
+    return FfiConverterTypeContractKeyProvider.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+          FfiConverterTypeContractError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_ddk_ffi_fn_constructor_contractkeyprovider_from_xprv(
+            FfiConverterUint8Array.lower(xprv, nativeModule().rustbuffer_alloc),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+      )
+    );
+  }
+
+  /**
+   * The 33-byte compressed funding public key for a contract, from its
+   * 32-byte temporary id. Publish this in the offer or accept message.
+   */
+  fundingPubkey(temporaryContractId: Uint8Array): Uint8Array /*throws*/ {
+    return ((__rb: Uint8Array) => {
+      try {
+        return FfiConverterUint8Array.lift(__rb);
+      } finally {
+        nativeModule().rustbuffer_free(__rb);
+      }
+    })(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeContractError.lift.bind(
+          FfiConverterTypeContractError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_ddk_ffi_fn_method_contractkeyprovider_funding_pubkey(
+            uniffiTypeContractKeyProviderObjectFactory.clonePointer(this),
+            FfiConverterUint8Array.lower(
+              temporaryContractId,
+              nativeModule().rustbuffer_alloc
+            ),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+      )
+    );
+  }
+
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeContractKeyProviderObjectFactory.pointer(this);
+      uniffiTypeContractKeyProviderObjectFactory.freePointer(pointer);
+      uniffiTypeContractKeyProviderObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj_: any): obj_ is ContractKeyProvider {
+    return uniffiTypeContractKeyProviderObjectFactory.isConcreteType(obj_);
+  }
+}
+
+const uniffiTypeContractKeyProviderObjectFactory: UniffiObjectFactory<ContractKeyProviderLike> =
+  (() => {
+    return {
+      create(pointer: UniffiHandle): ContractKeyProviderLike {
+        const instance = Object.create(ContractKeyProvider.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = 'ContractKeyProvider';
+        return instance;
+      },
+
+      bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_contractkeyprovider_ffi__bless_pointer(
+              p,
+              status
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      unbless(ptr_: UniffiGcObject) {
+        ptr_.markDestroyed();
+      },
+
+      pointer(obj_: ContractKeyProviderLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+      },
+
+      clonePointer(obj_: ContractKeyProviderLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_ddk_ffi_fn_clone_contractkeyprovider(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_ddk_ffi_fn_free_contractkeyprovider(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      isConcreteType(obj_: any): obj_ is ContractKeyProviderLike {
+        return (
+          obj_[destructorGuardSymbol] &&
+          obj_[uniffiTypeNameSymbol] === 'ContractKeyProvider'
+        );
+      },
+    };
+  })();
+const FfiConverterTypeContractKeyProvider = new FfiConverterObject(
+  uniffiTypeContractKeyProviderObjectFactory
 );
 
+// FfiConverter for Array<Uint8Array>
+const FfiConverterSequenceBytes = new FfiConverterArray(FfiConverterUint8Array);
+
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+
 // FfiConverter for Array<TxInput>
 const FfiConverterSequenceTypeTxInput = new FfiConverterArray(
   FfiConverterTypeTxInput
@@ -2637,6 +5384,19 @@ const FfiConverterSequenceTypeTransaction = new FfiConverterArray(
   FfiConverterTypeTransaction
 );
 
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for Array<PayoutRow>
+const FfiConverterSequenceTypePayoutRow = new FfiConverterArray(
+  FfiConverterTypePayoutRow
+);
+
+// FfiConverter for Uint8Array | undefined
+const FfiConverterOptionalBytes = new FfiConverterOptional(
+  FfiConverterUint8Array
+);
+
 // FfiConverter for Array<TxInputInfo>
 const FfiConverterSequenceTypeTxInputInfo = new FfiConverterArray(
   FfiConverterTypeTxInputInfo
@@ -2647,20 +5407,17 @@ const FfiConverterSequenceTypeDlcInputInfo = new FfiConverterArray(
   FfiConverterTypeDlcInputInfo
 );
 
-// FfiConverter for string | undefined
-const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
-
 // FfiConverter for Array<OracleInfo>
 const FfiConverterSequenceTypeOracleInfo = new FfiConverterArray(
   FfiConverterTypeOracleInfo
 );
 
-// FfiConverter for Array<Array<ArrayBuffer>>
+// FfiConverter for Array<Array<Uint8Array>>
 const FfiConverterSequenceSequenceBytes = new FfiConverterArray(
   FfiConverterSequenceBytes
 );
 
-// FfiConverter for Array<Array<Array<ArrayBuffer>>>
+// FfiConverter for Array<Array<Array<Uint8Array>>>
 const FfiConverterSequenceSequenceSequenceBytes = new FfiConverterArray(
   FfiConverterSequenceSequenceBytes
 );
@@ -2675,6 +5432,21 @@ const FfiConverterSequenceTypePayout = new FfiConverterArray(
   FfiConverterTypePayout
 );
 
+// FfiConverter for Array<SpliceKeyRef>
+const FfiConverterSequenceTypeSpliceKeyRef = new FfiConverterArray(
+  FfiConverterTypeSpliceKeyRef
+);
+
+// FfiConverter for Array<OracleAttestationRef>
+const FfiConverterSequenceTypeOracleAttestationRef = new FfiConverterArray(
+  FfiConverterTypeOracleAttestationRef
+);
+
+// FfiConverter for Array<DescriptorInput>
+const FfiConverterSequenceTypeDescriptorInput = new FfiConverterArray(
+  FfiConverterTypeDescriptorInput
+);
+
 /**
  * This should be called before anything else.
  *
@@ -2697,6 +5469,37 @@ function uniffiEnsureInitialized() {
       bindingsContractVersion
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_accept_offer() !== 49334
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_accept_offer'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_chain_hash_from_network() !==
+    782
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_chain_hash_from_network'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_compute_contract_id() !==
+    7849
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_compute_contract_id'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_contract_info_payouts() !==
+    5148
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_contract_info_payouts'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_convert_mnemonic_to_seed() !==
     29793
@@ -2741,6 +5544,14 @@ function uniffiEnsureInitialized() {
       'uniffi_ddk_ffi_checksum_func_create_cets'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_create_dlc_splice_input() !==
+    50727
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_create_dlc_splice_input'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_create_dlc_transactions() !==
     60266
@@ -2773,6 +5584,21 @@ function uniffiEnsureInitialized() {
       'uniffi_ddk_ffi_checksum_func_create_fund_tx_locking_script'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_create_funding_psbt() !==
+    39942
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_create_funding_psbt'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_create_offer() !== 39327
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_create_offer'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_create_refund_transaction() !==
     40230
@@ -2797,6 +5623,22 @@ function uniffiEnsureInitialized() {
       'uniffi_ddk_ffi_checksum_func_create_xpriv_from_parent_path'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_dlc_input_max_witness_len() !==
+    49586
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_dlc_input_max_witness_len'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_dlc_transactions_from_messages() !==
+    56492
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_dlc_transactions_from_messages'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_extract_ecdsa_signature_from_oracle_signatures() !==
     4868
@@ -2805,6 +5647,28 @@ function uniffiEnsureInitialized() {
       'uniffi_ddk_ffi_checksum_func_extract_ecdsa_signature_from_oracle_signatures'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_finalize_sign() !== 20463
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_finalize_sign'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_finalize_sign_spliced() !==
+    32005
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_finalize_sign_spliced'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_funding_input() !== 64911
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_funding_input'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_get_pubkey_from_extkey() !==
     18050
@@ -2829,6 +5693,66 @@ function uniffiEnsureInitialized() {
       'uniffi_ddk_ffi_checksum_func_get_xpub_from_xpriv'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_sign_accept() !== 37062
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_sign_accept'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_sign_accept_spliced() !==
+    32504
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_sign_accept_spliced'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_sign_contract_cet() !==
+    36727
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_sign_contract_cet'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_sign_contract_refund() !==
+    23156
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_sign_contract_refund'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_sign_funding_psbt_with_descriptor() !==
+    25961
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_sign_funding_psbt_with_descriptor'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_validate_accept() !== 9081
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_validate_accept'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_validate_offer() !== 24632
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_validate_offer'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_validate_sign() !== 7419
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_func_validate_sign'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_ddk_ffi_checksum_func_verify_cet_adaptor_sigs_from_oracle_info() !==
     32235
@@ -2842,21 +5766,74 @@ function uniffiEnsureInitialized() {
       'uniffi_ddk_ffi_checksum_func_version'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_descriptor() !==
+    47034
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_descriptor'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_mnemonic() !==
+    47667
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_mnemonic'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_seed() !==
+    47192
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_seed'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_xprv() !==
+    7002
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_constructor_contractkeyprovider_from_xprv'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_ddk_ffi_checksum_method_contractkeyprovider_funding_pubkey() !==
+    58577
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_ddk_ffi_checksum_method_contractkeyprovider_funding_pubkey'
+    );
+  }
 }
 
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
+    FfiConverterTypeAcceptOfferParams,
+    FfiConverterTypeAcceptResult,
     FfiConverterTypeAdaptorSignature,
     FfiConverterTypeCetAdaptorSignatureDebugInfo,
     FfiConverterTypeChangeOutputAndFees,
+    FfiConverterTypeContractError,
+    FfiConverterTypeContractKeyProvider,
+    FfiConverterTypeContractPartyParams,
+    FfiConverterTypeContractPayouts,
+    FfiConverterTypeCreateOfferParams,
     FfiConverterTypeDLCError,
+    FfiConverterTypeDescriptorInput,
     FfiConverterTypeDlcInputInfo,
     FfiConverterTypeDlcTransactions,
     FfiConverterTypeExtendedKey,
+    FfiConverterTypeOracleAttestationRef,
     FfiConverterTypeOracleInfo,
+    FfiConverterTypeParty,
     FfiConverterTypePartyParams,
     FfiConverterTypePayout,
+    FfiConverterTypePayoutRow,
+    FfiConverterTypeSignResult,
+    FfiConverterTypeSpliceKeyRef,
     FfiConverterTypeTransaction,
     FfiConverterTypeTxInput,
     FfiConverterTypeTxInputInfo,