@tideorg/js 0.13.19

package/dist/Models/VendorSettings.js

@@ -0,0 +1,32 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export default class VendorSettings {
+    constructor(regOn, backupOn, imageURL, logoURL) {
+        this.regOn = regOn;
+        this.backupOn = backupOn;
+        this.imageURL = imageURL;
+        this.logoURL = logoURL;
+    }
+    toString() {
+        return JSON.stringify({
+            RegOn: this.regOn,
+            BackupOn: this.backupOn,
+            ImageURL: this.imageURL,
+            LogoURL: this.logoURL
+        });
+    }
+}

package/dist/Models/index.d.ts

@@ -0,0 +1,13 @@
+export { default as AuthRequest } from './AuthRequest';
+export { default as BaseTideRequest } from './BaseTideRequest';
+export { default as Datum } from './Datum';
+export { Doken } from './Doken';
+export { default as EnclaveEntry } from './EnclaveEntry';
+export { ModelRegistry, HumanReadableModelBuilder, OffboardSignRequestBuilder } from './ModelRegistry';
+export { Policy, ApprovalType, ExecutionType } from './Policy';
+export { default as SerializedField } from './SerializedField';
+export { default as VendorData } from './VendorData';
+export { default as VendorSettings } from './VendorSettings';
+export * as Infos from './Infos';
+export * as Responses from './Responses';
+//# sourceMappingURL=index.d.ts.map

package/dist/Models/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../Models/index.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AACvG,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAG7D,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC"}

package/dist/Models/index.js

@@ -0,0 +1,30 @@
+//
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+//
+// This program is free software and is subject to the terms of
+// the Tide Community Open Code License as published by the
+// Tide Foundation Limited. You may modify it and redistribute
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind,
+// including without any implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+// Direct exports
+export { default as AuthRequest } from './AuthRequest';
+export { default as BaseTideRequest } from './BaseTideRequest';
+export { default as Datum } from './Datum';
+export { Doken } from './Doken';
+export { default as EnclaveEntry } from './EnclaveEntry';
+export { ModelRegistry, HumanReadableModelBuilder, OffboardSignRequestBuilder } from './ModelRegistry';
+export { Policy, ApprovalType, ExecutionType } from './Policy';
+export { default as SerializedField } from './SerializedField';
+export { default as VendorData } from './VendorData';
+export { default as VendorSettings } from './VendorSettings';
+// Namespace exports
+export * as Infos from './Infos';
+export * as Responses from './Responses';

package/dist/Tools/TideMemory.d.ts

@@ -0,0 +1,10 @@
+export declare class TideMemory extends Uint8Array {
+    static CreateFromArray(datas: Uint8Array[]): TideMemory;
+    static Create(initialValue: Uint8Array, totalLength: number, version?: number): TideMemory;
+    WriteValue(index: number, value: Uint8Array): void;
+    GetValue(index: number): TideMemory;
+    TryGetValue(index: number, returnObj: {
+        result: Uint8Array | undefined;
+    }): boolean;
+}
+//# sourceMappingURL=TideMemory.d.ts.map

package/dist/Tools/TideMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TideMemory.d.ts","sourceRoot":"","sources":["../../Tools/TideMemory.ts"],"names":[],"mappings":"AACA,qBAAa,UAAW,SAAQ,UAAU;IACtC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU;IASvD,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAU,GAAG,UAAU;IAyB7F,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IAwClD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAwCnC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE;QAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;KAAC,GAAG,OAAO;CASnF"}

package/dist/Tools/TideMemory.js

