@chironbuilder/ootle-sdk 0.1.0

package/dist/htlc.js

@@ -0,0 +1,69 @@
+// HTLC (hashed timelock contract) condition-tree helpers for stealth outputs, built on TIP-0006
+// script-path spending (`PayTo::Conditions`). See tari-project/tari-ootle#2426 and #2431 for the
+// underlying wasm capability this builds on (buildScriptPathWitness/buildStealthTransferStatement,
+// published in @tari-project/ootle-wasm@0.39.0).
+//
+// The exact nested shape here (`AccessRule`/`RestrictedAccessRule`/`RequireRule`/`RuleRequirement`/
+// `NonFungibleAddress`) mirrors `tari-ootle`'s own reference implementation
+// (`applications/tari_walletd/src/handlers/accounts.rs`'s `htlc_conditions`/`requires_public_key`
+// test helpers) and is cross-verified byte-for-byte against a real Rust-generated golden vector in
+// htlc.test.ts -- not hand-derived from docs alone. Getting this JSON shape wrong doesn't fail
+// loudly: it produces a condition tree that either can't be claimed by the intended party or can be
+// claimed by the wrong one, so treat any change here as fund-safety-critical.
+/** The well-known, protocol-fixed resource address for public-key-derived "virtual" ownership
+ * badges (`PUBLIC_IDENTITY_RESOURCE_ADDRESS` in `tari_template_lib_types::constants`). Presenting a
+ * proof of the non-fungible `{resource_address: this, id: {U256: pubkeyHex}}` -- which the engine
+ * auto-populates for any signer of the transaction -- is how "signed by this public key" is
+ * expressed as an `AccessRule` in this engine, unlike Bitcoin-style direct signature checks. */
+const PUBLIC_IDENTITY_RESOURCE_ADDRESS = "resource_0100000000000000000000000000000000000000000000000000000000000000";
+/** An `AccessRule` satisfied only by a transaction signed with `publicKeyHex` (32 raw bytes, hex). */
+export function accessRuleRequiringPublicKey(publicKeyHex) {
+    return {
+        Restricted: {
+            Require: {
+                Require: {
+                    NonFungibleAddress: {
+                        resource_address: PUBLIC_IDENTITY_RESOURCE_ADDRESS,
+                        id: { U256: publicKeyHex },
+                    },
+                },
+            },
+        },
+    };
+}
+/** The two-leaf HTLC condition tree, `[claimLeaf, refundLeaf]` -- pass directly as
+ * `createOutput({ payTo: { Conditions: htlcConditions(...) }, ... })`.
+ *
+ * Claim leaf: hashlock AND before the refund epoch AND the claimant's key.
+ * Refund leaf: at/after the refund epoch AND the refunder's key.
+ *
+ * The condition tree's root (computed on-chain from these leaves at output-creation time) is all
+ * that's committed publicly; these full leaves must be handed to the claimant out of band (e.g. by
+ * the swap protocol/dApp) so they can later reveal the claim leaf via `buildScriptPathWitness`. */
+export function htlcConditions(params) {
+    // The hash is the SHA-256 digest of the secret preimage: exactly 32 bytes (64 hex chars). A
+    // malformed value here silently produces a claim path that can never be satisfied by the
+    // intended claimant, so reject it up front rather than funding an unclaimable output. Hex is
+    // case-insensitive; normalize to lowercase for a canonical, deterministic hash string.
+    if (!/^[0-9a-f]{64}$/i.test(params.hashLockHex)) {
+        throw new Error(`htlcConditions: hashLockHex must be exactly 64 hex characters (32 bytes), got ${JSON.stringify(params.hashLockHex)}`);
+    }
+    if (!Number.isSafeInteger(Number(params.refundEpoch))) {
+        throw new Error(`htlcConditions: refundEpoch ${params.refundEpoch} is not representable as a safe JS integer`);
+    }
+    if (params.refundEpoch <= 0n) {
+        throw new Error(`htlcConditions: refundEpoch must be a positive epoch, got ${params.refundEpoch}`);
+    }
+    const hashLockHex = params.hashLockHex.toLowerCase();
+    const refundEpoch = Number(params.refundEpoch);
+    const claim = [
+        { Builtin: { HashLock: { hash: hashLockHex, alg: "Sha256" } } },
+        { Builtin: { BeforeEpoch: refundEpoch } },
+        { AccessRule: accessRuleRequiringPublicKey(params.claimantPublicKeyHex) },
+    ];
+    const refund = [
+        { Builtin: { AfterEpoch: refundEpoch } },
+        { AccessRule: accessRuleRequiringPublicKey(params.refunderPublicKeyHex) },
+    ];
+    return [claim, refund];
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export type { TransactionExecuteOpts, WalletAccountApi } from "./accountApi";
+export { ACCOUNT_TEMPLATE_ADDRESS, componentAddressFromWalletAddress, deriveAccountComponentAddress, deriveComponentAddress, } from "./componentAddress";
+export type { ConfidentialSumResult, ScannedStealthOutput } from "./confidential";
+export { scanTransactionsForOwnedOutputs, sumConfidentialCommitments } from "./confidential";
+export type { DerivedAccountKeys } from "./derivation";
+export { deriveAccountKeys } from "./derivation";
+export { DomainSeparatedHasher, KEY_MANAGER_DOMAIN, KEY_MANAGER_DOMAIN_VERSION, keyManagerDomainHasher } from "./domainHash";
+export type { HtlcConditionsParams } from "./htlc";
+export { accessRuleRequiringPublicKey, htlcConditions } from "./htlc";
+export type { NetworkName } from "./ootleNetwork";
+export { toOotleNetwork } from "./ootleNetwork";
+export { OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH, buildOwnershipProofMessage, buildWalletOwnershipMessage } from "./ownershipProof";
+export type { EncryptedVault } from "./vault";
+export { decryptVault, encryptVault, fromHex, toHex } from "./vault";
+export { withTimeout } from "./timeout";
+export type { KeyValueStore, PendingShield, ShieldedOutputRecord } from "./storage";
+export { addPendingShield, addShieldedOutput, configureOotleStorage, getKnownVersions, getPrivatePaymentScanCursor, listPendingShields, listShieldedOutputs, localAccountId, markShieldedOutputSpent, removePendingShield, serialized, setKnownVersions, setPrivatePaymentScanCursor, wipeOotleState, } from "./storage";
+export { chromeStorageAdapter, inMemoryAdapter, localStorageAdapter } from "./adapters";
+export type { PrivateBalance, TokenBalance } from "./wallet";
+export { OotleAccount, assertValidMinimumValuePromise, buildHtlcSpendStatement, extractMissingSubstateAddress, extractStaleLockVersion, forgetKnownVersions, pollTransactionResult, recoverPendingShields, resetKnownVersions, resolveInputsWithRetry, resolveSendPrivatelyPlan, resolveUnshieldPlan, selectShieldedUtxosForAmount, selectUnspentShieldedOutputs, substateExists, summarizePrivateHoldings, synthesizeShieldedOnlyBalances, } from "./wallet";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,YAAY,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAE7E,OAAO,EACL,wBAAwB,EACxB,iCAAiC,EACjC,6BAA6B,EAC7B,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAClF,OAAO,EAAE,+BAA+B,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAE7F,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE7H,YAAY,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,4BAA4B,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAEtE,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,oCAAoC,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAEjI,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACpF,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,uBAAuB,EACvB,mBAAmB,EACnB,UAAU,EACV,gBAAgB,EAChB,2BAA2B,EAC3B,cAAc,GACf,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAExF,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EACL,YAAY,EACZ,8BAA8B,EAC9B,uBAAuB,EACvB,6BAA6B,EAC7B,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,4BAA4B,EAC5B,4BAA4B,EAC5B,cAAc,EACd,wBAAwB,EACxB,8BAA8B,GAC/B,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+// Public surface. Import from the package root ("@chironbuilder/ootle-sdk") rather than reaching
+// into individual files -- the module layout underneath is free to change; this file is not.
+export { ACCOUNT_TEMPLATE_ADDRESS, componentAddressFromWalletAddress, deriveAccountComponentAddress, deriveComponentAddress, } from "./componentAddress";
+export { scanTransactionsForOwnedOutputs, sumConfidentialCommitments } from "./confidential";
+export { deriveAccountKeys } from "./derivation";
+export { DomainSeparatedHasher, KEY_MANAGER_DOMAIN, KEY_MANAGER_DOMAIN_VERSION, keyManagerDomainHasher } from "./domainHash";
+export { accessRuleRequiringPublicKey, htlcConditions } from "./htlc";
+export { toOotleNetwork } from "./ootleNetwork";
+export { OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH, buildOwnershipProofMessage, buildWalletOwnershipMessage } from "./ownershipProof";
+export { decryptVault, encryptVault, fromHex, toHex } from "./vault";
+export { withTimeout } from "./timeout";
+export { addPendingShield, addShieldedOutput, configureOotleStorage, getKnownVersions, getPrivatePaymentScanCursor, listPendingShields, listShieldedOutputs, localAccountId, markShieldedOutputSpent, removePendingShield, serialized, setKnownVersions, setPrivatePaymentScanCursor, wipeOotleState, } from "./storage";
+export { chromeStorageAdapter, inMemoryAdapter, localStorageAdapter } from "./adapters";
+export { OotleAccount, assertValidMinimumValuePromise, buildHtlcSpendStatement, extractMissingSubstateAddress, extractStaleLockVersion, forgetKnownVersions, pollTransactionResult, recoverPendingShields, resetKnownVersions, resolveInputsWithRetry, resolveSendPrivatelyPlan, resolveUnshieldPlan, selectShieldedUtxosForAmount, selectUnspentShieldedOutputs, substateExists, summarizePrivateHoldings, synthesizeShieldedOnlyBalances, } from "./wallet";

package/dist/ootleNetwork.d.ts

@@ -0,0 +1,4 @@
+import { Network } from "@tari-project/ootle";
+export type NetworkName = "esmeralda" | "igor";
+export declare function toOotleNetwork(name: NetworkName): Network;
+//# sourceMappingURL=ootleNetwork.d.ts.map

package/dist/ootleNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ootleNetwork.d.ts","sourceRoot":"","sources":["../src/ootleNetwork.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,MAAM,CAAC;AAE/C,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CASzD"}

package/dist/ootleNetwork.js

@@ -0,0 +1,11 @@
+import { Network } from "@tari-project/ootle";
+export function toOotleNetwork(name) {
+    switch (name) {
+        case "esmeralda":
+            return Network.Esmeralda;
+        case "igor":
+            return Network.Igor;
+        default:
+            throw new Error(`Unknown network: ${name}`);
+    }
+}

package/dist/ownershipProof.d.ts

@@ -0,0 +1,4 @@
+export declare const OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH = 500;
+export declare function buildOwnershipProofMessage(networkByte: number, resourceAddress: string, substateId: string, challenge: string): Uint8Array;
+export declare function buildWalletOwnershipMessage(networkByte: number, walletAddress: string, challenge: string): Uint8Array;
+//# sourceMappingURL=ownershipProof.d.ts.map

package/dist/ownershipProof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownershipProof.d.ts","sourceRoot":"","sources":["../src/ownershipProof.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,oCAAoC,MAAM,CAAC;AAExD,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,UAAU,CAUZ;AAaD,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CASrH"}

package/dist/ownershipProof.js

@@ -0,0 +1,53 @@
+// A dApp-facing proof that this account currently controls a specific stealth output's spend
+// key, without spending it and without producing anything that could ever be replayed as a real
+// transaction's authorization signature.
+//
+// The one-time secret this signs with (`c + k`, from `stealthDhSecret`) is exactly what
+// `SecretKeyWallet.addStealthSignature` uses to authorize spending the same output -- so the
+// message this signs must never be, or be derivable into, a real `hashUnsignedTransaction` output.
+// Real transaction signing hashes under domain "com.tari.ootle.transaction"
+// (tari-dan `crates/transaction/src/hashing.rs`); this hashes under a disjoint domain of its own,
+// so the two message spaces cannot collide under the same collision-resistance assumption Tari's
+// own protocol already relies on to keep ITS OWN domains apart (see domainHash.ts).
+//
+// Byte-identical across every consumer of this SDK -- a dApp must get the same signature semantics
+// from any wallet built on it. Verified empirically against tari-crypto's own committed domain-tag
+// test vector and round-tripped against the real `schnorrSign` WASM primitive; see
+// ownershipProof.test.ts and tari-paylink-dapp's scripts/verify-schnorr-roundtrip.mjs, which this
+// construction must stay byte-identical to.
+import { utf8ToBytes } from "@noble/hashes/utils.js";
+import { DomainSeparatedHasher } from "./domainHash";
+const OWNERSHIP_PROOF_DOMAIN = "com.tari.paylink.ownership_proof";
+const OWNERSHIP_PROOF_VERSION = 1;
+export const OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH = 500;
+export function buildOwnershipProofMessage(networkByte, resourceAddress, substateId, challenge) {
+    if (challenge.length > OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH) {
+        throw new Error(`Challenge text is too long (${OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH} characters max).`);
+    }
+    return new DomainSeparatedHasher(OWNERSHIP_PROOF_DOMAIN, OWNERSHIP_PROOF_VERSION, "v1", 64)
+        .chain(new Uint8Array([networkByte]))
+        .chain(utf8ToBytes(resourceAddress))
+        .chain(utf8ToBytes(substateId))
+        .chain(utf8ToBytes(challenge))
+        .finalize();
+}
+// A generic "I hold this otl_… wallet address" proof — signs with the account's own persistent
+// owner key (the same key `SecretKeyWallet.signTransaction` uses for revealed-balance spends),
+// NOT a per-output derived key. Same domain-separation reasoning as above applies with equal force
+// here: this key signs real transactions too, so the message must live under its own domain,
+// disjoint from "com.tari.ootle.transaction", or a signature could be replayable as spend
+// authorization. Deliberately a DIFFERENT domain from the per-output proof above as well, even
+// though the two never share a signing key -- one domain per distinct kind of claim being signed,
+// so a signature can never be mistaken for the wrong kind of proof.
+const WALLET_OWNERSHIP_PROOF_DOMAIN = "com.tari.paylink.wallet_ownership_proof";
+const WALLET_OWNERSHIP_PROOF_VERSION = 1;
+export function buildWalletOwnershipMessage(networkByte, walletAddress, challenge) {
+    if (challenge.length > OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH) {
+        throw new Error(`Challenge text is too long (${OWNERSHIP_PROOF_CHALLENGE_MAX_LENGTH} characters max).`);
+    }
+    return new DomainSeparatedHasher(WALLET_OWNERSHIP_PROOF_DOMAIN, WALLET_OWNERSHIP_PROOF_VERSION, "v1", 64)
+        .chain(new Uint8Array([networkByte]))
+        .chain(utf8ToBytes(walletAddress))
+        .chain(utf8ToBytes(challenge))
+        .finalize();
+}

package/dist/storage.d.ts

@@ -0,0 +1,61 @@
+export interface KeyValueStore {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+/** Call once, before any storage-touching `OotleAccount` method, with an adapter over whatever
+ * this host's real storage is (see `adapters.ts` for ready-made ones). */
+export declare function configureOotleStorage(store: KeyValueStore): void;
+export interface ShieldedOutputRecord {
+    accountId: string;
+    resourceAddress: string;
+    /** 32-byte Pedersen commitment, hex. */
+    commitment: string;
+    /** Raw, resource-native units (matches TokenBalance.amount's convention). */
+    amount: string;
+    transactionId: string;
+    createdAt: number;
+    /** Set true once this output has been spent via unshield. */
+    spent: boolean;
+    /** The output's plaintext memo, if any. Absent, not empty-string, when it carries none. */
+    memo?: string;
+}
+/**
+ * A shield or unshield submitted but not yet recorded in `shieldedOutputs` — carries every field
+ * needed to complete the write on recovery, since a reload between finalization and the storage
+ * write would otherwise strand the only lead to a real commitment.
+ */
+export interface PendingShield {
+    transactionId: string;
+    accountId: string;
+    resourceAddress: string;
+    amount: string;
+    /** For an unshield or private send: the now-spent commitments to mark on recovery. */
+    spentCommitments?: string[];
+    /** This account's own new commitment, when the operation creates one. */
+    ownCommitment?: string;
+    /** This account's own memo for the operation, if any. */
+    memo?: string;
+}
+export declare function localAccountId(index: number): string;
+/** Runs a whole read-modify-write cycle to completion before the next one starts, so two
+ * concurrent callers (two tabs, a page request racing a popup request) can't interleave their
+ * read-modify-write on this key and silently clobber each other's write. */
+export declare function serialized<T>(fn: () => Promise<T>): Promise<T>;
+export declare function listShieldedOutputs(accountId: string): Promise<ShieldedOutputRecord[]>;
+export declare function addShieldedOutput(record: ShieldedOutputRecord): Promise<void>;
+export declare function markShieldedOutputSpent(accountId: string, commitment: string): Promise<void>;
+export declare function listPendingShields(): Promise<PendingShield[]>;
+export declare function addPendingShield(pending: PendingShield): Promise<void>;
+export declare function removePendingShield(transactionId: string): Promise<void>;
+export declare function getPrivatePaymentScanCursor(accountId: string): Promise<string | null>;
+export declare function setPrivatePaymentScanCursor(accountId: string, transactionId: string): Promise<void>;
+/** Substate version cache -- see `wallet.ts`'s own doc comment on `knownVersionsPromise` for why
+ * this exists at all. */
+export declare function getKnownVersions(): Promise<Record<string, number>>;
+export declare function setKnownVersions(known: Record<string, number>): Promise<void>;
+/** Clears every key this module owns -- call this from a host's own "erase wallet" flow. Does not
+ * touch anything else the host's `KeyValueStore` might hold (address books, settings, ...); this
+ * SDK never wrote those keys, so it isn't this function's place to remove them. */
+export declare function wipeOotleState(): Promise<void>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAC5C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC;AAID;0EAC0E;AAC1E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAEhE;AAcD,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,KAAK,EAAE,OAAO,CAAC;IACf,2FAA2F;IAC3F,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,sFAAsF;IACtF,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAiBD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAaD;;4EAE4E;AAC5E,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAO9D;AAED,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAE5F;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAInF;AAED,wBAAsB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASlG;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAEnE;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAM5E;AAED,wBAAsB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAK9E;AAED,wBAAsB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAE3F;AAED,wBAAsB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKzG;AAED;yBACyB;AACzB,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAExE;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAInF;AAED;;mFAEmF;AACnF,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAIpD"}

package/dist/storage.js

@@ -0,0 +1,110 @@
+// The persistence surface `wallet.ts` (the account core) needs, backed by whatever key-value store
+// the host application supplies -- a Chrome extension has `chrome.storage.local`, a web page has
+// `localStorage`, a future host might have something else again. This module never touches a
+// concrete storage API directly; it reads and writes through `KeyValueStore`, configured once via
+// `configureOotleStorage()` before any `OotleAccount` method that touches storage is called.
+//
+// Deliberately narrow: this is exactly what the account core itself needs (shielded outputs,
+// pending shields, the private-payment scan cursor, the known-substate-versions cache) -- not
+// address books, connected-site permissions, daemon connections, or a full transaction-history UI.
+// Those are application concerns with very different shapes across hosts, and belong in each
+// consuming app's own storage layer, not in this SDK.
+let configuredStore = null;
+/** Call once, before any storage-touching `OotleAccount` method, with an adapter over whatever
+ * this host's real storage is (see `adapters.ts` for ready-made ones). */
+export function configureOotleStorage(store) {
+    configuredStore = store;
+}
+function store() {
+    if (!configuredStore) {
+        throw new Error("Ootle SDK storage has not been configured. Call configureOotleStorage(store) once at startup " +
+            "with a KeyValueStore for this host (see adapters.ts).");
+    }
+    return configuredStore;
+}
+const STORAGE_KEY = "ootle-sdk/v1";
+const DEFAULTS = {
+    shieldedOutputs: [],
+    pendingShields: [],
+    privatePaymentScanCursors: {},
+    knownVersions: {},
+};
+export function localAccountId(index) {
+    return `local:${index}`;
+}
+async function read() {
+    const raw = await store().get(STORAGE_KEY);
+    return { ...DEFAULTS, ...raw };
+}
+async function write(patch) {
+    await store().set(STORAGE_KEY, { ...(await read()), ...patch });
+}
+let writeQueue = Promise.resolve();
+/** Runs a whole read-modify-write cycle to completion before the next one starts, so two
+ * concurrent callers (two tabs, a page request racing a popup request) can't interleave their
+ * read-modify-write on this key and silently clobber each other's write. */
+export function serialized(fn) {
+    const result = writeQueue.then(fn, fn);
+    writeQueue = result.then(() => undefined, () => undefined);
+    return result;
+}
+export async function listShieldedOutputs(accountId) {
+    return (await read()).shieldedOutputs.filter((r) => r.accountId === accountId);
+}
+export async function addShieldedOutput(record) {
+    await serialized(async () => {
+        write({ shieldedOutputs: [...(await read()).shieldedOutputs, record] });
+    });
+}
+export async function markShieldedOutputSpent(accountId, commitment) {
+    await serialized(async () => {
+        const state = await read();
+        await write({
+            shieldedOutputs: state.shieldedOutputs.map((r) => r.accountId === accountId && r.commitment === commitment ? { ...r, spent: true } : r),
+        });
+    });
+}
+export async function listPendingShields() {
+    return (await read()).pendingShields;
+}
+export async function addPendingShield(pending) {
+    await serialized(async () => {
+        const state = await read();
+        if (state.pendingShields.some((p) => p.transactionId === pending.transactionId))
+            return;
+        await write({ pendingShields: [...state.pendingShields, pending] });
+    });
+}
+export async function removePendingShield(transactionId) {
+    await serialized(async () => {
+        const state = await read();
+        await write({ pendingShields: state.pendingShields.filter((p) => p.transactionId !== transactionId) });
+    });
+}
+export async function getPrivatePaymentScanCursor(accountId) {
+    return (await read()).privatePaymentScanCursors[accountId] ?? null;
+}
+export async function setPrivatePaymentScanCursor(accountId, transactionId) {
+    await serialized(async () => {
+        const state = await read();
+        await write({ privatePaymentScanCursors: { ...state.privatePaymentScanCursors, [accountId]: transactionId } });
+    });
+}
+/** Substate version cache -- see `wallet.ts`'s own doc comment on `knownVersionsPromise` for why
+ * this exists at all. */
+export async function getKnownVersions() {
+    return (await read()).knownVersions;
+}
+export async function setKnownVersions(known) {
+    await serialized(async () => {
+        await write({ knownVersions: known });
+    });
+}
+/** Clears every key this module owns -- call this from a host's own "erase wallet" flow. Does not
+ * touch anything else the host's `KeyValueStore` might hold (address books, settings, ...); this
+ * SDK never wrote those keys, so it isn't this function's place to remove them. */
+export async function wipeOotleState() {
+    await serialized(async () => {
+        await store().remove(STORAGE_KEY);
+    });
+}

package/dist/timeout.d.ts

@@ -0,0 +1,2 @@
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T>;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAOA,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAczF"}

package/dist/timeout.js

@@ -0,0 +1,19 @@
+// A hung fetch (or any other network stall) inside a page-triggered request otherwise blocks that
+// page's promise forever with no error and no way to recover short of reloading the extension —
+// confirmed empirically hitting exactly this waiting on a testnet indexer response, and again
+// waiting on an unreachable wallet daemon (a plain `fetch()` to a port nothing is listening on
+// doesn't reject quickly on every platform). Every individual network step in OotleAccount's and
+// DaemonAccount's execute() is wrapped in this so a stall surfaces as a clear timeout error
+// instead of an indefinite hang.
+export function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Timed out after ${ms}ms while ${label}.`)), ms);
+        promise.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}

package/dist/vault.d.ts

@@ -0,0 +1,12 @@
+export interface EncryptedVault {
+    version: 1;
+    salt: string;
+    iv: string;
+    ciphertext: string;
+}
+export declare function toHex(bytes: Uint8Array): string;
+export declare function fromHex(hex: string): Uint8Array;
+export declare function encryptVault(password: string, plaintext: Uint8Array): Promise<EncryptedVault>;
+/** @throws if the password is wrong or the vault is corrupt. */
+export declare function decryptVault(password: string, vault: EncryptedVault): Promise<Uint8Array>;
+//# sourceMappingURL=vault.d.ts.map

package/dist/vault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault.d.ts","sourceRoot":"","sources":["../src/vault.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAI/C;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAI/C;AAeD,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC,CAQnG;AAED,gEAAgE;AAChE,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,CAc/F"}

package/dist/vault.js

@@ -0,0 +1,44 @@
+// Password-based encryption for the wallet's master seed, using the browser's native WebCrypto
+// (available in both the background service worker and the popup) — no custom crypto here.
+// PBKDF2-HMAC-SHA256 with 600,000 iterations (OWASP's 2023 minimum recommendation) derives an
+// AES-256-GCM key from the unlock password; the encrypted blob is what's persisted to
+// chrome.storage.local. The derived key and plaintext seed only ever live in memory, and only for
+// as long as the wallet is unlocked (see background/session.ts).
+const PBKDF2_ITERATIONS = 600_000;
+export function toHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+export function fromHex(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++)
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    return bytes;
+}
+async function deriveAesKey(password, salt) {
+    const keyMaterial = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
+        "deriveKey",
+    ]);
+    return crypto.subtle.deriveKey({ name: "PBKDF2", salt: salt, iterations: PBKDF2_ITERATIONS, hash: "SHA-256" }, keyMaterial, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+export async function encryptVault(password, plaintext) {
+    const salt = crypto.getRandomValues(new Uint8Array(16));
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const key = await deriveAesKey(password, salt);
+    const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv }, key, plaintext));
+    return { version: 1, salt: toHex(salt), iv: toHex(iv), ciphertext: toHex(ciphertext) };
+}
+/** @throws if the password is wrong or the vault is corrupt. */
+export async function decryptVault(password, vault) {
+    const salt = fromHex(vault.salt);
+    const iv = fromHex(vault.iv);
+    const key = await deriveAesKey(password, salt);
+    try {
+        const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: iv }, key, fromHex(vault.ciphertext));
+        return new Uint8Array(plaintext);
+    }
+    catch {
+        throw new Error("Incorrect password");
+    }
+}