@provablehq/sdk 0.9.18 → 0.10.0

package/dist/mainnet/external-signing.d.ts

@@ -0,0 +1,76 @@
+import { ExecutionRequest } from "./wasm.js";
+import type { ExternalSigningInput, ExternalSigningOptions, ExecutionRequestParams, InputStrategy } from "./models/external-signing.js";
+export * from "./models/external-signing.js";
+/**
+ * Build an ExecutionRequest from externally signed data.
+ *
+ * The `strategy` parameter determines how record input IDs are resolved:
+ * - `{ recordViewKeys?, gammas? }` — explicit record view keys and gammas
+ * - `{ viewKey, gammas? }` — derive record view keys from a ViewKey
+ * - `{ inputIds }` — pre-computed input IDs (Field or [Field, Group, Field, Field, Field] tuples)
+ *
+ * @throws {Error} If `strategy` is not a valid `InputStrategy` variant.
+ *
+ * @example
+ * // With explicit record view keys
+ * buildExecutionRequestFromExternallySignedData(
+ *   { programId, functionName, inputs, inputTypes, signature, tvk, signer, skTag },
+ *   { recordViewKeys: [...], gammas: [...] },
+ * );
+ *
+ * // With a view key
+ * buildExecutionRequestFromExternallySignedData(
+ *   { programId, functionName, inputs, inputTypes, signature, tvk, signer, skTag },
+ *   { viewKey: "AViewKey1..." },
+ * );
+ *
+ * // With pre-computed input IDs
+ * buildExecutionRequestFromExternallySignedData(
+ *   { programId, functionName, inputs, inputTypes, signature, tvk, signer, skTag },
+ *   { inputIds: [...] },
+ * );
+ */
+export declare function buildExecutionRequestFromExternallySignedData(params: ExecutionRequestParams, strategy?: InputStrategy): ExecutionRequest;
+/**
+ * Computes the function ID and serialized input data for a program function call.
+ * Used by external signing wallets and other applications that need publicly computable inputs
+ * for building a signed execution request (e.g. before calling {@link ExecutionRequest.sign}).
+ *
+ * The optional `outputFormat` field controls how field elements are returned:
+ * - `"string"` (default) — human-readable strings like `"123field"`
+ * - `"bytes"` — raw little-endian `Uint8Array`s
+ *
+ * @param {ExternalSigningOptions} options - Program name, function name, inputs, input_types, root flag, an optional program checksum, an optional view key, and an optional output format.
+ * @throws Throws if parsing the program ID, function name, or inputs fails or if the inputs do not match the type signatures passed in the input_types parameter.
+ *
+ * @example
+ * // String output (default)
+ * const result = await computeExternalSigningInputs({
+ *   programName: "credits.aleo",
+ *   functionName: "transfer_public",
+ *   inputs: ["aleo1...", "100u64"],
+ *   inputTypes: ["address.public", "u64.public"],
+ *   isRoot: true,
+ * });
+ * result.functionId; // string
+ *
+ * @example
+ * // Bytes output
+ * const result = await computeExternalSigningInputs({
+ *   programName: "credits.aleo",
+ *   functionName: "transfer_public",
+ *   inputs: ["aleo1...", "100u64"],
+ *   inputTypes: ["address.public", "u64.public"],
+ *   isRoot: true,
+ *   outputFormat: "bytes",
+ * });
+ * result.functionId; // Uint8Array
+ *
+ * @returns {ExternalSigningInput} A JSON object for inputs to external signing algorithms.
+ */
+export declare function computeExternalSigningInputs(options: ExternalSigningOptions & {
+    outputFormat: "bytes";
+}): Promise<ExternalSigningInput<"bytes">>;
+export declare function computeExternalSigningInputs(options: ExternalSigningOptions & {
+    outputFormat?: "string";
+}): Promise<ExternalSigningInput<"string">>;

package/dist/mainnet/keys/keystore/error.d.ts

