@dynamic-labs-wallet/aleo 0.0.0 → 0.0.331

package/package.json

@@ -1 +1,34 @@
-{ "name": "@dynamic-labs-wallet/aleo", "version": "0.0.0" }
+{
+  "name": "@dynamic-labs-wallet/aleo",
+  "version": "0.0.331",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@dynamic-labs-wallet/browser": "0.0.331",
+    "@dynamic-labs-wallet/core": "0.0.331",
+    "@provablehq/sdk": "0.10.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "sourceRoot": "packages/aleo/src",
+    "projectType": "library",
+    "name": "aleo",
+    "targets": {
+      "build": {}
+    }
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.esm.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.cjs.js",
+      "default": "./index.esm.js"
+    }
+  }
+}

package/src/client/client.d.ts

@@ -0,0 +1,359 @@
+import { DynamicWalletClient, type DynamicWalletClientInternalOptions, type DynamicWalletClientProps, type RequestWithElevatedAccessToken, type ThresholdSignatureScheme } from '@dynamic-labs-wallet/browser';
+export declare class DynamicAleoWalletClient extends DynamicWalletClient {
+    readonly chainName = "ALEO";
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode, sdkVersion, forwardMPCClient, logger, }: DynamicWalletClientProps, internalOptions?: DynamicWalletClientInternalOptions);
+    createWalletAccount({ thresholdSignatureScheme, password, onError, signedSessionId, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+        signedSessionId: string;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: Uint8Array;
+    }>;
+    signMessage(_args: {
+        message: string;
+        accountAddress: string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        elevatedAccessToken?: string;
+    }): Promise<string>;
+    signTransaction(args: {
+        accountAddress: string;
+        signedSessionId: string;
+    }): Promise<string>;
+    exportPrivateKey({ accountAddress, password, signedSessionId, mfaToken, elevatedAccessToken, }: RequestWithElevatedAccessToken<{
+        accountAddress: string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+    }>): Promise<string>;
+    importPrivateKey(_args: {
+        privateKey: string;
+        chainName: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        signedSessionId: string;
+        onError?: (error: Error) => void;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: Uint8Array;
+    }>;
+    getAleoWallets(): Promise<any>;
+    /**
+     * Runs the Aleo signRequest MPC ceremony for the given structured payload.
+     * The payload is Sodot's `EdBls12377RequestSignPayload` shape:
+     * { function_id, is_root, program_checksum, inputs: [...] }.
+     * Returns the signed request with { signature, tvk, signer, gammas? } which
+     * the caller passes to `buildExecutionRequestFromExternallySignedData` to
+     * produce an ExecutionRequest for proving via Provable DPS.
+     */
+    signAleoRequest({ accountAddress, payload, password, signedSessionId, mfaToken, elevatedAccessToken, }: RequestWithElevatedAccessToken<{
+        accountAddress: string;
+        payload: unknown;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+    }>): Promise<unknown>;
+    /**
+     * LocalStorage key for caching the per-account Aleo view key in the iframe.
+     * Scoped to iframe origin — the DApp cannot read this via same-origin policy.
+     */
+    private getViewKeyCacheStorageKey;
+    /**
+     * Returns the Aleo view key for the given account. On first call runs the
+     * asymmetric exportViewKey MPC ceremony (client receives, server gets
+     * nothing) and caches the result in iframe localStorage. Subsequent calls
+     * return the cached value. View key never leaves the iframe — it is NOT
+     * postMessage'd to the DApp.
+     */
+    exportViewKey({ accountAddress, password, signedSessionId, mfaToken, elevatedAccessToken, }: RequestWithElevatedAccessToken<{
+        accountAddress: string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+    }>): Promise<string>;
+    /**
+     * Convert a Provable `ExternalSigningInput<'bytes'>` into the Sodot
+     * EdBls12377 signing payload shape. Mirrors the playground helper.
+     * All Uint8Array fields are preserved — this shape is passed directly to
+     * `mpcSigner.signRequest` locally. For HTTP transport, use
+     * `encodePayloadForTransport` to hex-encode the byte fields.
+     */
+    private toRequestSignPayload;
+    /**
+     * Hex-encode the Uint8Array fields of an EdBls12377 signing payload so it
+     * can travel through JSON HTTP without loss. Mirror of
+     * `decodeAleoSigningPayload` in wallet-service — both sides must agree on
+     * the wire format so the MPC ceremony sees identical byte arrays.
+     */
+    private encodePayloadForTransport;
+    /**
+     * Fetches the on-chain `program_checksum` for a deployed program and
+     * returns it as a 32-byte `Uint8Array` ready to feed into
+     * `computeExternalSigningInputs({ checksum })` and Sodot's
+     * `signRequest` payload (`program_checksum` field).
+     *
+     * Why we need this: the Aleo VM's external-signing path checks the
+     * program checksum for any program that has a constructor. Constructor-
+     * less programs (`credits.aleo`, `token_registry.aleo`) deploy without a
+     * `program_checksum` field and work with `checksum: null`. Programs with
+     * a constructor (USAD/USDCx Tier-3 stablecoins, any custom program)
+     * trip a hardcoded `"Program ID must be credits.aleo"` error in the WASM
+     * unless a real checksum is supplied.
+     *
+     * Returns `null` when the deployment has no checksum (constructor-less);
+     * caller is expected to pass that `null` through to `signRequest`.
+     *
+     * Source: the deployment transaction's `deployment.program_checksum`
+     * field, returned as a 32-element array of `<n>u8` literals (e.g.
+     * `["207u8", "221u8", ...]`).
+     */
+    private getProgramChecksum;
+    /**
+     * Computes (or returns from cache) the Sealance Merkle exclusion proof
+     * for `accountAddress` against the given freezelist program's tree.
+     *
+     * The Sealance flow proves the sender is *not* on the freeze list. Recipe:
+     *   1. Fetch the BigInt-string tree at
+     *      `/v2/{network}/programs/{freezelist}/compliance/freeze-list`.
+     *   2. `tree[tree.length - 1]` is the Merkle root.
+     *   3. `convertTreeToBigInt` → `getLeafIndices(addr)` → 2× `getSiblingPath`
+     *      → `formatMerkleProof` produces the formatted `[MerkleProof; 2u32]` literal.
+     *
+     * Cached per (accountAddress, freezelistProgram, root). On the next spend
+     * we only refetch the tree and rebuild when the root has changed.
+     */
+    private getSealanceProof;
+    /**
+     * Full Aleo transaction flow:
+     *   viewKey (MPC exported, cached) → computeExternalSigningInputs
+     *   → Sodot signAleoRequest MPC ceremony
+     *   → buildExecutionRequestFromExternallySignedData
+     *   → Provable DPS submitProvingRequest (computes ZK proof + broadcasts)
+     *
+     * Handles both non-record functions (transfer_public) and record-consuming
+     * functions (transfer_private, join, transfer_public_to_private).
+     *
+     * For Sealance-compliant tier-3 stablecoins (USAD, USDCx), the iframe also
+     * auto-fetches/computes the Merkle exclusion proof and appends it to
+     * `inputs`/`inputTypes` when the program/function pair calls for it. The
+     * caller passes the same shape as a credits.aleo transfer.
+     *
+     * @param broadcast - if true, DPS broadcasts the transaction and returns a
+     *   txId. If false, DPS returns the proving response and the caller
+     *   decides what to do with it.
+     */
+    proveTransaction({ accountAddress, programId, functionName, inputs, inputTypes, broadcast, password, signedSessionId, mfaToken, elevatedAccessToken, chainId, }: RequestWithElevatedAccessToken<{
+        accountAddress: string;
+        programId: string;
+        functionName: string;
+        inputs: string[];
+        inputTypes: string[];
+        broadcast?: boolean;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        /** Aleo network id (`'0'` mainnet, `'1'` testnet, or numeric). The
+         *  authoritative signal for which network the user is on; used to
+         *  pick the SDK build, the Feemaster policy, and the proving
+         *  endpoints. Falls back to `networkFromProgramId(programId)` when
+         *  unset — that's lossy for `credits.aleo` (same name on both
+         *  networks), so callers should always pass `chainId` for credits
+         *  flows. */
+        chainId?: string | number;
+    }>): Promise<{
+        txId?: string;
+        provingResponse?: unknown;
+    }>;
+    /**
+     * Sealance auto-injection. For tier-3 stablecoin transfer functions that
+     * require a freeze-list exclusion proof, append the formatted
+     * `[MerkleProof; 2u32].private` literal to inputs/inputTypes. Programs
+     * not in the registry / function not requiring proof → pass-through.
+     */
+    private injectSealanceProofIfNeeded;
+    /**
+     * Derive the program-checksum `Field` snarkVM's external-signing path
+     * needs for non-credits programs. `credits.aleo` is special-cased in the
+     * WASM and works with `null`. Other programs: fetch the on-chain 32-byte
+     * checksum, expand bytes → bits LE, truncate to `Field::SIZE_IN_DATA_BITS`
+     * (252 for Fr), and call `Field.fromBitsLe` — mirrors snarkVM's own
+     * `Stack::program_checksum_as_field`.
+     */
+    private deriveProgramChecksumField;
+    /**
+     * Build the proving request — feemaster path when ANF covers the
+     * (programId, functionName), user-paid fallback otherwise. Feemaster
+     * failures fall through silently so a transient policy/quota issue
+     * doesn't block the user; they just pay the fee themselves.
+     */
+    private buildProvingRequest;
+    /**
+     * Feemaster-sponsored proving request. Builds the user authorization via
+     * the WASM-direct ProgramManager static (no private key needed — the
+     * request is already MPC-signed), exchanges it with the Feemaster for a
+     * `feeAuthorization`, and returns the bundled `ProvingRequest`.
+     */
+    private buildFeemasterProvingRequest;
+    /**
+     * Standalone Feemaster coverage check for any (programId, functionName)
+     * pair on the connector-selected network. Used by the widget to decide
+     * whether a user-paid confirmation modal is needed before triggering a
+     * shield/send/join. Resolves the network from the caller-supplied
+     * `chainId`; defaults to testnet when omitted (mirrors `resolveAleoNetwork`).
+     *
+     * Never throws — returns `false` on any policy fetch failure so callers
+     * can default to "show modal" rather than silently shielding.
+     */
+    isFeemasterCovered({ programId, functionName, chainId, }: {
+        programId: string;
+        functionName: string;
+        chainId?: string | number;
+    }): Promise<boolean>;
+    /**
+     * Cached ProgramManager per Aleo network. The SDK ships separate
+     * mainnet/testnet builds (`@provablehq/sdk/{mainnet,testnet}.js`) that
+     * export network-specific class identities — `ExecutionRequest`,
+     * `ProvingRequest`, etc. each network's prebundle has its own constructor.
+     * `provingRequest` validates `executionRequest instanceof ExecutionRequest`
+     * against the manager's own SDK build, so a manager constructed from the
+     * testnet build will reject a mainnet-built executionRequest (silently
+     * falling into the no-executionRequest branch and throwing a misleading
+     * "No private key provided" error). Caching per network keeps both
+     * builds available and ensures the manager and the executionRequest
+     * always come from the same SDK build.
+     */
+    private readonly programManagersByNetwork;
+    /**
+     * Lazy-load the network-matching `@provablehq/sdk` build, instantiate a
+     * ProgramManager, and cache it. The Provable WASM bundle is ~20MB, so
+     * we avoid loading it eagerly at iframe init; both networks' bundles
+     * load on first use of each.
+     */
+    protected getProgramManager(network: 'testnet' | 'mainnet'): Promise<unknown>;
+    /**
+     * Cached RecordScanner instances per Aleo network. Each entry talks to a
+     * single network's scanner endpoint with a single network-specific SDK
+     * build (`@provablehq/sdk/{testnet,mainnet}.js`). Per-wallet identity is
+     * via the scanner UUID cached in walletStateStorage (also keyed by
+     * network). Scanner credentials (apiKey, consumerId) are shared across
+     * networks. The SDK handles JWT refresh automatically.
+     */
+    private readonly scannersByNetwork;
+    /**
+     * Cached `FeemasterClient` per Aleo network. Each instance holds an in-
+     * memory policy cache (5 min TTL) and delegates HTTP work to the
+     * inherited `this.apiClient` — the same `DynamicApiClient` every other
+     * iframe→redcoast call uses. So baseApiUrl, auth headers, traceContext
+     * propagation, etc. all come from the existing plumbing for free.
+     */
+    private readonly feemasterClients;
+    private getFeemasterClient;
+    /**
+     * In-memory cache of program checksums keyed by `${network}:${programId}`.
+     * The Aleo VM's external-signing path requires a non-null `program_checksum`
+     * for any program with a constructor (i.e. anything other than credits.aleo
+     * in our universe). The checksum is immutable for a given deployed program
+     * edition, so we fetch once per session and reuse. Persistence not needed —
+     * a single network round-trip on first use is cheap.
+     */
+    private readonly programChecksumCache;
+    /**
+     * Single-flight guard for `findOwnedRecords`, keyed by accountAddress.
+     * The widget's Shielded tab + the demo's "List my records" button can fire
+     * concurrent record scans on the same wallet; without dedup, multiple
+     * findRecords calls race against a stale cached UUID and serially trip
+     * UUIDErrors. With dedup, all concurrent callers await the same in-flight
+     * promise and the recovery path runs at most once.
+     */
+    private readonly pendingFindOwnedRecords;
+    /**
+     * Lazy-init RecordScanner for the given Aleo network using the shared
+     * Provable consumer credentials (VITE_ALEO_SCANNER_API_KEY +
+     * VITE_ALEO_SCANNER_CONSUMER_ID in iframe env). Scanner calls and JWT
+     * refresh both route through the Vite dev proxy `/aleo-api/*` to work
+     * around Provable's CORS 401 on preflight.
+     *
+     * The Provable SDK ships separate `testnet.js` / `mainnet.js` builds
+     * (verified in `node_modules/@provablehq/sdk/package.json#exports`). Each
+     * build pins the chain endpoints to that network, so the right scanner
+     * comes from importing the matching build. We cache an instance per
+     * network on `this.scannersByNetwork`; toggling networks at runtime is
+     * a Map lookup, no teardown.
+     */
+    protected getRecordScanner(network: 'testnet' | 'mainnet'): Promise<unknown>;
+    /**
+     * List all Aleo records owned by this wallet across every program (credits,
+     * custom tokens, etc.). Uses Provable's hosted RecordScanner with our shared
+     * consumer; per-wallet scanner UUID is cached in iframe IndexedDB
+     * (walletStateStorage) so subsequent calls skip the register step.
+     *
+     * Each returned record carries `program_name` + `record_name` so callers
+     * can classify by token. Credits records additionally get a `microcredits`
+     * field parsed in-iframe for convenience (public WASM primitive). Other
+     * tokens are returned as-is — the caller is responsible for amount parsing
+     * per program schema.
+     *
+     * Records are decrypted locally in the iframe via view-key only.
+     * Spent-tracking filters out locally-known spent nonces (records we
+     * consumed in our own proveTransaction calls, before the scanner has
+     * re-indexed).
+     */
+    findOwnedRecords(params: RequestWithElevatedAccessToken<{
+        accountAddress: string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        /** Aleo network id (`'0'` mainnet, `'1'` testnet, or numeric).
+         *  Routes the scan to the matching scanner instance + walletState
+         *  cache bucket. Omit to default to testnet. */
+        chainId?: string | number;
+    }>): Promise<{
+        records: unknown[];
+    }>;
+    private findOwnedRecordsInner;
+    /**
+     * Loads the network-specific Provable SDK build and surfaces a clear
+     * error log to the iframe console when WASM init fails (so the failure
+     * is debuggable; the throw still propagates).
+     */
+    private loadAleoSdkOrThrow;
+    /**
+     * Reads the per-(account, network) wallet state from IndexedDB. Errors
+     * are logged and rethrown — a wedged IDB blocks the find-records flow
+     * entirely, so silent fallback isn't safe here.
+     */
+    private loadWalletStateOrThrow;
+    /**
+     * Provable's RecordScanner can throw a `UUIDError` for several reasons —
+     * cached UUID expired server-side, consumer key rotated, scanner instance
+     * stale after a JWT refresh blip. Recovery: drop the cached scanner
+     * instance + cached UUID, re-register, retry up to twice. After that the
+     * problem isn't UUID-related and we surface the underlying error.
+     */
+    private findRecordsWithUuidRetry;
+    /**
+     * Wraps the encrypted view key and registers it with the scanner.
+     * `registerEncrypted` (not `register`) ensures the view key crosses the
+     * wire encrypted; same pattern Provable's `example-autojoin` uses.
+     */
+    private registerScannerWallet;
+    /**
+     * Decrypt the record's ciphertext locally (when missing) and surface
+     * `microcredits` / `amount` as decimal strings so the DApp side can
+     * display balances without needing the Provable WASM in its own bundle.
+     * Mutates the record in place — same contract the original loop had.
+     */
+    private enrichOwnedRecord;
+    /**
+     * Local spent-nonce filter — protects against the race where we've
+     * broadcast a record-spending transaction but the scanner hasn't indexed
+     * the spend yet.
+     */
+    private filterUnspentRecords;
+}
+//# sourceMappingURL=client.d.ts.map

package/src/client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"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"}

