@provablehq/sdk 0.6.9

package/dist/models/block.d.ts

@@ -0,0 +1,21 @@
+import { ConfirmedTransaction } from "./confirmed_transaction";
+export type Block = {
+    block_hash: string;
+    previous_hash: string;
+    header: Header;
+    transactions?: (ConfirmedTransaction)[];
+    signature: string;
+};
+export type Header = {
+    previous_state_root: string;
+    transactions_root: string;
+    metadata: Metadata;
+};
+export type Metadata = {
+    network: number;
+    round: number;
+    height: number;
+    coinbase_target: number;
+    proof_target: number;
+    timestamp: number;
+};

package/dist/models/confirmed_transaction.d.ts

@@ -0,0 +1,6 @@
+import { TransactionModel } from "./transactionModel";
+export type ConfirmedTransaction = {
+    type: string;
+    id: string;
+    transaction: TransactionModel;
+};

package/dist/models/execution.d.ts

@@ -0,0 +1,5 @@
+import { Transition } from "./transition";
+export type Execution = {
+    edition: number;
+    transitions?: (Transition)[];
+};

package/dist/models/input.d.ts

@@ -0,0 +1,10 @@
+export type Input = {
+    type: string;
+    id: string;
+    tag?: string;
+    origin?: Origin;
+    value?: string;
+};
+export type Origin = {
+    commitment: string;
+};

package/dist/models/output.d.ts

@@ -0,0 +1,6 @@
+export type Output = {
+    type: string;
+    id: string;
+    checksum: string;
+    value: string;
+};

package/dist/models/transactionModel.d.ts

@@ -0,0 +1,6 @@
+import { Execution } from "./execution";
+export type TransactionModel = {
+    type: string;
+    id: string;
+    execution: Execution;
+};

package/dist/models/transition.d.ts

@@ -0,0 +1,13 @@
+import { Input } from "./input";
+import { Output } from "./output";
+export type Transition = {
+    id: string;
+    program: string;
+    function: string;
+    inputs?: (Input)[];
+    outputs?: (Output)[];
+    proof: string;
+    tpk: string;
+    tcm: string;
+    fee: number;
+};

package/dist/network-client.d.ts