@@ -0,0 +1,105 @@
+// Tide Memory Object helper functions from tide-js
+export class TideMemory extends Uint8Array {
+    static CreateFromArray(datas) {
+        if (datas.length == 0)
+            return new TideMemory();
+        const length = datas.reduce((sum, next) => sum + 4 + next.length, 0);
+        const mem = this.Create(datas[0], length);
+        for (let i = 1; i < datas.length; i++) {
+            mem.WriteValue(i, datas[i]);
+        }
+        return mem;
+    }
+    static Create(initialValue, totalLength, version = 1) {
+        if (totalLength < initialValue.length + 4) {
+            throw new Error("Not enough space to allocate requested data. Make sure to request more space in totalLength than length of InitialValue plus 4 bytes for length.");
+        }
+        // Total buffer length is 4 (version) + totalLength
+        const bufferLength = 4 + totalLength;
+        const buffer = new TideMemory(bufferLength);
+        const dataView = new DataView(buffer.buffer);
+        // Write version at position 0 (4 bytes)
+        dataView.setInt32(0, version, true); // true for little-endian
+        let dataLocationIndex = 4;
+        // Write data length of initialValue at position 4 (4 bytes)
+        dataView.setInt32(dataLocationIndex, initialValue.length, true);
+        dataLocationIndex += 4;
+        // Write initialValue starting from position 8
+        buffer.set(initialValue, dataLocationIndex);
+        return buffer;
+    }
+    WriteValue(index, value) {
+        if (index < 0)
+            throw new Error("Index cannot be less than 0");
+        if (index === 0)
+            throw new Error("Use CreateTideMemory to set value at index 0");
+        if (this.length < 4 + value.length)
+            throw new Error("Could not write to memory. Memory too small for this value");
+        const dataView = new DataView(this.buffer);
+        let dataLocationIndex = 4; // Start after the version number
+        // Navigate through existing data segments
+        for (let i = 0; i < index; i++) {
+            if (dataLocationIndex + 4 > this.length) {
+                throw new RangeError("Index out of range.");
+            }
+            // Read data length at current position
+            const nextDataLength = dataView.getInt32(dataLocationIndex, true);
+            dataLocationIndex += 4;
+            dataLocationIndex += nextDataLength;
+        }
+        // Check if there's enough space to write the value
+        if (dataLocationIndex + 4 + value.length > this.length) {
+            throw new RangeError("Not enough space to write value");
+        }
+        // Check if data has already been written to this index
+        const existingLength = dataView.getInt32(dataLocationIndex, true);
+        if (existingLength !== 0) {
+            throw new Error("Data has already been written to this index");
+        }
+        // Write data length of value at current position
+        dataView.setInt32(dataLocationIndex, value.length, true);
+        dataLocationIndex += 4;
+        // Write value starting from current position
+        this.set(value, dataLocationIndex);
+    }
+    GetValue(index) {
+        // 'a' should be an ArrayBuffer or Uint8Array
+        if (this.length < 4) {
+            throw new Error("Insufficient data to read.");
+        }
+        // Create a DataView for reading integers in little-endian format
+        const dataView = new DataView(this.buffer, this.byteOffset, this.byteLength);
+        // Optional: Read the version if needed
+        // const version = dataView.getInt32(0, true);
+        let dataLocationIndex = 4;
+        for (let i = 0; i < index; i++) {
+            // Check if there's enough data to read the length of the next segment
+            if (dataLocationIndex + 4 > this.length) {
+                throw new RangeError("Index out of range.");
+            }
+            const nextDataLength = dataView.getInt32(dataLocationIndex, true);
+            dataLocationIndex += 4 + nextDataLength;
+        }
+        // Check if there's enough data to read the length of the final segment
+        if (dataLocationIndex + 4 > this.length) {
+            throw new RangeError("Index out of range.");
+        }
+        const finalDataLength = dataView.getInt32(dataLocationIndex, true);
+        dataLocationIndex += 4;
+        // Check if the final data segment is within bounds
+        if (dataLocationIndex + finalDataLength > this.length) {
+            throw new RangeError("Index out of range.");
+        }
+        return this.subarray(dataLocationIndex, dataLocationIndex + finalDataLength);
+    }
+    TryGetValue(index, returnObj) {
+        try {
+            returnObj.result = this.GetValue(index);
+            return true;
+        }
+        catch {
+            returnObj.result = undefined;
+            return false;
+        }
+    }
+}

package/dist/Tools/Utils.d.ts