package/src/client/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const ERROR_KEYGEN_FAILED = "Error with Aleo keygen";
+export declare const ERROR_CREATE_WALLET_ACCOUNT = "Error creating Aleo wallet account";
+export declare const ERROR_ACCOUNT_ADDRESS_REQUIRED = "Account address is required";
+export declare const ERROR_EXPORT_PRIVATE_KEY = "Error exporting Aleo private key";
+export declare const ERROR_IMPORT_PRIVATE_KEY_NOT_SUPPORTED = "Aleo importPrivateKey is not supported yet";
+export declare const ERROR_SIGN_MESSAGE_NOT_SUPPORTED = "Aleo signMessage is not supported yet \u2014 pending arbitrary-bytes EdBls12377 signing";
+export declare const ERROR_SIGN_TRANSACTION_NOT_SUPPORTED = "Aleo signTransaction is not supported yet \u2014 coming in Phase 2";
+export declare const ALEO_NETWORKS: {
+    readonly MAINNET: "mainnet";
+    readonly TESTNET: "testnet";
+};
+/**
+ * Default Provable Delegated Proving Service endpoint.
+ * Used by `submitProvingRequest` — Provable computes the ZK proof on their
+ * accelerator hardware and (optionally) broadcasts. No API key required for
+ * testnet during Phase 2.
+ */
+export declare const DEFAULT_PROVABLE_PROVER_URI = "https://accelerate.provable.com";
+export type AleoNetwork = (typeof ALEO_NETWORKS)[keyof typeof ALEO_NETWORKS];
+//# sourceMappingURL=constants.d.ts.map

