@stacks/storage 4.3.6-pr.f9a3196.0 → 4.3.7-beta.1

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@stacks/storage",
-  "version": "4.3.6-pr.f9a3196.0",
+  "version": "4.3.7-beta.1",
   "description": "Stacks storage library",
   "license": "MIT",
   "author": "Hiro Systems PBC (https://hiro.so)",
   "homepage": "https://hiro.so/stacks-js",
   "scripts": {
-    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:umd",
+    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:umd && npm run build:polyfill",
     "build:cjs": "tsc -b tsconfig.build.json",
     "build:esm": "tsc -p tsconfig.build.json --module ES6 --outDir ./dist/esm",
+    "build:polyfill": "NODE_OPTIONS=--max-old-space-size=8192 rollup -c ../../configs/rollup.config.js && rimraf dist/polyfill/dist",
     "build:umd": "NODE_OPTIONS=--max-old-space-size=8192 webpack --config webpack.config.js",
     "clean": "rimraf dist && tsc -b tsconfig.build.json --clean",
     "pack": "npm pack",
@@ -20,12 +21,11 @@
     "typecheck:watch": "npm run typecheck -- --watch"
   },
   "dependencies": {
-    "@stacks/auth": "^4.3.6-pr.f9a3196.0",
-    "@stacks/common": "^4.3.6-pr.f9a3196.0",
-    "@stacks/encryption": "^4.3.6-pr.f9a3196.0",
-    "@stacks/network": "^4.3.6-pr.f9a3196.0",
-    "base64-js": "^1.5.1",
-    "jsontokens": "^4.0.1"
+    "@stacks/auth": "^4.3.7-beta.1",
+    "@stacks/common": "^4.3.7-beta.1",
+    "@stacks/encryption": "^4.3.7-beta.1",
+    "@stacks/network": "^4.3.7-beta.1",
+    "jsontokens": "^3.1.1"
   },
   "devDependencies": {
     "@stacks/network": "^4.1.0",
@@ -38,7 +38,12 @@
     "process": "^0.11.10",
     "rimraf": "^3.0.2",
     "stream-browserify": "^3.0.0",
-    "ts-jest": "^26.5.5"
+    "ts-jest": "^26.5.5",
+    "ts-loader": "^9.1.1",
+    "typescript": "^4.2.4",
+    "webpack": "^5.36.1",
+    "webpack-bundle-analyzer": "^4.5.0",
+    "webpack-cli": "^4.6.0"
   },
   "sideEffects": false,
   "typings": "dist/index.d.ts",
@@ -60,5 +65,5 @@
   "bugs": {
     "url": "https://github.com/blockstack/blockstack.js/issues"
   },
-  "gitHead": "f9a3196694795fdd3327149ac98357d27f65e82f"
+  "gitHead": "2d22629a8d0c29b5ba5b29871014c98f40bbda0f"
 }

package/src/fileContentLoader.ts

@@ -1,5 +1,4 @@
-import { utf8ToBytes } from '@stacks/common';
-
+import { Buffer } from '@stacks/common';
 /**
  * Retrieves the specified file from the app's data store.
  * @param {String} path - the path to the file to read
@@ -7,11 +6,11 @@ import { utf8ToBytes } from '@stacks/common';
  * or rejects with an error
  */
 export /** @ignore */