@@ -0,0 +1,13 @@
+import OrkInfo from "../Models/Infos/OrkInfo";
+export declare const Threshold = 14;
+export declare const Max = 20;
+export declare function CurrentTime(): number;
+export declare function WaitForNumberofORKs(orkList_Ref: OrkInfo[], pre_responses: Promise<any>[], keyType: string, amountRequired?: number, bitwise_p?: (0 | 1)[], optionalArray?: any[], customTimeout?: number, customPromiseChecker?: Function): Promise<{
+    fulfilledResponses: any[];
+    bitwise: any[];
+}>;
+export declare function removeRandomElements(array: any[], targetArraySize: number): any[];
+export declare function randBetween(x: any, y: any): bigint;
+export declare function sortORKs(orks: OrkInfo[]): OrkInfo[];
+export declare function randomiseEmails(arr: any): any[];
+//# sourceMappingURL=Utils.d.ts.map

package/dist/Tools/Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.d.ts","sourceRoot":"","sources":["../../Tools/Utils.ts"],"names":[],"mappings":"AAiBA,OAAO,OAAO,MAAM,yBAAyB,CAAC;AAE9C,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,GAAG,KAAK,CAAC;AAEtB,wBAAgB,WAAW,WAE1B;AAiFD,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,OAAO,EAAE,EAAE,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,MAAkB,EAAE,SAAS,GAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAS,EAAE,aAAa,GAAE,GAAG,EAAS,EAAE,aAAa,GAAE,MAAa,EAAE,oBAAoB,GAAE,QAAe;;;GAgFlR;AACD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,eAAe,EAAE,MAAM,GAAG,GAAG,EAAE,CAejF;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,UAc/B;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,aAOvC;AAGD,wBAAgB,eAAe,CAAC,GAAG,KAAA,SA8BlC"}

package/dist/Tools/Utils.js

