@super-protocol/sdk-js 0.6.0

package/build/proto/TRI.d.ts

@@ -0,0 +1,122 @@
+import * as _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "";
+export interface Encryption {
+    algo: string;
+    key?: Uint8Array | undefined;
+    cipher?: string | undefined;
+    ciphertext?: Uint8Array | undefined;
+    iv?: Uint8Array | undefined;
+    mac?: Uint8Array | undefined;
+    encoding: string;
+}
+export interface Hash {
+    type: string;
+    hash: Uint8Array;
+}
+export interface TRI {
+    solutionHashes: Hash[];
+    mrenclave: Uint8Array;
+    args: string;
+    encryption: Encryption | undefined;
+}
+export declare const Encryption: {
+    encode(message: Encryption, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Encryption;
+    fromJSON(object: any): Encryption;
+    toJSON(message: Encryption): unknown;
+    fromPartial<I extends {
+        algo?: string | undefined;
+        key?: Uint8Array | undefined;
+        cipher?: string | undefined;
+        ciphertext?: Uint8Array | undefined;
+        iv?: Uint8Array | undefined;
+        mac?: Uint8Array | undefined;
+        encoding?: string | undefined;
+    } & {
+        algo?: string | undefined;
+        key?: Uint8Array | undefined;
+        cipher?: string | undefined;
+        ciphertext?: Uint8Array | undefined;
+        iv?: Uint8Array | undefined;
+        mac?: Uint8Array | undefined;
+        encoding?: string | undefined;
+    } & Record<Exclude<keyof I, keyof Encryption>, never>>(object: I): Encryption;
+};
+export declare const Hash: {
+    encode(message: Hash, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Hash;
+    fromJSON(object: any): Hash;
+    toJSON(message: Hash): unknown;
+    fromPartial<I extends {
+        type?: string | undefined;
+        hash?: Uint8Array | undefined;
+    } & {
+        type?: string | undefined;
+        hash?: Uint8Array | undefined;
+    } & Record<Exclude<keyof I, keyof Hash>, never>>(object: I): Hash;
+};
+export declare const TRI: {
+    encode(message: TRI, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TRI;
+    fromJSON(object: any): TRI;
+    toJSON(message: TRI): unknown;
+    fromPartial<I extends {
+        solutionHashes?: {
+            type?: string | undefined;
+            hash?: Uint8Array | undefined;
+        }[] | undefined;
+        mrenclave?: Uint8Array | undefined;
+        args?: string | undefined;
+        encryption?: {
+            algo?: string | undefined;
+            key?: Uint8Array | undefined;
+            cipher?: string | undefined;
+            ciphertext?: Uint8Array | undefined;
+            iv?: Uint8Array | undefined;
+            mac?: Uint8Array | undefined;
+            encoding?: string | undefined;
+        } | undefined;
+    } & {
+        solutionHashes?: ({
+            type?: string | undefined;
+            hash?: Uint8Array | undefined;
+        }[] & ({
+            type?: string | undefined;
+            hash?: Uint8Array | undefined;
+        } & {
+            type?: string | undefined;
+            hash?: Uint8Array | undefined;
+        } & Record<Exclude<keyof I["solutionHashes"][number], keyof Hash>, never>)[] & Record<Exclude<keyof I["solutionHashes"], keyof {
+            type?: string | undefined;
+            hash?: Uint8Array | undefined;
+        }[]>, never>) | undefined;
+        mrenclave?: Uint8Array | undefined;
+        args?: string | undefined;
+        encryption?: ({
+            algo?: string | undefined;
+            key?: Uint8Array | undefined;
+            cipher?: string | undefined;
+            ciphertext?: Uint8Array | undefined;
+            iv?: Uint8Array | undefined;
+            mac?: Uint8Array | undefined;
+            encoding?: string | undefined;
+        } & {
+            algo?: string | undefined;
+            key?: Uint8Array | undefined;
+            cipher?: string | undefined;
+            ciphertext?: Uint8Array | undefined;
+            iv?: Uint8Array | undefined;
+            mac?: Uint8Array | undefined;
+            encoding?: string | undefined;
+        } & Record<Exclude<keyof I["encryption"], keyof Encryption>, never>) | undefined;
+    } & Record<Exclude<keyof I, keyof TRI>, never>>(object: I): TRI;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+declare type KeysOfUnion<T> = T extends T ? keyof T : never;
+export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
+export {};

package/build/proto/TRI.js

@@ -0,0 +1,316 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRI = exports.Hash = exports.Encryption = exports.protobufPackage = void 0;
+/* eslint-disable */
+var long_1 = __importDefault(require("long"));
+var _m0 = __importStar(require("protobufjs/minimal"));
+exports.protobufPackage = "";
+function createBaseEncryption() {
+    return {
+        algo: "",
+        key: undefined,
+        cipher: undefined,
+        ciphertext: undefined,
+        iv: undefined,
+        mac: undefined,
+        encoding: "",
+    };
+}
+exports.Encryption = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.algo !== "") {
+            writer.uint32(10).string(message.algo);
+        }
+        if (message.key !== undefined) {
+            writer.uint32(18).bytes(message.key);
+        }
+        if (message.cipher !== undefined) {
+            writer.uint32(26).string(message.cipher);
+        }
+        if (message.ciphertext !== undefined) {
+            writer.uint32(34).bytes(message.ciphertext);
+        }
+        if (message.iv !== undefined) {
+            writer.uint32(50).bytes(message.iv);
+        }
+        if (message.mac !== undefined) {
+            writer.uint32(58).bytes(message.mac);
+        }
+        if (message.encoding !== "") {
+            writer.uint32(66).string(message.encoding);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseEncryption();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.algo = reader.string();
+                    break;
+                case 2:
+                    message.key = reader.bytes();
+                    break;
+                case 3:
+                    message.cipher = reader.string();
+                    break;
+                case 4:
+                    message.ciphertext = reader.bytes();
+                    break;
+                case 6:
+                    message.iv = reader.bytes();
+                    break;
+                case 7:
+                    message.mac = reader.bytes();
+                    break;
+                case 8:
+                    message.encoding = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            algo: isSet(object.algo) ? String(object.algo) : "",
+            key: isSet(object.key) ? bytesFromBase64(object.key) : undefined,
+            cipher: isSet(object.cipher) ? String(object.cipher) : undefined,
+            ciphertext: isSet(object.ciphertext) ? bytesFromBase64(object.ciphertext) : undefined,
+            iv: isSet(object.iv) ? bytesFromBase64(object.iv) : undefined,
+            mac: isSet(object.mac) ? bytesFromBase64(object.mac) : undefined,
+            encoding: isSet(object.encoding) ? String(object.encoding) : "",
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.algo !== undefined && (obj.algo = message.algo);
+        message.key !== undefined && (obj.key = message.key !== undefined ? base64FromBytes(message.key) : undefined);
+        message.cipher !== undefined && (obj.cipher = message.cipher);
+        message.ciphertext !== undefined &&
+            (obj.ciphertext = message.ciphertext !== undefined ? base64FromBytes(message.ciphertext) : undefined);
+        message.iv !== undefined && (obj.iv = message.iv !== undefined ? base64FromBytes(message.iv) : undefined);
+        message.mac !== undefined && (obj.mac = message.mac !== undefined ? base64FromBytes(message.mac) : undefined);
+        message.encoding !== undefined && (obj.encoding = message.encoding);
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var message = createBaseEncryption();
+        message.algo = (_a = object.algo) !== null && _a !== void 0 ? _a : "";
+        message.key = (_b = object.key) !== null && _b !== void 0 ? _b : undefined;
+        message.cipher = (_c = object.cipher) !== null && _c !== void 0 ? _c : undefined;
+        message.ciphertext = (_d = object.ciphertext) !== null && _d !== void 0 ? _d : undefined;
+        message.iv = (_e = object.iv) !== null && _e !== void 0 ? _e : undefined;
+        message.mac = (_f = object.mac) !== null && _f !== void 0 ? _f : undefined;
+        message.encoding = (_g = object.encoding) !== null && _g !== void 0 ? _g : "";
+        return message;
+    },
+};
+function createBaseHash() {
+    return { type: "", hash: new Uint8Array() };
+}
+exports.Hash = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.type !== "") {
+            writer.uint32(10).string(message.type);
+        }
+        if (message.hash.length !== 0) {
+            writer.uint32(18).bytes(message.hash);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseHash();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.string();
+                    break;
+                case 2:
+                    message.hash = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            type: isSet(object.type) ? String(object.type) : "",
+            hash: isSet(object.hash) ? bytesFromBase64(object.hash) : new Uint8Array(),
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.type !== undefined && (obj.type = message.type);
+        message.hash !== undefined &&
+            (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b;
+        var message = createBaseHash();
+        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : "";
+        message.hash = (_b = object.hash) !== null && _b !== void 0 ? _b : new Uint8Array();
+        return message;
+    },
+};
+function createBaseTRI() {
+    return { solutionHashes: [], mrenclave: new Uint8Array(), args: "", encryption: undefined };
+}
+exports.TRI = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        for (var _i = 0, _a = message.solutionHashes; _i < _a.length; _i++) {
+            var v = _a[_i];
+            exports.Hash.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.mrenclave.length !== 0) {
+            writer.uint32(18).bytes(message.mrenclave);
+        }
+        if (message.args !== "") {
+            writer.uint32(26).string(message.args);
+        }
+        if (message.encryption !== undefined) {
+            exports.Encryption.encode(message.encryption, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseTRI();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.solutionHashes.push(exports.Hash.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.mrenclave = reader.bytes();
+                    break;
+                case 3:
+                    message.args = reader.string();
+                    break;
+                case 4:
+                    message.encryption = exports.Encryption.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            solutionHashes: Array.isArray(object === null || object === void 0 ? void 0 : object.solutionHashes)
+                ? object.solutionHashes.map(function (e) { return exports.Hash.fromJSON(e); })
+                : [],
+            mrenclave: isSet(object.mrenclave) ? bytesFromBase64(object.mrenclave) : new Uint8Array(),
+            args: isSet(object.args) ? String(object.args) : "",
+            encryption: isSet(object.encryption) ? exports.Encryption.fromJSON(object.encryption) : undefined,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        if (message.solutionHashes) {
+            obj.solutionHashes = message.solutionHashes.map(function (e) { return (e ? exports.Hash.toJSON(e) : undefined); });
+        }
+        else {
+            obj.solutionHashes = [];
+        }
+        message.mrenclave !== undefined &&
+            (obj.mrenclave = base64FromBytes(message.mrenclave !== undefined ? message.mrenclave : new Uint8Array()));
+        message.args !== undefined && (obj.args = message.args);
+        message.encryption !== undefined &&
+            (obj.encryption = message.encryption ? exports.Encryption.toJSON(message.encryption) : undefined);
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c;
+        var message = createBaseTRI();
+        message.solutionHashes = ((_a = object.solutionHashes) === null || _a === void 0 ? void 0 : _a.map(function (e) { return exports.Hash.fromPartial(e); })) || [];
+        message.mrenclave = (_b = object.mrenclave) !== null && _b !== void 0 ? _b : new Uint8Array();
+        message.args = (_c = object.args) !== null && _c !== void 0 ? _c : "";
+        message.encryption =
+            object.encryption !== undefined && object.encryption !== null
+                ? exports.Encryption.fromPartial(object.encryption)
+                : undefined;
+        return message;
+    },
+};
+var globalThis = (function () {
+    if (typeof globalThis !== "undefined")
+        return globalThis;
+    if (typeof self !== "undefined")
+        return self;
+    if (typeof window !== "undefined")
+        return window;
+    if (typeof global !== "undefined")
+        return global;
+    throw "Unable to locate global object";
+})();
+var atob = globalThis.atob || (function (b64) { return globalThis.Buffer.from(b64, "base64").toString("binary"); });
+function bytesFromBase64(b64) {
+    var bin = atob(b64);
+    var arr = new Uint8Array(bin.length);
+    for (var i = 0; i < bin.length; ++i) {
+        arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+}
+var btoa = globalThis.btoa || (function (bin) { return globalThis.Buffer.from(bin, "binary").toString("base64"); });
+function base64FromBytes(arr) {
+    var bin = [];
+    arr.forEach(function (byte) {
+        bin.push(String.fromCharCode(byte));
+    });
+    return btoa(bin.join(""));
+}
+if (_m0.util.Long !== long_1.default) {
+    _m0.util.Long = long_1.default;
+    _m0.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/build/providers/storage/ChunksDownloadDecorator.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from "stream";
+import Offer from "../../models/Offer";
+import StorageObject from "../../types/storage/StorageObject";
+import IStorageProvider, { DownloadConfig } from "./IStorageProvider";
+export declare type DownloadChunkMethodType = (provider: IStorageProvider, objectPath: string, chunk: ChunkType) => Promise<Buffer>;
+export declare type RetryDownloadChunkOptions = {
+    retryMaxCount?: number;
+    onRetry?: (error: unknown, chunk: ChunkType, attemptLeft: number) => void;
+    retryWaitTimeFactory?: () => () => number;
+};
+export declare type ChunkType = {
+    offset: bigint;
+    length: number;
+    dataSize: bigint;
+    chunk: number;
+    chunkCount: number;
+};
+export declare const downloadChunkMethod: (provider: IStorageProvider, objectPath: string, chunk: ChunkType) => Promise<Buffer>;
+export declare const createDownloadChunkMethodWithRetry: (downloadChunkMethod: DownloadChunkMethodType, { retryMaxCount, retryWaitTimeFactory, onRetry }?: RetryDownloadChunkOptions) => DownloadChunkMethodType;
+export declare class DownloadDecorator implements IStorageProvider {
+    private provider;
+    private chunkDownloaderMethod;
+    private options;
+    constructor(provider: IStorageProvider, chunkDownloaderMethod: DownloadChunkMethodType, options: {
+        chunkSize: number;
+        concurrency: number;
+        offset?: number;
+    });
+    uploadFile(inputStream: Readable, remotePath: string, contentLength: number, progressListener?: (total: number, current: number) => void): Promise<void>;
+    downloadFile(remotePath: string, config?: DownloadConfig, progressListener?: (total: number, current: number) => void): Promise<Readable>;
+    deleteObject(remotePath: string): Promise<void>;
+    listObjects(remotePath: string): Promise<StorageObject[]>;
+    getObjectSize(remotePath: string): Promise<number>;
+    getLastModified(remotePath: string): Promise<Date>;
+    calculateStorageDeposit(offer: Offer, sizeMb: number, hours: number): Promise<string>;
+}