@@ -1,10 +1,11 @@
 /**
  * Reason code for invalid locator validation failures.
- * - `"reserved_name"`: Locator is empty or the reserved name `"."` or `".."`.
- * - `"path_traversal"`: Locator contains `..`.
- * - `"path_separator"`: Locator contains a path separator (`/`, `\`) or null byte.
+ * - `"reserved_name"`: A locator component is empty or `"."`.
+ * - `"path_traversal"`: A locator component contains `..`.
+ * - `"path_separator"`: A locator component contains a path separator (`/`, `\`) or null byte.
+ * - `"negative_value"`: A numeric locator field (edition, amendment, recordInputPosition) is not a non-negative integer.
  */
-export type InvalidLocatorReason = "reserved_name" | "path_traversal" | "path_separator";
+export type InvalidLocatorReason = "reserved_name" | "path_traversal" | "path_separator" | "negative_value";
 /**
  * Error thrown when a key locator is invalid for filesystem use.
  * Used to prevent path traversal and other filesystem injection when deriving paths from locators.

package/dist/mainnet/keys/keystore/file.d.ts

@@ -1,6 +1,6 @@
 import { FunctionKeyPair } from "../../models/keyPair.js";
 import { KeyFingerprint } from "../verifier/interface.js";
-import { KeyLocator, KeyStore } from "./interface.js";
+import { KeyLocator, KeyStore, ProvingKeyLocator, VerifyingKeyLocator } from "./interface.js";
 import { ProvingKey, VerifyingKey } from "../../wasm.js";
 export declare class LocalFileKeyStore implements KeyStore {
     private directory;
@@ -15,13 +15,45 @@ export declare class LocalFileKeyStore implements KeyStore {
      */
     constructor(directory?: string);
     /**
-     * Validates that a locator is a safe filesystem identifier.
+     * Validates a single locator component for unsafe filesystem characters.
      *
      * @private
-     * @param {string} locator - Unique identifier used to derive a metadata file path.
-     * @throws {InvalidLocatorError} If the locator could cause path traversal.
+     * @param {string} value - The component value to validate.
+     * @param {string} label - Label for error messages (e.g. "program", "functionName").
+     * @throws {InvalidLocatorError} If the value is empty, contains traversal sequences, path separators, or null bytes.
      */