@@ -0,0 +1,242 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export const Threshold = 14;
+export const Max = 20;
+export function CurrentTime() {
+    return Math.floor(Date.now() / 1000); // this will be affected by the 2038 problem
+}
+async function PromiseRace(promises, keyType, amountRequired, customTimeout = null, customPromiseChecker = null) {
+    let results = [];
+    let failed = [];
+    let timeoutReached = false;
+    let initLength = promises.length;
+    // Function to set a timeout promise
+    const timeout = (ms, id) => new Promise(resolve => setTimeout(resolve, ms, id));
+    // Start the timeout checks
+    const oneSecondCheck = timeout(1000, '1s');
+    const timeoutLength = customTimeout == null ? 8000 : customTimeout;
+    const timeoutCheck = timeout(timeoutLength, 'ts');
+    promises.push(oneSecondCheck);
+    promises.push(timeoutCheck);
+    let oneSecCheckPassed = false;
+    let fullyCompletedPromises = 0;
+    while (promises.length > 0 && fullyCompletedPromises < initLength) {
+        const racePromises = promises.map((p, index) => p.then(result => ({ result, index })).catch(error => ({ error, index })));
+        const fastestPromise = await Promise.race(racePromises);
+        if (fastestPromise.result === '1s') {
+            oneSecCheckPassed = true;
+        }
+        else if (fastestPromise.result === 'ts') {
+            if (fullyCompletedPromises >= amountRequired) {
+                break;
+            }
+            else if (failed.length > 0) {
+                console.log("Errors in flow:");
+                failed.forEach(f => console.error(f));
+                break;
+            }
+            else {
+                timeoutReached = true;
+                break;
+            }
+        }
+        else {
+            if (!fastestPromise.error) {
+                if (customPromiseChecker != null) {
+                    if (customPromiseChecker(fastestPromise.result)) {
+                        fullyCompletedPromises++;
+                    }
+                    results.push(fastestPromise.result); // Promise resolved successfully
+                }
+                else {
+                    fullyCompletedPromises++;
+                    results.push(fastestPromise.result); // Promise resolved successfully
+                }
+            }
+            else {
+                failed.push(fastestPromise.error); // Promise rejected
+            }
+        }
+        // Removed one sec check passed condition for slighly faster requests - add back in when we start penalising orks
+        //if(oneSecCheckPassed && fullyCompletedPromises >=amountRequired) break;
+        if (fullyCompletedPromises >= amountRequired)
+            break;
+        // Remove the resolved or rejected promise from the list
+        promises.splice(fastestPromise.index, 1);
+    }
+    // Error checking and finalization
+    if (fullyCompletedPromises >= amountRequired) {
+        return results; // Return results if threshold amount is met
+    }
+    else {
+        if (failed.some(ex => ex === "Too many attempts")) {
+            throw Error("enclave.throttled");
+        }
+        else if (failed.length > 0) {
+            throw Error(failed[0]);
+        }
+        else if (timeoutReached) {
+            throw Error("enclave.thresholdTimeoutFailure");
+        }
+        else {
+            throw Error(keyType + " Orks for this account are down");
+        }
+    }
+}
+export async function WaitForNumberofORKs(orkList_Ref, pre_responses, keyType, amountRequired = Threshold, bitwise_p = null, optionalArray = null, customTimeout = null, customPromiseChecker = null) {
+    // See Utils.cs on Midgard Core for how this can be improved
+    // Basically, you don't need indexes in the responses, just use .indexOf
+    const unsortedResponses = await PromiseRace(pre_responses, keyType, amountRequired, customTimeout, customPromiseChecker);
+    const sortedResponses = unsortedResponses.sort((a, b) => a.index - b.index);
+    let bitwise = [];
+    if (bitwise_p != null) {
+        // bitwise provided, this func is being called from a sequential flow
+        // ork array will be modified 
+        // bitwise returned will be new/updated bitwise
+        // Get an array of active ork indexs (used to update bitwise)
+        let previousActiveOrkIndexes = [];
+        bitwise_p.forEach((b, i) => {
+            if (b == 1)
+                previousActiveOrkIndexes.push(i);
+        });
+        // This is too confusing to try and explain. Ask chatgpt.
+        // Hint: We have to skip existing unavilable orks in the bitwise and 
+        // take the indexes in the unresponsive list as the nth active bitwise element to switch off
+        let currentUnresponsiveOrkIndexs = []; // unresponsive ork indexes from an array that previpusly contained only active orks
+        let i = 0, j = 0;
+        console.log("total: " + orkList_Ref.length);
+        console.log("responded: " + sortedResponses.length);
+        while (i < orkList_Ref.length && j < sortedResponses.length) {
+            if (i === sortedResponses[j].index) {
+                i++;
+                j++;
+            }
+            else {
+                currentUnresponsiveOrkIndexs.push(i);
+                console.log(orkList_Ref[i].orkID + ":" + orkList_Ref[i].orkURL + " is slow");
+                i++;
+            }
+        }
+        // Add any remaining elements from orkLiftRef
+        while (i < orkList_Ref.length) {
+            currentUnresponsiveOrkIndexs.push(i);
+            console.log(orkList_Ref[i].orkID + ":" + orkList_Ref[i].orkURL + " is slow");
+            i++;
+        }
+        console.log("didn't respond: " + currentUnresponsiveOrkIndexs.length);
+        // TODO: once this works, shorten the code
+        bitwise = bitwise_p.slice();
+        let occurrenceCount = 0;
+        let indexCount = 0;
+        for (let i = 0; i < bitwise.length; i++) {
+            if (bitwise[i] === 1) {
+                occurrenceCount++;
+                if (occurrenceCount === currentUnresponsiveOrkIndexs[indexCount] + 1) { // + 1 as we are converting a index to a counter
+                    bitwise[i] = 0;
+                    indexCount++;
+                }
+            }
+        }
+    }
+    else {
+        bitwise = Array(Max).fill(0).map((_, i) => sortedResponses.every(resp => resp.index != i) ? 0 : 1);
+    }
+    const newOrkList = orkList_Ref.filter((_, i) => !sortedResponses.every(resp => resp.index != i)); // if ork at index 0 does not include a response with index 0, remove ork
+    orkList_Ref.splice(0, orkList_Ref.length);
+    newOrkList.forEach(el => orkList_Ref.push(el));
+    if (optionalArray != null) {
+        const newOptArray = optionalArray.filter((_, i) => !sortedResponses.every(resp => resp.index != i)); // modifies array!
+        optionalArray.splice(0, optionalArray.length);
+        newOptArray.forEach(el => optionalArray.push(el));
+    }
+    // remove index field from json, return the OTHER (unknown to us) field
+    const cleanedResponses = sortedResponses.map(resp => {
+        for (let key in resp) {
+            if (resp.hasOwnProperty(key) && key !== "index" && key !== "tag")
+                return resp[key];
+        }
+        throw Error("WaitForThresholdNumberofORKs should only be used on NodeClient responses that return an index in the JSON");
+    });
+    return { fulfilledResponses: cleanedResponses, bitwise };
+}
+export function removeRandomElements(array, targetArraySize) {
+    let newArray = array.slice();
+    // Check if the array size is > n
+    if (newArray.length < targetArraySize) {
+        throw new Error("Array size must be greater than n.");
+    }
+    else if (newArray.length == targetArraySize)
+        return newArray;
+    // Randomly remove elements until the array size is n
+    while (newArray.length > targetArraySize) {
+        let randomIndex = Math.floor(Math.random() * newArray.length);
+        newArray.splice(randomIndex, 1);
+    }
+    return newArray;
+}
+export function randBetween(x, y) {
+    // Swapping x and y if x is greater than y
+    x = BigInt(x);
+    y = BigInt(y);
+    if (x > y) {
+        const temp = x;
+        x = y;
+        y = temp;
+    }
+    // Generating random BigInt between x and y
+    const range = BigInt(y) - BigInt(x) + BigInt(1);
+    const randNum = Math.floor(Math.random() * Number(range));
+    const rand = BigInt(randNum);
+    return rand + BigInt(x);
+}
+export function sortORKs(orks) {
+    const orkRef = orks.slice(); // don't modify original
+    return orkRef.sort((a, b) => {
+        if (BigInt(a.orkID) < BigInt(b.orkID))
+            return -1;
+        if (BigInt(a.orkID) > BigInt(b.orkID))
+            return 1;
+        return 0;
+    });
+}
+export function randomiseEmails(arr) {
+    // Thanks ChatGPT
+    // Validation
+    if (arr == null) {
+        return Array(Max).fill(null);
+    }
+    // Prepare the output array
+    let output = [];
+    const repetitions = Math.floor(Max / arr.length); // Base number of repetitions for each element
+    let remainingSpaces = Max % arr.length; // Additional repetitions needed
+    // Fill the output array
+    arr.forEach(item => {
+        for (let i = 0; i < repetitions; i++) {
+            output.push(item);
+        }
+        if (remainingSpaces > 0) {
+            output.push(item);
+            remainingSpaces--;
+        }
+    });
+    // Shuffle the output array (Fisher-Yates shuffle)
+    for (let i = output.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [output[i], output[j]] = [output[j], output[i]]; // Swap elements
+    }
+    return output;
+}