package/src/client/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/client/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAC5D,eAAO,MAAM,2BAA2B,uCAAuC,CAAC;AAChF,eAAO,MAAM,8BAA8B,gCAAgC,CAAC;AAC5E,eAAO,MAAM,wBAAwB,qCAAqC,CAAC;AAC3E,eAAO,MAAM,sCAAsC,+CAA+C,CAAC;AACnG,eAAO,MAAM,gCAAgC,4FACyC,CAAC;AACvF,eAAO,MAAM,oCAAoC,uEAAkE,CAAC;AAEpH,eAAO,MAAM,aAAa;;;CAGhB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,oCAAoC,CAAC;AAE7E,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC"}

package/src/client/feemasterClient.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Iframe-side Feemaster surface used by `proveTransaction`.
+ *
+ * Earlier versions made `fetch()` calls to ANF directly with a hardcoded
+ * Bearer key shipped in the iframe bundle. As of Phase A1 the iframe goes
+ * through redcoast (which holds the ANF key server-side) — and by reusing
+ * the existing `DynamicApiClient` in `@dynamic-labs-wallet/core`, all the
+ * baseApiUrl / Authorization-header / retry plumbing is shared with the
+ * other waas redcoast endpoints (`exportAleoViewKey`, `signAleoRequest`,
+ * etc.).
+ *
+ * This file is now a thin wrapper that:
+ *   - holds the network the iframe is bound to
+ *   - keeps a 5-min in-memory policy cache (matches the previous behaviour)
+ *   - delegates HTTP work to `DynamicApiClient`
+ *
+ * Surface kept identical (`fetchPolicy`, `isCovered`, `requestFeeAuthorization`)
+ * so call sites in `proveTransaction` don't change.
+ */
+import type { DynamicApiClient } from '@dynamic-labs-wallet/core';
+export interface FeemasterPolicyEntry {
+    program_id: string;
+    /** `null` (or absent) means all functions on the program are sponsored. */
+    allowed_functions?: string[] | null;
+}
+export interface FeemasterPolicy {
+    /** `null` means all programs are sponsored (wildcard). */
+    allowed_programs: FeemasterPolicyEntry[] | null;
+}
+export type FeemasterNetwork = 'mainnet' | 'testnet';
+export declare class FeemasterClient {
+    private readonly apiClient;
+    private readonly network;
+    private policyCache;
+    constructor(args: {
+        apiClient: DynamicApiClient;
+        network: FeemasterNetwork;
+    });
+    /** Fetches the Feemaster policy for the configured network. Cached for
+     *  5 minutes; pass `force: true` after a quota-exhausted response. */
+    fetchPolicy(force?: boolean): Promise<FeemasterPolicy>;
+    /** Returns true when the configured network's policy permits sponsoring
+     *  `(programId, functionName)`. Never throws — returns false on any
+     *  policy fetch failure so callers can fall back to user-paid. */
+    isCovered(programId: string, functionName: string): Promise<boolean>;
+    /** Forwards a user-signed Aleo Authorization to ANF (via redcoast) and
+     *  returns the corresponding `feeAuthorization` for bundling into a
+     *  ProvingRequest. Throws on quota / service errors so the caller falls
+     *  back to user-paid fees. */
+    requestFeeAuthorization(params: {
+        /** User Authorization serialized via `Authorization.toString()`. */
+        authorizationString: string;
+        priorityFee?: number;
+    }): Promise<{
+        feeAuthorizationString: string;
+    }>;
+}
+//# sourceMappingURL=feemasterClient.d.ts.map