@@ -0,0 +1,267 @@
+import { Account, Block, Program, RecordPlaintext, PrivateKey, Transaction, TransactionModel } from "./index";
+type ProgramImports = {
+    [key: string]: string | Program;
+};
+interface AleoNetworkClientOptions {
+    headers?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Client library that encapsulates REST calls to publicly exposed endpoints of Aleo nodes. The methods provided in this
+ * allow users to query public information from the Aleo blockchain and submit transactions to the network.
+ *
+ * @param {string} host
+ * @example
+ * // Connection to a local node
+ * const localNetworkClient = new AleoNetworkClient("http://localhost:3030");
+ *
+ * // Connection to a public beacon node
+ * const publicnetworkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+ */
+declare class AleoNetworkClient {
+    host: string;
+    headers: {
+        [key: string]: string;
+    };
+    account: Account | undefined;
+    constructor(host: string, options?: AleoNetworkClientOptions);
+    /**
+     * Set an account to use in networkClient calls
+     *
+     * @param {Account} account
+     * @example
+     * const account = new Account();
+     * networkClient.setAccount(account);
+     */
+    setAccount(account: Account): void;
+    /**
+     * Return the Aleo account used in the networkClient
+     *
+     * @example
+     * const account = networkClient.getAccount();
+     */
+    getAccount(): Account | undefined;
+    /**
+     * Set a new host for the networkClient
+     *
+     * @param {string} host The address of a node hosting the Aleo API
+     * @param host
+     */
+    setHost(host: string): void;
+    fetchData<Type>(url?: string): Promise<Type>;
+    /**
+     * Attempts to find unspent records in the Aleo blockchain for a specified private key
+     * @param {number} startHeight - The height at which to start searching for unspent records
+     * @param {number} endHeight - The height at which to stop searching for unspent records
+     * @param {string | PrivateKey} privateKey - The private key to use to find unspent records
+     * @param {number[]} amounts - The amounts (in microcredits) to search for (eg. [100, 200, 3000])
+     * @param {number} maxMicrocredits - The maximum number of microcredits to search for
+     * @param {string[]} nonces - The nonces of already found records to exclude from the search
+     *
+     * @example
+     * // Find all unspent records
+     * const privateKey = "[PRIVATE_KEY]";
+     * const records = networkClient.findUnspentRecords(0, undefined, privateKey);
+     *
+     * // Find specific amounts
+     * const startHeight = 500000;
+     * const amounts = [600000, 1000000];
+     * const records = networkClient.findUnspentRecords(startHeight, undefined, privateKey, amounts);
+     *
+     * // Find specific amounts with a maximum number of cumulative microcredits
+     * const maxMicrocredits = 100000;
+     * const records = networkClient.findUnspentRecords(startHeight, undefined, privateKey, undefined, maxMicrocredits);
+     */
+    findUnspentRecords(startHeight: number, endHeight: number | undefined, privateKey: string | PrivateKey | undefined, amounts: number[] | undefined, maxMicrocredits?: number | undefined, nonces?: string[] | undefined): Promise<Array<RecordPlaintext> | Error>;
+    /**
+     * Returns the contents of the block at the specified block height
+     *
+     * @param {number} height
+     * @example
+     * const block = networkClient.getBlock(1234);
+     */
+    getBlock(height: number): Promise<Block | Error>;
+    /**
+     * Returns a range of blocks between the specified block heights
+     *
+     * @param {number} start
+     * @param {number} end
+     * @example
+     * const blockRange = networkClient.getBlockRange(2050, 2100);
+     */
+    getBlockRange(start: number, end: number): Promise<Array<Block> | Error>;
+    /**
+     * Returns the deployment transaction id associated with the specified program
+     *
+     * @param {Program | string} program
+     * @returns {TransactionModel | Error}
+     */
+    getDeploymentTransactionIDForProgram(program: Program | string): Promise<string | Error>;
+    /**
+     * Returns the deployment transaction associated with a specified program
+     *
+     * @param {Program | string} program
+     * @returns {TransactionModel | Error}
+     */
+    getDeploymentTransactionForProgram(program: Program | string): Promise<TransactionModel | Error>;
+    /**
+     * Returns the contents of the latest block
+     *
+     * @example
+     * const latestHeight = networkClient.getLatestBlock();
+     */
+    getLatestBlock(): Promise<Block | Error>;
+    /**
+     * Returns the latest committee
+     *
+     * @returns {Promise<object>} A javascript object containing the latest committee
+     */
+    getLatestCommittee(): Promise<object | Error>;
+    /**
+     * Returns the latest block height
+     *
+     * @example
+     * const latestHeight = networkClient.getLatestHeight();
+     */
+    getLatestHeight(): Promise<number | Error>;
+    /**
+     * Returns the source code of a program given a program ID
+     *
+     * @param {string} programId The program ID of a program deployed to the Aleo Network
+     * @return {Promise<string>} Source code of the program
+     *
+     * @example
+     * const program = networkClient.getProgram("hello_hello.aleo");
+     * const expectedSource = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n"
+     * assert.equal(program, expectedSource);
+     */
+    getProgram(programId: string): Promise<string | Error>;
+    /**
+     * Returns a program object from a program ID or program source code
+     *
+     * @param {string} inputProgram The program ID or program source code of a program deployed to the Aleo Network
+     * @return {Promise<Program | Error>} Source code of the program
+     *
+     * @example
+     * const programID = "hello_hello.aleo";
+     * const programSource = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n"
+     *
+     * // Get program object from program ID or program source code
+     * const programObjectFromID = await networkClient.getProgramObject(programID);
+     * const programObjectFromSource = await networkClient.getProgramObject(programSource);
+     *
+     * // Both program objects should be equal
+     * assert.equal(programObjectFromID.to_string(), programObjectFromSource.to_string());
+     */
+    getProgramObject(inputProgram: string): Promise<Program | Error>;
+    /**
+     *  Returns an object containing the source code of a program and the source code of all programs it imports
+     *
+     * @param {Program | string} inputProgram The program ID or program source code of a program deployed to the Aleo Network
+     * @returns {Promise<ProgramImports>} Object of the form { "program_id": "program_source", .. } containing program id & source code for all program imports
+     *
+     * @example
+     * const double_test_source = "import multiply_test.aleo;\n\nprogram double_test.aleo;\n\nfunction double_it:\n    input r0 as u32.private;\n    call multiply_test.aleo/multiply 2u32 r0 into r1;\n    output r1 as u32.private;\n"
+     * const double_test = Program.fromString(double_test_source);
+     * const expectedImports = {
+     *     "multiply_test.aleo": "program multiply_test.aleo;\n\nfunction multiply:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    mul r0 r1 into r2;\n    output r2 as u32.private;\n"
+     * }
+     *
+     * // Imports can be fetched using the program ID, source code, or program object
+     * let programImports = await networkClient.getProgramImports("double_test.aleo");
+     * assert.deepStrictEqual(programImports, expectedImports);
+     *
+     * // Using the program source code
+     * programImports = await networkClient.getProgramImports(double_test_source);
+     * assert.deepStrictEqual(programImports, expectedImports);
+     *
+     * // Using the program object
+     * programImports = await networkClient.getProgramImports(double_test);
+     * assert.deepStrictEqual(programImports, expectedImports);
+     */
+    getProgramImports(inputProgram: Program | string): Promise<ProgramImports | Error>;
+    /**
+     * Get a list of the program names that a program imports
+     *
+     * @param {Program | string} inputProgram - The program id or program source code to get the imports of
+     * @returns {string[]} - The list of program names that the program imports
+     *
+     * @example
+     * const programImportsNames = networkClient.getProgramImports("double_test.aleo");
+     * const expectedImportsNames = ["multiply_test.aleo"];
+     * assert.deepStrictEqual(programImportsNames, expectedImportsNames);
+     */
+    getProgramImportNames(inputProgram: Program | string): Promise<string[] | Error>;
+    /**
+     * Returns the names of the mappings of a program
+     *
+     * @param {string} programId - The program ID to get the mappings of (e.g. "credits.aleo")
+     * @example
+     * const mappings = networkClient.getProgramMappingNames("credits.aleo");
+     * const expectedMappings = ["account"];
+     * assert.deepStrictEqual(mappings, expectedMappings);
+     */
+    getProgramMappingNames(programId: string): Promise<Array<string> | Error>;
+    /**
+     * Returns the value of a program's mapping for a specific key
+     *
+     * @param {string} programId - The program ID to get the mapping value of (e.g. "credits.aleo")
+     * @param {string} mappingName - The name of the mapping to get the value of (e.g. "account")
+     * @param {string} key - The key of the mapping to get the value of (e.g. "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px")
+     * @return {Promise<string>} String representation of the value of the mapping
+     *
+     * @example
+     * // Get public balance of an account
+     * const mappingValue = networkClient.getMappingValue("credits.aleo", "account", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px");
+     * const expectedValue = "0u64";
+     * assert.equal(mappingValue, expectedValue);
+     */
+    getProgramMappingValue(programId: string, mappingName: string, key: string): Promise<string | Error>;
+    /**
+     * Returns the latest state/merkle root of the Aleo blockchain
+     *
+     * @example
+     * const stateRoot = networkClient.getStateRoot();
+     */
+    getStateRoot(): Promise<string | Error>;
+    /**
+     * Returns a transaction by its unique identifier
+     *
+     * @param {string} id
+     * @example
+     * const transaction = networkClient.getTransaction("at1handz9xjrqeynjrr0xay4pcsgtnczdksz3e584vfsgaz0dh0lyxq43a4wj");
+     */
+    getTransaction(id: string): Promise<TransactionModel | Error>;
+    /**
+     * Returns the transactions present at the specified block height
+     *
+     * @param {number} height
+     * @example
+     * const transactions = networkClient.getTransactions(654);
+     */
+    getTransactions(height: number): Promise<Array<TransactionModel> | Error>;
+    /**
+     * Returns the transactions in the memory pool.
+     *
+     * @example
+     * const transactions = networkClient.getTransactionsInMempool();
+     */
+    getTransactionsInMempool(): Promise<Array<TransactionModel> | Error>;
+    /**
+     * Returns the transition ID of the transition corresponding to the ID of the input or output.
+     * @param {string} inputOrOutputID - ID of the input or output.
+     *
+     * @example
+     * const transitionId = networkClient.getTransitionId("2429232855236830926144356377868449890830704336664550203176918782554219952323field");
+     */
+    getTransitionId(inputOrOutputID: string): Promise<string | Error>;
+    /**
+     * Submit an execute or deployment transaction to the Aleo network
+     *
+     * @param {Transaction | string} transaction  - The transaction to submit to the network
+     * @returns {string | Error} - The transaction id of the submitted transaction or the resulting error
+     */
+    submitTransaction(transaction: Transaction | string): Promise<string | Error>;
+}
+export { AleoNetworkClient, AleoNetworkClientOptions, ProgramImports };

package/dist/node-polyfill.d.ts

@@ -0,0 +1,4 @@
+import "./polyfill/crypto";
+import "./polyfill/fetch";
+import "./polyfill/xmlhttprequest";
+import "./polyfill/worker";

package/dist/node-polyfill.js

@@ -0,0 +1,302 @@
+import { webcrypto } from 'node:crypto';
+import * as $fs from 'node:fs';
+import $mime from 'mime/lite.js';
+import $request from 'sync-request';
+import * as $worker from 'node:worker_threads';
+import * as $os from 'node:os';
+
+if (globalThis.crypto == null) {
+    globalThis.crypto = webcrypto;
+}
+
+const oldFetch = globalThis.fetch;
+// We always polyfill fetch because Node's fetch doesn't support file URLs.
+globalThis.fetch = async function (resource, options) {
+    const request = new Request(resource, options);
+    const url = new URL(request.url);
+    if (url.protocol === "file:") {
+        const readStream = $fs.createReadStream(url);
+        const headers = {};
+        const type = $mime.getType(url.pathname);
+        if (type) {
+            headers["Content-Type"] = type;
+        }
+        return new Response(readStream, {
+            status: 200,
+            statusText: "OK",
+            headers,
+        });
+    }
+    else {
+        return await oldFetch(request);
+    }
+};
+
+globalThis.XMLHttpRequest = class extends EventTarget {
+    static UNSENT = 0;
+    static OPENED = 1;
+    static HEADERS_RECEIVED = 2;
+    static LOADING = 3;
+    static DONE = 4;
+    UNSENT = XMLHttpRequest.UNSENT;
+    OPENED = XMLHttpRequest.OPENED;
+    HEADERS_RECEIVED = XMLHttpRequest.HEADERS_RECEIVED;
+    LOADING = XMLHttpRequest.LOADING;
+    DONE = XMLHttpRequest.DONE;
+    responseType;
+    withCredentials;
+    timeout;
+    readyState;
+    response;
+    responseText;
+    responseURL;
+    responseXML;
+    status;
+    statusText;
+    upload;
+    _url;
+    _mime;
+    constructor() {
+        super();
+        this._reset();
+        this._mime = "text/xml";
+    }
+    _reset() {
+        this.readyState = XMLHttpRequest.UNSENT;
+        this.response = null;
+        this.responseText = "";
+        this.responseType = "";
+        this.responseURL = "";
+        this.responseXML = null;
+        this.status = 0;
+        this.statusText = "";
+        this.timeout = 0;
+        this.upload = null;
+        this.withCredentials = false;
+        this._url = null;
+    }
+    _success() {
+        this.readyState = XMLHttpRequest.DONE;
+        this.status = 200;
+        this.statusText = "OK";
+    }
+    set onabort(value) {
+        throw new Error("Not implemented");
+    }
+    set onerror(value) {
+        throw new Error("Not implemented");
+    }
+    set onreadystatechange(value) {
+        throw new Error("Not implemented");
+    }
+    set onloadstart(value) {
+        throw new Error("Not implemented");
+    }
+    set onload(value) {
+        throw new Error("Not implemented");
+    }
+    set onloadend(value) {
+        throw new Error("Not implemented");
+    }
+    set onprogress(value) {
+        throw new Error("Not implemented");
+    }
+    set ontimeout(value) {
+        throw new Error("Not implemented");
+    }
+    abort() {
+        throw new Error("Not implemented");
+    }
+    overrideMimeType(mime) {
+        this._mime = mime;
+    }
+    getResponseHeader() {
+        throw new Error("Not implemented");
+    }
+    getAllResponseHeaders() {
+        throw new Error("Not implemented");
+    }
+    setRequestHeader() {
+        throw new Error("Not implemented");
+    }
+    open(method, url, async = true, username, password) {
+        if (async) {
+            throw new Error("Async XMLHttpRequest is not implemented yet");
+        }
+        if (method !== "GET") {
+            throw new Error("Non-GET requests are not implemented yet");
+        }
+        this._reset();
+        this._url = url;
+    }
+    send(body = null) {
+        if (body !== null) {
+            throw new Error("XMLHttpRequest send body is not implemented yet");
+        }
+        if (!this._url) {
+            throw new Error("You must call open before you call send");
+        }
+        const response = $request("GET", this._url, {
+            headers: {
+                "Content-Type": this._mime,
+            }
+        });
+        const buffer = response.body.buffer;
+        const responseText = new TextDecoder("iso-8859-5", { fatal: true }).decode(buffer);
+        this.response = this.responseText = responseText;
+        this._url = null;
+        this._success();
+    }
+};
+
+// This is technically not a part of the Worker polyfill,
+// but Workers are used for multi-threading, so this is often
+// needed when writing Worker code.
+if (globalThis.navigator == null) {
+    globalThis.navigator = {
+        hardwareConcurrency: $os.cpus().length,
+    };
+}
+globalThis.Worker = class Worker extends EventTarget {
+    _worker;
+    constructor(url, options) {
+        super();
+        if (url instanceof URL) {
+            if (url.protocol !== "file:") {
+                throw new Error("Worker only supports file: URLs");
+            }
+            url = url.href;
+        }
+        else {
+            throw new Error("Filepaths are unreliable, use `new URL(\"...\", import.meta.url)` instead.");
+        }
+        if (!options || options.type !== "module") {
+            throw new Error("Workers must use \`type: \"module\"\`");
+        }
+        const code = `
+            const { workerData } = require("node:worker_threads");
+
+            import(workerData.polyfill)
+                .then(() => import(workerData.url))
+                .catch((e) => {
+                    // TODO maybe it should send a message to the parent?
+                    console.error(e.stack);
+                });
+        `;
+        this._worker = new $worker.Worker(code, {
+            eval: true,
+            workerData: {
+                url,
+                polyfill: new URL("node-polyfill.js", import.meta.url).href,
+            },
+        });
+        this._worker.on("message", (data) => {
+            this.dispatchEvent(new MessageEvent("message", { data }));
+        });
+        this._worker.on("messageerror", (error) => {
+            throw new Error("UNIMPLEMENTED");
+        });
+        this._worker.on("error", (error) => {
+            // TODO attach the error to the event somehow
+            const event = new Event("error");
+            this.dispatchEvent(event);
+        });
+    }
+    set onmessage(f) {
+        throw new Error("UNIMPLEMENTED");
+    }
+    set onmessageerror(f) {
+        throw new Error("UNIMPLEMENTED");
+    }
+    set onerror(f) {
+        throw new Error("UNIMPLEMENTED");
+    }
+    postMessage(value, transfer) {
+        this._worker.postMessage(value, transfer);
+    }
+    terminate() {
+        this._worker.terminate();
+    }
+    // This is Node-specific, it allows the process to exit
+    // even if the Worker is still running.
+    unref() {
+        this._worker.unref();
+    }
+};
+if (!$worker.isMainThread) {
+    const globals = globalThis;
+    // This is used to create the onmessage, onmessageerror, and onerror setters
+    const makeSetter = (prop, event) => {
+        let oldvalue;
+        Object.defineProperty(globals, prop, {
+            get() {
+                return oldvalue;
+            },
+            set(value) {
+                if (oldvalue) {
+                    globals.removeEventListener(event, oldvalue);
+                }
+                oldvalue = value;
+                if (oldvalue) {
+                    globals.addEventListener(event, oldvalue);
+                }
+            },
+        });
+    };
+    // This makes sure that `f` is only run once
+    const memoize = (f) => {
+        let run = false;
+        return () => {
+            if (!run) {
+                run = true;
+                f();
+            }
+        };
+    };
+    // We only start listening for messages / errors when the worker calls addEventListener
+    const startOnMessage = memoize(() => {
+        $worker.parentPort.on("message", (data) => {
+            workerEvents.dispatchEvent(new MessageEvent("message", { data }));
+        });
+    });
+    const startOnMessageError = memoize(() => {
+        throw new Error("UNIMPLEMENTED");
+    });
+    const startOnError = memoize(() => {
+        $worker.parentPort.on("error", (data) => {
+            workerEvents.dispatchEvent(new Event("error"));
+        });
+    });
+    // Node workers don't have top-level events, so we have to make our own
+    const workerEvents = new EventTarget();
+    globals.close = () => {
+        process.exit();
+    };
+    globals.addEventListener = (type, callback, options) => {
+        workerEvents.addEventListener(type, callback, options);
+        if (type === "message") {
+            startOnMessage();
+        }
+        else if (type === "messageerror") {
+            startOnMessageError();
+        }
+        else if (type === "error") {
+            startOnError();
+        }
+    };
+    globals.removeEventListener = (type, callback, options) => {
+        workerEvents.removeEventListener(type, callback, options);
+    };
+    function postMessage(value, transfer) {
+        $worker.parentPort.postMessage(value, transfer);
+    }
+    globals.postMessage = postMessage;
+    makeSetter("onmessage", "message");
+    makeSetter("onmessageerror", "messageerror");
+    makeSetter("onerror", "error");
+}
+
+if (!globalThis.self) {
+    globalThis.self = globalThis;
+}
+//# sourceMappingURL=node-polyfill.js.map