@arkade-os/sdk 0.4.0-next.0 → 0.4.0-next.1

package/dist/esm/bip322/index.js

@@ -0,0 +1,267 @@
+import { p2tr, p2wpkh, Address, OutScript, RawWitness, SigHash, } from "@scure/btc-signer";
+import { concatBytes, hash160, sha256x2, } from "@scure/btc-signer/utils.js";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
+import { equalBytes } from "@noble/curves/utils.js";
+import { base64 } from "@scure/base";
+import { Transaction } from '../utils/transaction.js';
+import { craftToSpendTx, OP_RETURN_EMPTY_PKSCRIPT } from '../intent/index.js';
+const TAG_BIP322 = "BIP0322-signed-message";
+/**
+ * BIP-322 simple message signing and verification.
+ *
+ * Supports P2TR (Taproot) signing and verification, P2WPKH verification,
+ * and legacy P2PKH verification (Bitcoin Core signmessage format).
+ *
+ * Reuses the same toSpend/toSign transaction construction as Intent proofs,
+ * but with the standard BIP-322 tagged hash ("BIP0322-signed-message")
+ * instead of the Ark-specific tag.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ *
+ * @example
+ * ```typescript
+ * // Sign a message (P2TR)
+ * const signature = await BIP322.sign("Hello Bitcoin!", identity);
+ *
+ * // Verify a signature (P2TR or P2WPKH)
+ * const valid = BIP322.verify("Hello Bitcoin!", signature, "bc1p...");
+ * const valid2 = BIP322.verify("Hello Bitcoin!", signature, "bc1q...");
+ * ```
+ */
+export var BIP322;
+(function (BIP322) {
+    /**
+     * Sign a message using the BIP-322 simple signature scheme.
+     *
+     * Constructs the standard BIP-322 toSpend and toSign transactions,
+     * signs via the Identity interface, and returns the base64-encoded
+     * witness stack.
+     *
+     * @param message - The message to sign
+     * @param identity - Identity instance (holds the private key internally)
+     * @param network - Optional Bitcoin network for P2TR address derivation
+     * @returns Base64-encoded BIP-322 simple signature (witness stack)
+     */
+    async function sign(message, identity, network) {
+        const xOnlyPubKey = await identity.xOnlyPublicKey();
+        const payment = p2tr(xOnlyPubKey, undefined, network);
+        // Build BIP-322 toSpend using shared construction with BIP-322 tag
+        const toSpend = craftToSpendTx(message, payment.script, TAG_BIP322);
+        // Build BIP-322 toSign: version 0, single input spending toSpend, OP_RETURN output
+        const toSign = craftBIP322ToSignP2TR(toSpend, payment.script, xOnlyPubKey);
+        // Sign with identity (handles P2TR key-spend internally)
+        const signed = await identity.sign(toSign, [0]);
+        // Finalize and extract witness
+        signed.finalizeIdx(0);
+        const input = signed.getInput(0);
+        if (!input.finalScriptWitness) {
+            throw new Error("BIP-322: failed to produce witness after signing");
+        }
+        return base64.encode(RawWitness.encode(input.finalScriptWitness));
+    }
+    BIP322.sign = sign;
+    /**
+     * Verify a BIP-322 signature for a P2TR, P2WPKH, or legacy P2PKH address.
+     *
+     * For segwit addresses (P2TR, P2WPKH), reconstructs the BIP-322
+     * toSpend/toSign transactions and verifies the witness signature.
+     *
+     * For P2PKH addresses, verifies using the Bitcoin Core legacy
+     * `signmessage` format (compact recoverable ECDSA signature).
+     *
+     * @param message - The original message that was signed
+     * @param signature - Base64-encoded signature (BIP-322 witness or legacy compact)
+     * @param address - P2TR, P2WPKH, or P2PKH address of the signer
+     * @param network - Optional Bitcoin network for address decoding
+     * @returns true if the signature is valid
+     */
+    function verify(message, signature, address, network) {
+        let decoded;
+        try {
+            decoded = Address(network).decode(address);
+        }
+        catch {
+            return false;
+        }
+        // Legacy P2PKH: signature is base64 of 65 raw bytes, not a witness
+        if (decoded.type === "pkh") {
+            try {
+                return verifyLegacy(message, base64.decode(signature), decoded.hash);
+            }
+            catch {
+                return false;
+            }
+        }
+        // BIP-322 simple: signature is base64 of RawWitness
+        let pkScript;
+        let witnessItems;
+        try {
+            pkScript = OutScript.encode(decoded);
+            witnessItems = RawWitness.decode(base64.decode(signature));
+        }
+        catch {
+            return false;
+        }
+        if (witnessItems.length === 0) {
+            return false;
+        }
+        if (decoded.type === "tr") {
+            return verifyP2TR(message, witnessItems, pkScript, decoded.pubkey);
+        }
+        if (decoded.type === "wpkh") {
+            return verifyP2WPKH(message, witnessItems, pkScript, decoded.hash);
+        }
+        throw new Error(`BIP-322 verify: unsupported address type '${decoded.type}'`);
+    }
+    BIP322.verify = verify;
+})(BIP322 || (BIP322 = {}));
+function verifyP2TR(message, witnessItems, pkScript, pubkey) {
+    // P2TR key-spend witness is exactly [schnorr_signature].
+    // Multiple items indicates a script-path spend, which BIP-322 simple doesn't cover.
+    if (witnessItems.length !== 1) {
+        return false;
+    }
+    const sig = witnessItems[0];
+    if (sig.length !== 64 && sig.length !== 65) {
+        return false;
+    }
+    // BIP-322 simple only allows SIGHASH_DEFAULT (64-byte sig) or SIGHASH_ALL (0x01).
+    const sighashType = sig.length === 65 ? sig[64] : SigHash.DEFAULT;
+    if (sighashType !== SigHash.DEFAULT && sighashType !== SigHash.ALL) {
+        return false;
+    }
+    const toSpend = craftToSpendTx(message, pkScript, TAG_BIP322);
+    const toSign = craftBIP322ToSignP2TR(toSpend, pkScript, pubkey);
+    const sighash = toSign.preimageWitnessV1(0, [pkScript], sighashType, [0n]);
+    const rawSig = sig.length === 65 ? sig.subarray(0, 64) : sig;
+    return schnorr.verify(rawSig, sighash, pubkey);
+}
+function verifyP2WPKH(message, witnessItems, pkScript, addressHash) {
+    // P2WPKH witness: [der_signature || sighash_byte, compressed_pubkey]
+    if (witnessItems.length !== 2) {
+        return false;
+    }
+    const sigWithHash = witnessItems[0];
+    const pubkey = witnessItems[1];
+    if (pubkey.length !== 33 || sigWithHash.length < 2) {
+        return false;
+    }
+    // Verify the pubkey matches the address hash
+    const derived = p2wpkh(pubkey);
+    if (!equalBytes(derived.hash, addressHash)) {
+        return false;
+    }
+    // Extract sighash type (last byte) and DER signature
+    const sighashType = sigWithHash[sigWithHash.length - 1];
+    const derSig = sigWithHash.subarray(0, sigWithHash.length - 1);
+    // Build toSpend and toSign
+    const toSpend = craftToSpendTx(message, pkScript, TAG_BIP322);
+    const toSign = craftBIP322ToSignSimple(toSpend, pkScript);
+    // BIP-143 scriptCode for P2WPKH: equivalent P2PKH script
+    const scriptCode = OutScript.encode({ type: "pkh", hash: addressHash });
+    const sighash = toSign.preimageWitnessV0(0, scriptCode, sighashType, 0n);
+    return secp256k1.verify(derSig, sighash, pubkey, {
+        prehash: false,
+        format: "der",
+    });
+}
+/**
+ * Verify a legacy Bitcoin Core signmessage signature for a P2PKH address.
+ *
+ * The signature is 65 bytes: [recovery_flag, r(32), s(32)].
+ * The recovery flag encodes both the recovery ID and whether the key is
+ * compressed: flag = 27 + recovery_id (+ 4 if compressed).
+ */
+function verifyLegacy(message, sigBytes, addressHash) {
+    if (sigBytes.length !== 65) {
+        return false;
+    }
+    const flag = sigBytes[0];
+    if (flag < 27 || flag > 34) {
+        return false;
+    }
+    const compressed = flag >= 31;
+    const recoveryId = compressed ? flag - 31 : flag - 27;
+    const compactSig = sigBytes.subarray(1, 65);
+    const msgHash = bitcoinMessageHash(message);
+    try {
+        const sig = secp256k1.Signature.fromBytes(compactSig, "compact").addRecoveryBit(recoveryId);
+        const point = sig.recoverPublicKey(msgHash);
+        const pubkeyBytes = point.toBytes(compressed);
+        return equalBytes(hash160(pubkeyBytes), addressHash);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Compute the Bitcoin message hash: SHA256d(magic_prefix + CompactSize(len) + message).
+ */
+function bitcoinMessageHash(message) {
+    const MAGIC = new TextEncoder().encode("\x18Bitcoin Signed Message:\n");
+    const msgBytes = new TextEncoder().encode(message);
+    return sha256x2(concatBytes(MAGIC, encodeCompactSize(msgBytes.length), msgBytes));
+}
+function encodeCompactSize(n) {
+    if (n < 253)
+        return new Uint8Array([n]);
+    if (n <= 0xffff) {
+        const buf = new Uint8Array(3);
+        buf[0] = 253;
+        buf[1] = n & 0xff;
+        buf[2] = (n >> 8) & 0xff;
+        return buf;
+    }
+    const buf = new Uint8Array(5);
+    buf[0] = 254;
+    buf[1] = n & 0xff;
+    buf[2] = (n >> 8) & 0xff;
+    buf[3] = (n >> 16) & 0xff;
+    buf[4] = (n >> 24) & 0xff;
+    return buf;
+}
+/**
+ * Build the BIP-322 "toSign" transaction for P2TR key-spend.
+ */
+function craftBIP322ToSignP2TR(toSpend, pkScript, tapInternalKey) {
+    const tx = new Transaction({ version: 0 });
+    tx.addInput({
+        txid: toSpend.id,
+        index: 0,
+        sequence: 0,
+        witnessUtxo: {
+            script: pkScript,
+            amount: 0n,
+        },
+        tapInternalKey,
+        sighashType: SigHash.DEFAULT,
+    });
+    tx.addOutput({
+        amount: 0n,
+        script: OP_RETURN_EMPTY_PKSCRIPT,
+    });
+    return tx;
+}
+/**
+ * Build the BIP-322 "toSign" transaction (generic, no key metadata).
+ *
+ * Used for P2WPKH verification where the toSign only needs
+ * the witnessUtxo, not tapInternalKey.
+ */
+function craftBIP322ToSignSimple(toSpend, pkScript) {
+    const tx = new Transaction({ version: 0 });
+    tx.addInput({
+        txid: toSpend.id,
+        index: 0,
+        sequence: 0,
+        witnessUtxo: {
+            script: pkScript,
+            amount: 0n,
+        },
+    });
+    tx.addOutput({
+        amount: 0n,
+        script: OP_RETURN_EMPTY_PKSCRIPT,
+    });
+    return tx;
+}

package/dist/esm/index.js

@@ -23,6 +23,7 @@ import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisig
 import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, combineTapscriptSigs, isValidArkAddress, } from './utils/arkTransaction.js';
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
 import { Intent } from './intent/index.js';
+import { BIP322 } from './bip322/index.js';
 import { ArkNote } from './arknote/index.js';
 import { networks } from './networks.js';
 import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
@@ -37,7 +38,7 @@ export * from './arkfee/index.js';
 export * as asset from './asset/index.js';
 // Contracts
 import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from './contracts/index.js';
-import { closeDatabase, openDatabase } from './db/manager.js';
+import { closeDatabase, openDatabase } from './repositories/indexedDB/manager.js';
 import { WalletMessageHandler } from './wallet/serviceWorker/wallet-message-handler.js';
 export { 
 // Wallets
@@ -66,6 +67,8 @@ closeDatabase, openDatabase,
 IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, 
 // Intent proof
 Intent, 
+// BIP-322 message signing
+BIP322, 
 // TxTree
 TxTree, 
 // Anchor

package/dist/esm/intent/index.js

@@ -103,10 +103,10 @@ export var Intent;
     }
     Intent.encodeMessage = encodeMessage;
 })(Intent || (Intent = {}));