-    private validateLocator;
+    private validateComponent;
+    /**
+     * Validates that a numeric locator field is not negative.
+     *
+     * @private
+     * @param {number} value - The numeric value to validate.
+     * @param {string} label - Label for error messages (e.g. "edition", "amendment").
+     * @throws {InvalidLocatorError} If the value is negative.
+     */
+    private validateNonNegative;
+    /**
+     * Serializes a {@link KeyLocator} to a filesystem-safe flat string, validating components first.
+     *
+     * For prover/verifier keys: `{program}.{functionName}.e{edition}.a{amendment}.{network}.{keyType}`
+     * For translation keys: `{program}.{functionName}.e{edition}.a{amendment}.{network}.translation.{recordName}.{recordInputPosition}`
+     *
+     * Note: The optional `checksum` field is excluded — it is used for integrity verification only
+     * (via {@link checksumToFingerprint}) and is not part of the key identity.
+     *
+     * @private
+     * @param {KeyLocator} locator - The key locator.
+     * @returns {string} A dot-delimited string safe for use as a filename.
+     * @throws {InvalidLocatorError} If any component contains unsafe characters.
+     */
+    private serializeLocator;
+    /**
+     * Converts an optional checksum string from a locator into a KeyFingerprint
+     * suitable for the key verifier, using the actual key byte length for size.
+     *
+     * @private
+     */
+    private checksumToFingerprint;
     /**
      * Generates the path for a key metadata file based on the locator.
      *
@@ -72,146 +104,74 @@ export declare class LocalFileKeyStore implements KeyStore {
      */
     private clearDirectory;
     /**
-     * Retrieves the key bytes from storage and optionally verifies them against a fingerprint.
+     * Retrieves the key bytes from storage and optionally verifies them.
      *
-     * @param {KeyLocator} locator - Object containing a locator string for the key + optional fingerprint for verification.
-     * @returns {Promise<Uint8Array | null>} The key bytes if found and verified (if fingerprint provided), null if not found.
-     * @throws {KeyVerificationError} If fingerprint verification fails.
-     * @example
-     * const keyBytes = await getKeyBytes({
-     *   locator: 'transfer_private.prover.421e5a5',
-     *   fingerprint: { checksum: '421e5a52f01a1eeb068bbf56d15e19477ff7290e4b988d1013e15563f2b77801', size: 116746954 }
-     * });
-     * if (keyBytes) {
-     *   // Use the verified key bytes
-     * }
+     * @param {KeyLocator} locator - The key locator with optional checksum for verification.
+     * @returns {Promise<Uint8Array | null>} The key bytes if found and verified, null if not found.
+     * @throws {KeyVerificationError} If verification fails.
      */
     getKeyBytes(locator: KeyLocator): Promise<Uint8Array | null>;
     /**
      * Retrieves and verifies a proving key from storage.
      *
-     * @param {KeyLocator} locator - Object containing the proving key location and optional fingerprint.
+     * @param {ProvingKeyLocator} locator - The proving key locator.
      * @returns {Promise<ProvingKey | null>} The proving key if found and verified, null if not found.
-     * @throws {KeyVerificationError} If fingerprint verification fails.
+     * @throws {KeyVerificationError} If verification fails.
      * @throws {Error} If key bytes cannot be parsed into a valid ProvingKey.
-     *
-     * @example
-     * try {
-     *   const key = await getProvingKey({
-     *     locator: 'transfer_private.prover.421e5a5'
-     *   });
-     *   if (key) {
-     *     // Use the verified proving key
-     *   }
-     * } catch (err) {
-     *   if (err instanceof KeyVerificationError) {
-     *     // Handle verification failure.
-     *   } else {
-     *     // Handle key parsing error.
-     *   }
-     * }
-     */
-    getProvingKey(locator: KeyLocator): Promise<ProvingKey | null>;
+     */
+    getProvingKey(locator: ProvingKeyLocator): Promise<ProvingKey | null>;
     /**
      * Retrieves and verifies a verifying key from storage.
      *
-     * @param {KeyLocator} locator - Object containing the verifying key location and optional fingerprint.
+     * @param {VerifyingKeyLocator} locator - The verifying key locator.
      * @returns {Promise<VerifyingKey | null>} The verifying key if found and verified, null if not found.
-     * @throws {KeyVerificationError} If fingerprint verification fails.
+     * @throws {KeyVerificationError} If verification fails.
      * @throws {Error} If key bytes cannot be parsed into a valid VerifyingKey.
-     *
-     * @example
-     * try {
-     *   const key = await getVerifyingKey({
-     *     locator: 'transfer_private.verifier.4ac2f71'
-     *   });
-     *   if (key) {
-     *     // Use the verified verifying key
-     *   }
-     * } catch (err) {
-     *   if (err instanceof KeyVerificationError) {
-     *     // Handle verification failure.
-     *   } else {
-     *     // Handle key parsing error.
-     *   }
-     * }
-     */
-    getVerifyingKey(locator: KeyLocator): Promise<VerifyingKey | null>;
+     */
+    getVerifyingKey(locator: VerifyingKeyLocator): Promise<VerifyingKey | null>;
     /**
      * Stores proving and verifying keys in key storage.
      *
-     * @param {KeyLocator} proverLocator The unique locator for the desired proving key.
-     * @param {KeyLocator} verifierLocator The unique locator for the desired verifying key.
+     * @param {ProvingKeyLocator} proverLocator The locator for the proving key.
+     * @param {VerifyingKeyLocator} verifierLocator The locator for the verifying key.
      * @param {FunctionKeyPair} keys The proving and verifying keys.
-     *
-     * @example
-     * const keys = await generateKeys();
-     * await setKeys(
-     *   { locator: 'transfer_private.prover' },
-     *   { locator: 'transfer_private.verifier' },
-     *   keys
-     * );
      */
