@nihilium/client-sdk 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,51 +0,0 @@
-// Example: re-export browser entry from privacy-lib
-import * as nhsdk from '@nihilium/privacy-lib';
-export * from '@nihilium/privacy-lib';
-import { getDatastreams, getProcessors, getProcessorEndpoint } from './lib/endpoint-selection';
-export { getFullDatastreams, getFullProcessors } from './lib/endpoint-selection';
-export { getProcessorEndpoint, setApiEndpoint } from './lib/endpoint-selection';
-export const cryptoTools = nhsdk.cryptoTools;
-// export const devProcessorUrl:string = "https://processor1.nihilium.io";
-// export const devDataStreamUrl:string = "https://datastream1.nihilium.io";
-export async function check_if_reveal_value_is_published(datastream_url, reveal_value) {
-    const dataStream = new nhsdk.DataStreamClient(datastream_url);
-    await dataStream.initialize();
-    const isProvable = await dataStream.isProvable(reveal_value.toString());
-    return isProvable;
-}
-// export async function getSealingProcessing(
-//     processorEndpoint: SelectableProcessor,
-//     dataStream: SelectableDataStream,
-//     chainedProofCollection:nhsdk.ChainedProofCollection) {
-//     const resolvedProcessorEndpoint = await getProcessorEndpoint(processorEndpoint.url);
-//     const resolvedDataStream = new nhsdk.DataStreamClient(dataStream.url);
-//     const proofCollection = chainedProofCollection;
-//     const sealingProcess = new nhsdk.ClientSingleShareSealingProcess(
-//         resolvedProcessorEndpoint,
-//         proofCollection);
-//     return sealingProcess;
-// }
-export async function getDefaultSealingProcess(chainId = nhsdk.NETWORK_IDS.ANVIL) {
-    var dataStreams = await getDatastreams();
-    var dataStream = dataStreams[0];
-    const resolvedDataStream = new nhsdk.DataStreamClient(dataStream.url);
-    await resolvedDataStream.initialize();
-    var processorEndpoints = await getProcessors();
-    var processorEndpoint = processorEndpoints[0];
-    const resolvedProcessorEndpoint = await getProcessorEndpoint(processorEndpoint.url);
-    const genanche = nhsdk.deployedProtocolContracts[chainId];
-    const proofCollection = nhsdk.createRevealOnlyCollection(chainId);
-    const sealingProcess = new nhsdk.ClientSingleShareSealingProcess(resolvedProcessorEndpoint, [resolvedDataStream], proofCollection.template);
-    return sealingProcess;
-}
-export async function getDefaultUnsealingProcess(seal, chainId = nhsdk.NETWORK_IDS.ANVIL) {
-    const processorEndpoint = await getProcessorEndpoint(seal.public_package.processor_url);
-    const dataStream = new nhsdk.DataStreamClient(seal.public_package.data_stream_urls[0]);
-    await dataStream.initialize();
-    const proofCollectionClass = nhsdk.createRevealOnlyCollection(chainId);
-    // Spread the fields of reveal_collection_inputs as constructor arguments, then add [dataStream] as the last argument
-    proofCollectionClass.template = nhsdk.CollectionTemplateTypes.from_json(seal.private_package.unseal_template, nhsdk.proofLibrary, nhsdk.moduleLibrary);
-    var unsealingProcess = new nhsdk.ClientSingleShareUnsealingProcess(processorEndpoint, proofCollectionClass.collection, proofCollectionClass.template, { [dataStream.getAddress()]: dataStream }, seal);
-    return unsealingProcess;
-}
-export { nhsdk };

package/dist/lib/endpoint-selection.d.ts

@@ -1,14 +0,0 @@
-import { SelectableDataStream, SelectableProcessor } from "./types";
-import * as nhsdk from "@nihilium/privacy-lib";
-export declare function setApiEndpoint(endpoint: string): void;
-export declare function getProcessors(): Promise<SelectableProcessor[]>;
-export declare function getDatastreams(): Promise<SelectableDataStream[]>;
-export declare function getProcessorEndpoint(url: string): Promise<{
-    url: string;
-    is_tor: boolean;
-    public_verification_key: [bigint, bigint];
-    public_he_encryption_key: [bigint, bigint];
-    server_address: string;
-}>;
-export declare function getFullDatastreams(): Promise<nhsdk.DataStreamClient[]>;
-export declare function getFullProcessors(): Promise<nhsdk.protocolTypes.ProcessorEndpoint[]>;

package/dist/lib/endpoint-selection.js