-const OP_RETURN_EMPTY_PKSCRIPT = new Uint8Array([OP.RETURN]);
+export const OP_RETURN_EMPTY_PKSCRIPT = new Uint8Array([OP.RETURN]);
 const ZERO_32 = new Uint8Array(32).fill(0);
 const MAX_INDEX = 0xffffffff;
-const TAG_INTENT_PROOF = "ark-intent-proof-message";
+export const TAG_INTENT_PROOF = "ark-intent-proof-message";
 function validateInput(input) {
     if (input.index === undefined)
         throw new Error("intent proof input requires index");
@@ -131,9 +131,18 @@ function validateOutputs(outputs) {
     outputs.forEach(validateOutput);
     return true;
 }
-// craftToSpendTx creates the initial transaction that will be spent in the proof
-function craftToSpendTx(message, pkScript) {
-    const messageHash = hashMessage(message);
+/**
+ * Creates the "to_spend" transaction used by both intent proofs and BIP-322.
+ *
+ * The message is hashed with the given tagged-hash tag before being placed
+ * into the scriptSig as `OP_0 <hash>`.
+ *
+ * @param message - The message to embed
+ * @param pkScript - The scriptPubKey of the signer's address
+ * @param tag - Tagged-hash tag (defaults to the Ark intent proof tag)
+ */
+export function craftToSpendTx(message, pkScript, tag = TAG_INTENT_PROOF) {
+    const messageHash = hashMessage(message, tag);
     const tx = new Transaction({
         version: 0,
     });
@@ -203,8 +212,8 @@ function craftToSignTx(toSpend, inputs, outputs) {
     }
     return tx;
 }
-function hashMessage(message) {
-    return schnorr.utils.taggedHash(TAG_INTENT_PROOF, new TextEncoder().encode(message));
+function hashMessage(message, tag = TAG_INTENT_PROOF) {
+    return schnorr.utils.taggedHash(tag, new TextEncoder().encode(message));
 }
 function prepareCoinAsIntentProofInput(coin) {
     if (!("tapTree" in coin)) {

package/dist/esm/repositories/indexedDB/contractRepository.js

@@ -1,5 +1,5 @@
 import { DB_VERSION, STORE_CONTRACTS } from './db.js';
-import { closeDatabase, openDatabase } from '../../db/manager.js';
+import { closeDatabase, openDatabase } from './manager.js';
 import { initDatabase } from './schema.js';
 import { DEFAULT_DB_NAME } from '../../worker/browser/utils.js';
 /**

package/dist/esm/repositories/indexedDB/db.js

@@ -1,42 +1,4 @@
-import { hex } from "@scure/base";
-import { TaprootControlBlock } from "@scure/btc-signer";
 import { DB_VERSION, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, STORE_TRANSACTIONS, STORE_UTXOS, STORE_VTXOS, STORE_WALLET_STATE, } from './schema.js';
 export { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, DB_VERSION, };
-export const serializeTapLeaf = ([cb, s]) => ({
-    cb: hex.encode(TaprootControlBlock.encode(cb)),
-    s: hex.encode(s),
-});
-export const serializeVtxo = (v) => ({
-    ...v,
-    tapTree: hex.encode(v.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
-    extraWitness: v.extraWitness?.map(hex.encode),
-});
-export const serializeUtxo = (u) => ({
-    ...u,
-    tapTree: hex.encode(u.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
-    extraWitness: u.extraWitness?.map(hex.encode),
-});
-export const deserializeTapLeaf = (t) => {
-    const cb = TaprootControlBlock.decode(hex.decode(t.cb));
-    const s = hex.decode(t.s);
-    return [cb, s];
-};
-export const deserializeVtxo = (o) => ({
-    ...o,
-    createdAt: new Date(o.createdAt),
-    tapTree: hex.decode(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(hex.decode),
-});
-export const deserializeUtxo = (o) => ({
-    ...o,
-    tapTree: hex.decode(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(hex.decode),
-});
+// Serialization helpers (re-exported from shared module)
+export { serializeTapLeaf, serializeVtxo, serializeUtxo, deserializeTapLeaf, deserializeVtxo, deserializeUtxo, } from '../serialization.js';

package/dist/esm/repositories/indexedDB/walletRepository.js

@@ -1,5 +1,5 @@
 import { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, DB_VERSION, } from './db.js';
-import { closeDatabase, openDatabase } from '../../db/manager.js';
+import { closeDatabase, openDatabase } from './manager.js';
 import { initDatabase } from './schema.js';
 import { DEFAULT_DB_NAME } from '../../worker/browser/utils.js';
 /**

package/dist/esm/repositories/realm/contractRepository.js

@@ -0,0 +1,116 @@
+/**
+ * Realm-based implementation of ContractRepository.
+ *
+ * Consumers must open Realm with the schemas from `./schemas.ts` and pass
+ * the instance to the constructor.
+ *
+ * Realm handles schema creation on open, so `ensureInit()` is a no-op.
+ * The consumer owns the Realm lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+export class RealmContractRepository {
+    constructor(realm) {
+        this.realm = realm;
+        this.version = 1;
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────
+    async ensureInit() {
+        // Realm handles schema on open — nothing to initialise.
+    }
+    async [Symbol.asyncDispose]() {
+        // no-op — consumer owns the Realm lifecycle
+    }
+    // ── Clear ──────────────────────────────────────────────────────────
+    async clear() {
+        await this.ensureInit();
+        this.realm.write(() => {
+            this.realm.delete(this.realm.objects("ArkContract"));
+        });
+    }
+    // ── Contract management ────────────────────────────────────────────
+    async getContracts(filter) {
+        await this.ensureInit();
+        let results = this.realm.objects("ArkContract");
+        if (filter) {
+            const filterParts = [];
+            const filterArgs = [];
+            let argIndex = 0;
+            argIndex = this.addFilterCondition(filterParts, filterArgs, "script", filter.script, argIndex);
+            argIndex = this.addFilterCondition(filterParts, filterArgs, "state", filter.state, argIndex);
+            argIndex = this.addFilterCondition(filterParts, filterArgs, "type", filter.type, argIndex);
+            if (filterParts.length > 0) {
+                const query = filterParts.join(" AND ");
+                results = results.filtered(query, ...filterArgs);
+            }
+        }
+        return [...results].map(contractObjectToDomain);
+    }
+    async saveContract(contract) {
+        await this.ensureInit();
+        this.realm.write(() => {
+            this.realm.create("ArkContract", {
+                script: contract.script,
+                address: contract.address,
+                type: contract.type,
+                state: contract.state,
+                paramsJson: JSON.stringify(contract.params),
+                createdAt: contract.createdAt,
+                expiresAt: contract.expiresAt ?? null,
+                label: contract.label ?? null,
+                metadataJson: contract.metadata
+                    ? JSON.stringify(contract.metadata)
+                    : null,
+            }, "modified");
+        });
+    }
+    async deleteContract(script) {
+        await this.ensureInit();
+        this.realm.write(() => {
+            const toDelete = this.realm
+                .objects("ArkContract")
+                .filtered("script == $0", script);
+            this.realm.delete(toDelete);
+        });
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────
+    addFilterCondition(parts, args, column, value, argIndex) {
+        if (value === undefined)
+            return argIndex;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return argIndex;
+            const conditions = value.map((_, i) => {
+                return `${column} == $${argIndex + i}`;
+            });
+            parts.push(`(${conditions.join(" OR ")})`);
+            args.push(...value);
+            return argIndex + value.length;
+        }
+        else {
+            parts.push(`${column} == $${argIndex}`);
+            args.push(value);
+            return argIndex + 1;
+        }
+    }
+}
+// ── Realm object → Domain converter ──────────────────────────────────────
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function contractObjectToDomain(obj) {
+    const contract = {
+        script: obj.script,
+        address: obj.address,
+        type: obj.type,
+        state: obj.state,
+        params: JSON.parse(obj.paramsJson),
+        createdAt: obj.createdAt,
+    };
+    if (obj.expiresAt !== null && obj.expiresAt !== undefined) {
+        contract.expiresAt = obj.expiresAt;
+    }
+    if (obj.label !== null && obj.label !== undefined) {
+        contract.label = obj.label;
+    }
+    if (obj.metadataJson !== null && obj.metadataJson !== undefined) {
+        contract.metadata = JSON.parse(obj.metadataJson);
+    }
+    return contract;
+}

package/dist/esm/repositories/realm/index.js

@@ -0,0 +1,3 @@
+export { RealmWalletRepository } from './walletRepository.js';
+export { RealmContractRepository } from './contractRepository.js';
+export { ArkRealmSchemas } from './schemas.js';

package/dist/esm/repositories/realm/schemas.js

@@ -0,0 +1,105 @@
+/**
+ * Realm object schemas for the Ark wallet.
+ *
+ * All schema names are prefixed with "Ark" to avoid collisions with
+ * other Realm schemas in the consuming application.
+ *
+ * Since `realm` is a peer dependency (not installed in this package),
+ * schemas are defined as plain JS objects conforming to Realm's
+ * ObjectSchema shape.
+ */
+export const ArkVtxoSchema = {
+    name: "ArkVtxo",
+    primaryKey: "pk",
+    properties: {
+        pk: "string", // composite: `${txid}:${vout}`
+        address: { type: "string", indexed: true },
+        txid: "string",
+        vout: "int",
+        value: "int",
+        tapTree: "string", // hex-encoded
+        forfeitCb: "string",
+        forfeitS: "string",
+        intentCb: "string",
+        intentS: "string",
+        extraWitnessJson: "string?",
+        statusJson: "string",
+        virtualStatusJson: "string",
+        spentBy: "string?",
+        settledBy: "string?",
+        arkTxId: "string?",
+        createdAt: "string", // ISO 8601
+        isUnrolled: "bool",
+        isSpent: "bool?",
+        assetsJson: "string?",
+    },
+};
+export const ArkUtxoSchema = {
+    name: "ArkUtxo",
+    primaryKey: "pk",
+    properties: {
+        pk: "string", // composite: `${txid}:${vout}`
+        address: { type: "string", indexed: true },
+        txid: "string",
+        vout: "int",
+        value: "int",
+        tapTree: "string", // hex-encoded
+        forfeitCb: "string",
+        forfeitS: "string",
+        intentCb: "string",
+        intentS: "string",
+        extraWitnessJson: "string?",
+        statusJson: "string",
+    },
+};
+export const ArkTransactionSchema = {
+    name: "ArkTransaction",
+    primaryKey: "pk",
+    properties: {
+        pk: "string", // composite: `${address}:${boardingTxid}:${commitmentTxid}:${arkTxid}`
+        address: { type: "string", indexed: true },
+        boardingTxid: "string",
+        commitmentTxid: "string",
+        arkTxid: "string",
+        type: "string",
+        amount: "int",
+        settled: "bool",
+        createdAt: "int",
+        assetsJson: "string?",
+    },
+};
+export const ArkWalletStateSchema = {
+    name: "ArkWalletState",
+    primaryKey: "key",
+    properties: {
+        key: "string",
+        lastSyncTime: "int?",
+        settingsJson: "string?",
+    },
+};
+export const ArkContractSchema = {
+    name: "ArkContract",
+    primaryKey: "script",
+    properties: {
+        script: "string",
+        address: "string",
+        type: { type: "string", indexed: true },
+        state: { type: "string", indexed: true },
+        paramsJson: "string",
+        createdAt: "int",
+        expiresAt: "int?",
+        label: "string?",
+        metadataJson: "string?",
+    },
+};
+/**
+ * All Realm schemas needed by the Ark wallet repositories.
+ * Pass this array to your Realm configuration's `schema` property.
+ */
+export const ArkRealmSchemas = [
+    ArkVtxoSchema,
+    ArkUtxoSchema,
+    ArkTransactionSchema,
+    ArkWalletStateSchema,
+    ArkContractSchema,
+];

package/dist/esm/repositories/realm/types.js

@@ -0,0 +1,6 @@
+/**
+ * Minimal interface for the subset of the Realm API used by the
+ * Ark repositories.  Consumers pass their real Realm instance and
+ * the compiler validates it satisfies this shape.
+ */
+export {};