@blocklet/store 1.16.26-beta-c724c8e6

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018-2020 ArcBlock
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/dist/index.cjs

@@ -0,0 +1,365 @@
+'use strict';
+
+const security = require('@abtnode/util/lib/security');
+const lodash = require('lodash');
+const tweetnacl = require('tweetnacl');
+const SealedBox = require('tweetnacl-sealedbox-js');
+const joinUrl = require('url-join');
+const axios = require('@abtnode/util/lib/axios');
+const pWaitFor = require('p-wait-for');
+const wallet = require('@ocap/wallet');
+const util$1 = require('@blocklet/meta/lib/util');
+const path = require('path');
+const fs$1 = require('fs-extra');
+const did = require('@arcblock/did');
+const v2 = require('@blocklet/meta/lib/payment/v2');
+const FormData = require('form-data');
+const Client = require('@ocap/client');
+const constant$1 = require('@abtnode/constant');
+const constant = require('@blocklet/constant');
+const util = require('@ocap/util');
+const stableStringify = require('json-stable-stringify');
+const xbytes = require('xbytes');
+const fs = require('fs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const tweetnacl__default = /*#__PURE__*/_interopDefaultCompat(tweetnacl);
+const SealedBox__default = /*#__PURE__*/_interopDefaultCompat(SealedBox);
+const joinUrl__default = /*#__PURE__*/_interopDefaultCompat(joinUrl);
+const axios__default = /*#__PURE__*/_interopDefaultCompat(axios);
+const pWaitFor__default = /*#__PURE__*/_interopDefaultCompat(pWaitFor);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+const FormData__default = /*#__PURE__*/_interopDefaultCompat(FormData);
+const Client__default = /*#__PURE__*/_interopDefaultCompat(Client);
+const stableStringify__default = /*#__PURE__*/_interopDefaultCompat(stableStringify);
+const xbytes__default = /*#__PURE__*/_interopDefaultCompat(xbytes);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function request(options) {
+  return axios__default({
+    maxContentLength: Number.POSITIVE_INFINITY,
+    maxBodyLength: Number.POSITIVE_INFINITY,
+    ...options
+  });
+}
+
+const fetchConfigs = async ({
+  connectUrl,
+  sessionId,
+  fetchInterval,
+  fetchTimeout,
+  connectAction
+}) => {
+  const ENDPOINT_CHECK_SESSION = `/api/did/${connectAction}/status`;
+  const ENDPOINT_INVALIDATE_SESSION = `/api/did/${connectAction}/timeout`;
+  const fetchSessionStatus = async () => {
+    const url = `${joinUrl__default(connectUrl, ENDPOINT_CHECK_SESSION)}?_t_=${sessionId}`;
+    const { data } = await request({
+      url,
+      method: "GET",
+      timeout: fetchTimeout
+    });
+    return data;
+  };
+  const condition = async () => {
+    const { status, error } = await fetchSessionStatus();
+    if (status === "error" || !!error) {
+      throw new Error(error);
+    }
+    return status === "succeed";
+  };
+  try {
+    await pWaitFor__default(condition, { interval: fetchInterval, timeout: fetchTimeout });
+    const { config } = await fetchSessionStatus();
+    return config;
+  } catch (e) {
+    const err = e;
+    if (err.name === "TimeoutError") {
+      await request({
+        url: `${joinUrl__default(connectUrl, ENDPOINT_INVALIDATE_SESSION)}?_t_=${sessionId}`,
+        method: "GET",
+        timeout: fetchTimeout
+      });
+    }
+    throw err;
+  }
+};
+
+function baseWrapSpinner(_, waiting) {
+  return Promise.resolve(waiting());
+}
+
+async function createConnect({
+  connectUrl = "https://store.blocklet.dev",
+  openPage,
+  fetchTimeout = 30 * 1e3,
+  fetchInterval = 3 * 1e3,
+  retry = 60,
+  connectAction = "connect-cli",
+  wrapSpinner = baseWrapSpinner,
+  enableEncrypt = false,
+  ...restParams
+} = {}) {
+  const ENDPOINT_CREATE_SESSION = `/api/did/${connectAction}/token`;
+  const DID_CONNECT_URL = `/${connectAction}`;
+  const keyPair = tweetnacl__default.box.keyPair();
+  const decrypt = (value) => {
+    const decrypted = SealedBox__default.open(
+      Uint8Array.from(Buffer.from(value, "base64")),
+      keyPair.publicKey,
+      keyPair.secretKey
+    );
+    return JSON.parse(Buffer.from(decrypted).toString("utf8"));
+  };
+  const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
+  let masterSite;
+  try {
+    const { data: blocklet } = await request({
+      url: joinUrl__default(connectUrl, BLOCKLET_JSON_PATH),
+      method: "GET",
+      timeout: fetchTimeout
+    });
+    masterSite = blocklet?.settings?.federated?.master;
+  } catch {
+  }
+  try {
+    const mergeParams = {
+      _ek_: security.encodeEncryptionKey(keyPair.publicKey),
+      sourceAppPid: masterSite?.appPid || void 0,
+      ...restParams
+    };
+    const res = await request({
+      url: joinUrl__default(connectUrl, ENDPOINT_CREATE_SESSION),
+      params: mergeParams,
+      // for sensitive info encryption
+      method: "GET",
+      timeout: fetchTimeout
+    });
+    const { url, token } = res.data;
+    const encodedUrl = encodeURIComponent(Buffer.from(url).toString("base64"));
+    const pageUrl = `${joinUrl__default(connectUrl, DID_CONNECT_URL)}?__connect_url__=${encodedUrl}`;
+    openPage?.(pageUrl);
+    return await wrapSpinner(`Waiting for connection: ${connectUrl}`, async () => {
+      const fetchData = await fetchConfigs({
+        connectUrl,
+        sessionId: token,
+        connectAction,
+        fetchTimeout: retry * fetchInterval,
+        fetchInterval: retry
+      });
+      const decryptData = enableEncrypt ? decrypt(fetchData) : fetchData;
+      return decryptData;
+    });
+  } catch (e) {
+    const err = e;
+    const response = lodash.get(err, "response");
+    let errorMessage;
+    if (response) {
+      errorMessage = lodash.get(response, "data.error", response.statusText) || "";
+      errorMessage = `[${response.status}] ${errorMessage}`;
+    } else {
+      errorMessage = err.message;
+    }
+    throw new Error(`failed to connect to store (${errorMessage})`);
+  }
+}
+
+const getStoreInfo = async (url) => {
+  const { data } = await axios__default.get(joinUrl__default(url, constant$1.BLOCKLET_STORE_META_PATH), { timeout: 20 * 1e3 });
+  return data;
+};
+const isValidChainEndpoint = async (endpoint) => {
+  if (!endpoint) {
+    return false;
+  }
+  const client = new Client__default(endpoint);
+  try {
+    const { info } = await client.getChainInfo();
+    if (info.consensusVersion.split(" ").length === 2) {
+      return client;
+    }
+    return false;
+  } catch (err) {
+    return false;
+  }
+};
+const getShare = async ({
+  meta,
+  storeUrl,
+  developerDid
+}) => {
+  const info = await getStoreInfo(storeUrl);
+  const shares = lodash.cloneDeep(lodash.get(meta, "payment.share", []));
+  if (shares.length === 0) {
+    shares.push({
+      name: "developer",
+      address: developerDid,
+      value: constant.BLOCKLET_FACTORY_SHARES.developer
+    });
+  }
+  if (!shares.find((x) => x.address === info.id)) {
+    shares.push({
+      name: "store",
+      address: info.id,
+      value: constant.BLOCKLET_FACTORY_SHARES.store
+    });
+  }
+  return shares;
+};
+const ensureBlockletNftFactory = async ({
+  meta,
+  storeUrl
+}) => {
+  const info = await getStoreInfo(storeUrl);
+  const endpoint = info.chainHost;
+  const ocapClient = await isValidChainEndpoint(endpoint);
+  if (ocapClient === false) {
+    throw new Error("Invalid chain endpoint fetched from store, please contact store administrator to fix");
+  }
+  const { itx } = await v2.createNftFactoryItx({
+    blockletMeta: meta,
+    ocapClient,
+    issuers: [info.id],
+    storeUrl
+  });
+  return itx.address;
+};
+
+const sign = (blockletMeta, wallet) => {
+  const walletJSON = wallet.toJSON();
+  const signatureData = {
+    type: walletJSON.type.pk,
+    name: blockletMeta.name,
+    signer: walletJSON.address,
+    pk: util.toBase58(walletJSON.pk),
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const signature = wallet.sign(stableStringify__default({ ...blockletMeta, signatures: [signatureData] }));
+  signatureData.sig = util.toBase58(signature);
+  return signatureData;
+};
+
+const verifyBundleSize = async ({
+  storeUrl,
+  tarballFilePath
+}) => {
+  const { data: storeJson } = await axios__default({
+    url: `${storeUrl}/api/store.json`
+  }).catch(() => {
+    return {};
+  });
+  if (xbytes__default.isBytes(storeJson?.maxBundleSize) && fs__default.existsSync(tarballFilePath)) {
+    const { size: tarballFileBytes } = fs__default.statSync(tarballFilePath);
+    const maxBundleBytes = xbytes__default.parseSize(storeJson.maxBundleSize);
+    if (tarballFileBytes > maxBundleBytes) {
+      throw new Error(
+        `The release file ${path__default.basename(tarballFilePath)} size cannot exceed ${storeJson.maxBundleSize}`
+      );
+    }
+  }
+};
+
+async function upload({
+  storeUrl,
+  accessToken,
+  developerDid,
+  metaFile,
+  wrapSpinner = baseWrapSpinner,
+  printSuccess = () => {
+  },
+  printTar = async () => {
+  },
+  debug = () => {
+  }
+}) {
+  if (!fs__default$1.existsSync(metaFile)) {
+    throw new Error(`Invalid release meta file ${metaFile} not exists`);
+  }
+  const meta = fs__default$1.readJSONSync(metaFile);
+  if (meta.payment === void 0) {
+    const { charging } = meta;
+    const payment = {};
+    if (charging && Array.isArray(charging.tokens)) {
+      payment.price = charging.tokens.map((x) => ({
+        address: x.address,
+        value: x.price
+      }));
+    }
+    if (charging && Array.isArray(charging.shares)) {
+      payment.share = charging.shares.map((x) => ({
+        name: x.name,
+        address: x.address,
+        value: x.share
+      }));
+    }
+    meta.payment = payment;
+    delete meta.charging;
+  }
+  const { tarball } = meta.dist;
+  const tarballFilePath = path__default.join(path__default.dirname(metaFile), tarball);
+  await verifyBundleSize({ storeUrl, tarballFilePath });
+  const wallet$1 = wallet.fromSecretKey(accessToken);
+  if (!wallet$1) {
+    throw new Error(
+      `[NO-ACCESS] Blocklet store accessToken is used to authorize developers when uploading blocklets, you can generate your own accessToken from ${storeUrl}`
+    );
+  }
+  if (util$1.isFreeBlocklet(meta) === false) {
+    if (!developerDid || did.isValid(developerDid) === false) {
+      throw new Error(
+        `developerDid is required to upload a paid blocklet, please get your developerDid from ${storeUrl}`
+      );
+    }
+    try {
+      const typeInfo = did.toTypeInfo(meta.did);
+      const isNewDid = typeInfo.role === did.types.RoleType.ROLE_BLOCKLET;
+      meta.payment.share = await getShare({ meta, storeUrl, developerDid: isNewDid ? meta.did : developerDid });
+      const nftFactory = await ensureBlockletNftFactory({ meta, storeUrl });
+      meta.nftFactory = nftFactory;
+      printSuccess(`NFT Factory for ${meta.name}: ${nftFactory}`);
+    } catch (err) {
+      throw new Error(`Can not determine NFT factory for ${meta.name}: ${err.message}`);
+    }
+  } else {
+    await v2.checkFreeBlocklet(meta);
+  }
+  const signature = sign(meta, wallet$1);
+  meta.signatures = [signature];
+  printSuccess("Blocklet release signed successfully, signature:", signature.sig);
+  await printTar(meta, tarballFilePath);
+  const data = new FormData__default();
+  data.append("blocklet-meta", Buffer.from(JSON.stringify(meta)), { filename: path__default.basename(metaFile) });
+  data.append("blocklet-tarball", fs__default$1.readFileSync(tarballFilePath), { filename: path__default.basename(tarballFilePath) });
+  let uploadResult = {};
+  try {
+    await wrapSpinner(`Uploading ${meta.name}@${meta.version}...`, async () => {
+      uploadResult = await axios__default({
+        url: joinUrl__default(storeUrl, "/api/blocklets/upload"),
+        method: "POST",
+        data,
+        headers: {
+          ...data.getHeaders(),
+          "blocklet-version": meta.version,
+          "blocklet-did": meta.did
+        },
+        timeout: 10 * 60 * 1e3,
+        // 10 minute
+        maxContentLength: Number.POSITIVE_INFINITY,
+        maxBodyLength: Number.POSITIVE_INFINITY
+      });
+    });
+    debug("Upload result:", uploadResult.data);
+  } catch (err) {
+    if (err.response) {
+      const errorMessage = lodash.get(err.response, "data.error", err.response.statusText);
+      throw new Error(`Upload failed with error: [${err.response.status}] ${errorMessage}`);
+    }
+    throw new Error(`Upload failed with error: ${err.message}`);
+  }
+  return { ...meta, status: uploadResult.data?.status || "" };
+}
+
+exports.createConnect = createConnect;
+exports.upload = upload;

package/dist/index.d.cts

@@ -0,0 +1,34 @@
+declare function baseWrapSpinner(_: string, waiting: () => Promise<unknown>): Promise<unknown>;
+
+interface CreateConnectOptions {
+    connectUrl?: string;
+    openPage?: (url: string) => void;
+    fetchTimeout?: number;
+    fetchInterval?: number;
+    retry?: number;
+    connectAction?: string;
+    enableEncrypt?: boolean;
+    wrapSpinner?: typeof baseWrapSpinner;
+}
+declare function createConnect({ connectUrl, openPage, fetchTimeout, fetchInterval, retry, connectAction, wrapSpinner, enableEncrypt, ...restParams }?: CreateConnectOptions): Promise<unknown>;
+
+interface BlockletMeta {
+    name: string;
+    version: string;
+    did: string;
+    status: string;
+}
+
+interface UploadOptions {
+    storeUrl: string;
+    accessToken: string;
+    developerDid: string;
+    metaFile: string;
+    wrapSpinner?: typeof baseWrapSpinner;
+    printSuccess: (...args: unknown[]) => void;
+    printTar: (meta: unknown, metaPath: string) => Promise<void>;
+    debug: (...args: unknown[]) => void;
+}
+declare function upload({ storeUrl, accessToken, developerDid, metaFile, wrapSpinner, printSuccess, printTar, debug, }: UploadOptions): Promise<BlockletMeta | undefined>;
+
+export { type UploadOptions, createConnect, upload };

package/dist/index.d.mts

@@ -0,0 +1,34 @@
+declare function baseWrapSpinner(_: string, waiting: () => Promise<unknown>): Promise<unknown>;
+
+interface CreateConnectOptions {
+    connectUrl?: string;
+    openPage?: (url: string) => void;
+    fetchTimeout?: number;
+    fetchInterval?: number;
+    retry?: number;
+    connectAction?: string;
+    enableEncrypt?: boolean;
+    wrapSpinner?: typeof baseWrapSpinner;
+}
+declare function createConnect({ connectUrl, openPage, fetchTimeout, fetchInterval, retry, connectAction, wrapSpinner, enableEncrypt, ...restParams }?: CreateConnectOptions): Promise<unknown>;
+
+interface BlockletMeta {
+    name: string;
+    version: string;
+    did: string;
+    status: string;
+}
+
+interface UploadOptions {
+    storeUrl: string;
+    accessToken: string;
+    developerDid: string;
+    metaFile: string;
+    wrapSpinner?: typeof baseWrapSpinner;
+    printSuccess: (...args: unknown[]) => void;
+    printTar: (meta: unknown, metaPath: string) => Promise<void>;
+    debug: (...args: unknown[]) => void;
+}
+declare function upload({ storeUrl, accessToken, developerDid, metaFile, wrapSpinner, printSuccess, printTar, debug, }: UploadOptions): Promise<BlockletMeta | undefined>;
+
+export { type UploadOptions, createConnect, upload };

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+declare function baseWrapSpinner(_: string, waiting: () => Promise<unknown>): Promise<unknown>;
+
+interface CreateConnectOptions {
+    connectUrl?: string;
+    openPage?: (url: string) => void;
+    fetchTimeout?: number;
+    fetchInterval?: number;
+    retry?: number;
+    connectAction?: string;
+    enableEncrypt?: boolean;
+    wrapSpinner?: typeof baseWrapSpinner;
+}
+declare function createConnect({ connectUrl, openPage, fetchTimeout, fetchInterval, retry, connectAction, wrapSpinner, enableEncrypt, ...restParams }?: CreateConnectOptions): Promise<unknown>;
+
+interface BlockletMeta {
+    name: string;
+    version: string;
+    did: string;
+    status: string;
+}
+
+interface UploadOptions {
+    storeUrl: string;
+    accessToken: string;
+    developerDid: string;
+    metaFile: string;
+    wrapSpinner?: typeof baseWrapSpinner;
+    printSuccess: (...args: unknown[]) => void;
+    printTar: (meta: unknown, metaPath: string) => Promise<void>;
+    debug: (...args: unknown[]) => void;
+}
+declare function upload({ storeUrl, accessToken, developerDid, metaFile, wrapSpinner, printSuccess, printTar, debug, }: UploadOptions): Promise<BlockletMeta | undefined>;
+
+export { type UploadOptions, createConnect, upload };

package/dist/index.mjs

@@ -0,0 +1,347 @@
+import { encodeEncryptionKey } from '@abtnode/util/lib/security';
+import { get, cloneDeep } from 'lodash';
+import tweetnacl from 'tweetnacl';
+import SealedBox from 'tweetnacl-sealedbox-js';
+import joinUrl from 'url-join';
+import axios from '@abtnode/util/lib/axios';
+import pWaitFor from 'p-wait-for';
+import { fromSecretKey } from '@ocap/wallet';
+import { isFreeBlocklet } from '@blocklet/meta/lib/util';
+import path from 'path';
+import fs$1 from 'fs-extra';
+import { isValid, toTypeInfo, types } from '@arcblock/did';
+import { createNftFactoryItx, checkFreeBlocklet } from '@blocklet/meta/lib/payment/v2';
+import FormData from 'form-data';
+import Client from '@ocap/client';
+import { BLOCKLET_STORE_META_PATH } from '@abtnode/constant';
+import { BLOCKLET_FACTORY_SHARES } from '@blocklet/constant';
+import { toBase58 } from '@ocap/util';
+import stableStringify from 'json-stable-stringify';
+import xbytes from 'xbytes';
+import fs from 'fs';
+
+function request(options) {
+  return axios({
+    maxContentLength: Number.POSITIVE_INFINITY,
+    maxBodyLength: Number.POSITIVE_INFINITY,
+    ...options
+  });
+}
+
+const fetchConfigs = async ({
+  connectUrl,
+  sessionId,
+  fetchInterval,
+  fetchTimeout,
+  connectAction
+}) => {
+  const ENDPOINT_CHECK_SESSION = `/api/did/${connectAction}/status`;
+  const ENDPOINT_INVALIDATE_SESSION = `/api/did/${connectAction}/timeout`;
+  const fetchSessionStatus = async () => {
+    const url = `${joinUrl(connectUrl, ENDPOINT_CHECK_SESSION)}?_t_=${sessionId}`;
+    const { data } = await request({
+      url,
+      method: "GET",
+      timeout: fetchTimeout
+    });
+    return data;
+  };
+  const condition = async () => {
+    const { status, error } = await fetchSessionStatus();
+    if (status === "error" || !!error) {
+      throw new Error(error);
+    }
+    return status === "succeed";
+  };
+  try {
+    await pWaitFor(condition, { interval: fetchInterval, timeout: fetchTimeout });
+    const { config } = await fetchSessionStatus();
+    return config;
+  } catch (e) {
+    const err = e;
+    if (err.name === "TimeoutError") {
+      await request({
+        url: `${joinUrl(connectUrl, ENDPOINT_INVALIDATE_SESSION)}?_t_=${sessionId}`,
+        method: "GET",
+        timeout: fetchTimeout
+      });
+    }
+    throw err;
+  }
+};
+
+function baseWrapSpinner(_, waiting) {
+  return Promise.resolve(waiting());
+}
+
+async function createConnect({
+  connectUrl = "https://store.blocklet.dev",
+  openPage,
+  fetchTimeout = 30 * 1e3,
+  fetchInterval = 3 * 1e3,
+  retry = 60,
+  connectAction = "connect-cli",
+  wrapSpinner = baseWrapSpinner,
+  enableEncrypt = false,
+  ...restParams
+} = {}) {
+  const ENDPOINT_CREATE_SESSION = `/api/did/${connectAction}/token`;
+  const DID_CONNECT_URL = `/${connectAction}`;
+  const keyPair = tweetnacl.box.keyPair();
+  const decrypt = (value) => {
+    const decrypted = SealedBox.open(
+      Uint8Array.from(Buffer.from(value, "base64")),
+      keyPair.publicKey,
+      keyPair.secretKey
+    );
+    return JSON.parse(Buffer.from(decrypted).toString("utf8"));
+  };
+  const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
+  let masterSite;
+  try {
+    const { data: blocklet } = await request({
+      url: joinUrl(connectUrl, BLOCKLET_JSON_PATH),
+      method: "GET",
+      timeout: fetchTimeout
+    });
+    masterSite = blocklet?.settings?.federated?.master;
+  } catch {
+  }
+  try {
+    const mergeParams = {
+      _ek_: encodeEncryptionKey(keyPair.publicKey),
+      sourceAppPid: masterSite?.appPid || void 0,
+      ...restParams
+    };
+    const res = await request({
+      url: joinUrl(connectUrl, ENDPOINT_CREATE_SESSION),
+      params: mergeParams,
+      // for sensitive info encryption
+      method: "GET",
+      timeout: fetchTimeout
+    });
+    const { url, token } = res.data;
+    const encodedUrl = encodeURIComponent(Buffer.from(url).toString("base64"));
+    const pageUrl = `${joinUrl(connectUrl, DID_CONNECT_URL)}?__connect_url__=${encodedUrl}`;
+    openPage?.(pageUrl);
+    return await wrapSpinner(`Waiting for connection: ${connectUrl}`, async () => {
+      const fetchData = await fetchConfigs({
+        connectUrl,
+        sessionId: token,
+        connectAction,
+        fetchTimeout: retry * fetchInterval,
+        fetchInterval: retry
+      });
+      const decryptData = enableEncrypt ? decrypt(fetchData) : fetchData;
+      return decryptData;
+    });
+  } catch (e) {
+    const err = e;
+    const response = get(err, "response");
+    let errorMessage;
+    if (response) {
+      errorMessage = get(response, "data.error", response.statusText) || "";
+      errorMessage = `[${response.status}] ${errorMessage}`;
+    } else {
+      errorMessage = err.message;
+    }
+    throw new Error(`failed to connect to store (${errorMessage})`);
+  }
+}
+
+const getStoreInfo = async (url) => {
+  const { data } = await axios.get(joinUrl(url, BLOCKLET_STORE_META_PATH), { timeout: 20 * 1e3 });
+  return data;
+};
+const isValidChainEndpoint = async (endpoint) => {
+  if (!endpoint) {
+    return false;
+  }
+  const client = new Client(endpoint);
+  try {
+    const { info } = await client.getChainInfo();
+    if (info.consensusVersion.split(" ").length === 2) {
+      return client;
+    }
+    return false;
+  } catch (err) {
+    return false;
+  }
+};
+const getShare = async ({
+  meta,
+  storeUrl,
+  developerDid
+}) => {
+  const info = await getStoreInfo(storeUrl);
+  const shares = cloneDeep(get(meta, "payment.share", []));
+  if (shares.length === 0) {
+    shares.push({
+      name: "developer",
+      address: developerDid,
+      value: BLOCKLET_FACTORY_SHARES.developer
+    });
+  }
+  if (!shares.find((x) => x.address === info.id)) {
+    shares.push({
+      name: "store",
+      address: info.id,
+      value: BLOCKLET_FACTORY_SHARES.store
+    });
+  }
+  return shares;
+};
+const ensureBlockletNftFactory = async ({
+  meta,
+  storeUrl
+}) => {
+  const info = await getStoreInfo(storeUrl);
+  const endpoint = info.chainHost;
+  const ocapClient = await isValidChainEndpoint(endpoint);
+  if (ocapClient === false) {
+    throw new Error("Invalid chain endpoint fetched from store, please contact store administrator to fix");
+  }
+  const { itx } = await createNftFactoryItx({
+    blockletMeta: meta,
+    ocapClient,
+    issuers: [info.id],
+    storeUrl
+  });
+  return itx.address;
+};
+
+const sign = (blockletMeta, wallet) => {
+  const walletJSON = wallet.toJSON();
+  const signatureData = {
+    type: walletJSON.type.pk,
+    name: blockletMeta.name,
+    signer: walletJSON.address,
+    pk: toBase58(walletJSON.pk),
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const signature = wallet.sign(stableStringify({ ...blockletMeta, signatures: [signatureData] }));
+  signatureData.sig = toBase58(signature);
+  return signatureData;
+};
+
+const verifyBundleSize = async ({
+  storeUrl,
+  tarballFilePath
+}) => {
+  const { data: storeJson } = await axios({
+    url: `${storeUrl}/api/store.json`
+  }).catch(() => {
+    return {};
+  });
+  if (xbytes.isBytes(storeJson?.maxBundleSize) && fs.existsSync(tarballFilePath)) {
+    const { size: tarballFileBytes } = fs.statSync(tarballFilePath);
+    const maxBundleBytes = xbytes.parseSize(storeJson.maxBundleSize);
+    if (tarballFileBytes > maxBundleBytes) {
+      throw new Error(
+        `The release file ${path.basename(tarballFilePath)} size cannot exceed ${storeJson.maxBundleSize}`
+      );
+    }
+  }
+};
+
+async function upload({
+  storeUrl,
+  accessToken,
+  developerDid,
+  metaFile,
+  wrapSpinner = baseWrapSpinner,
+  printSuccess = () => {
+  },
+  printTar = async () => {
+  },
+  debug = () => {
+  }
+}) {
+  if (!fs$1.existsSync(metaFile)) {
+    throw new Error(`Invalid release meta file ${metaFile} not exists`);
+  }
+  const meta = fs$1.readJSONSync(metaFile);
+  if (meta.payment === void 0) {
+    const { charging } = meta;
+    const payment = {};
+    if (charging && Array.isArray(charging.tokens)) {
+      payment.price = charging.tokens.map((x) => ({
+        address: x.address,
+        value: x.price
+      }));
+    }
+    if (charging && Array.isArray(charging.shares)) {
+      payment.share = charging.shares.map((x) => ({
+        name: x.name,
+        address: x.address,
+        value: x.share
+      }));
+    }
+    meta.payment = payment;
+    delete meta.charging;
+  }
+  const { tarball } = meta.dist;
+  const tarballFilePath = path.join(path.dirname(metaFile), tarball);
+  await verifyBundleSize({ storeUrl, tarballFilePath });
+  const wallet = fromSecretKey(accessToken);
+  if (!wallet) {
+    throw new Error(
+      `[NO-ACCESS] Blocklet store accessToken is used to authorize developers when uploading blocklets, you can generate your own accessToken from ${storeUrl}`
+    );
+  }
+  if (isFreeBlocklet(meta) === false) {
+    if (!developerDid || isValid(developerDid) === false) {
+      throw new Error(
+        `developerDid is required to upload a paid blocklet, please get your developerDid from ${storeUrl}`
+      );
+    }
+    try {
+      const typeInfo = toTypeInfo(meta.did);
+      const isNewDid = typeInfo.role === types.RoleType.ROLE_BLOCKLET;
+      meta.payment.share = await getShare({ meta, storeUrl, developerDid: isNewDid ? meta.did : developerDid });
+      const nftFactory = await ensureBlockletNftFactory({ meta, storeUrl });
+      meta.nftFactory = nftFactory;
+      printSuccess(`NFT Factory for ${meta.name}: ${nftFactory}`);
+    } catch (err) {
+      throw new Error(`Can not determine NFT factory for ${meta.name}: ${err.message}`);
+    }
+  } else {
+    await checkFreeBlocklet(meta);
+  }
+  const signature = sign(meta, wallet);
+  meta.signatures = [signature];
+  printSuccess("Blocklet release signed successfully, signature:", signature.sig);
+  await printTar(meta, tarballFilePath);
+  const data = new FormData();
+  data.append("blocklet-meta", Buffer.from(JSON.stringify(meta)), { filename: path.basename(metaFile) });
+  data.append("blocklet-tarball", fs$1.readFileSync(tarballFilePath), { filename: path.basename(tarballFilePath) });
+  let uploadResult = {};
+  try {
+    await wrapSpinner(`Uploading ${meta.name}@${meta.version}...`, async () => {
+      uploadResult = await axios({
+        url: joinUrl(storeUrl, "/api/blocklets/upload"),
+        method: "POST",
+        data,
+        headers: {
+          ...data.getHeaders(),
+          "blocklet-version": meta.version,
+          "blocklet-did": meta.did
+        },
+        timeout: 10 * 60 * 1e3,
+        // 10 minute
+        maxContentLength: Number.POSITIVE_INFINITY,
+        maxBodyLength: Number.POSITIVE_INFINITY
+      });
+    });
+    debug("Upload result:", uploadResult.data);
+  } catch (err) {
+    if (err.response) {
+      const errorMessage = get(err.response, "data.error", err.response.statusText);
+      throw new Error(`Upload failed with error: [${err.response.status}] ${errorMessage}`);
+    }
+    throw new Error(`Upload failed with error: ${err.message}`);
+  }
+  return { ...meta, status: uploadResult.data?.status || "" };
+}
+
+export { createConnect, upload };

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@blocklet/store",
+  "version": "1.16.26-beta-c724c8e6",
+  "description": "Connect Store and upload blocklet to Store",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "ts-check": "npx tsc --noemit --skipLibCheck --incremental --tsBuildInfoFile './node_modules/.tsbuildinfo'",
+    "lint": "npm run ts-check && eslint src",
+    "lint:fix": "npm run lint -- --fix",
+    "build": "unbuild",
+    "build:blocklet-store": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@abtnode/constant": "1.16.26-beta-c724c8e6",
+    "@abtnode/util": "1.16.26-beta-c724c8e6",
+    "@arcblock/did": "1.18.114",
+    "@blocklet/constant": "1.16.26-beta-c724c8e6",
+    "@blocklet/meta": "1.16.26-beta-c724c8e6",
+    "@ocap/client": "^1.18.114",
+    "@ocap/util": "1.18.114",
+    "@ocap/wallet": "1.18.114",
+    "form-data": "^4.0.0",
+    "fs-extra": "^11.2.0",
+    "json-stable-stringify": "^1.0.1",
+    "lodash": "^4.17.21",
+    "p-wait-for": "3.2.0",
+    "tweetnacl": "^1.0.3",
+    "tweetnacl-sealedbox-js": "^1.2.0",
+    "url-join": "^4.0.1",
+    "xbytes": "^1.8.0"
+  },
+  "devDependencies": {
+    "@arcblock/eslint-config-ts": "^0.3.0",
+    "@types/jest": "^29.5.11",
+    "@types/node": "^18.11.0",
+    "@typescript-eslint/eslint-plugin": "^5.40.1",
+    "@typescript-eslint/parser": "^5.40.1",
+    "dts-bundle-generator": "^9.2.3",
+    "eslint": "^8.25.0",
+    "jest": "^29.7.0",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.0.4",
+    "unbuild": "^2.0.0"
+  },
+  "gitHead": "f2b51533d934be041b1cc5b4b2fc8c56f4855a26"
+}