@@ -1,79 +0,0 @@
-import { API_PATHS } from "../api-endpoints";
-import * as nhsdk from "@nihilium/privacy-lib";
-import axios from "axios";
-var apiEndpoint = "https://api.nihilium.io";
-//var apiEndpoint = "http://localhost:8080";
-export function setApiEndpoint(endpoint) {
-    apiEndpoint = endpoint;
-}
-export async function getProcessors() {
-    const response = await fetch(`${apiEndpoint}/${API_PATHS.GET_PROCESSORS}`);
-    const data = await response.json();
-    return data;
-    // return [
-    //     {
-    //         url: "https://processor1.nihilium.io",
-    //         is_tor: false,
-    //         jurisdiction: "US",
-    //         stake: BigInt(1000000000000000000),
-    //     },
-    //     {
-    //         url: "https://processor2.nihilium.io",
-    //         is_tor: false,
-    //         jurisdiction: "US",
-    //         stake: BigInt(1000000000000000000),
-    //     },
-    //     {
-    //         url: "https://processor3.nihilium.io",
-    //         is_tor: false,
-    //         jurisdiction: "US",
-    //         stake: BigInt(1000000000000000000),
-    //     },
-    // ]
-}
-export async function getDatastreams() {
-    const response = await fetch(`${apiEndpoint}/${API_PATHS.GET_DATA_STREAMS}`);
-    const data = await response.json();
-    return data;
-    // return [
-    //     {
-    //         url: "https://datastream1.nihilium.io",
-    //         is_tor: false,
-    //         jurisdiction: "US",
-    //         stake: BigInt(1000000000000000000),
-    //     },
-    //     {
-    //         url: "https://datastream2.nihilium.io",
-    //         is_tor: false,
-    //         jurisdiction: "US",
-    //         stake: BigInt(1000000000000000000),
-    //     },
-    //     {
-    //         url: "https://datastream3.nihilium.io",
-    //         is_tor: false,
-    //         jurisdiction: "US",
-    //         stake: BigInt(1000000000000000000),
-    //     },
-    // ]
-}
-export async function getProcessorEndpoint(url) {
-    const response = await axios.get(url + "/get_public_keys");
-    const data = response.data;
-    const addsPubKey = [data.signing_public_key[0], data.signing_public_key[1]];
-    const he_encryption = [data.he_public_key[0], data.he_public_key[1]];
-    return {
-        url: url,
-        is_tor: false,
-        public_verification_key: [BigInt(addsPubKey[0]), BigInt(addsPubKey[1])],
-        public_he_encryption_key: [BigInt(he_encryption[0]), BigInt(he_encryption[1])],
-        server_address: "0x0000000000000000000000000000000000000000000000000000000000000000"
-    };
-}
-export async function getFullDatastreams() {
-    const dataStreams = await getDatastreams();
-    return dataStreams.map(dataStream => new nhsdk.DataStreamClient(dataStream.url));
-}
-export async function getFullProcessors() {
-    const processors = await getProcessors();
-    return Promise.all(processors.map(async (processor) => await getProcessorEndpoint(processor.url)));
-}

package/dist/lib/nihiliumapi.d.ts

@@ -1,19 +0,0 @@
-import { SelectableDataStream, SelectableProcessor } from "./types";
-export declare const API_PATHS: {
-    GET_PROCESSORS: string;
-    GET_DATA_STREAMS: string;
-    GET_PROCESSOR_TOKEN: string;
-    GET_DATA_STREAM_TOKEN: string;
-};
-export declare function exampleProcessorTokenRequest(endpoint: string, processorId: string, requestId: string): Promise<any>;
-export declare function exampleDataStreamTokenRequest(endpoint: string, dataStreamId: string, requestId: string): Promise<any>;
-export declare class NihiliumAPI {
-    protected endpoint: string;
-    protected processorTokenRequest: (processorId: string, requestId: string) => Promise<string>;
-    protected dataStreamTokenRequest: (dataStreamId: string, requestId: string) => Promise<string>;
-    constructor(endpoint: string, processorTokenRequest?: (processorId: string, requestId: string) => Promise<string>, dataStreamTokenRequest?: (dataStreamId: string, requestId: string) => Promise<string>);
-    getProcessors(): Promise<SelectableProcessor[]>;
-    getDatastreams(): Promise<SelectableDataStream[]>;
-    getProcessorToken(processorId: string, requestId: string): Promise<string>;
-    getDataStreamToken(dataStreamId: string, requestId: string): Promise<string>;
-}

package/dist/lib/nihiliumapi.js

