@stacks/storage 4.3.6-pr.de51016.0 → 4.3.6-pr.f9a3196.0

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@stacks/storage",
-  "version": "4.3.6-pr.de51016.0",
+  "version": "4.3.6-pr.f9a3196.0",
   "description": "Stacks storage library",
   "license": "MIT",
   "author": "Hiro Systems PBC (https://hiro.so)",
-  "homepage": "https://www.hiro.so/stacks-js",
+  "homepage": "https://hiro.so/stacks-js",
   "scripts": {
-    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:umd && npm run build:polyfill",
+    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:umd",
     "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",
@@ -21,11 +20,12 @@
     "typecheck:watch": "npm run typecheck -- --watch"
   },
   "dependencies": {
-    "@stacks/auth": "^4.3.6-pr.de51016.0",
-    "@stacks/common": "^4.3.6-pr.de51016.0",
-    "@stacks/encryption": "^4.3.6-pr.de51016.0",
-    "@stacks/network": "^4.3.6-pr.de51016.0",
-    "jsontokens": "^3.1.1"
+    "@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"
   },
   "devDependencies": {
     "@stacks/network": "^4.1.0",
@@ -38,12 +38,7 @@
     "process": "^0.11.10",
     "rimraf": "^3.0.2",
     "stream-browserify": "^3.0.0",
-    "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"
+    "ts-jest": "^26.5.5"
   },
   "sideEffects": false,
   "typings": "dist/index.d.ts",
@@ -65,5 +60,5 @@
   "bugs": {
     "url": "https://github.com/blockstack/blockstack.js/issues"
   },
-  "gitHead": "de51016a0406798f8e51c2624f9955d8c05431db"
+  "gitHead": "f9a3196694795fdd3327149ac98357d27f65e82f"
 }

package/src/fileContentLoader.ts

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

package/src/hub.ts

@@ -1,6 +1,6 @@
 import {
   BadPathError,
-  Buffer,
+  bytesToHex,
   ConflictError,
   DoesNotExist,
   GaiaHubErrorResponse,
@@ -9,6 +9,7 @@ import {
   NotEnoughProofError,
   PayloadTooLargeError,
   PreconditionFailedError,
+  utf8ToBytes,
   ValidationError,
 } from '@stacks/common';
 import {
@@ -21,6 +22,7 @@ import {
   Signature,
 } from '@stacks/encryption';
 import { createFetchFn, FetchFn } from '@stacks/network';
+import { fromByteArray } from 'base64-js';
 import { TokenSigner } from 'jsontokens';
 
 /**
@@ -57,7 +59,7 @@ interface UploadResponse {
  */
 export async function uploadToGaiaHub(
   filename: string,
-  contents: Blob | Buffer | ArrayBufferView | string,
+  contents: Blob | Uint8Array | ArrayBufferView | string,
   hubConfig: GaiaHubConfig,
   contentType = 'application/octet-stream',
   newFile = true,
@@ -148,19 +150,16 @@ 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(Buffer.from(challengeText));
-    const signatureBuffer = ecSign(digest, compressPrivateKey(signerKeyHex));
+    const digest = hashSha256Sync(utf8ToBytes(challengeText));
+    const signatureBytes = ecSign(digest, compressPrivateKey(signerKeyHex));
     // We only want the DER encoding so use toDERHex provided by @noble/secp256k1
-    const signature = Signature.fromCompact(signatureBuffer.toString('hex')).toDERHex();
+    const signature = Signature.fromCompact(bytesToHex(signatureBytes)).toDERHex();
 
     const publickey = getPublicKeyFromPrivate(signerKeyHex);
-    const token = Buffer.from(JSON.stringify({ publickey, signature })).toString('base64');
+    const token = fromByteArray(utf8ToBytes(JSON.stringify({ publickey, signature })));
     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.');
 }
 
 /**
@@ -187,7 +186,7 @@ function makeV1GaiaAuthToken(
     return makeLegacyAuthToken(challengeText, signerKeyHex);
   }
 
-  const salt = randomBytes(16).toString('hex');
+  const salt = bytesToHex(randomBytes(16));
   const payload = {
     gaiaChallenge: challengeText,
     hubUrl,

package/src/storage.ts

@@ -8,12 +8,14 @@ import {
   megabytesToBytes,
   PayloadTooLargeError,
   SignatureVerificationError,
+  utf8ToBytes,
 } from '@stacks/common';
 import {
   eciesGetJsonStringLength,
   EncryptionOptions,
   getPublicKeyFromPrivate,
   publicKeyToAddress,
+  publicKeyToBtcAddress,
   signECDSA,
   verifyECDSA,
 } from '@stacks/encryption';
@@ -321,20 +323,19 @@ 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 {
@@ -342,40 +343,39 @@ 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.`
           );
-        } else {
-          throw err;
-        }
+        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})`
         );
-      } else if (!verifyECDSA(fileContents, publicKey, signature)) {
+
+      if (
+        !verifyECDSA(
+          typeof fileContents === 'string'
+            ? utf8ToBytes(fileContents)
+            : new Uint8Array(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}`
         );
-      } else {
-        throw err;
-      }
+      throw err;
     }
   }
 
@@ -393,18 +393,14 @@ export class Storage {
     privateKey?: string,
     username?: string,
     zoneFileLookupURL?: string
-    // eslint-disable-next-line node/prefer-global/buffer
-  ): Promise<string | Buffer> {
+  ): Promise<string | Uint8Array> {
     const appPrivateKey = privateKey || this.userSession.loadUserData().appPrivateKey;
 
     const appPublicKey = getPublicKeyFromPrivate(appPrivateKey);
 
-    let address: string;
-    if (username) {
-      address = await this.getGaiaAddress(app, username, zoneFileLookupURL);
-    } else {
-      address = publicKeyToAddress(appPublicKey);
-    }
+    const address: string = username
+      ? await this.getGaiaAddress(app, username, zoneFileLookupURL)
+      : publicKeyToBtcAddress(appPublicKey);
     if (!address) {
       throw new SignatureVerificationError(
         `Failed to get gaia address for verification of: ${path}`
@@ -416,9 +412,7 @@ 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;
@@ -431,15 +425,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 };
@@ -452,7 +446,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|Buffer} content - the data to store in the file
+   * @param {String|Uint8Array} content - the data to store in the file
    * @param options a [[PutFileOptions]] object
    *
    * @returns {Promise} that resolves if the operation succeed and rejects
@@ -460,8 +454,7 @@ export class Storage {
    */
   async putFile(
     path: string,
-    // eslint-disable-next-line node/prefer-global/buffer
-    content: string | Buffer | ArrayBufferView | Blob,
+    content: string | Uint8Array | ArrayBufferView | Blob,
     options?: PutFileOptions
   ): Promise<string> {
     const defaults: PutFileOptions = {
@@ -557,8 +550,7 @@ export class Storage {
       };
     } else {
       // In all other cases, we only need one upload.
-      // eslint-disable-next-line node/prefer-global/buffer
-      let contentForUpload: string | Buffer | Blob;
+      let contentForUpload: string | Uint8Array | 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.