@arkade-os/sdk 0.4.27 → 0.4.28

package/dist/esm/repositories/migrations/contractRepositoryImpl.js

@@ -1,121 +0,0 @@
-export const getContractStorageKey = (id, key) => `contract:${id}:${key}`;
-export const getCollectionStorageKey = (type) => `collection:${type}`;
-/**
- * @deprecated This is only to be used in migration from storage V1
- */
-export class ContractRepositoryImpl {
-    constructor(storage) {
-        this.version = 1;
-        this.storage = storage;
-    }
-    async getContractData(contractId, key) {
-        const stored = await this.storage.getItem(getContractStorageKey(contractId, key));
-        if (!stored)
-            return null;
-        try {
-            const data = JSON.parse(stored);
-            return data;
-        }
-        catch (error) {
-            console.error(`Failed to parse contract data for ${contractId}:${key}:`, error);
-            return null;
-        }
-    }
-    async setContractData(contractId, key, data) {
-        try {
-            await this.storage.setItem(getContractStorageKey(contractId, key), JSON.stringify(data));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract data for ${contractId}:${key}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async deleteContractData(contractId, key) {
-        try {
-            await this.storage.removeItem(getContractStorageKey(contractId, key));
-        }
-        catch (error) {
-            console.error(`Failed to remove contract data for ${contractId}:${key}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async getContractCollection(contractType) {
-        const stored = await this.storage.getItem(getCollectionStorageKey(contractType));
-        if (!stored)
-            return [];
-        try {
-            const collection = JSON.parse(stored);
-            return collection;
-        }
-        catch (error) {
-            console.error(`Failed to parse contract collection ${contractType}:`, error);
-            return [];
-        }
-    }
-    async saveToContractCollection(contractType, item, idField) {
-        const collection = await this.getContractCollection(contractType);
-        // Validate that the item has the required id field
-        const itemId = item[idField];
-        if (itemId === undefined || itemId === null) {
-            throw new Error(`Item is missing required field '${String(idField)}'`);
-        }
-        // Find existing item index without mutating the original collection
-        const existingIndex = collection.findIndex((i) => i[idField] === itemId);
-        // Build new collection without mutating the cached one
-        let newCollection;
-        if (existingIndex !== -1) {
-            // Replace existing item
-            newCollection = [
-                ...collection.slice(0, existingIndex),
-                item,
-                ...collection.slice(existingIndex + 1),
-            ];
-        }
-        else {
-            // Add new item
-            newCollection = [...collection, item];
-        }
-        try {
-            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(newCollection));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract collection ${contractType}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async removeFromContractCollection(contractType, id, idField) {
-        // Validate input parameters
-        if (id === undefined || id === null) {
-            throw new Error(`Invalid id provided for removal: ${String(id)}`);
-        }
-        const collection = await this.getContractCollection(contractType);
-        // Build new collection without the specified item
-        const filtered = collection.filter((item) => item[idField] !== id);
-        try {
-            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(filtered));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract collection removal for ${contractType}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    // The following methods are implemented for compatibility with the new ContractRepository interface
-    // but aren't used.
-    async getContracts(_) {
-        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
-    }
-    async saveContract(_) {
-        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
-    }
-    async deleteContract(_) {
-        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
-    }
-    // used only for tests
-    async clear() {
-        await this.storage.clear();
-    }
-    async [Symbol.asyncDispose]() {
-        // deprecated StorageAdapter doesn't have a `close()` method
-        return;
-    }
-}

package/dist/esm/repositories/migrations/fromStorageAdapter.js

@@ -1,58 +0,0 @@
-import { WalletRepositoryImpl } from "./walletRepositoryImpl.js";
-export const MIGRATION_KEY = (repoType) => `migration-from-storage-adapter-${repoType}`;
-export async function getMigrationStatus(repoType, storageAdapter) {
-    try {
-        const migration = await storageAdapter.getItem(MIGRATION_KEY(repoType));
-        if (migration === "done")
-            return "done";
-        if (migration === "in-progress")
-            return "in-progress";
-        return "pending";
-    }
-    catch (e) {
-        if (e instanceof DOMException && e.name === "NotFoundError")
-            return "not-needed";
-        throw e;
-    }
-}
-export async function requiresMigration(repoType, storageAdapter) {
-    const status = await getMigrationStatus(repoType, storageAdapter);
-    return status === "pending" || status === "in-progress";
-}
-export async function rollbackMigration(repoType, storageAdapter) {
-    await storageAdapter.removeItem(MIGRATION_KEY(repoType));
-}
-/**
- * Migrate wallet data from the legacy storage adapter to the new one.
- * It accepts both onchain and offchain addresses, make sure to pass both.
- *
- * @param storageAdapter
- * @param fresh
- * @param addresses
- */
-export async function migrateWalletRepository(storageAdapter, fresh, addresses) {
-    const migrate = await requiresMigration("wallet", storageAdapter);
-    if (!migrate)
-        return;
-    await storageAdapter.setItem(MIGRATION_KEY("wallet"), "in-progress");
-    const old = new WalletRepositoryImpl(storageAdapter);
-    const walletData = await old.getWalletState();
-    const onchainAddrData = await Promise.all(addresses.onchain.map(async (address) => {
-        const utxos = await old.getUtxos(address);
-        return { address, utxos };
-    }));
-    const offchainAddrData = await Promise.all(addresses.offchain.map(async (address) => {
-        const vtxos = await old.getVtxos(address);
-        const txs = await old.getTransactionHistory(address);
-        return { address, vtxos, txs };
-    }));
-    await Promise.all([
-        walletData && fresh.saveWalletState(walletData),
-        ...offchainAddrData.map((addressData) => Promise.all([
-            fresh.saveVtxos(addressData.address, addressData.vtxos),
-            fresh.saveTransactions(addressData.address, addressData.txs),
-        ])),
-        ...onchainAddrData.map((addressData) => fresh.saveUtxos(addressData.address, addressData.utxos)),
-    ]);
-    await storageAdapter.setItem(MIGRATION_KEY("wallet"), "done");
-}

package/dist/esm/repositories/migrations/walletRepositoryImpl.js

@@ -1,180 +0,0 @@
-import { hex } from "@scure/base";
-import { TaprootControlBlock } from "@scure/btc-signer";
-import { serializeAssets, deserializeAssets, serializeTransaction, deserializeTransaction, } from "../serialization.js";
-const getVtxosStorageKey = (address) => `vtxos:${address}`;
-const getUtxosStorageKey = (address) => `utxos:${address}`;
-const getTransactionsStorageKey = (address) => `tx:${address}`;
-const walletStateStorageKey = "wallet:state";
-// Utility functions for (de)serializing complex structures
-const serializeVtxo = (v) => ({
-    ...v,
-    tapTree: hex.encode(v.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
-    extraWitness: v.extraWitness?.map(hex.encode),
-    assets: serializeAssets(v.assets),
-});
-const serializeUtxo = (u) => ({
-    ...u,
-    tapTree: hex.encode(u.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
-    extraWitness: u.extraWitness?.map(hex.encode),
-});
-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),
-    assets: deserializeAssets(o.assets),
-});
-const deserializeUtxo = (o) => ({
-    ...o,
-    tapTree: hex.decode(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(hex.decode),
-});
-const serializeTapLeaf = ([cb, s]) => ({
-    cb: hex.encode(TaprootControlBlock.encode(cb)),
-    s: hex.encode(s),
-});
-const deserializeTapLeaf = (t) => {
-    const cb = TaprootControlBlock.decode(hex.decode(t.cb));
-    const s = hex.decode(t.s);
-    return [cb, s];
-};
-/**
- * @deprecated This is only to be used in migration from storage V1
- */
-export class WalletRepositoryImpl {
-    constructor(storage) {
-        this.version = 1;
-        this.storage = storage;
-    }
-    async getVtxos(address) {
-        const stored = await this.storage.getItem(getVtxosStorageKey(address));
-        if (!stored)
-            return [];
-        try {
-            const parsed = JSON.parse(stored);
-            return parsed.map(deserializeVtxo);
-        }
-        catch (error) {
-            console.error(`Failed to parse VTXOs for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveVtxos(address, vtxos) {
-        const storedVtxos = await this.getVtxos(address);
-        for (const vtxo of vtxos) {
-            const existing = storedVtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
-            if (existing !== -1) {
-                storedVtxos[existing] = vtxo;
-            }
-            else {
-                storedVtxos.push(vtxo);
-            }
-        }
-        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(storedVtxos.map(serializeVtxo)));
-    }
-    async clearVtxos(address) {
-        return this.deleteVtxos(address);
-    }
-    async deleteVtxos(address) {
-        await this.storage.removeItem(getVtxosStorageKey(address));
-    }
-    async getUtxos(address) {
-        const stored = await this.storage.getItem(getUtxosStorageKey(address));
-        if (!stored)
-            return [];
-        try {
-            const parsed = JSON.parse(stored);
-            return parsed.map(deserializeUtxo);
-        }
-        catch (error) {
-            console.error(`Failed to parse UTXOs for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveUtxos(address, utxos) {
-        const storedUtxos = await this.getUtxos(address);
-        utxos.forEach((utxo) => {
-            const existing = storedUtxos.findIndex((u) => u.txid === utxo.txid && u.vout === utxo.vout);
-            if (existing !== -1) {
-                storedUtxos[existing] = utxo;
-            }
-            else {
-                storedUtxos.push(utxo);
-            }
-        });
-        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(storedUtxos.map(serializeUtxo)));
-    }
-    async clearUtxos(address) {
-        return this.deleteVtxos(address);
-    }
-    async deleteUtxos(address) {
-        await this.storage.removeItem(getUtxosStorageKey(address));
-    }
-    async getTransactionHistory(address) {
-        const storageKey = getTransactionsStorageKey(address);
-        const stored = await this.storage.getItem(storageKey);
-        if (!stored)
-            return [];
-        try {
-            const parsed = JSON.parse(stored);
-            return parsed.map(deserializeTransaction);
-        }
-        catch (error) {
-            console.error(`Failed to parse transactions for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveTransactions(address, txs) {
-        const storedTransactions = await this.getTransactionHistory(address);
-        for (const tx of txs) {
-            const existing = storedTransactions.findIndex((t) => t.key.boardingTxid === tx.key.boardingTxid &&
-                t.key.commitmentTxid === tx.key.commitmentTxid &&
-                t.key.arkTxid === tx.key.arkTxid);
-            if (existing !== -1) {
-                storedTransactions[existing] = tx;
-            }
-            else {
-                storedTransactions.push(tx);
-            }
-        }
-        await this.storage.setItem(getTransactionsStorageKey(address), JSON.stringify(storedTransactions.map(serializeTransaction)));
-    }
-    async clearTransactions(address) {
-        return this.deleteTransactions(address);
-    }
-    async deleteTransactions(address) {
-        await this.storage.removeItem(getTransactionsStorageKey(address));
-    }
-    async getWalletState() {
-        const stored = await this.storage.getItem(walletStateStorageKey);
-        if (!stored)
-            return null;
-        try {
-            const state = JSON.parse(stored);
-            return state;
-        }
-        catch (error) {
-            console.error("Failed to parse wallet state:", error);
-            return null;
-        }
-    }
-    async saveWalletState(state) {
-        await this.storage.setItem(walletStateStorageKey, JSON.stringify(state));
-    }
-    // New method added in V2, not implemented for legacy
-    async clear() {
-        throw new Error("Method not implemented.");
-    }
-    async [Symbol.asyncDispose]() {
-        // deprecated StorageAdapter doesn't have a `close()` method
-        return;
-    }
-}

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

@@ -1,112 +0,0 @@
-/**
- * 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,
-                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.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

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

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

@@ -1,153 +0,0 @@
-/**
- * Realm object schemas for the Arkade 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.
- */
-import { scriptFromArkAddress } from "../scriptFromAddress.js";
-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?",
-        // scriptPubKey (hex) locking this VTXO, indexed so contract-scoped
-        // queries can resolve ownership without touching address mapping.
-        // Required as of schema v2; legacy rows are backfilled from `address`
-        // during migration (see `runArkRealmMigrations`).
-        script: { type: "string", indexed: true },
-    },
-};
-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 Arkade wallet repositories.
- * Pass this array to your Realm configuration's `schema` property.
- */
-export const ArkRealmSchemas = [
-    ArkVtxoSchema,
-    ArkUtxoSchema,
-    ArkTransactionSchema,
-    ArkWalletStateSchema,
-    ArkContractSchema,
-];
-/**
- * Current Realm schema version for the Arkade wallet.
- *
- * Consumers opening Realm must pass a `schemaVersion` at least this high so
- * legacy databases get migrated; merge it with your own app's version:
- *
- * ```ts
- * await Realm.open({
- *     schema: [...ArkRealmSchemas, ...yourSchemas],
- *     schemaVersion: Math.max(ARK_REALM_SCHEMA_VERSION, yourSchemaVersion),
- *     onMigration: (oldRealm, newRealm) => {
- *         runArkRealmMigrations(oldRealm, newRealm);
- *         // your own migrations
- *     },
- * });
- * ```
- *
- * History:
- *   - v1: initial ArkVtxo/ArkUtxo/... schemas, `script` nullable.
- *   - v2: ArkVtxo.script becomes required; NULL values are backfilled from
- *     the owning Ark address during migration.
- */
-export const ARK_REALM_SCHEMA_VERSION = 2;
-/**
- * Run every Arkade schema migration applicable to the open Realm.
- *
- * Designed to be composed with the consumer's own migrations inside a single
- * `onMigration` callback. Each migration step does a per-row check so it
- * remains idempotent and independent of the app's global `schemaVersion` —
- * a consumer whose app is already at version 10 can still trigger the
- * Arkade v1→v2 script backfill when the row has never been populated.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function runArkRealmMigrations(oldRealm, newRealm) {
-    const newVtxos = newRealm.objects("ArkVtxo");
-    for (let i = 0; i < newVtxos.length; i++) {
-        const newVtxo = newVtxos[i];
-        if (!newVtxo.script) {
-            newVtxo.script = scriptFromArkAddress(newVtxo.address);
-        }
-    }
-}

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

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