@sen-use/web3/dist/ipfs.js

The library for Sentre

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.IPFS = void 0;
const web3_storage_1 = require("web3.storage");
const cid_1 = require("multiformats/cid");
const dataloader_1 = require("./dataloader");
class IPFS {
    constructor(key, IDL, endpoint = 'https://api.web3.storage') {
        this.key = key;
        this.IDL = IDL;
        this.endpoint = endpoint;
        this.decodeCID = (digest) => {
            if (typeof digest === 'string')
                return digest;
            const v0Prefix = new Uint8Array([18, 32]);
            const v0Digest = new Uint8Array(v0Prefix.length + (digest === null || digest === void 0 ? void 0 : digest.length));
            v0Digest.set(v0Prefix); // multicodec + length
            v0Digest.set(digest, v0Prefix.length);
            const cid = cid_1.CID.decode(v0Digest);
            return cid.toString();
        };
        this.provider = new web3_storage_1.Web3Storage({
            endpoint: new URL(this.endpoint),
            token: this.key,
        });
    }
    get methods() {
        const methods = {};
        for (const elm of this.IDL) {
            methods[elm] = {
                set: (data) => this.set(data),
                get: (digest) => this.get(digest),
            };
        }
        return methods;
    }
    set(data) {
        return __awaiter(this, void 0, void 0, function* () {
            const file = new web3_storage_1.File([JSON.stringify(data)], 'file', {
                type: 'application/json',
            });
            const cid = yield this.provider.put([file]);
            const { multihash: { digest }, } = cid_1.CID.parse(cid);
            return { cid, digest };
        });
    }
    get(digest) {
        return __awaiter(this, void 0, void 0, function* () {
            const cid = this.decodeCID(digest);
            return dataloader_1.DataLoader.load(`ipfs:${cid}`, () => __awaiter(this, void 0, void 0, function* () {
                const re = yield this.provider.get(cid);
                const file = ((yield (re === null || re === void 0 ? void 0 : re.files())) || [])[0];
                const reader = new FileReader();
                return new Promise((resolve, reject) => {
                    try {
                        if (!file)
                            throw new Error('Cannot read empty file');
                        reader.onload = () => {
                            var _a;
                            const contents = (_a = reader.result) === null || _a === void 0 ? void 0 : _a.toString();
                            if (!contents)
                                throw new Error('Cannot read empty file');
                            return resolve(JSON.parse(contents));
                        };
                        reader.readAsText(file);
                    }
                    catch (er) {
                        return reject(er.message);
                    }
                });
            }));
        });
    }
}
exports.IPFS = IPFS;