-    setKeys(proverLocator: KeyLocator, verifierLocator: KeyLocator, keys: FunctionKeyPair): Promise<void>;
+    setKeys(proverLocator: ProvingKeyLocator, verifierLocator: VerifyingKeyLocator, keys: FunctionKeyPair): Promise<void>;
     /**
-     * Store a raw proving or verifying key in storage along with its fingerprint metadata for future verification.
+     * Store a raw key in storage along with its fingerprint metadata for future verification.
      *
-     * @param {Uint8Array} keyBytes The raw proving and verifying key bytes.
-     * @param {KeyLocator} locator The unique locator for the desired key pair.
+     * @param {Uint8Array} keyBytes The raw key bytes.
+     * @param {KeyLocator} locator The unique locator for the key.
      * @returns {Promise<void>}
      * @throws {Error} If computing key metadata or writing to storage fails
-     *
-     * @example
-     * const keys = await generateKeys();
-     * await setKeyBytes(keys.provingKey.toBytes(), { locator: 'transfer_private.prover' });
      */
     setKeyBytes(keyBytes: Uint8Array, locator: KeyLocator): Promise<void>;
     /**
      * Returns stored metadata for a key, if any.
      *
-     * @param {string} locator The unique locator for the key.
-     * @returns {Promise<KeyFingerprint | null>} The stored fingerprint metadata for that locator, or null if none exists.
-     *
-     * @example
-     * const metadata = await getKeyMetadata('transfer_private.prover.421e5a5');
-     * if (metadata) {
-     *   // Use the stored metadata.
-     * }
+     * @param {KeyLocator} locator The unique locator for the key.
+     * @returns {Promise<KeyFingerprint | null>} The stored fingerprint metadata, or null if none exists.
      */
-    getKeyMetadata(locator: string): Promise<KeyFingerprint | null>;
+    getKeyMetadata(locator: KeyLocator): Promise<KeyFingerprint | null>;
     /**
-     * Checks if a key exists at the specified locator path.
+     * Checks if a key exists for the given locator.
      *
-     * @param {string} locator - Unique identifier for the key location.
-     * @returns {Promise<boolean>} True if key exists at location, false otherwise.
-     *
-     * @example
-     * const exists = await has('transfer_private.prover.421e5a5');
-     * if (exists) {
-     *   // Key exists at location.
-     * } else {
-     *   // Key does not exist at location.
-     * }
+     * @param {KeyLocator} locator - The unique key locator.
+     * @returns {Promise<boolean>} True if key exists, false otherwise.
      */
-    has(locator: string): Promise<boolean>;
+    has(locator: KeyLocator): Promise<boolean>;
     /**
      * Deletes a key and its associated metadata from storage. Silently ignores errors if files don't exist.
      *
-     * @param {string} locator - Unique identifier for the key to delete.
+     * @param {KeyLocator} locator - The unique key locator.
      * @returns {Promise<void>}
-     *
-     * @example
-     * await delete('transfer_private.prover.421e5a5');
      */
-    delete(locator: string): Promise<void>;
+    delete(locator: KeyLocator): Promise<void>;
     /**
      * Clears the key storage directory by recursively removing all files and subdirectories under it, then removes the keystore directory itself.
      *
      * @returns {Promise<void>}
      * @throws {Error} If directory listing fails for reasons other than non-existence.
-     *
-     * @example
-     * await clear(); // Removes all files under the keystore directory.
      */
     clear(): Promise<void>;
 }

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