@@ -1,49 +0,0 @@
-export const API_PATHS = {
-    GET_PROCESSORS: "api/get-processors",
-    GET_DATA_STREAMS: "api/get-datastreams",
-    GET_PROCESSOR_TOKEN: "api/get-processor-token",
-    GET_DATA_STREAM_TOKEN: "api/get-datastream-token"
-};
-export async function exampleProcessorTokenRequest(endpoint, processorId, requestId) {
-    const response = await fetch(`${endpoint}/${API_PATHS.GET_PROCESSOR_TOKEN}`, {
-        method: "POST",
-        body: JSON.stringify({ processorId, requestId }),
-        headers: {
-            "Content-Type": "application/json",
-            "X-API-Key": `user-key`
-        }
-    });
-    return response.json();
-}
-export async function exampleDataStreamTokenRequest(endpoint, dataStreamId, requestId) {
-    const response = await fetch(`${endpoint}/${API_PATHS.GET_DATA_STREAM_TOKEN}`, {
-        method: "POST",
-        body: JSON.stringify({ dataStreamId, requestId }),
-        headers: {
-            "Content-Type": "application/json",
-            "X-API-Key": `user-key`
-        }
-    });
-    return response.json();
-}
-export class NihiliumAPI {
-    constructor(endpoint, processorTokenRequest, dataStreamTokenRequest) {
-        this.endpoint = endpoint;
-        this.processorTokenRequest = processorTokenRequest || (async (processorId, requestId) => { return await exampleProcessorTokenRequest(this.endpoint, processorId, requestId); });
-        this.dataStreamTokenRequest = dataStreamTokenRequest || (async (dataStreamId, requestId) => { return await exampleDataStreamTokenRequest(this.endpoint, dataStreamId, requestId); });
-    }
-    async getProcessors() {
-        const response = await fetch(`${this.endpoint}/${API_PATHS.GET_PROCESSORS}`);
-        return response.json();
-    }
-    async getDatastreams() {
-        const response = await fetch(`${this.endpoint}/${API_PATHS.GET_DATA_STREAMS}`);
-        return response.json();
-    }
-    async getProcessorToken(processorId, requestId) {
-        return await this.processorTokenRequest(processorId, requestId);
-    }
-    async getDataStreamToken(dataStreamId, requestId) {
-        return await this.dataStreamTokenRequest(dataStreamId, requestId);
-    }
-}

package/dist/lib/server-client.d.ts

@@ -1,7 +0,0 @@
-import { NihiliumAPI } from "./nihiliumapi";
-export declare class DevSDKAPIClient extends NihiliumAPI {
-    private apiKey;
-    constructor(endpoint: string, apiKey: string);
-    exampleProcessorTokenRequest(processorId: string, requestId: string): Promise<any>;
-    exampleDataStreamTokenRequest(dataStreamId: string, requestId: string): Promise<any>;
-}

package/dist/lib/server-client.js

@@ -1,31 +0,0 @@
-import { NihiliumAPI, API_PATHS } from "./nihiliumapi";
-export class DevSDKAPIClient extends NihiliumAPI {
-    constructor(endpoint, apiKey) {
-        super(endpoint);
-        this.apiKey = apiKey;
-        this.processorTokenRequest = this.exampleProcessorTokenRequest;
-        this.dataStreamTokenRequest = this.exampleDataStreamTokenRequest;
-    }
-    async exampleProcessorTokenRequest(processorId, requestId) {
-        const response = await fetch(`${this.endpoint}/${API_PATHS.GET_PROCESSOR_TOKEN}`, {
-            method: "POST",
-            body: JSON.stringify({ processorId, requestId }),
-            headers: {
-                "Content-Type": "application/json",
-                "X-API-Key": this.apiKey
-            }
-        });
-        return response.json();
-    }
-    async exampleDataStreamTokenRequest(dataStreamId, requestId) {
-        const response = await fetch(`${this.endpoint}/${API_PATHS.GET_DATA_STREAM_TOKEN}`, {
-            method: "POST",
-            body: JSON.stringify({ dataStreamId, requestId }),
-            headers: {
-                "Content-Type": "application/json",
-                "X-API-Key": this.apiKey
-            }
-        });
-        return response.json();
-    }
-}

package/dist/lib/types.d.ts

@@ -1,12 +0,0 @@
-export type SelectableProcessor = {
-    url: string;
-    is_tor: boolean;
-    jurisdiction: string;
-    stake: bigint;
-};
-export type SelectableDataStream = {
-    url: string;
-    is_tor: boolean;
-    jurisdiction: string;
-    stake: bigint;
-};

package/dist/lib/types.js

@@ -1 +0,0 @@
-export {};