package/dist/Tools/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Utils';
+export * from './TideMemory';
+//# sourceMappingURL=index.d.ts.map

package/dist/Tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../Tools/index.ts"],"names":[],"mappings":"AAiBA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

package/dist/Tools/index.js

@@ -0,0 +1,18 @@
+//
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+//
+// This program is free software and is subject to the terms of
+// the Tide Community Open Code License as published by the
+// Tide Foundation Limited. You may modify it and redistribute
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind,
+// including without any implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export * from './Utils';
+export * from './TideMemory';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * as Clients from './Clients';
+export * as Contracts from './Contracts';
+export * as Cryptide from './Cryptide';
+export * as Flow from './Flow';
+export * as Math from './Math';
+export * as Models from './Models';
+export * as Tools from './Tools';
+import * as Utils from './Tools';
+export { Utils };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAGjC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+//
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+//
+// This program is free software and is subject to the terms of
+// the Tide Community Open Code License as published by the
+// Tide Foundation Limited. You may modify it and redistribute
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind,
+// including without any implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export * as Clients from './Clients';
+export * as Contracts from './Contracts';
+export * as Cryptide from './Cryptide';
+export * as Flow from './Flow';
+export * as Math from './Math';
+export * as Models from './Models';
+export * as Tools from './Tools';
+// Backwards compatibility alias
+import * as Utils from './Tools';
+export { Utils };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@tideorg/js",
+  "version": "0.13.19",
+  "description": "Browser side modules required to interact with the Tide's Cybersecurity Fabric.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tide-foundation/tide-js.git"
+  },
+  "author": "",
+  "license": "SEE LICENSE IN LICENSE",
+  "bugs": {
+    "url": "https://github.com/tide-foundation/tide-js/issues"
+  },
+  "homepage": "https://github.com/tide-foundation/tide-js#readme",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}