@@ -4,18 +4,100 @@ export { InvalidLocatorError } from "./error.js";
 import { KeyFingerprint } from "../verifier/interface.js";
 import { ProvingKey, VerifyingKey } from "../../wasm.js";
 /**
- * The key locator string and optional fingerprint to verify the integrity of the key.
+ * Discriminates the type of key a locator refers to.
+ */
+export type KeyType = "prover" | "verifier" | "translation";
+/**
+ * Shared fields for all function key locators.
+ *
+ * @property {string} program - The program name (e.g. "credits.aleo").
+ * @property {string} functionName - The function name (e.g. "transfer_private").
+ * @property {number} edition - The program edition (u16). Incremented when a program is re-deployed.
+ * @property {number} amendment - The program amendment. Reserved for future protocol-level amendments; defaults to 0.
+ * @property {string} network - The network name (e.g. "mainnet", "testnet").
+ * @property {string} [checksum] - Optional SHA-256 checksum for key verification. Used for integrity verification only; not part of the key identity or serialized form.
+ */
+export interface BaseFunctionKeyLocator {
+    program: string;
+    functionName: string;
+    edition: number;
+    amendment: number;
+    network: string;
+    checksum?: string;
+}
+/**
+ * Locator for a proving key.
+ */
+export interface ProvingKeyLocator extends BaseFunctionKeyLocator {
+    keyType: "prover";
+}
+/**
+ * Locator for a verifying key.
+ */
+export interface VerifyingKeyLocator extends BaseFunctionKeyLocator {
+    keyType: "verifier";
+}
+/**
+ * Locator for a translation key, which requires additional record information.
  *
- * @property {string} locator - The unique identifier for the key.
- * @property {KeyFingerprint} [fingerprint] - Optional fingerprint for verification.
+ * @property {string} recordName - The name of the record associated with the translation key.
+ * @property {number} recordInputPosition - The position of the record input in the function signature.
  */