package/src/client/feemasterClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feemasterClient.d.ts","sourceRoot":"","sources":["../../src/client/feemasterClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,eAAe;IAC9B,0DAA0D;IAC1D,gBAAgB,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAAC;CACjD;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,CAAC;AAIrD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,WAAW,CAA8D;gBAErE,IAAI,EAAE;QAAE,SAAS,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAA;KAAE;IAK5E;0EACsE;IAChE,WAAW,CAAC,KAAK,UAAQ,GAAG,OAAO,CAAC,eAAe,CAAC;IAW1D;;sEAEkE;IAC5D,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAwB1E;;;kCAG8B;IACxB,uBAAuB,CAAC,MAAM,EAAE;QACpC,oEAAoE;QACpE,mBAAmB,EAAE,MAAM,CAAC;QAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC;QAAE,sBAAsB,EAAE,MAAM,CAAA;KAAE,CAAC;CAQhD"}

package/src/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client.js';
+//# sourceMappingURL=index.d.ts.map

package/src/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/src/client/redcoastRecordScanner.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Iframe-side RecordScanner that mirrors the Provable SDK's surface but
+ * routes every HTTP call through redcoast. This is the Phase A2 swap —
+ * before this, the iframe held a hardcoded scanner apiKey + consumerId;
+ * now those credentials live in redcoast env vars and the iframe
+ * authenticates via the user's Dynamic JWT (handled by `DynamicApiClient`).
+ *
+ * What stays in the iframe:
+ *   - The `crypto_box_seal` wrap of the view key (`encryptRegistrationRequest`
+ *     from the Provable SDK). The view key plaintext never leaves the
+ *     iframe; only its encrypted form crosses the wire.
+ *
+ * What now lives in redcoast:
+ *   - The Provable Bearer apiKey + consumerId.
+ *   - JWT lifecycle (the SDK used to manage this in the browser; redcoast
+ *     manages it server-side now and the iframe is unaware).
+ *
+ * The class signature intentionally matches the parts of `sdk.RecordScanner`
+ * the iframe consumes (`registerEncrypted`, `findRecords`) so the rest of
+ * `DynamicAleoWalletClient.findOwnedRecordsInner` doesn't change.
+ */
+import type { DynamicApiClient } from '@dynamic-labs-wallet/core';
+export type RedcoastRecordScannerNetwork = 'mainnet' | 'testnet';
+interface ProvableSdkLike {
+    /** `encryptRegistrationRequest(public_key: string, viewKey: ViewKey, start: number) → ciphertext (base64).`
+     *  Exported by both `@provablehq/sdk/testnet.js` and `mainnet.js`. */
+    encryptRegistrationRequest: (publicKey: string, viewKey: unknown, start: number) => string;
+}
+export type RegisterResult = {
+    ok: true;
+    data: {
+        uuid: string;
+    } & Record<string, unknown>;
+} | {
+    ok: false;
+    status?: number;
+    error?: {
+        message?: string;
+    };
+};
+export type FindRecordsFilter = {
+    uuid: string;
+    decrypt?: boolean;
+    unspent?: boolean;
+    filter?: Record<string, unknown>;
+};
+export declare class RedcoastRecordScanner {
+    private readonly apiClient;
+    private readonly network;
+    private readonly sdk;
+    constructor(args: {
+        apiClient: DynamicApiClient;
+        network: RedcoastRecordScannerNetwork;
+        /** Network-specific Provable SDK build. Used only for the
+         *  `encryptRegistrationRequest` helper (libsodium `crypto_box_seal`).
+         *  Must be the same network as `network`. */
+        sdk: ProvableSdkLike;
+    });
+    /**
+     * Registers an encrypted view key with the scanner. Mirrors
+     * `sdk.RecordScanner.registerEncrypted(viewKey, startBlock)`:
+     *
+     *   1. GET `/scanner/pubkey` → ephemeral public key
+     *   2. Wrap `(viewKey, startBlock)` via libsodium `crypto_box_seal`
+     *   3. POST `/scanner/register` with `{ key_id, ciphertext }`
+     *
+     * Returns the SDK-shaped Result so callers don't have to change.
+     */
+    registerEncrypted(viewKey: unknown, startBlock: number): Promise<RegisterResult>;
+    /**
+     * Find owned records by uuid. Mirrors the subset of
+     * `sdk.RecordScanner.findRecords(filter)` the iframe consumes.
+     *
+     * The SDK's filter shape is `{ uuid, decrypt, unspent, filter, ... }`.
+     * We forward it verbatim. Records returned are still encrypted on
+     * the wire; the caller (`DynamicAleoWalletClient.findOwnedRecordsInner`)
+     * decrypts them locally with the view key — same as before A2, just
+     * with a different transport underneath.
+     */
+    findRecords(filter: FindRecordsFilter): Promise<unknown[]>;
+    /** Optional but useful for parity with the SDK; not currently called. */
+    revoke(uuid: string): Promise<Record<string, unknown>>;
+}
+export {};
+//# sourceMappingURL=redcoastRecordScanner.d.ts.map

package/src/client/redcoastRecordScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redcoastRecordScanner.d.ts","sourceRoot":"","sources":["../../src/client/redcoastRecordScanner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,MAAM,MAAM,4BAA4B,GAAG,SAAS,GAAG,SAAS,CAAC;AAEjE,UAAU,eAAe;IACvB;0EACsE;IACtE,0BAA0B,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5F;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC9D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAEjE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;gBAE1B,IAAI,EAAE;QAChB,SAAS,EAAE,gBAAgB,CAAC;QAC5B,OAAO,EAAE,4BAA4B,CAAC;QACtC;;qDAE6C;QAC7C,GAAG,EAAE,eAAe,CAAC;KACtB;IAMD;;;;;;;;;OASG;IACG,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAmBtF;;;;;;;;;OASG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAQhE,yEAAyE;IACnE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAM7D"}