-type PutFileContent = string | Uint8Array | ArrayBufferView | ArrayBufferLike | Blob;
+type PutFileContent = string | Buffer | ArrayBufferView | ArrayBufferLike | Blob;
 
 /** @ignore */
 export class FileContentLoader {
-  readonly content: Uint8Array | Blob;
+  readonly content: Buffer | Blob;
 
   readonly wasString: boolean;
 
@@ -19,11 +18,11 @@ export class FileContentLoader {
 
   readonly contentByteLength: number;
 
-  private loadedData?: Promise<Uint8Array>;
+  private loadedData?: Promise<Buffer>;
 
   static readonly supportedTypesMsg =
     'Supported types are: `string` (to be UTF8 encoded), ' +
-    '`Blob`, `File`, `ArrayBuffer`, `UInt8Array` or any other typed array buffer. ';
+    '`Buffer`, `Blob`, `File`, `ArrayBuffer`, `UInt8Array` or any other typed array buffer. ';
 
   constructor(content: PutFileContent, contentType: string) {
     this.wasString = typeof content === 'string';
@@ -35,7 +34,7 @@ export class FileContentLoader {
   private static normalizeContentDataType(
     content: PutFileContent,
     contentType: string
-  ): Uint8Array | Blob {
+  ): Buffer | Blob {
     try {
       if (typeof content === 'string') {
         // If a charset is specified it must be either utf8 or ascii, otherwise the encoded content
@@ -50,19 +49,17 @@ export class FileContentLoader {
         }
         if (typeof TextEncoder !== 'undefined') {
           const encodedString = new TextEncoder().encode(content);
-          return new Uint8Array(encodedString.buffer);
+          return Buffer.from(encodedString.buffer);
         }
-        return utf8ToBytes(content);
-      } else if (content instanceof Uint8Array) {
+        return Buffer.from(content);
+      } else if (Buffer.isBuffer(content)) {
         return content;
       } else if (ArrayBuffer.isView(content)) {
-        return new Uint8Array(
-          content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength)
-        );
+        return Buffer.from(content.buffer, content.byteOffset, content.byteLength);
       } else if (typeof Blob !== 'undefined' && content instanceof Blob) {
         return content;
       } else if (typeof ArrayBuffer !== 'undefined' && content instanceof ArrayBuffer) {
-        return new Uint8Array(content);
+        return Buffer.from(content);
       } else if (Array.isArray(content)) {
         // Provided with a regular number `Array` -- this is either an (old) method
         // of representing an octet array, or a dev error. Perform basic check for octet array.
@@ -74,7 +71,7 @@ export class FileContentLoader {
             `Unexpected array values provided as file data: value "${content[0]}" at index 0 is not an octet number. ${this.supportedTypesMsg}`
           );
         }
-        return new Uint8Array(content);
+        return Buffer.from(content);
       } else {
         const typeName = Object.prototype.toString.call(content);
         throw new Error(
@@ -98,7 +95,7 @@ export class FileContentLoader {
   }
 
   private detectContentLength(): number {
-    if (ArrayBuffer.isView(this.content) || this.content instanceof Uint8Array) {
+    if (ArrayBuffer.isView(this.content) || Buffer.isBuffer(this.content)) {
       return this.content.byteLength;
     } else if (typeof Blob !== 'undefined' && this.content instanceof Blob) {
       return this.content.size;
@@ -109,29 +106,26 @@ export class FileContentLoader {
     throw error;
   }
 
-  private async loadContent(): Promise<Uint8Array> {
+  private async loadContent(): Promise<Buffer> {
     try {
-      if (this.content instanceof Uint8Array) {
+      if (Buffer.isBuffer(this.content)) {
         return this.content;
       } else if (ArrayBuffer.isView(this.content)) {
-        return new Uint8Array(
-          this.content.buffer,
-          this.content.byteOffset,
-          this.content.byteLength
-        );
+        return Buffer.from(this.content.buffer, this.content.byteOffset, this.content.byteLength);
       } else if (typeof Blob !== 'undefined' && this.content instanceof Blob) {
         const reader = new FileReader();
-        const readPromise = new Promise<Uint8Array>((resolve, reject) => {
+        const readPromise = new Promise<Buffer>((resolve, reject) => {
           reader.onerror = err => {
             reject(err);
           };
           reader.onload = () => {
             const arrayBuffer = reader.result as ArrayBuffer;
-            resolve(new Uint8Array(arrayBuffer));
+            resolve(Buffer.from(arrayBuffer));
           };
           reader.readAsArrayBuffer(this.content as Blob);
         });
-        return await readPromise;
+        const result = await readPromise;
+        return result;
       } else {
         const typeName = Object.prototype.toString.call(this.content);
         throw new Error(`Unexpected type ${typeName}`);
@@ -144,7 +138,7 @@ export class FileContentLoader {
     }
   }
 
-  load(): Promise<Uint8Array | string> {
+  load(): Promise<Buffer | string> {
     if (this.loadedData === undefined) {
       this.loadedData = this.loadContent();
     }

package/src/hub.ts

@@ -1,6 +1,6 @@
 import {
   BadPathError,
-  bytesToHex,
+  Buffer,
   ConflictError,
   DoesNotExist,
   GaiaHubErrorResponse,
@@ -9,7 +9,6 @@ import {
   NotEnoughProofError,
   PayloadTooLargeError,
   PreconditionFailedError,
-  utf8ToBytes,
   ValidationError,
 } from '@stacks/common';
 import {
@@ -22,7 +21,6 @@ import {
   Signature,
 } from '@stacks/encryption';
 import { createFetchFn, FetchFn } from '@stacks/network';
-import { fromByteArray } from 'base64-js';
 import { TokenSigner } from 'jsontokens';
 
 /**
@@ -59,7 +57,7 @@ interface UploadResponse {
  */
 export async function uploadToGaiaHub(
   filename: string,
-  contents: Blob | Uint8Array | ArrayBufferView | string,
+  contents: Blob | Buffer | ArrayBufferView | string,
   hubConfig: GaiaHubConfig,
   contentType = 'application/octet-stream',
   newFile = true,
@@ -150,16 +148,19 @@ function makeLegacyAuthToken(challengeText: string, signerKeyHex: string): strin
     throw new Error('Failed in parsing legacy challenge text from the gaia hub.');
   }
   if (parsedChallenge[0] === 'gaiahub' && parsedChallenge[3] === 'blockstack_storage_please_sign') {
-    const digest = hashSha256Sync(utf8ToBytes(challengeText));
-    const signatureBytes = ecSign(digest, compressPrivateKey(signerKeyHex));
+    const digest = hashSha256Sync(Buffer.from(challengeText));
+    const signatureBuffer = ecSign(digest, compressPrivateKey(signerKeyHex));
     // We only want the DER encoding so use toDERHex provided by @noble/secp256k1
-    const signature = Signature.fromCompact(bytesToHex(signatureBytes)).toDERHex();
+    const signature = Signature.fromCompact(signatureBuffer.toString('hex')).toDERHex();
 
     const publickey = getPublicKeyFromPrivate(signerKeyHex);
-    const token = fromByteArray(utf8ToBytes(JSON.stringify({ publickey, signature })));
+    const token = Buffer.from(JSON.stringify({ publickey, signature })).toString('base64');
     return token;
+  } else {
+    throw new Error(
+      'Failed to connect to legacy gaia hub. If you operate this hub, please update.'
+    );
   }
-  throw new Error('Failed to connect to legacy gaia hub. If you operate this hub, please update.');
 }
 
 /**
@@ -186,7 +187,7 @@ function makeV1GaiaAuthToken(
     return makeLegacyAuthToken(challengeText, signerKeyHex);
   }
 
-  const salt = bytesToHex(randomBytes(16));
+  const salt = randomBytes(16).toString('hex');
   const payload = {
     gaiaChallenge: challengeText,
     hubUrl,

package/src/storage.ts

@@ -8,14 +8,12 @@ import {
   megabytesToBytes,
   PayloadTooLargeError,
   SignatureVerificationError,
-  utf8ToBytes,
 } from '@stacks/common';
 import {
   eciesGetJsonStringLength,
   EncryptionOptions,
   getPublicKeyFromPrivate,
   publicKeyToAddress,
-  publicKeyToBtcAddress,
   signECDSA,
   verifyECDSA,
 } from '@stacks/encryption';
@@ -323,19 +321,20 @@ export class Storage {
         this.getGaiaAddress(opt.app!, opt.username, opt.zoneFileLookupURL),
       ]);
 
-      if (!fileContents) return fileContents;
-
-      if (!gaiaAddress)
+      if (!fileContents) {
+        return fileContents;
+      }
+      if (!gaiaAddress) {
         throw new SignatureVerificationError(
           `Failed to get gaia address for verification of: ${path}`
         );
-
-      if (!signatureContents || typeof signatureContents !== 'string')
+      }
+      if (!signatureContents || typeof signatureContents !== 'string') {
         throw new SignatureVerificationError(
           'Failed to obtain signature for file: ' +
             `${path} -- looked in ${path}${SIGNATURE_FILE_SUFFIX}`
         );
-
+      }
       let signature;
       let publicKey;
       try {
@@ -343,39 +342,40 @@ export class Storage {
         signature = sigObject.signature;
         publicKey = sigObject.publicKey;
       } catch (err) {
-        if (err instanceof SyntaxError)
+        if (err instanceof SyntaxError) {
           throw new Error(
-            `Failed to parse signature content JSON (path: ${path}${SIGNATURE_FILE_SUFFIX}) The content may be corrupted.`
+            'Failed to parse signature content JSON ' +
+              `(path: ${path}${SIGNATURE_FILE_SUFFIX})` +
+              ' The content may be corrupted.'
           );
-        throw err;
+        } else {
+          throw err;
+        }
       }
       const signerAddress = publicKeyToAddress(publicKey);
-      if (gaiaAddress !== signerAddress)
+      if (gaiaAddress !== signerAddress) {
         throw new SignatureVerificationError(
-          `Signer pubkey address (${signerAddress}) doesn't match gaia address (${gaiaAddress})`
+          `Signer pubkey address (${signerAddress}) doesn't` +
+            ` match gaia address (${gaiaAddress})`
         );
-
-      if (
-        !verifyECDSA(
-          typeof fileContents === 'string'
-            ? utf8ToBytes(fileContents)
-            : new Uint8Array(fileContents),
-          publicKey,
-          signature
-        )
-      ) {
+      } else if (!verifyECDSA(fileContents, publicKey, signature)) {
         throw new SignatureVerificationError(
-          `Contents do not match ECDSA signature: path: ${path}, signature: ${path}${SIGNATURE_FILE_SUFFIX}`
+          'Contents do not match ECDSA signature: ' +
+            `path: ${path}, signature: ${path}${SIGNATURE_FILE_SUFFIX}`
         );
+      } else {
+        return fileContents;
       }
-      return fileContents;
     } catch (err) {
       // For missing .sig files, throw `SignatureVerificationError` instead of `DoesNotExist` error.
-      if (err instanceof DoesNotExist && err.message.indexOf(sigPath) >= 0)
+      if (err instanceof DoesNotExist && err.message.indexOf(sigPath) >= 0) {
         throw new SignatureVerificationError(
-          `Failed to obtain signature for file: ${path} -- looked in ${path}${SIGNATURE_FILE_SUFFIX}`
+          'Failed to obtain signature for file: ' +
+            `${path} -- looked in ${path}${SIGNATURE_FILE_SUFFIX}`
         );
-      throw err;
+      } else {
+        throw err;
+      }
     }
   }
 
@@ -393,14 +393,18 @@ export class Storage {
     privateKey?: string,
     username?: string,
     zoneFileLookupURL?: string
-  ): Promise<string | Uint8Array> {
+    // eslint-disable-next-line node/prefer-global/buffer
+  ): Promise<string | Buffer> {
     const appPrivateKey = privateKey || this.userSession.loadUserData().appPrivateKey;
 
     const appPublicKey = getPublicKeyFromPrivate(appPrivateKey);
 
-    const address: string = username
-      ? await this.getGaiaAddress(app, username, zoneFileLookupURL)
-      : publicKeyToBtcAddress(appPublicKey);
+    let address: string;
+    if (username) {
+      address = await this.getGaiaAddress(app, username, zoneFileLookupURL);
+    } else {
+      address = publicKeyToAddress(appPublicKey);
+    }
     if (!address) {
       throw new SignatureVerificationError(
         `Failed to get gaia address for verification of: ${path}`
@@ -412,7 +416,9 @@ export class Storage {
     } catch (err) {
       if (err instanceof SyntaxError) {
         throw new Error(
-          'Failed to parse encrypted, signed content JSON. The content may not be encrypted. If using getFile, try passing { verify: false, decrypt: false }.'
+          'Failed to parse encrypted, signed content JSON. The content may not ' +
+            'be encrypted. If using getFile, try passing' +
+            ' { verify: false, decrypt: false }.'
         );
       } else {
         throw err;
@@ -425,15 +431,15 @@ export class Storage {
 
     if (!signerPublicKey || !cipherText || !signature) {
       throw new SignatureVerificationError(
-        `Failed to get signature verification data from file: ${path}`
+        'Failed to get signature verification data from file:' + ` ${path}`
       );
     } else if (signerAddress !== address) {
       throw new SignatureVerificationError(
-        `Signer pubkey address (${signerAddress}) doesn't match gaia address (${address})`
+        `Signer pubkey address (${signerAddress}) doesn't` + ` match gaia address (${address})`
       );
     } else if (!verifyECDSA(cipherText, signerPublicKey, signature)) {
       throw new SignatureVerificationError(
-        `Contents do not match ECDSA signature in file: ${path}`
+        'Contents do not match ECDSA signature in file:' + ` ${path}`
       );
     } else if (typeof privateKey === 'string') {
       const decryptOpt = { privateKey };
@@ -446,7 +452,7 @@ export class Storage {
   /**
    * Stores the data provided in the app's data store to to the file specified.
    * @param {String} path - the path to store the data in
-   * @param {String|Uint8Array} content - the data to store in the file
+   * @param {String|Buffer} content - the data to store in the file
    * @param options a [[PutFileOptions]] object
    *
    * @returns {Promise} that resolves if the operation succeed and rejects
@@ -454,7 +460,8 @@ export class Storage {
    */
   async putFile(
     path: string,
-    content: string | Uint8Array | ArrayBufferView | Blob,
+    // eslint-disable-next-line node/prefer-global/buffer
+    content: string | Buffer | ArrayBufferView | Blob,
     options?: PutFileOptions
   ): Promise<string> {
     const defaults: PutFileOptions = {
@@ -550,7 +557,8 @@ export class Storage {
       };
     } else {
       // In all other cases, we only need one upload.
-      let contentForUpload: string | Uint8Array | Blob;
+      // eslint-disable-next-line node/prefer-global/buffer
+      let contentForUpload: string | Buffer | Blob;
       if (!opt.encrypt && !opt.sign) {
         // If content does not need encrypted or signed, it can be passed directly
         // to the fetch request without loading into memory.