-export interface KeyLocator {
-    locator: string;
-    fingerprint?: KeyFingerprint;
+export interface TranslationKeyLocator extends BaseFunctionKeyLocator {
+    keyType: "translation";
+    recordName: string;
+    recordInputPosition: number;
 }
+/**
+ * A locator that uniquely identifies a function's proving, verifying, or translation key.
+ * Discriminated on the {@link KeyType} field.
+ *
+ * @example
+ * const prover: KeyLocator = { program: "credits.aleo", functionName: "transfer_private", edition: 1, amendment: 0, network: "mainnet", keyType: "prover" };
+ * const verifier: KeyLocator = { program: "credits.aleo", functionName: "transfer_private", edition: 1, amendment: 0, network: "mainnet", keyType: "verifier" };
+ */
+export type KeyLocator = ProvingKeyLocator | VerifyingKeyLocator | TranslationKeyLocator;
+/**
+ * Creates a {@link ProvingKeyLocator}.
+ *
+ * @param {string} program - The program name (e.g. "credits.aleo").
+ * @param {string} functionName - The function name (e.g. "transfer_private").
+ * @param {number} [edition=1] - The program edition.
+ * @param {number} [amendment=0] - The program amendment.
+ * @param {string} [network] - The network name. Defaults to the build-time network.
+ * @param {string} [checksum] - Optional SHA-256 checksum for key verification.
+ * @returns {ProvingKeyLocator}
+ */
+export declare function provingKeyLocator(program: string, functionName: string, edition?: number, amendment?: number, network?: string, checksum?: string): ProvingKeyLocator;
+/**
+ * Creates a {@link VerifyingKeyLocator}.
+ *
+ * @param {string} program - The program name (e.g. "credits.aleo").
+ * @param {string} functionName - The function name (e.g. "transfer_private").
+ * @param {number} [edition=1] - The program edition.
+ * @param {number} [amendment=0] - The program amendment.
+ * @param {string} [network] - The network name. Defaults to the build-time network.
+ * @param {string} [checksum] - Optional SHA-256 checksum for key verification.
+ * @returns {VerifyingKeyLocator}
+ */
+export declare function verifyingKeyLocator(program: string, functionName: string, edition?: number, amendment?: number, network?: string, checksum?: string): VerifyingKeyLocator;
+/**
+ * Creates a {@link TranslationKeyLocator}.
+ *
+ * @param {string} program - The program name (e.g. "credits.aleo").
+ * @param {string} functionName - The function name (e.g. "transfer_private").
+ * @param {string} recordName - The record name associated with the translation key.
+ * @param {number} recordInputPosition - The record input position in the function signature.
+ * @param {number} [edition=1] - The program edition.
+ * @param {number} [amendment=0] - The program amendment.
+ * @param {string} [network] - The network name. Defaults to the build-time network.
+ * @param {string} [checksum] - Optional SHA-256 checksum for key verification.
+ * @returns {TranslationKeyLocator}
+ */
+export declare function translationKeyLocator(program: string, functionName: string, recordName: string, recordInputPosition: number, edition?: number, amendment?: number, network?: string, checksum?: string): TranslationKeyLocator;
 export interface KeyStore {
     /**
-     * Returns the raw bytes of a proving or verifying key for a given locator.
+     * Returns the raw bytes of a key for a given locator.
      *
      * @param {KeyLocator} locator The unique locator for the desired key.
      * @returns {Promise<Uint8Array | null>} The raw key bytes if they exist, or null if not found.
@@ -24,60 +106,54 @@ export interface KeyStore {
     /**
      * Returns the `ProvingKey` for a given locator.
      *
-     * @param {KeyLocator} locator The unique locator for the desired `ProvingKey`.
-     *
+     * @param {ProvingKeyLocator} locator The unique locator for the desired `ProvingKey`.
      * @returns {Promise<ProvingKey | null>} Returns the `ProvingKey` for the given locator if it exists or null if it does not.
      */
-    getProvingKey(locator: KeyLocator): Promise<ProvingKey | null>;
+    getProvingKey(locator: ProvingKeyLocator): Promise<ProvingKey | null>;
     /**
      * Returns the `VerifyingKey` for a given locator.
      *
-     * @param {KeyLocator} locator The unique locator for the desired `VerifyingKey`.
-     *
+     * @param {VerifyingKeyLocator} locator The unique locator for the desired `VerifyingKey`.
      * @returns {Promise<VerifyingKey | null>} Returns the `VerifyingKey` for the given locator if it exists or null if it does not exist.
      */
-    getVerifyingKey(locator: KeyLocator): Promise<VerifyingKey | null>;
+    getVerifyingKey(locator: VerifyingKeyLocator): Promise<VerifyingKey | null>;
     /**
      * Stores proving and verifying keys in key storage.
      *
-     * @param {KeyLocator} proverLocator The unique locator for the desired proving key.
-     * @param {KeyLocator} verifierLocator The unique locator for the desired verifying key.
+     * @param {ProvingKeyLocator} proverLocator The locator for the proving key.
+     * @param {VerifyingKeyLocator} verifierLocator The locator for the verifying key.
      * @param {FunctionKeyPair} keys The proving and verifying keys.
      */
-    setKeys(proverLocator: KeyLocator, verifierLocator: KeyLocator, keys: FunctionKeyPair): Promise<void>;
+    setKeys(proverLocator: ProvingKeyLocator, verifierLocator: VerifyingKeyLocator, keys: FunctionKeyPair): Promise<void>;
     /**
-     * Store a raw proving or verifying key in storage along with its fingerprint metadata for future verification.
+     * Store a raw key in storage along with its fingerprint metadata for future verification.
      *
-     * @param {Uint8Array} keyBytes The raw proving and verifying key bytes.
-     * @param {KeyLocator} locator The unique locator for the desired key pair.
+     * @param {Uint8Array} keyBytes The raw key bytes.
+     * @param {KeyLocator} locator The unique locator for the desired key.
      * @returns {Promise<void>}
-     *
-     * @example
-     * const keys = await generateKeys();
-     * await setKeyBytes(keys.provingKey.toBytes(), { locator: 'transfer_private.prover' });
      */
     setKeyBytes(keyBytes: Uint8Array, locator: KeyLocator): Promise<void>;
     /**
      * Returns stored metadata for a key, if any.
      *
-     * @param {string} locator The unique locator for the key.
-     * @returns {Promise<KeyFingerprint | null>} The stored fingerprint for that locator, or null if none exists.
+     * @param {KeyLocator} locator The unique locator for the key.
+     * @returns {Promise<KeyFingerprint | null>} The stored fingerprint for that key, or null if none exists.
      */
-    getKeyMetadata(locator: string): Promise<KeyFingerprint | null>;
+    getKeyMetadata(locator: KeyLocator): Promise<KeyFingerprint | null>;
     /**
      * Determines if a given key exists or not.
      *
-     * @param {string} locator The unique locator for the desired key.
+     * @param {KeyLocator} locator The unique locator for the key.
      * @returns {Promise<boolean>} True if the key exists, false otherwise.
      */
-    has(locator: string): Promise<boolean>;
+    has(locator: KeyLocator): Promise<boolean>;
     /**
      * Deletes a key and its metadata corresponding to a given locator.
      *
-     * @param {string} locator The unique locator for the desired key.
+     * @param {KeyLocator} locator The unique locator for the key.
      * @returns {Promise<void>}
      */
-    delete(locator: string): Promise<void>;
+    delete(locator: KeyLocator): Promise<void>;
     /**
      * Clears all keys in the keystore.
      */

package/dist/mainnet/models/external-signing.d.ts

@@ -0,0 +1,123 @@
+import { Address, Field, Group, Signature, ViewKey } from "../wasm.js";
+/** A Field, a string representation, or raw LE bytes. */
+export type FieldLike = Field | string | Uint8Array;
+/** A Group, a Field (x-coordinate), a string representation, or raw LE bytes. */
+export type GroupLike = Group | Field | string | Uint8Array;
+/** A ViewKey, a string representation, or raw LE bytes. */
+export type ViewKeyLike = ViewKey | string | Uint8Array;
+/** A Signature, a string representation, or raw LE bytes. */
+export type SignatureLike = Signature | string | Uint8Array;
+/** An Address, a string representation, or raw LE bytes. */
+export type AddressLike = Address | string | Uint8Array;
+/** An input ID is either a single Field-like (public/private) or a 5-tuple (record) with flexible deserialization. */
+export type InputID = FieldLike | [FieldLike, GroupLike, FieldLike, FieldLike, FieldLike];
+export declare function toField(value: FieldLike): Field;
+export declare function toGroup(value: GroupLike): Group;
+export declare function toViewKey(value: ViewKeyLike): ViewKey;
+export declare function toSignature(value: SignatureLike): Signature;
+export declare function toAddress(value: AddressLike): Address;
+/** Output format discriminant for `computeExternalSigningInputs`. */
+export type OutputFormat = "string" | "bytes";
+/** Maps an {@link OutputFormat} to the concrete field-element representation. */
+export type FieldOutput<F extends OutputFormat> = F extends "bytes" ? Uint8Array : string;
+/**
+ * Type surrounding the input to an external signing request.
+ *
+ * The generic parameter `F` controls whether field elements are serialised as
+ * human-readable strings (`"string"`, the default) or raw little-endian bytes
+ * (`"bytes"`).
+ *
+ * @property {string} signingInputType - The type of signing input being requested.
+ * @property {FieldOutput<F>} index - The index of the output represented as an Ed/BLS-377 base field element.
+ * @property {FieldOutput<F>[]} data - The data represented as Ed/BLS-377 base field elements.
+ * @property {string} [name] - The name of the record being requested.
+ * @property {FieldOutput<F>} [h] - The h value of the record represented as an Ed/BLS-377 base field element.
+ * @property {FieldOutput<F>} [tag] - The tag of the record represented as an Ed/BLS-377 base field element.
+ * @property {FieldOutput<F>} [recordViewKey] - The record view key (present for record inputs when viewKey was provided).
+ */
+export interface RequestSignInput<F extends OutputFormat = "string"> {
+    signingInputType: "constant" | "public" | "private" | "record" | "external_record" | "dynamic_record";
+    index: FieldOutput<F>;
+    data: FieldOutput<F>[];
+    name?: string;
+    h?: FieldOutput<F>;
+    tag?: FieldOutput<F>;
+    recordViewKey?: FieldOutput<F>;
+}
+/**
+ * Type representing the output of an external signing request.
+ *
+ * The generic parameter `F` controls whether field elements are serialised as
+ * human-readable strings (`"string"`, the default) or raw little-endian bytes
+ * (`"bytes"`).
+ *
+ * @property {FieldOutput<F>} functionId - The function ID as Ed/BLS-377 base field element(s).
+ * @property {boolean} isRoot - Whether this is a top-level transition.
+ * @property {RequestSignInput<F>[]} requestInputs - The inputs to the function being executed.
+ * @property {FieldOutput<F>} [checksum] - The Ed/BLS-377 base field representation of the program checksum.
+ * @property {string} [signer] - The signer address string (present when viewKey was provided).
+ * @property {string} [skTag] - The tag secret key string (present when viewKey was provided).
+ */
+export interface ExternalSigningInput<F extends OutputFormat = "string"> {
+    functionId: FieldOutput<F>;
+    isRoot: boolean;
+    requestInputs: RequestSignInput<F>[];
+    checksum?: FieldOutput<F>;
+    signer?: string;
+    skTag?: string;
+}
+/**
+ * Type representing the options for pre-computing the inputs to an external signing request.
+ *
+ * @property {string} programName - The name of the program containing the function to execute.
+ * @property {string} functionName - The name of the function to execute within the program.
+ * @property {string[]} inputs - The inputs to the function being executed.
+ * @property {string[]} inputTypes - The input types of the function (e.g. ["address.public", "u64.public"]).
+ * @property {boolean} isRoot - Whether this transition is the first transition being executed in a transaction.
+ * @property {FieldLike} [checksum] - The optional checksum of the program.
+ * @property {ViewKeyLike} [viewKey] - The optional view key used to derive signer and skTag.
+ * @property {OutputFormat} [outputFormat] - Controls whether field elements are serialised as strings (default) or Uint8Arrays.
+ */
+export interface ExternalSigningOptions {
+    programName: string;
+    functionName: string;
+    inputs: string[];
+    inputTypes: string[];
+    isRoot: boolean;
+    checksum?: FieldLike | null;
+    viewKey?: ViewKeyLike | null;
+    outputFormat?: OutputFormat;
+}
+/** Common parameters shared by all `buildExecutionRequest` variants. */
+export interface ExecutionRequestParams {
+    programId: string;
+    functionName: string;
+    inputs: string[];
+    inputTypes: string[];
+    signature: SignatureLike;
+    tvk: FieldLike;
+    signer: AddressLike;
+    skTag: FieldLike;
+}
+/** Provide explicit record view keys and gammas. */
+export interface RecordViewKeyStrategy {
+    recordViewKeys?: FieldLike[];
+    gammas?: GroupLike[];
+}
+/** Provide a view key to derive record view keys internally. */
+export interface ViewKeyStrategy {
+    viewKey: ViewKeyLike;
+    gammas?: GroupLike[];
+}
+/** Provide pre-computed input IDs directly. */
+export interface InputIdStrategy {
+    inputIds: InputID[];
+}
+/** Determines how record input IDs are resolved when building an ExecutionRequest. */
+export type InputStrategy = RecordViewKeyStrategy | ViewKeyStrategy | InputIdStrategy;
+/** Returns `true` if the strategy provides a `viewKey` for deriving record view keys. */
+export declare function isViewKeyStrategy(r: InputStrategy): r is ViewKeyStrategy;
+/** Returns `true` if the strategy provides pre-computed `inputIds`. */
+export declare function isInputIdStrategy(r: InputStrategy): r is InputIdStrategy;
+/** Returns `true` if the strategy provides explicit `recordViewKeys` (or is the default empty variant). */
+export declare function isRecordViewKeyStrategy(r: InputStrategy): r is RecordViewKeyStrategy;

package/dist/mainnet/models/input/inputJSON.d.ts

@@ -6,4 +6,5 @@ export interface InputJSON {
     id: string;
     tag?: string;
     value?: string;
+    dynamic_id?: string;
 }

package/dist/mainnet/models/input/inputObject.d.ts

@@ -11,4 +11,5 @@ export interface InputObject {
     id: "string" | Field;
     tag?: string | Field;
     value?: Ciphertext | Plaintext | PlaintextObject;
+    dynamic_id?: string | Field;
 }

package/dist/mainnet/models/output/outputJSON.d.ts

@@ -3,4 +3,5 @@ export interface OutputJSON {
     id: string;
     checksum?: string;
     value: string;
+    dynamic_id?: string;
 }