@provablehq/sdk 0.10.2 → 0.10.4

package/dist/mainnet/keys/provider/offline.d.cts

@@ -0,0 +1,365 @@
+import { FunctionKeyProvider, KeySearchParams } from "./interface.js";
+import { CachedKeyPair, FunctionKeyPair } from "../../models/keyPair.js";
+import { ProvingKey, VerifyingKey } from "../../wasm.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.
+ *
+ * @example
+ * // If storing a key for a custom program function
+ * offlineSearchParams = new OfflineSearchParams("myprogram.aleo/myfunction");
+ *
+ * // If storing a key for a credits.aleo program function
+ * bondPublicKeyParams = OfflineSearchParams.bondPublicKeyParams();
+ */
+declare class OfflineSearchParams implements KeySearchParams {
+    cacheKey: string | undefined;
+    verifyCreditsKeys: boolean | undefined;
+    /**
+     * Create a new OfflineSearchParams instance.
+     *
+     * @param {string} cacheKey - Key used to store the local function proving & verifying keys. This should be stored
+     * under the naming convention "programName/functionName" (i.e. "myprogram.aleo/myfunction")
+     * @param {boolean} verifyCreditsKeys - Whether to verify the keys against the credits.aleo program,
+     * defaults to false, but should be set to true if using keys from the credits.aleo program
+     */
+    constructor(cacheKey: string, verifyCreditsKeys?: boolean);
+    /**
+     * Create a new OfflineSearchParams instance for the bond_public function of the credits.aleo program.
+     */
+    static bondPublicKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the bond_validator function of the credits.aleo program.
+     */
+    static bondValidatorKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the claim_unbond_public function of the credits.aleo program.
+     */
+    static claimUnbondPublicKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the fee_private function of the credits.aleo program.
+     */
+    static feePrivateKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the fee_public function of the credits.aleo program.
+     */
+    static feePublicKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the inclusion prover function.
+     */
+    static inclusionKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the join function of the credits.aleo program.
+     */
+    static joinKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the set_validator_state function of the credits.aleo program.
+     */
+    static setValidatorStateKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the split function of the credits.aleo program.
+     */
+    static splitKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the transfer_private function of the credits.aleo program.
+     */
+    static transferPrivateKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the transfer_private_to_public function of the credits.aleo program.
+     */
+    static transferPrivateToPublicKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the transfer_public function of the credits.aleo program.
+     */
+    static transferPublicKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the transfer_public_as_signer function of the credits.aleo program.
+     */
+    static transferPublicAsSignerKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the transfer_public_to_private function of the credits.aleo program.
+     */
+    static transferPublicToPrivateKeyParams(): OfflineSearchParams;
+    /**
+     * Create a new OfflineSearchParams instance for the unbond_public function of the credits.aleo program.
+     */
+    static unbondPublicKeyParams(): OfflineSearchParams;
+}
+/**
+ * A key provider meant for building transactions offline on devices such as hardware wallets. This key provider is not
+ * able to contact the internet for key material and instead relies on the user to insert Aleo function proving &
+ * verifying keys from local storage prior to usage.
+ *
+ * @example
+ * // Create an offline program manager
+ * const programManager = new ProgramManager();
+ *
+ * // Create a temporary account for the execution of the program
+ * const account = new Account();
+ * programManager.setAccount(account);
+ *
+ * // Create the proving keys from the key bytes on the offline machine
+ * console.log("Creating proving keys from local key files");
+ * const program = "program hello_hello.aleo; function hello: input r0 as u32.public; input r1 as u32.private; add r0 r1 into r2; output r2 as u32.private;";
+ * const myFunctionProver = await getLocalKey("/path/to/my/function/hello_hello.prover");
+ * const myFunctionVerifier = await getLocalKey("/path/to/my/function/hello_hello.verifier");
+ * const feePublicProvingKeyBytes = await getLocalKey("/path/to/credits.aleo/feePublic.prover");
+ *
+ * myFunctionProvingKey = ProvingKey.fromBytes(myFunctionProver);
+ * myFunctionVerifyingKey = VerifyingKey.fromBytes(myFunctionVerifier);
+ * const feePublicProvingKey = ProvingKey.fromBytes(feePublicKeyBytes);
+ *
+ * // Create an offline key provider
+ * console.log("Creating offline key provider");
+ * const offlineKeyProvider = new OfflineKeyProvider();
+ *
+ * // Cache the keys
+ * // Cache the proving and verifying keys for the custom hello function
+ * OfflineKeyProvider.cacheKeys("hello_hello.aleo/hello", myFunctionProvingKey, myFunctionVerifyingKey);
+ *
+ * // Cache the proving key for the fee_public function (the verifying key is automatically cached)
+ * OfflineKeyProvider.insertFeePublicKey(feePublicProvingKey);
+ *
+ * // Create an offline query using the latest state root in order to create the inclusion proof
+ * const offlineQuery = new OfflineQuery("latestStateRoot");
+ *
+ * // Insert the key provider into the program manager
+ * programManager.setKeyProvider(offlineKeyProvider);
+ *
+ * // Create the offline search params
+ * const offlineSearchParams = new OfflineSearchParams("hello_hello.aleo/hello");
+ *
+ * // Create the offline transaction
+ * 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.provable.com/v2");
+ * const txId = await networkClient.broadcastTransaction(offlineExecuteTx);
+ */
+declare class OfflineKeyProvider implements FunctionKeyProvider {
+    cache: Map<string, CachedKeyPair>;
+    constructor();
+    keyStore(): Promise<KeyStore | undefined>;
+    /**
+     * Get bond_public function keys from the credits.aleo program. The keys must be cached prior to calling this
+     * method for it to work.
+     *
+     * @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. The keys must be cached prior to calling this
+     * method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the bond_public 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. The keys must be cached prior to calling this
+     * method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the unbond_public function
+     */
+    claimUnbondPublicKeys(): Promise<FunctionKeyPair>;
+    /**
+     * Get arbitrary function key from the offline key provider cache.
+     *
+     * @param {KeySearchParams | undefined} params - Optional search parameters for the key provider
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the specified program
+     *
+     * @example
+     * /// First cache the keys from local offline resources
+     * const offlineKeyProvider = new OfflineKeyProvider();
+     * const myFunctionVerifyingKey = VerifyingKey.fromString("verifier...");
+     * const myFunctionProvingKeyBytes = await readBinaryFile('./resources/myfunction.prover');
+     * const myFunctionProvingKey = ProvingKey.fromBytes(myFunctionProvingKeyBytes);
+     *
+     * /// Cache the keys for future use with a memorable locator
+     * offlineKeyProvider.cacheKeys("myprogram.aleo/myfunction", [myFunctionProvingKey, myFunctionVerifyingKey]);
+     *
+     * /// When they're needed, retrieve the keys from the cache
+     *
+     * /// First create a search parameter object with the same locator used to cache the keys
+     * const keyParams = new OfflineSearchParams("myprogram.aleo/myfunction");
+     *
+     * /// Then retrieve the keys
+     * const [myFunctionProver, myFunctionVerifier] = await offlineKeyProvider.functionKeys(keyParams);
+     */
+    functionKeys(params?: KeySearchParams): Promise<FunctionKeyPair>;
+    /**
+     * Determines if the keys for a given credits function match the expected keys.
+     *
+     * @returns {boolean} Whether the keys match the expected keys
+     */
+    verifyCreditsKeys(locator: string, provingKey: ProvingKey, verifyingKey: VerifyingKey): boolean;
+    /**
+     * Get fee_private function keys from the credits.aleo program. The keys must be cached prior to calling this
+     * method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
+     */
+    feePrivateKeys(): Promise<FunctionKeyPair>;
+    /**
+     * Get fee_public function keys from the credits.aleo program. The keys must be cached prior to calling this
+     * method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
+     */
+    feePublicKeys(): Promise<FunctionKeyPair>;
+    /**
+     * Get the inclusion prover keys from. The keys must be cached prior to calling this method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the inclusion prover
+     */
+    inclusionKeys(): Promise<FunctionKeyPair>;
+    /**
+     * Get join function keys from the credits.aleo program. The keys must be cached prior to calling this
+     * method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
+     */
+    joinKeys(): Promise<FunctionKeyPair>;
+    /**
+     * Get split function keys from the credits.aleo program. The keys must be cached prior to calling this
+     * method for it to work.
+     *
+     * @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 OfflineKeyProvider
+     * const offlineKeyProvider = new OfflineKeyProvider();
+     *
+     * // Cache the keys for future use with the official locator
+     * const transferPublicProvingKeyBytes = await readBinaryFile('./resources/transfer_public.prover.a74565e');
+     * const transferPublicProvingKey = ProvingKey.fromBytes(transferPublicProvingKeyBytes);
+     *
+     * // Cache the transfer_public keys for future use with the OfflinKeyProvider's convenience method for
+     * // transfer_public (the verifying key will be cached automatically)
+     * offlineKeyProvider.insertTransferPublicKeys(transferPublicProvingKey);
+     *
+     * /// When they're needed, retrieve the keys from the cache
+     * 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>;
+    /**
+     * Insert the proving and verifying keys for the bond_public function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for bond_public before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertBondPublicKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the claim_unbond_public function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for claim_unbond_public before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertClaimUnbondPublicKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the fee_private function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for fee_private before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertFeePrivateKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the fee_public function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for fee_public before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertFeePublicKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the inclusion prover into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for the inclusion prover.
+     *
+     * @param provingKey
+     */
+    insertInclusionKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the join function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for join before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertJoinKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the set_validator_state function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for set_validator_state before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertSetValidatorStateKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the split function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for split before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertSplitKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the transfer_private function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for transfer_private before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertTransferPrivateKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the transfer_private_to_public function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for transfer_private_to_public before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertTransferPrivateToPublicKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the transfer_public function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for transfer_public before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertTransferPublicKeys(provingKey: ProvingKey): void;
+    /**
+     * Insert the proving and verifying keys for the transfer_public_to_private function into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for transfer_public_to_private before inserting them into the cache.
+     *
+     * @param provingKey
+     */
+    insertTransferPublicToPrivateKeys(provingKey: ProvingKey): void;
+    insertUnbondPublicKeys(provingKey: ProvingKey): void;
+}
+export { OfflineKeyProvider, OfflineSearchParams };

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

