@provablehq/sdk 0.9.16-rc → 0.9.17

package/dist/{testnet/keys/provider/function-key-provider.d.ts → mainnet/keys/provider/memory.d.ts}

@@ -1,19 +1,13 @@
-import { Key } from "../../constants";
-import { CachedKeyPair, FunctionKeyPair } from "../../models/keyPair";
-import { KeyStore } from "../keystore/keystore";
-import { ProvingKey, VerifyingKey } from "../../wasm";
+import { Key } from "../../constants.js";
+import { CachedKeyPair, FunctionKeyPair } from "../../models/keyPair.js";
+import { FunctionKeyProvider, KeySearchParams } from "./interface";
+import { ProvingKey, VerifyingKey } from "../../wasm.js";
+import { KeyStore } from "../keystore/interface.js";
 type AleoKeyProviderInitParams = {
     proverUri?: string;
     verifierUri?: string;
     cacheKey?: string;
 };
-/**
- * Interface for record search parameters. This allows for arbitrary search parameters to be passed to record provider
- * implementations.
- */
-interface KeySearchParams {
-    [key: string]: any;
-}
 /**
  * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
  * verifierUri to fetch keys via HTTP from a remote resource as well as a unique cacheKey to store the keys in memory.
@@ -39,168 +33,8 @@ declare class AleoKeyProviderParams implements KeySearchParams {
     });
 }
 /**
- * KeyProvider interface. Enables the retrieval of public proving and verifying keys for Aleo Programs.
- */
-interface FunctionKeyProvider {
-    /**
-     * Get bond_public function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the bond_public function
-     */
-    bondPublicKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Get bond_validator function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the bond_validator function
-     */
-    bondValidatorKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Cache a set of keys. This will overwrite any existing keys with the same keyId. The user can check if a keyId
-     * exists in the cache using the containsKeys method prior to calling this method if overwriting is not desired.
-     *
-     * @param {string} keyId access key for the cache
-     * @param {FunctionKeyPair} keys keys to cache
-     */
-    cacheKeys(keyId: string, keys: FunctionKeyPair): void;
-    /**
-     * Get unbond_public function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the unbond_public function
-     */
-    claimUnbondPublicKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Get arbitrary function keys from a provider
-     *
-     * @param {KeySearchParams | undefined} params - Optional search parameters for the key provider
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the specified program
-     *
-     * @example
-     * // Create a search object which implements the KeySearchParams interface
-     * class IndexDbSearch implements KeySearchParams {
-     *     db: string
-     *     keyId: string
-     *     constructor(params: {db: string, keyId: string}) {
-     *         this.db = params.db;
-     *         this.keyId = params.keyId;
-     *     }
-     * }
-     *
-     * // Create a new object which implements the KeyProvider interface
-     * class IndexDbKeyProvider implements FunctionKeyProvider {
-     *     async functionKeys(params: KeySearchParams): Promise<FunctionKeyPair> {
-     *         return new Promise((resolve, reject) => {
-     *             const request = indexedDB.open(params.db, 1);
-     *
-     *             request.onupgradeneeded = function(e) {
-     *                 const db = e.target.result;
-     *                 if (!db.objectStoreNames.contains('keys')) {
-     *                     db.createObjectStore('keys', { keyPath: 'id' });
-     *                 }
-     *             };
-     *
-     *             request.onsuccess = function(e) {
-     *                 const db = e.target.result;
-     *                 const transaction = db.transaction(["keys"], "readonly");
-     *                 const store = transaction.objectStore("keys");
-     *                 const request = store.get(params.keyId);
-     *                 request.onsuccess = function(e) {
-     *                     if (request.result) {
-     *                         resolve(request.result as FunctionKeyPair);
-     *                     } else {
-     *                         reject(new Error("Key not found"));
-     *                     }
-     *                 };
-     *                 request.onerror = function(e) { reject(new Error("Error fetching key")); };
-     *             };
-     *
-     *             request.onerror = function(e) { reject(new Error("Error opening database")); };
-     *         });
-     *     }
-     *
-     *     // implement the other methods...
-     * }
-     *
-     *
-     * const keyProvider = new AleoKeyProvider();
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
-     *
-     * // Keys can also be fetched manually
-     * const searchParams = new IndexDbSearch({db: "keys", keyId: "credits.aleo:transferPrivate"});
-     * const [transferPrivateProvingKey, transferPrivateVerifyingKey] = await keyProvider.functionKeys(searchParams);
-     */
-    functionKeys(params?: KeySearchParams): Promise<FunctionKeyPair>;
-    /**
-     * Gets an object which implements the `KeyStore` interface key store object for accessing proving and verifying
-     * keys directly from persistent storage.
-     *
-     * @return {KeyStore}
-     */
-    keyStore(): Promise<KeyStore | undefined>;
-    /**
-     * Get fee_private function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
-     */
-    feePrivateKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Get fee_public function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
-     */
-    feePublicKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Get keys for the inclusion proof.
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
-     */
-    inclusionKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Get join function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
-     */
-    joinKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Get split function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
-     */
-    splitKeys(): Promise<FunctionKeyPair>;
-    /**
-     * Get keys for a variant of the transfer function from the credits.aleo program
-     *
-     * @param {string} visibility Visibility of the transfer function (private, public, privateToPublic, publicToPrivate)
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the specified transfer function
-     *
-     * @example
-     * // Create a new object which implements the KeyProvider interface
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
-     *
-     * // Keys can also be fetched manually
-     * const [transferPublicProvingKey, transferPublicVerifyingKey] = await keyProvider.transferKeys("public");
-     */
-    transferKeys(visibility: string): Promise<FunctionKeyPair>;
-    /**
-     * Get unbond_public function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
-     */
-    unBondPublicKeys(): Promise<FunctionKeyPair>;
-}
-/**
- * AleoKeyProvider class. Implements the KeyProvider interface. Enables the retrieval of Aleo program proving and
- * verifying keys for the credits.aleo program over http from official Aleo sources and storing and retrieving function
+ * AleoKeyProvider class. Implements the FunctionKeyProvider interface. Enables the retrieval of Aleo program proving and
+ * verifying keys for the credits.aleo program over HTTP from official Aleo sources and storing and retrieving function
  * keys from a local memory cache.
  */
 declare class AleoKeyProvider implements FunctionKeyProvider {
@@ -257,12 +91,12 @@ declare class AleoKeyProvider implements FunctionKeyProvider {
      *
      * @example
      * // Create a new object which implements the KeyProvider interface
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+     * const networkClient = new AleoNetworkClient("https://api.provable.com/v2");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.provable.com/v2", keyProvider, recordProvider);
      * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
      *
      * // Keys can also be fetched manually using the key provider
@@ -281,12 +115,12 @@ declare class AleoKeyProvider implements FunctionKeyProvider {
      *
      * @example
      * // Create a new AleoKeyProvider object
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+     * const networkClient = new AleoNetworkClient("https://api.provable.com/v2");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.provable.com/v2", keyProvider, recordProvider);
      * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
      *
      * // Keys can also be fetched manually
@@ -316,12 +150,12 @@ declare class AleoKeyProvider implements FunctionKeyProvider {
      *
      * @example
      * // Create a new AleoKeyProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+     * const networkClient = new AleoNetworkClient("https://api.provable.com/v2");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.provable.com/v2", keyProvider, recordProvider);
      * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
      *
      * // Keys can also be fetched manually
@@ -372,4 +206,4 @@ declare class AleoKeyProvider implements FunctionKeyProvider {
     getVerifyingKey(verifierUri: string): Promise<VerifyingKey>;
     unBondPublicKeys(): Promise<FunctionKeyPair>;
 }
-export { AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, FunctionKeyProvider, KeySearchParams };
+export { AleoKeyProvider, AleoKeyProviderInitParams, AleoKeyProviderParams };

package/dist/{testnet/keys/provider/offline-key-provider.d.ts → mainnet/keys/provider/offline.d.ts}

@@ -1,7 +1,7 @@
-import { FunctionKeyProvider, KeySearchParams } from "./function-key-provider.js";
+import { FunctionKeyProvider, KeySearchParams } from "./interface.js";
 import { CachedKeyPair, FunctionKeyPair } from "../../models/keyPair.js";
 import { ProvingKey, VerifyingKey } from "../../wasm.js";
-import { KeyStore } from "../keystore/keystore.js";
+import { KeyStore } from "../keystore/interface.js";
 /**
  * Search parameters for the offline key provider. This class implements the KeySearchParams interface and includes
  * a convenience method for creating a new instance of this class for each function of the credits.aleo program.
@@ -34,7 +34,7 @@ declare class OfflineSearchParams implements KeySearchParams {
      */
     static bondValidatorKeyParams(): OfflineSearchParams;
     /**
-     * Create a new OfflineSearchParams instance for the claim_unbond_public function of the
+     * Create a new OfflineSearchParams instance for the claim_unbond_public function of the credits.aleo program.
      */
     static claimUnbondPublicKeyParams(): OfflineSearchParams;
     /**
@@ -134,7 +134,7 @@ declare class OfflineSearchParams implements KeySearchParams {
  * const offlineExecuteTx = <Transaction>await this.buildExecutionTransaction("hello_hello.aleo", "hello", 1, false, ["5u32", "5u32"], undefined, offlineSearchParams, undefined, undefined, undefined, undefined, offlineQuery, program);
  *
  * // Broadcast the transaction later on a machine with internet access
- * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+ * const networkClient = new AleoNetworkClient("https://api.provable.com/v2");
  * const txId = await networkClient.broadcastTransaction(offlineExecuteTx);
  */
 declare class OfflineKeyProvider implements FunctionKeyProvider {

package/dist/mainnet/keys/verifier/interface.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Fingerprint for a proving and verifying key that includes the checksum of the bytes and size in number of bytes.
+ *
+ * @property {string} checksum - SHA-256 checksum of the key bytes.
+ * @property {number} size - Size of the key in number of bytes.
+ */
+export interface KeyFingerprint {
+    checksum: string;
+    size: number;
+}
+/**
+ * Options for verifying the integrity of proving and verifying keys. An identifier to allow the interface to find key metadata and/or the desired metadata to verify must be passed in.
+ *
+ * @property {Uint8Array} keyBytes - The raw bytes of the cryptographic key.
+ * @property {string} [locator] - Optional identifier or path indicating where the key or KeyFingerprint might be stored.
+ * @property {KeyFingerprint} [fingerprint] - Optional metadata containing the key's expected checksum and size for verification purposes.
+ */
+export interface KeyMetadata {
+    keyBytes: Uint8Array;
+    locator?: string;
+    fingerprint?: KeyFingerprint;
+}
+/**
+ * Error thrown when there is a mismatch between expected and actual key metadata.
+ * This can occur during verification of either the checksum or size of a key.
+ *
+ * @extends Error
+ */
+export declare class KeyVerificationError extends Error {
+    readonly locator: string;
+    readonly field: "checksum" | "size";
+    readonly expected: string;
+    readonly actual: string;
+    /**
+     * Creates a new KeyVerificationError instance (error.name is "ChecksumMismatchError").
+     *
+     * @param {string} locator - The key locator where the mismatch occurred.
+     * @param {"checksum" | "size"} field - The field that failed verification (either "checksum" or "size").
+     * @param {string} expected - The expected value of the field.
+     * @param {string} actual - The actual value encountered.
+     */
+    constructor(locator: string, field: "checksum" | "size", expected: string, actual: string);
+}
+/**
+ * Computes the SHA-256 checksum of a given set of bytes.
+ *
+ * @param {Uint8Array} bytes - The bytes to compute the checksum of.
+ */
+export declare function sha256Hex(bytes: Uint8Array): Promise<string>;
+/**
+ * Verifies key-pair metadata (checksums and sizes) against raw bytes in order to ensure the correct keypair is used.
+ * Implementations throw {@link KeyVerificationError} when verification fails.
+ */
+export interface KeyVerifier {
+    /**
+     * Computes and optionally stores key metadata. If keyFingerprint is provided, verifies against it.
+     * @param {KeyMetadata} keyMetadata - Object containing key bytes and optional verification data.
+     * @throws {KeyVerificationError} When provided keyFingerprint doesn't match computed values.
+     * @returns {Promise<KeyFingerprint>} Computed key metadata.
+     */
+    computeKeyMetadata(keyMetadata: KeyMetadata): Promise<KeyFingerprint>;
+    /**
+     * Verifies prover bytes against key metadata (size + checksum).
+     *
+     * @param {KeyMetadata} keyMetadata - Object containing the key bytes, an optional locator and optional metadata for verification.
+     * @throws {KeyVerificationError} when size or checksum does not match.
+     * @returns {Promise<void>} Promise that resolves when verification succeeds.
+     */
+    verifyKeyBytes(keyMetadata: KeyMetadata): Promise<void>;
+}

package/dist/mainnet/keys/verifier/memory.d.ts

@@ -0,0 +1,37 @@
+import { KeyVerifier, KeyFingerprint, KeyMetadata } from "./interface";
+/**
+ * In-memory implementation of KeyVerifier that stores and verifies key fingerprints.
+ * Provides functionality to compute and verify cryptographic checksums of keys, storing them
+ * in memory for subsequent verification. This implementation is primarily used for testing
+ * and development purposes where persistence is not required.
+ *
+ * Key features:
+ * - Computes SHA-256 checksums and sizes for key bytes.
+ * - Stores key fingerprints in memory using string locators.
+ * - Verifies key bytes against stored or provided fingerprints.
+ *
+ * @implements {KeyVerifier}
+ */
+export declare class MemKeyVerifier implements KeyVerifier {
+    private keyStore;
+    /**
+     * Computes and optionally stores key metadata. If a keyFingerprint is provided, this function will verify the computed checksum against it before storing it.
+     *
+     * @param {KeyMetadata} keyMetadata - Object containing key bytes and optional verification data.
+     * @throws {KeyVerificationError} When provided keyFingerprint doesn't match computed values.
+     * @returns {Promise<KeyFingerprint>} Computed key metadata.
+     */
+    computeKeyMetadata(keyMetadata: KeyMetadata): Promise<KeyFingerprint>;
+    /**
+     * Verifies key bytes against stored or provided metadata. Follows a priority verification scheme:
+     * 1. If KeyFingerprint is provided in the metadata, this method verifies against that first.
+     * 2. If a locator is provided, attempts to verify against stored fingerprint.
+     * 3. If neither is available, throws an error.
+     *
+     * @param {KeyMetadata} keyMetadata - Object containing the key bytes and optional verification metadata.
+     * @throws {Error} When neither fingerprint nor valid locator is provided for verification.
+     * @throws {KeyVerificationError} When size or checksum verification fails.
+     * @returns {Promise<void>} Promise that resolves when verification succeeds.
+     */
+    verifyKeyBytes(keyMetadata: KeyMetadata): Promise<void>;
+}

package/dist/mainnet/models/cryptoBoxPubkey.d.ts

@@ -0,0 +1,4 @@
+export interface CryptoBoxPubKey {
+    key_id: string;
+    public_key: string;
+}

package/dist/mainnet/models/encryptedProvingRequest.d.ts

@@ -0,0 +1,4 @@
+export interface EncryptedProvingRequest {
+    key_id: string;
+    ciphertext: string;
+}

package/dist/mainnet/models/provingResponse.d.ts

@@ -1,5 +1,51 @@
-import { TransactionJSON } from "./transaction/transactionJSON";
+import { TransactionJSON } from "./transaction/transactionJSON.js";
+/** HTTP status and optional message from snarkOS broadcast (Accepted/Rejected variants). */
+export interface BroadcastResponse {
+    status_code: bigint | number;
+    message?: string;
+}
+/** Result of the optional broadcast step. Discriminated by `status`. */
+export type BroadcastResult = {
+    status: "Accepted";
+    status_code: bigint | number;
+    message?: string;
+} | {
+    status: "Rejected";
+    status_code: bigint | number;
+    message?: string;
+} | {
+    status: "Failed";
+    message: string;
+} | {
+    status: "Skipped";
+};
+/** Success response body for POST /prove (HTTP 200). */
 export interface ProvingResponse {
     transaction: TransactionJSON;
-    broadcast?: boolean;
+    broadcast_result: BroadcastResult;
+}
+/** Error response body for POST /prove (HTTP 400, 500, 503). Same shape for all error cases. */
+export interface ProveApiErrorBody {
+    message: string;
+}
+/** Error thrown on prove API failure; `status` is set for retry logic (e.g. retryWithBackoff checks error.status >= 500). */
+export interface ProvingRequestError extends Error {
+    status?: number;
+}
+/** Success variant of a proving request result. */
+export interface ProvingSuccess {
+    ok: true;
+    data: ProvingResponse;
+}
+/** Failure variant of a proving request result (HTTP 400, 500, 503). */
+export interface ProvingFailure {
+    ok: false;
+    status: number;
+    error: ProveApiErrorBody;
 }
+/** Result of a proving request. Type used to give callers the ability to self-handle errors. */
+export type ProvingResult = ProvingSuccess | ProvingFailure;
+/** Type guard: value is a ProvingResponse. */
+export declare function isProvingResponse(value: unknown): value is ProvingResponse;
+/** Type guard: value is a ProveApiErrorBody. */
+export declare function isProveApiErrorBody(value: unknown): value is ProveApiErrorBody;

package/dist/mainnet/models/record-scanner/encryptedRecordsResult.d.ts

@@ -0,0 +1,7 @@
+import type { RecordScannerFailure } from "./error.js";
+import type { EncryptedRecord } from "../record-provider/encryptedRecord.js";
+export interface EncryptedRecordsSuccess {
+    ok: true;
+    data: EncryptedRecord[];
+}
+export type EncryptedRecordsResult = EncryptedRecordsSuccess | RecordScannerFailure;

package/dist/mainnet/models/record-scanner/encryptedRegistrationRequest.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Payload for the /register/encrypted record scanner endpoint.
+ * Contains the ephemeral key id and the sealed ciphertext of the registration request.
+ */
+export interface EncryptedRegistrationRequest {
+    key_id: string;
+    ciphertext: string;
+}

package/dist/mainnet/models/record-scanner/error.d.ts

@@ -0,0 +1,47 @@
+import { OwnedFilter } from "./ownedFilter";
+/**
+ * Error thrown when a record scanner request fails (e.g. /register, /register/encrypted).
+ * Includes HTTP status so callers can handle 422 vs 500 etc.
+ */
+export declare class RecordScannerRequestError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/** Error thrown when findCreditsRecord or findCreditsRecords is called but decryption is not enabled on the record scanner. */
+export declare class DecryptionNotEnabledError extends Error {
+    readonly filter?: OwnedFilter;
+    constructor(message: string, filter?: OwnedFilter);
+}
+/** Error thrown when findCreditsRecord or findCreditsRecords is called but no view key for the UUID is stored in viewKeys or the account. */
+export declare class ViewKeyNotStoredError extends Error {
+    readonly uuid?: string;
+    readonly filter?: OwnedFilter;
+    constructor(message: string, uuid?: string, filter?: OwnedFilter);
+}
+/** Error thrown when no record matches the supplied search filter (e.g. findCreditsRecord / findCreditsRecords). */
+export declare class RecordNotFoundError extends Error {
+    readonly filter?: OwnedFilter;
+    constructor(message: string, filter?: OwnedFilter);
+}
+/** Error thrown when no UUID is configured, the UUID is invalid, or a record scanner request fails due to an invalid UUID/response. */
+export declare class UUIDError extends Error {
+    readonly uuid?: string;
+    readonly filter?: OwnedFilter;
+    constructor(message: string, uuid?: string, filter?: OwnedFilter);
+}
+/** General error payload returned from record-scanner endpoints on failure. */
+export interface RecordScannerErrorBody {
+    /** Raw error text returned by the service. */
+    message: string;
+    /** HTTP status code from the response. */
+    status: number;
+}
+/**
+ * Failure variant shared by record-scanner result types.
+ * Use with a success interface to form a discriminated union (e.g. Success | RecordScannerFailure).
+ */
+export interface RecordScannerFailure {
+    ok: false;
+    status: number;
+    error: RecordScannerErrorBody;
+}

package/dist/mainnet/models/record-scanner/ownedFilter.d.ts

@@ -8,7 +8,6 @@ import { OwnedRecordsResponseFilter } from "./ownedRecordsResponseFilter";
  * const ownedFilter: OwnedFilter = {
  *     unspent: true,
  *     nonces: ["3077450429259593211617823051143573281856129402760267155982965992208217472983group"],
- *     decrypt: true,
  *     filter: {
  *         program: "credits.aleo",
  *         record: "credits",
@@ -16,7 +15,6 @@ import { OwnedRecordsResponseFilter } from "./ownedRecordsResponseFilter";
  * }
  */
 export interface OwnedFilter extends RecordSearchParams {
-    decrypt?: boolean;
     filter?: RecordsFilter;
     responseFilter?: OwnedRecordsResponseFilter;
     unspent?: boolean;

package/dist/mainnet/models/record-scanner/ownedRecordsResult.d.ts

@@ -0,0 +1,13 @@
+import type { RecordScannerFailure } from "./error.js";
+import type { OwnedRecord } from "../record-provider/ownedRecord.js";
+/**
+ * Success variant of ownedRecords() result.
+ *
+ * @property ok - Whether the request was successful, always true for this interface variant.
+ * @property data - List of owned records corresponding to the filter used.
+ */
+export interface OwnedRecordsSuccess {
+    ok: true;
+    data: OwnedRecord[];
+}
+export type OwnedRecordsResult = OwnedRecordsSuccess | RecordScannerFailure;

package/dist/mainnet/models/record-scanner/registrationResponse.d.ts

@@ -4,12 +4,10 @@
  * @example
  * const registrationResponse: RegistrationResponse = {
  *     uuid: "5291249998620209321712738612705518874926462927543783711572375085855029172391field",
- *     job_id: "3019177021147406178755252788128212930359855601860174268911518336835545087409field",
  *     status: "pending",
  * }
  */
 export interface RegistrationResponse {
     uuid: string;
-    job_id?: string;
     status?: string;
 }

package/dist/mainnet/models/record-scanner/registrationResult.d.ts

@@ -0,0 +1,9 @@
+import type { RecordScannerFailure } from "./error.js";
+import type { RegistrationResponse } from "./registrationResponse.js";
+/** Success variant of registration result. */
+export interface RegisterSuccess {
+    ok: true;
+    data: RegistrationResponse;
+}
+/** Result of register() and registerEncrypted(); never throws on HTTP error. */
+export type RegisterResult = RegisterSuccess | RecordScannerFailure;

package/dist/mainnet/models/record-scanner/revokeResult.d.ts

@@ -0,0 +1,17 @@
+import type { RecordScannerFailure } from "./error.js";
+/**
+ * Response from the record scanning service's revoke endpoint on success.
+ *
+ * @example
+ * const revokeResponse: RevokeResponse = { status: "OK" };
+ */
+export interface RevokeResponse {
+    status: string;
+}
+/** Success variant of revoke result. */
+export interface RevokeSuccess {
+    ok: true;
+    data: RevokeResponse;
+}
+/** Result of revoke(); never throws on HTTP error. */
+export type RevokeResult = RevokeSuccess | RecordScannerFailure;

package/dist/mainnet/models/record-scanner/serialNumbersResult.d.ts

@@ -0,0 +1,15 @@
+import type { RecordScannerFailure } from "./error.js";
+/**
+ * Success variant of serialNumbers() result.
+ *
+ * @property ok - Whether the request was successful, always true for this interface.
+ * @property data - A map of serial numbers to whether they are owned by the account.
+ */
+export interface SerialNumbersSuccess {
+    ok: true;
+    data: Record<string, boolean>;
+}
+/**
+ * Success or failure variant of serialNumbers() result.
+ */
+export type SerialNumbersResult = SerialNumbersSuccess | RecordScannerFailure;

package/dist/mainnet/models/record-scanner/statusResult.d.ts

@@ -0,0 +1,13 @@
+import type { RecordScannerFailure } from "./error.js";
+import type { StatusResponse } from "./statusResponse.js";
+/**
+ * Success variant of status() result.
+ *
+ * @property ok - Whether the request was successful, always true for this interface variant.
+ * @property data - StatusResponse returned by the server.
+ */
+export interface StatusSuccess {
+    ok: true;
+    data: StatusResponse;
+}
+export type StatusResult = StatusSuccess | RecordScannerFailure;

package/dist/mainnet/models/record-scanner/tagsResult.d.ts

@@ -0,0 +1,12 @@
+import type { RecordScannerFailure } from "./error.js";
+/**
+ * Success variant of tags() result.
+ *
+ * @property ok - Whether the request was successful, always true for this interface variant.
+ * @property data - A map of tags to whether they are owned by the account.
+ */
+export interface TagsSuccess {
+    ok: true;
+    data: Record<string, boolean>;
+}
+export type TagsResult = TagsSuccess | RecordScannerFailure;