@bennyblader/ddk-rn 0.4.0 → 1.0.0-rc2

package/lib/typescript/module/src/ddk_ffi.d.ts

@@ -1,19 +1,53 @@
-import { type UniffiByteArray, RustBuffer, uniffiTypeNameSymbol } from '@ubjs/core';
-export declare function convertMnemonicToSeed(mnemonic: string, passphrase: string | undefined): ArrayBuffer;
+import { type UniffiByteArray, type UniffiGcObject, type UniffiHandle, FfiConverterObject, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from '@ubjs/core';
+/**
+ * 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 declare function acceptOffer(offer: Uint8Array, params: AcceptOfferParams, keys: ContractKeyProviderLike, newTemporaryContractId: Uint8Array): AcceptResult;
+/**
+ * The 32-byte chain hash for a network (`bitcoin` / `testnet` / `signet` /
+ * `regtest`). Use it for [`CreateOfferParams::chain_hash`].
+ */
+export declare function chainHashFromNetwork(network: string): Uint8Array;
+/**
+ * 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 declare function computeContractId(offer: Uint8Array, accept: Uint8Array): Uint8Array;
+/**
+ * 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 declare function contractInfoPayouts(contractInfo: Uint8Array): ContractPayouts;
+export declare function convertMnemonicToSeed(mnemonic: string, passphrase: string | undefined): Uint8Array;
 /**
  * Create a single CET
  */
 export declare function createCet(localOutput: TxOutput, localPayoutSerialId: bigint, remoteOutput: TxOutput, remotePayoutSerialId: bigint, fundTxId: string, fundVout: number, lockTime: number): Transaction;
-export declare function createCetAdaptorPointsFromOracleInfo(oracleInfo: Array<OracleInfo>, msgs: Array<Array<Array<ArrayBuffer>>>): Array<ArrayBuffer>;
-export declare function createCetAdaptorSigsFromOracleInfo(cets: Array<Transaction>, oracleInfo: Array<OracleInfo>, fundingSecretKey: ArrayBuffer, fundingScriptPubkey: ArrayBuffer, fundOutputValue: bigint, msgs: Array<Array<Array<ArrayBuffer>>>): Array<AdaptorSignature>;
+export declare function createCetAdaptorPointsFromOracleInfo(oracleInfo: Array<OracleInfo>, msgs: Array<Array<Array<Uint8Array>>>): Array<Uint8Array>;
+export declare function createCetAdaptorSigsFromOracleInfo(cets: Array<Transaction>, oracleInfo: Array<OracleInfo>, fundingSecretKey: Uint8Array, fundingScriptPubkey: Uint8Array, fundOutputValue: bigint, msgs: Array<Array<Array<Uint8Array>>>): Array<AdaptorSignature>;
 /**
  * Create adaptor signatures from pre-computed adaptor points.
  */
-export declare function createCetAdaptorSigsFromPoints(cets: Array<Transaction>, adaptorPoints: Array<ArrayBuffer>, fundingSecretKey: ArrayBuffer, fundingScriptPubkey: ArrayBuffer, fundOutputValue: bigint): Array<AdaptorSignature>;
+export declare function createCetAdaptorSigsFromPoints(cets: Array<Transaction>, adaptorPoints: Array<Uint8Array>, fundingSecretKey: Uint8Array, fundingScriptPubkey: Uint8Array, fundOutputValue: bigint): Array<AdaptorSignature>;
 /**
  * Create multiple CETs
  */
-export declare function createCets(fundTxId: string, fundVout: number, localFinalScriptPubkey: ArrayBuffer, remoteFinalScriptPubkey: ArrayBuffer, outcomes: Array<Payout>, lockTime: number, localSerialId: bigint, remoteSerialId: bigint): Array<Transaction>;
+export declare function createCets(fundTxId: string, fundVout: number, localFinalScriptPubkey: Uint8Array, remoteFinalScriptPubkey: Uint8Array, outcomes: Array<Payout>, lockTime: number, localSerialId: bigint, remoteSerialId: bigint): Array<Transaction>;
+/**
+ * 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 declare function createDlcSpliceInput(prevOffer: Uint8Array, prevAccept: Uint8Array, localParty: Party, inputSerialId: bigint | undefined, maxWitnessLen: number): Uint8Array;
 /**
  * Create complete DLC transactions
  */
@@ -22,20 +56,28 @@ export declare function createDlcTransactions(outcomes: Array<Payout>, localPara
  * Derive child extended private key from parent extended key
  * Input: 78-byte encoded xpriv, Output: 78-byte encoded xpriv
  */
-export declare function createExtkeyFromParentPath(extkey: ArrayBuffer, path: string): ArrayBuffer;
+export declare function createExtkeyFromParentPath(extkey: Uint8Array, path: string): Uint8Array;
 /**
  * Create master extended private key from 64-byte seed
  * Returns 78-byte encoded xpriv
  */
-export declare function createExtkeyFromSeed(seed: ArrayBuffer, network: string): ArrayBuffer;
+export declare function createExtkeyFromSeed(seed: Uint8Array, network: string): Uint8Array;
 /**
  * Create a funding script pubkey for DLC transactions
  */
-export declare function createFundTxLockingScript(localFundPubkey: ArrayBuffer, remoteFundPubkey: ArrayBuffer): ArrayBuffer;
+export declare function createFundTxLockingScript(localFundPubkey: Uint8Array, remoteFundPubkey: Uint8Array): Uint8Array;
+/**
+ * Rebuilds the BIP-174 funding PSBT from the offer and accept messages.
+ */
+export declare function createFundingPsbt(offer: Uint8Array, accept: Uint8Array): Uint8Array;
+/**
+ * Creates an offer. Returns the wire-encoded `OfferDlc` to send to the accepting party.
+ */
+export declare function createOffer(params: CreateOfferParams): Uint8Array;
 /**
  * Create a refund transaction
  */
-export declare function createRefundTransaction(localFinalScriptPubkey: ArrayBuffer, remoteFinalScriptPubkey: ArrayBuffer, localAmount: bigint, remoteAmount: bigint, lockTime: number, fundTxId: string, fundVout: number): Transaction;
+export declare function createRefundTransaction(localFinalScriptPubkey: Uint8Array, remoteFinalScriptPubkey: Uint8Array, localAmount: bigint, remoteAmount: bigint, lockTime: number, fundTxId: string, fundVout: number): Transaction;
 /**
  * Create spliced DLC transactions
  */
@@ -44,13 +86,47 @@ export declare function createSplicedDlcTransactions(outcomes: Array<Payout>, lo
  * DEPRECATED: Use create_extkey_from_seed + create_extkey_from_parent_path instead
  * This function handles both seeds (64 bytes) and xprivs (78 bytes) which is confusing
  */
-export declare function createXprivFromParentPath(seedOrXpriv: ArrayBuffer, baseDerivationPath: string, network: string, path: string): ArrayBuffer;
-export declare function extractEcdsaSignatureFromOracleSignatures(oracleSignatures: Array<ArrayBuffer>, adaptorSignature: ArrayBuffer): ArrayBuffer;
+export declare function createXprivFromParentPath(seedOrXpriv: Uint8Array, baseDerivationPath: string, network: string, path: string): Uint8Array;
+/**
+ * The required `max_witness_len` for a DLC (splice) funding input (220).
+ */
+export declare function dlcInputMaxWitnessLen(): number;
+/**
+ * Rebuilds the unsigned funding, CET, and refund transactions from the messages.
+ */
+export declare function dlcTransactionsFromMessages(offer: Uint8Array, accept: Uint8Array): DlcTransactions;
+export declare function extractEcdsaSignatureFromOracleSignatures(oracleSignatures: Array<Uint8Array>, adaptorSignature: Uint8Array): Uint8Array;
+/**
+ * The accepting party verifies the sign message and completes the funding
+ * transaction. Returns the Bitcoin consensus-serialized signed transaction.
+ */
+export declare function finalizeSign(offer: Uint8Array, accept: Uint8Array, sign: Uint8Array, signedFundingPsbt: Uint8Array): Uint8Array;
+/**
+ * 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 declare function finalizeSignSpliced(offer: Uint8Array, accept: Uint8Array, sign: Uint8Array, signedFundingPsbt: Uint8Array, keys: ContractKeyProviderLike, spliceKeys: Array<SpliceKeyRef>): Uint8Array;
+/**
+ * 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 declare function fundingInput(previousTransaction: Uint8Array, vout: number, inputSerialId: bigint | undefined, sequence: number, maxWitnessLen: number, redeemScript: Uint8Array): Uint8Array;
 /**
  * Extract public key from extended key (private or public)
  * Input: 78-byte encoded xpriv/xpub, Output: 33-byte compressed public key
  */
-export declare function getPubkeyFromExtkey(extkey: ArrayBuffer, network: string): ArrayBuffer;
+export declare function getPubkeyFromExtkey(extkey: Uint8Array, network: string): Uint8Array;
 /**
  * Get total input virtual size for fee calculation
  */
@@ -59,12 +135,244 @@ export declare function getTotalInputVsize(inputs: Array<TxInputInfo>): number;
  * Convert extended private key to extended public key
  * Input: 78-byte encoded xpriv, Output: 78-byte encoded xpub
  */
-export declare function getXpubFromXpriv(xpriv: ArrayBuffer, network: string): ArrayBuffer;
-export declare function verifyCetAdaptorSigsFromOracleInfo(adaptorSigs: Array<AdaptorSignature>, cets: Array<Transaction>, oracleInfos: Array<OracleInfo>, pubkey: ArrayBuffer, fundingScriptPubkey: ArrayBuffer, totalCollateral: bigint, msgs: Array<Array<Array<ArrayBuffer>>>): boolean;
+export declare function getXpubFromXpriv(xpriv: Uint8Array, network: string): Uint8Array;
+/**
+ * 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 declare function signAccept(offer: Uint8Array, accept: Uint8Array, keys: ContractKeyProviderLike, temporaryContractId: Uint8Array, signedFundingPsbt: Uint8Array): SignResult;
+/**
+ * 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 declare function signAcceptSpliced(offer: Uint8Array, accept: Uint8Array, keys: ContractKeyProviderLike, temporaryContractId: Uint8Array, signedFundingPsbt: Uint8Array, spliceKeys: Array<SpliceKeyRef>): SignResult;
+/**
+ * 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 declare function signContractCet(offer: Uint8Array, accept: Uint8Array, sign: Uint8Array, keys: ContractKeyProviderLike, temporaryContractId: Uint8Array, attestations: Array<OracleAttestationRef>): Uint8Array;
+/**
+ * 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 declare function signContractRefund(offer: Uint8Array, accept: Uint8Array, sign: Uint8Array, keys: ContractKeyProviderLike, temporaryContractId: Uint8Array): Uint8Array;
+/**
+ * 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 declare function signFundingPsbtWithDescriptor(offer: Uint8Array, accept: Uint8Array, fundingPsbt: Uint8Array, descriptor: string, inputs: Array<DescriptorInput>): Uint8Array;
+/**
+ * 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 declare function validateAccept(offer: Uint8Array, accept: Uint8Array): void;
+/**
+ * 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 declare function validateOffer(offer: Uint8Array, minTimeoutInterval: number, maxTimeoutInterval: number): void;
+/**
+ * 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 declare function validateSign(offer: Uint8Array, accept: Uint8Array, sign: Uint8Array): void;
+export declare function verifyCetAdaptorSigsFromOracleInfo(adaptorSigs: Array<AdaptorSignature>, cets: Array<Transaction>, oracleInfos: Array<OracleInfo>, pubkey: Uint8Array, fundingScriptPubkey: Uint8Array, totalCollateral: bigint, msgs: Array<Array<Array<Uint8Array>>>): boolean;
 export declare function version(): string;
+/**
+ * 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 ContractPartyParams} record objects.
+ */
+export declare const ContractPartyParams: Readonly<{
+    create: (partial: Partial<ContractPartyParams> & Required<Omit<ContractPartyParams, "payoutSerialId" | "changeSerialId">>) => ContractPartyParams;
+    new: (partial: Partial<ContractPartyParams> & Required<Omit<ContractPartyParams, "payoutSerialId" | "changeSerialId">>) => ContractPartyParams;
+    defaults: () => Partial<ContractPartyParams>;
+}>;
+/**
+ * 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 declare const AcceptOfferParams: Readonly<{
+    create: (partial: Partial<AcceptOfferParams> & Required<Omit<AcceptOfferParams, never>>) => AcceptOfferParams;
+    new: (partial: Partial<AcceptOfferParams> & Required<Omit<AcceptOfferParams, never>>) => AcceptOfferParams;
+    defaults: () => Partial<AcceptOfferParams>;
+}>;
+export type TxInput = {
+    txid: string;
+    vout: number;
+    scriptSig: Uint8Array;
+    sequence: number;
+    witness: Array<Uint8Array>;
+};
+/**
+ * Generated factory for {@link TxInput} record objects.
+ */
+export declare const TxInput: Readonly<{
+    create: (partial: Partial<TxInput> & Required<Omit<TxInput, never>>) => TxInput;
+    new: (partial: Partial<TxInput> & Required<Omit<TxInput, never>>) => TxInput;
+    defaults: () => Partial<TxInput>;
+}>;
+export type TxOutput = {
+    value: bigint;
+    scriptPubkey: Uint8Array;
+};
+/**
+ * Generated factory for {@link TxOutput} record objects.
+ */
+export declare const TxOutput: Readonly<{
+    create: (partial: Partial<TxOutput> & Required<Omit<TxOutput, never>>) => TxOutput;
+    new: (partial: Partial<TxOutput> & Required<Omit<TxOutput, never>>) => TxOutput;
+    defaults: () => Partial<TxOutput>;
+    isDust(self_: TxOutput): boolean;
+}>;
+export type Transaction = {
+    version: number;
+    lockTime: number;
+    inputs: Array<TxInput>;
+    outputs: Array<TxOutput>;
+    rawBytes: Uint8Array;
+};
+/**
+ * Generated factory for {@link Transaction} record objects.
+ */
+export declare const Transaction: Readonly<{
+    create: (partial: Partial<Transaction> & Required<Omit<Transaction, never>>) => Transaction;
+    new: (partial: Partial<Transaction> & Required<Omit<Transaction, never>>) => Transaction;
+    defaults: () => Partial<Transaction>;
+    addSignature(self_: Transaction, signature: Uint8Array, pubkey: Uint8Array, inputIndex: number): Transaction;
+    cetAdaptorSignatureFromOracleInfo(self_: Transaction, oracleInfo: OracleInfo, fundingSk: Uint8Array, fundingScriptPubkey: Uint8Array, totalCollateral: bigint, msgs: Array<Uint8Array>): AdaptorSignature;
+    cetAdaptorSignatureInputs(self_: Transaction, oracleInfo: Array<OracleInfo>, fundingScriptPubkey: Uint8Array, fundOutputValue: bigint, msgs: Array<Array<Uint8Array>>): CetAdaptorSignatureDebugInfo;
+    cetSighash(self_: Transaction, fundingScriptPubkey: Uint8Array, fundOutputValue: bigint): Uint8Array;
+    rawFundingInputSignature(self_: Transaction, privkey: Uint8Array, prevTxId: string, prevTxVout: number, value: bigint): Uint8Array;
+    signCet(self_: Transaction, adaptorSignature: Uint8Array, oracleSignatures: Array<Uint8Array>, fundingSecretKey: Uint8Array, otherPubkey: Uint8Array, fundingScriptPubkey: Uint8Array, fundOutputValue: bigint): Transaction;
+    signFundInput(self_: Transaction, privkey: Uint8Array, prevTxId: string, prevTxVout: number, value: bigint): Transaction;
+    signMultiSigInput(self_: Transaction, dlcInput: DlcInputInfo, localPrivkey: Uint8Array, remoteSignature: Uint8Array): Transaction;
+    verifyFundSignature(self_: Transaction, signature: Uint8Array, pubkey: Uint8Array, txid: string, vout: number, inputAmount: bigint): boolean;
+}>;
+export type DlcTransactions = {
+    fund: Transaction;
+    cets: Array<Transaction>;
+    refund: Transaction;
+    fundingScriptPubkey: Uint8Array;
+};
+/**
+ * Generated factory for {@link DlcTransactions} record objects.
+ */
+export declare const DlcTransactions: Readonly<{
+    create: (partial: Partial<DlcTransactions> & Required<Omit<DlcTransactions, never>>) => DlcTransactions;
+    new: (partial: Partial<DlcTransactions> & Required<Omit<DlcTransactions, never>>) => DlcTransactions;
+    defaults: () => Partial<DlcTransactions>;
+}>;
+/**
+ * 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 AcceptResult} record objects.
+ */
+export declare const AcceptResult: Readonly<{
+    create: (partial: Partial<AcceptResult> & Required<Omit<AcceptResult, never>>) => AcceptResult;
+    new: (partial: Partial<AcceptResult> & Required<Omit<AcceptResult, never>>) => AcceptResult;
+    defaults: () => Partial<AcceptResult>;
+}>;
 export type AdaptorSignature = {
-    signature: ArrayBuffer;
-    proof: ArrayBuffer;
+    signature: Uint8Array;
+    proof: Uint8Array;
 };
 /**
  * Generated factory for {@link AdaptorSignature} record objects.
@@ -73,211 +381,1794 @@ export declare const AdaptorSignature: Readonly<{
     create: (partial: Partial<AdaptorSignature> & Required<Omit<AdaptorSignature, never>>) => AdaptorSignature;
     new: (partial: Partial<AdaptorSignature> & Required<Omit<AdaptorSignature, never>>) => AdaptorSignature;
     defaults: () => Partial<AdaptorSignature>;
-    verifyFromOracleInfo(self_: AdaptorSignature, cet: Transaction, oracleInfos: Array<OracleInfo>, pubkey: ArrayBuffer, fundingScriptPubkey: ArrayBuffer, totalCollateral: bigint, msgs: Array<Array<ArrayBuffer>>): boolean;
+    verifyFromOracleInfo(self_: AdaptorSignature, cet: Transaction, oracleInfos: Array<OracleInfo>, pubkey: Uint8Array, fundingScriptPubkey: Uint8Array, totalCollateral: bigint, msgs: Array<Array<Uint8Array>>): boolean;
+}>;
+/**
+ * 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 CetAdaptorSignatureDebugInfo} record objects.
+ */
+export declare const CetAdaptorSignatureDebugInfo: Readonly<{
+    create: (partial: Partial<CetAdaptorSignatureDebugInfo> & Required<Omit<CetAdaptorSignatureDebugInfo, never>>) => CetAdaptorSignatureDebugInfo;
+    new: (partial: Partial<CetAdaptorSignatureDebugInfo> & Required<Omit<CetAdaptorSignatureDebugInfo, never>>) => CetAdaptorSignatureDebugInfo;
+    defaults: () => Partial<CetAdaptorSignatureDebugInfo>;
+}>;
+export type ChangeOutputAndFees = {
+    changeOutput: TxOutput;
+    fundFee: bigint;
+    cetFee: bigint;
+};
+/**
+ * Generated factory for {@link ChangeOutputAndFees} record objects.
+ */
+export declare const ChangeOutputAndFees: Readonly<{
+    create: (partial: Partial<ChangeOutputAndFees> & Required<Omit<ChangeOutputAndFees, never>>) => ChangeOutputAndFees;
+    new: (partial: Partial<ChangeOutputAndFees> & Required<Omit<ChangeOutputAndFees, never>>) => ChangeOutputAndFees;
+    defaults: () => Partial<ChangeOutputAndFees>;
+}>;
+/**
+ * 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 PayoutRow} record objects.
+ */
+export declare const PayoutRow: Readonly<{
+    create: (partial: Partial<PayoutRow> & Required<Omit<PayoutRow, "outcome" | "rangeStart" | "rangeEnd">>) => PayoutRow;
+    new: (partial: Partial<PayoutRow> & Required<Omit<PayoutRow, "outcome" | "rangeStart" | "rangeEnd">>) => PayoutRow;
+    defaults: () => Partial<PayoutRow>;
+}>;
+/**
+ * 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 declare const ContractPayouts: Readonly<{
+    create: (partial: Partial<ContractPayouts> & Required<Omit<ContractPayouts, never>>) => ContractPayouts;
+    new: (partial: Partial<ContractPayouts> & Required<Omit<ContractPayouts, never>>) => ContractPayouts;
+    defaults: () => Partial<ContractPayouts>;
+}>;
+/**
+ * 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 declare const CreateOfferParams: Readonly<{
+    create: (partial: Partial<CreateOfferParams> & Required<Omit<CreateOfferParams, "temporaryContractId" | "fundOutputSerialId">>) => CreateOfferParams;
+    new: (partial: Partial<CreateOfferParams> & Required<Omit<CreateOfferParams, "temporaryContractId" | "fundOutputSerialId">>) => CreateOfferParams;
+    defaults: () => Partial<CreateOfferParams>;
+}>;
+/**
+ * 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 declare const DescriptorInput: Readonly<{
+    create: (partial: Partial<DescriptorInput> & Required<Omit<DescriptorInput, never>>) => DescriptorInput;
+    new: (partial: Partial<DescriptorInput> & Required<Omit<DescriptorInput, never>>) => DescriptorInput;
+    defaults: () => Partial<DescriptorInput>;
+}>;
+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 declare const DlcInputInfo: Readonly<{
+    create: (partial: Partial<DlcInputInfo> & Required<Omit<DlcInputInfo, never>>) => DlcInputInfo;
+    new: (partial: Partial<DlcInputInfo> & Required<Omit<DlcInputInfo, never>>) => DlcInputInfo;
+    defaults: () => Partial<DlcInputInfo>;
+}>;
+/**
+ * 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 declare const OracleAttestationRef: Readonly<{
+    create: (partial: Partial<OracleAttestationRef> & Required<Omit<OracleAttestationRef, never>>) => OracleAttestationRef;
+    new: (partial: Partial<OracleAttestationRef> & Required<Omit<OracleAttestationRef, never>>) => OracleAttestationRef;
+    defaults: () => Partial<OracleAttestationRef>;
+}>;
+export type OracleInfo = {
+    publicKey: Uint8Array;
+    nonces: Array<Uint8Array>;
+};
+/**
+ * Generated factory for {@link OracleInfo} record objects.
+ */
+export declare const OracleInfo: Readonly<{
+    create: (partial: Partial<OracleInfo> & Required<Omit<OracleInfo, never>>) => OracleInfo;
+    new: (partial: Partial<OracleInfo> & Required<Omit<OracleInfo, never>>) => OracleInfo;
+    defaults: () => Partial<OracleInfo>;
+}>;
+export type TxInputInfo = {
+    txid: string;
+    vout: number;
+    scriptSig: Uint8Array;
+    maxWitnessLength: number;
+    serialId: bigint;
+};
+/**
+ * Generated factory for {@link TxInputInfo} record objects.
+ */
+export declare const TxInputInfo: Readonly<{
+    create: (partial: Partial<TxInputInfo> & Required<Omit<TxInputInfo, never>>) => TxInputInfo;
+    new: (partial: Partial<TxInputInfo> & Required<Omit<TxInputInfo, never>>) => TxInputInfo;
+    defaults: () => Partial<TxInputInfo>;
+}>;
+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 declare const PartyParams: Readonly<{
+    create: (partial: Partial<PartyParams> & Required<Omit<PartyParams, never>>) => PartyParams;
+    new: (partial: Partial<PartyParams> & Required<Omit<PartyParams, never>>) => PartyParams;
+    defaults: () => Partial<PartyParams>;
+    changeOutputAndFees(self_: PartyParams, feeRate: bigint): ChangeOutputAndFees;
+}>;
+export type Payout = {
+    offer: bigint;
+    accept: bigint;
+};
+/**
+ * Generated factory for {@link Payout} record objects.
+ */
+export declare const Payout: Readonly<{
+    create: (partial: Partial<Payout> & Required<Omit<Payout, never>>) => Payout;
+    new: (partial: Partial<Payout> & Required<Omit<Payout, never>>) => Payout;
+    defaults: () => Partial<Payout>;
+}>;
+/**
+ * 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 declare const SignResult: Readonly<{
+    create: (partial: Partial<SignResult> & Required<Omit<SignResult, never>>) => SignResult;
+    new: (partial: Partial<SignResult> & Required<Omit<SignResult, never>>) => SignResult;
+    defaults: () => Partial<SignResult>;
+}>;
+/**
+ * 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 declare const SpliceKeyRef: Readonly<{
+    create: (partial: Partial<SpliceKeyRef> & Required<Omit<SpliceKeyRef, never>>) => SpliceKeyRef;
+    new: (partial: Partial<SpliceKeyRef> & Required<Omit<SpliceKeyRef, never>>) => SpliceKeyRef;
+    defaults: () => Partial<SpliceKeyRef>;
+}>;
+export declare 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 declare const ContractError: Readonly<{
+    instanceOf: (obj: any) => obj is ContractError;
+    InvalidOffer: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidOffer;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidOffer;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidOffer;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidOffer;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.InvalidOffer;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidAccept: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidAccept;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidAccept;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidAccept;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidAccept;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.InvalidAccept;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidSign: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidSign;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidSign;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidSign;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidSign;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.InvalidSign;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidFundingInput: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidFundingInput;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidFundingInput;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidFundingInput;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidFundingInput;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.InvalidFundingInput;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    PsbtMismatch: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.PsbtMismatch;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.PsbtMismatch;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.PsbtMismatch;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.PsbtMismatch;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.PsbtMismatch;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    MissingFinalizedInput: {
+        new (inner: {
+            inputIndex: number;
+        }): {
+            readonly tag: ContractError_Tags.MissingFinalizedInput;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            inputIndex: number;
+        }): {
+            readonly tag: ContractError_Tags.MissingFinalizedInput;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.MissingFinalizedInput;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.MissingFinalizedInput;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.MissingFinalizedInput;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            inputIndex: number;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    UnsupportedScriptType: {
+        new (inner: {
+            inputIndex: number;
+        }): {
+            readonly tag: ContractError_Tags.UnsupportedScriptType;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            inputIndex: number;
+        }): {
+            readonly tag: ContractError_Tags.UnsupportedScriptType;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.UnsupportedScriptType;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.UnsupportedScriptType;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.UnsupportedScriptType;
+            readonly inner: Readonly<{
+                inputIndex: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            inputIndex: number;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidAttestation: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidAttestation;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidAttestation;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidAttestation;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidAttestation;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.InvalidAttestation;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    NoMatchingOutcome: {
+        new (): {
+            readonly tag: ContractError_Tags.NoMatchingOutcome;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: ContractError_Tags.NoMatchingOutcome;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.NoMatchingOutcome;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.NoMatchingOutcome;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+    };
+    Descriptor: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Descriptor;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Descriptor;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.Descriptor;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.Descriptor;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.Descriptor;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    Wallet: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Wallet;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Wallet;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.Wallet;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.Wallet;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.Wallet;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    Bip32: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Bip32;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Bip32;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.Bip32;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.Bip32;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.Bip32;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    Dlc: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Dlc;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Dlc;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.Dlc;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.Dlc;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.Dlc;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    Key: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Key;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Key;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.Key;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.Key;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.Key;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    Serialization: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Serialization;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.Serialization;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.Serialization;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.Serialization;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.Serialization;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidNetwork: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidNetwork;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ContractError_Tags.InvalidNetwork;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidNetwork;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidNetwork;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.InvalidNetwork;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            message: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidLength: {
+        new (inner: {
+            field: string;
+            expected: number;
+            actual: number;
+        }): {
+            readonly tag: ContractError_Tags.InvalidLength;
+            readonly inner: Readonly<{
+                field: string;
+                expected: number;
+                actual: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            field: string;
+            expected: number;
+            actual: number;
+        }): {
+            readonly tag: ContractError_Tags.InvalidLength;
+            readonly inner: Readonly<{
+                field: string;
+                expected: number;
+                actual: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidLength;
+            readonly inner: Readonly<{
+                field: string;
+                expected: number;
+                actual: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ContractError_Tags.InvalidLength;
+            readonly inner: Readonly<{
+                field: string;
+                expected: number;
+                actual: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ContractError_Tags.InvalidLength;
+            readonly inner: Readonly<{
+                field: string;
+                expected: number;
+                actual: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ContractError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            field: string;
+            expected: number;
+            actual: number;
+        }>;
+        isError(error: unknown): error is Error;
+    };
 }>;
 /**
- * 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.
+ * Errors returned by the stateless contract API.
  *
- * 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;
-};
-/**
- * Generated factory for {@link CetAdaptorSignatureDebugInfo} record objects.
- */
-export declare const CetAdaptorSignatureDebugInfo: Readonly<{
-    create: (partial: Partial<CetAdaptorSignatureDebugInfo> & Required<Omit<CetAdaptorSignatureDebugInfo, never>>) => CetAdaptorSignatureDebugInfo;
-    new: (partial: Partial<CetAdaptorSignatureDebugInfo> & Required<Omit<CetAdaptorSignatureDebugInfo, never>>) => CetAdaptorSignatureDebugInfo;
-    defaults: () => Partial<CetAdaptorSignatureDebugInfo>;
-}>;
-export type TxOutput = {
-    value: bigint;
-    scriptPubkey: ArrayBuffer;
-};
-/**
- * Generated factory for {@link TxOutput} record objects.
- */
-export declare const TxOutput: Readonly<{
-    create: (partial: Partial<TxOutput> & Required<Omit<TxOutput, never>>) => TxOutput;
-    new: (partial: Partial<TxOutput> & Required<Omit<TxOutput, never>>) => TxOutput;
-    defaults: () => Partial<TxOutput>;
-    isDust(self_: TxOutput): boolean;
-}>;
-export type ChangeOutputAndFees = {
-    changeOutput: TxOutput;
-    fundFee: bigint;
-    cetFee: bigint;
-};
-/**
- * Generated factory for {@link ChangeOutputAndFees} record objects.
- */
-export declare const ChangeOutputAndFees: Readonly<{
-    create: (partial: Partial<ChangeOutputAndFees> & Required<Omit<ChangeOutputAndFees, never>>) => ChangeOutputAndFees;
-    new: (partial: Partial<ChangeOutputAndFees> & Required<Omit<ChangeOutputAndFees, never>>) => ChangeOutputAndFees;
-    defaults: () => Partial<ChangeOutputAndFees>;
-}>;
-export type TxInput = {
-    txid: string;
-    vout: number;
-    scriptSig: ArrayBuffer;
-    sequence: number;
-    witness: Array<ArrayBuffer>;
-};
-/**
- * Generated factory for {@link TxInput} record objects.
- */
-export declare const TxInput: Readonly<{
-    create: (partial: Partial<TxInput> & Required<Omit<TxInput, never>>) => TxInput;
-    new: (partial: Partial<TxInput> & Required<Omit<TxInput, never>>) => TxInput;
-    defaults: () => Partial<TxInput>;
-}>;
-export type Transaction = {
-    version: number;
-    lockTime: number;
-    inputs: Array<TxInput>;
-    outputs: Array<TxOutput>;
-    rawBytes: ArrayBuffer;
-};
-/**
- * Generated factory for {@link Transaction} record objects.
- */
-export declare const Transaction: Readonly<{
-    create: (partial: Partial<Transaction> & Required<Omit<Transaction, never>>) => Transaction;
-    new: (partial: Partial<Transaction> & Required<Omit<Transaction, never>>) => Transaction;
-    defaults: () => Partial<Transaction>;
-    addSignature(self_: Transaction, signature: ArrayBuffer, pubkey: ArrayBuffer, inputIndex: number): Transaction;
-    cetAdaptorSignatureFromOracleInfo(self_: Transaction, oracleInfo: OracleInfo, fundingSk: ArrayBuffer, fundingScriptPubkey: ArrayBuffer, totalCollateral: bigint, msgs: Array<ArrayBuffer>): AdaptorSignature;
-    cetAdaptorSignatureInputs(self_: Transaction, oracleInfo: Array<OracleInfo>, fundingScriptPubkey: ArrayBuffer, fundOutputValue: bigint, msgs: Array<Array<ArrayBuffer>>): CetAdaptorSignatureDebugInfo;
-    cetSighash(self_: Transaction, fundingScriptPubkey: ArrayBuffer, fundOutputValue: bigint): ArrayBuffer;
-    rawFundingInputSignature(self_: Transaction, privkey: ArrayBuffer, prevTxId: string, prevTxVout: number, value: bigint): ArrayBuffer;
-    signCet(self_: Transaction, adaptorSignature: ArrayBuffer, oracleSignatures: Array<ArrayBuffer>, fundingSecretKey: ArrayBuffer, otherPubkey: ArrayBuffer, fundingScriptPubkey: ArrayBuffer, fundOutputValue: bigint): Transaction;
-    signFundInput(self_: Transaction, privkey: ArrayBuffer, prevTxId: string, prevTxVout: number, value: bigint): Transaction;
-    signMultiSigInput(self_: Transaction, dlcInput: DlcInputInfo, localPrivkey: ArrayBuffer, remoteSignature: ArrayBuffer): Transaction;
-    verifyFundSignature(self_: Transaction, signature: ArrayBuffer, pubkey: ArrayBuffer, txid: string, vout: number, inputAmount: bigint): boolean;
-}>;
-export type DlcInputInfo = {
-    fundTx: Transaction;
-    fundVout: number;
-    localFundPubkey: ArrayBuffer;
-    remoteFundPubkey: ArrayBuffer;
-    fundAmount: bigint;
-    maxWitnessLen: number;
-    inputSerialId: bigint;
-    contractId: ArrayBuffer;
-};
-/**
- * Generated factory for {@link DlcInputInfo} record objects.
- */
-export declare const DlcInputInfo: Readonly<{
-    create: (partial: Partial<DlcInputInfo> & Required<Omit<DlcInputInfo, never>>) => DlcInputInfo;
-    new: (partial: Partial<DlcInputInfo> & Required<Omit<DlcInputInfo, never>>) => DlcInputInfo;
-    defaults: () => Partial<DlcInputInfo>;
-}>;
-export type DlcTransactions = {
-    fund: Transaction;
-    cets: Array<Transaction>;
-    refund: Transaction;
-    fundingScriptPubkey: ArrayBuffer;
-};
-/**
- * Generated factory for {@link DlcTransactions} record objects.
- */
-export declare const DlcTransactions: Readonly<{
-    create: (partial: Partial<DlcTransactions> & Required<Omit<DlcTransactions, never>>) => DlcTransactions;
-    new: (partial: Partial<DlcTransactions> & Required<Omit<DlcTransactions, never>>) => DlcTransactions;
-    defaults: () => Partial<DlcTransactions>;
-}>;
-export type OracleInfo = {
-    publicKey: ArrayBuffer;
-    nonces: Array<ArrayBuffer>;
-};
-/**
- * Generated factory for {@link OracleInfo} record objects.
- */
-export declare const OracleInfo: Readonly<{
-    create: (partial: Partial<OracleInfo> & Required<Omit<OracleInfo, never>>) => OracleInfo;
-    new: (partial: Partial<OracleInfo> & Required<Omit<OracleInfo, never>>) => OracleInfo;
-    defaults: () => Partial<OracleInfo>;
-}>;
-export type TxInputInfo = {
-    txid: string;
-    vout: number;
-    scriptSig: ArrayBuffer;
-    maxWitnessLength: number;
-    serialId: bigint;
-};
-/**
- * Generated factory for {@link TxInputInfo} record objects.
- */
-export declare const TxInputInfo: Readonly<{
-    create: (partial: Partial<TxInputInfo> & Required<Omit<TxInputInfo, never>>) => TxInputInfo;
-    new: (partial: Partial<TxInputInfo> & Required<Omit<TxInputInfo, never>>) => TxInputInfo;
-    defaults: () => Partial<TxInputInfo>;
-}>;
-export type PartyParams = {
-    fundPubkey: ArrayBuffer;
-    changeScriptPubkey: ArrayBuffer;
-    changeSerialId: bigint;
-    payoutScriptPubkey: ArrayBuffer;
-    payoutSerialId: bigint;
-    inputs: Array<TxInputInfo>;
-    inputAmount: bigint;
-    collateral: bigint;
-    dlcInputs: Array<DlcInputInfo>;
-};
-/**
- * Generated factory for {@link PartyParams} record objects.
- */
-export declare const PartyParams: Readonly<{
-    create: (partial: Partial<PartyParams> & Required<Omit<PartyParams, never>>) => PartyParams;
-    new: (partial: Partial<PartyParams> & Required<Omit<PartyParams, never>>) => PartyParams;
-    defaults: () => Partial<PartyParams>;
-    changeOutputAndFees(self_: PartyParams, feeRate: bigint): ChangeOutputAndFees;
-}>;
-export type Payout = {
-    offer: bigint;
-    accept: bigint;
-};
-/**
- * Generated factory for {@link Payout} record objects.
+ * Mirrors [`ddk::contract::ContractError`] as a uniffi error so the typed
+ * variants survive across the binding boundary. Variants carry plain strings.
  */
-export declare const Payout: Readonly<{
-    create: (partial: Partial<Payout> & Required<Omit<Payout, never>>) => Payout;
-    new: (partial: Partial<Payout> & Required<Omit<Payout, never>>) => Payout;
-    defaults: () => Partial<Payout>;
-}>;
+export type ContractError = InstanceType<(typeof ContractError)['InvalidOffer' | 'InvalidAccept' | 'InvalidSign' | 'InvalidFundingInput' | 'PsbtMismatch' | 'MissingFinalizedInput' | 'UnsupportedScriptType' | 'InvalidAttestation' | 'NoMatchingOutcome' | 'Descriptor' | 'Wallet' | 'Bip32' | 'Dlc' | 'Key' | 'Serialization' | 'InvalidNetwork' | 'InvalidLength']>;
 export declare enum ExtendedKey {
     InvalidMnemonic = 0,
     InvalidXpriv = 1,
@@ -909,6 +2800,80 @@ export declare const DlcError: Readonly<{
     };
 }>;
 export type DlcError = InstanceType<(typeof DlcError)['InvalidSignature' | 'InvalidPublicKey' | 'InvalidTransaction' | 'InsufficientFunds' | 'InvalidArgument' | 'SerializationError' | 'Secp256k1Error' | 'MiniscriptError' | 'InvalidNetwork' | 'KeyError']>;
+/**
+ * Identifies which party's funding inputs an operation applies to.
+ */
+export declare enum Party {
+    /**
+     * The party that created the offer.
+     */
+    Offer = 0,
+    /**
+     * The party that accepted the offer.
+     */
+    Accept = 1
+}
+/**
+ * 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): 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 declare class ContractKeyProvider extends UniffiAbstractObject implements ContractKeyProviderLike {
+    readonly [uniffiTypeNameSymbol] = "ContractKeyProvider";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    /**
+     * 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;
+    /**
+     * Builds a provider from a BIP39 mnemonic (with optional passphrase).
+     */
+    static fromMnemonic(mnemonic: string, passphrase: string | undefined, network: string): ContractKeyProviderLike;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is ContractKeyProvider;
+}
 /**
  * This should be called before anything else.
  *
@@ -923,6 +2888,20 @@ declare function uniffiEnsureInitialized(): void;
 declare const _default: Readonly<{
     initialize: typeof uniffiEnsureInitialized;
     converters: {
+        FfiConverterTypeAcceptOfferParams: {
+            read(from: RustBuffer): AcceptOfferParams;
+            write(value: AcceptOfferParams, into: RustBuffer): void;
+            allocationSize(value: AcceptOfferParams): number;
+            lift(value: UniffiByteArray): AcceptOfferParams;
+            lower(value: AcceptOfferParams, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeAcceptResult: {
+            read(from: RustBuffer): AcceptResult;
+            write(value: AcceptResult, into: RustBuffer): void;
+            allocationSize(value: AcceptResult): number;
+            lift(value: UniffiByteArray): AcceptResult;
+            lower(value: AcceptResult, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeAdaptorSignature: {
             read(from: RustBuffer): AdaptorSignature;
             write(value: AdaptorSignature, into: RustBuffer): void;
@@ -944,6 +2923,35 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ChangeOutputAndFees;
             lower(value: ChangeOutputAndFees, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeContractError: {
+            read(from: RustBuffer): ContractError;
+            write(value: ContractError, into: RustBuffer): void;
+            allocationSize(value: ContractError): number;
+            lift(value: UniffiByteArray): ContractError;
+            lower(value: ContractError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeContractKeyProvider: FfiConverterObject<ContractKeyProviderLike>;
+        FfiConverterTypeContractPartyParams: {
+            read(from: RustBuffer): ContractPartyParams;
+            write(value: ContractPartyParams, into: RustBuffer): void;
+            allocationSize(value: ContractPartyParams): number;
+            lift(value: UniffiByteArray): ContractPartyParams;
+            lower(value: ContractPartyParams, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeContractPayouts: {
+            read(from: RustBuffer): ContractPayouts;
+            write(value: ContractPayouts, into: RustBuffer): void;
+            allocationSize(value: ContractPayouts): number;
+            lift(value: UniffiByteArray): ContractPayouts;
+            lower(value: ContractPayouts, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreateOfferParams: {
+            read(from: RustBuffer): CreateOfferParams;
+            write(value: CreateOfferParams, into: RustBuffer): void;
+            allocationSize(value: CreateOfferParams): number;
+            lift(value: UniffiByteArray): CreateOfferParams;
+            lower(value: CreateOfferParams, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeDLCError: {
             read(from: RustBuffer): DlcError;
             write(value: DlcError, into: RustBuffer): void;
@@ -951,6 +2959,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): DlcError;
             lower(value: DlcError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeDescriptorInput: {
+            read(from: RustBuffer): DescriptorInput;
+            write(value: DescriptorInput, into: RustBuffer): void;
+            allocationSize(value: DescriptorInput): number;
+            lift(value: UniffiByteArray): DescriptorInput;
+            lower(value: DescriptorInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeDlcInputInfo: {
             read(from: RustBuffer): DlcInputInfo;
             write(value: DlcInputInfo, into: RustBuffer): void;
@@ -972,6 +2987,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ExtendedKey;
             lower(value: ExtendedKey, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeOracleAttestationRef: {
+            read(from: RustBuffer): OracleAttestationRef;
+            write(value: OracleAttestationRef, into: RustBuffer): void;
+            allocationSize(value: OracleAttestationRef): number;
+            lift(value: UniffiByteArray): OracleAttestationRef;
+            lower(value: OracleAttestationRef, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeOracleInfo: {
             read(from: RustBuffer): OracleInfo;
             write(value: OracleInfo, into: RustBuffer): void;
@@ -979,6 +3001,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): OracleInfo;
             lower(value: OracleInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeParty: {
+            read(from: RustBuffer): Party;
+            write(value: Party, into: RustBuffer): void;
+            allocationSize(value: Party): number;
+            lift(value: UniffiByteArray): Party;
+            lower(value: Party, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypePartyParams: {
             read(from: RustBuffer): PartyParams;
             write(value: PartyParams, into: RustBuffer): void;
@@ -993,6 +3022,27 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): Payout;
             lower(value: Payout, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypePayoutRow: {
+            read(from: RustBuffer): PayoutRow;
+            write(value: PayoutRow, into: RustBuffer): void;
+            allocationSize(value: PayoutRow): number;
+            lift(value: UniffiByteArray): PayoutRow;
+            lower(value: PayoutRow, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSignResult: {
+            read(from: RustBuffer): SignResult;
+            write(value: SignResult, into: RustBuffer): void;
+            allocationSize(value: SignResult): number;
+            lift(value: UniffiByteArray): SignResult;
+            lower(value: SignResult, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSpliceKeyRef: {
+            read(from: RustBuffer): SpliceKeyRef;
+            write(value: SpliceKeyRef, into: RustBuffer): void;
+            allocationSize(value: SpliceKeyRef): number;
+            lift(value: UniffiByteArray): SpliceKeyRef;
+            lower(value: SpliceKeyRef, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeTransaction: {
             read(from: RustBuffer): Transaction;
             write(value: Transaction, into: RustBuffer): void;