@@ -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.cts

@@ -0,0 +1,37 @@
+import { KeyVerifier, KeyFingerprint, KeyMetadata } from "./interface.js";
+/**
+ * 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/keys/verifier/memory.d.ts

@@ -1,4 +1,4 @@
-import { KeyVerifier, KeyFingerprint, KeyMetadata } from "./interface";
+import { KeyVerifier, KeyFingerprint, KeyMetadata } from "./interface.js";
 /**
  * In-memory implementation of KeyVerifier that stores and verifies key fingerprints.
  * Provides functionality to compute and verify cryptographic checksums of keys, storing them

package/dist/mainnet/models/authorization.d.cts

@@ -0,0 +1,6 @@
+import { RequestJSON } from "./request.js";
+import { TransitionJSON } from "./transition/transitionJSON.js";
+export interface AuthorizationJSON {
+    requests: RequestJSON[];
+    transitions: TransitionJSON[];
+}

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

@@ -1,5 +1,5 @@
-import { RequestJSON } from "./request";
-import { TransitionJSON } from "./transition/transitionJSON";
+import { RequestJSON } from "./request.js";
+import { TransitionJSON } from "./transition/transitionJSON.js";
 export interface AuthorizationJSON {
     requests: RequestJSON[];
     transitions: TransitionJSON[];

package/dist/mainnet/models/blockJSON.d.cts

@@ -0,0 +1,33 @@
+import { ConfirmedTransactionJSON } from "./confirmed_transaction.js";
+import { RatificationJSON } from "./ratification.js";
+import { SolutionsJSON } from "./solution.js";
+export type BlockJSON = {
+    block_hash: string;
+    previous_hash: string;
+    header: Header;
+    transactions?: (ConfirmedTransactionJSON)[];
+    signature: string;
+    ratifications: (RatificationJSON)[];
+    solutions: SolutionsJSON;
+    aborted_solution_ids: string[];
+    aborted_transaction_ids: string[];
+};
+export type Header = {
+    previous_state_root: string;
+    transactions_root: string;
+    finalize_root: string;
+    ratifications_root: string;
+    solutions_root: string;
+    subdag_root: string;
+    metadata: Metadata;
+};
+export type Metadata = {
+    network: bigint;
+    round: bigint;
+    height: bigint;
+    coinbase_target: bigint;
+    proof_target: bigint;
+    timestamp: bigint;
+    cumulative_weight: bigint;
+    cumulative_proof_target: bigint;
+};

package/dist/mainnet/models/confirmed_transaction.d.cts

@@ -0,0 +1,9 @@
+import { TransactionJSON } from "./transaction/transactionJSON.js";
+import { FinalizeJSON } from "./finalizeJSON.js";
+export interface ConfirmedTransactionJSON {
+    status: string;
+    type: string;
+    index: bigint;
+    transaction: TransactionJSON;
+    finalize: FinalizeJSON[];
+}

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

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

package/dist/mainnet/models/deployment/deploymentJSON.d.cts

@@ -0,0 +1,6 @@
+export type VerifyingKeys = [string, [string, string]];
+export interface DeploymentJSON {
+    "edition": number;
+    "program": string;
+    "verifying_keys": VerifyingKeys;
+}

package/dist/mainnet/models/deployment/deploymentObject.d.cts

@@ -0,0 +1,6 @@
+import { FunctionObject } from "../functionObject.js";
+export interface DeploymentObject {
+    "edition": number;
+    "program": string;
+    "functions": FunctionObject[];
+}

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

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

package/dist/mainnet/models/execution/executionJSON.d.cts

@@ -0,0 +1,11 @@
+import { TransitionJSON } from "../transition/transitionJSON.js";
+export interface ExecutionJSON {
+    transitions: TransitionJSON[];
+    proof: string;
+    global_state_root: string;
+}
+export interface FeeExecutionJSON {
+    transition: TransitionJSON;
+    proof: string;
+    global_state_root: string;
+}

package/dist/mainnet/models/execution/executionObject.d.cts

@@ -0,0 +1,11 @@
+import { TransitionObject } from "../transition/transitionObject.js";
+export interface ExecutionObject {
+    transitions: TransitionObject[];
+    proof: string;
+    global_state_root: string;
+}
+export interface FeeExecutionObject {
+    transition: TransitionObject;
+    proof: string;
+    global_state_root: string;
+}