@upcoming/bee-js 12.0.0 → 12.2.3

package/dist/mjs/bee.js

@@ -284,8 +284,8 @@ export class Bee {
       const fileName = name ?? data.name;
       const contentType = data.type;
       const fileOptions = {
-        contentType,
-        ...options
+        ...options,
+        contentType
       };
       return bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), fileData, postageBatchId, fileName, fileOptions);
     } else {
@@ -1602,10 +1602,16 @@ export class Bee {
     const currentAmount = getAmountForDuration(batch.duration, chainState.currentPrice, blockTime);
     const targetAmount = duration.isZero() ? currentAmount * multiplier : (currentAmount + additionalAmount) * multiplier;
     const amountDelta = targetAmount - currentAmount;
-    const transactionId = await this.topUpBatch(batch.batchID, amountDelta, requestOptions);
+    let transactionId;
+    if (amountDelta > 0n) {
+      transactionId = await this.topUpBatch(batch.batchID, amountDelta, requestOptions);
+    }
     if (depthDelta > 0) {
       return this.diluteBatch(batch.batchID, depth, requestOptions);
     }
+    if (!transactionId) {
+      throw new Error('Nothing to extend, both size and duration are already sufficient');
+    }
     return transactionId;
   }
   /**
@@ -1733,16 +1739,15 @@ export class Bee {
   /**
    * Calculates the `amount` and expected duration extension for topping up a postage batch with a given BZZ value.
    *
-   * @param postageBatchId
+   * @param depth Depth of the postage batch to top up.
    * @param bzz The amount of BZZ to spend on the top-up.
    * @param requestOptions Options for making requests, such as timeouts, custom HTTP agents, headers, etc.
    * @returns An object with `amount` (to pass to {@link topUpBatch}) and `duration` (the expected TTL extension).
    */
-  async calculateTopUpForBzz(postageBatchId, bzz, requestOptions) {
-    const batch = await this.getPostageBatch(postageBatchId, requestOptions);
+  async calculateTopUpForBzz(depth, bzz, requestOptions) {
     const chainState = await this.getChainState(requestOptions);
     const blockTime = this.network === 'gnosis' ? 5 : 15;
-    const amount = bzz.toPLURBigInt() / 2n ** BigInt(batch.depth);
+    const amount = bzz.toPLURBigInt() / 2n ** BigInt(depth);
     const duration = getStampDuration(amount, chainState.currentPrice, blockTime);
     return {
       amount,

package/dist/mjs/index.js

@@ -1,5 +1,4 @@
 import { Bee } from "./bee.js";
-import { BeeDev } from "./bee-dev.js";
 import { Stamper } from "./stamper/stamper.js";
 export { MerkleTree } from 'cafe-utility';
 export { MantarayNode } from "./manifest/manifest.js";
@@ -13,4 +12,4 @@ export * as Utils from "./utils/expose.js";
 export { Size } from "./utils/size.js";
 export * from "./utils/tokens.js";
 export * from "./utils/typed-bytes.js";
-export { Bee, BeeDev, Stamper };
+export { Bee, Stamper };

package/dist/mjs/modules/feed.js

@@ -57,7 +57,9 @@ export async function fetchLatestFeedUpdate(requestOptions, owner, topic, option
   const response = await http(requestOptions, {
     responseType: 'arraybuffer',
     url: `${feedEndpoint}/${owner}/${topic}`,
-    params: options
+    params: {
+      ...options
+    }
   });
   return {
     payload: new Bytes(response.data),

package/dist/mjs/modules/status.js

@@ -7,7 +7,8 @@ import { http } from "../utils/http.js";
  */
 export async function checkConnection(requestOptions) {
   await http(requestOptions, {
-    url: ''
+    url: '',
+    responseType: 'text'
   });
 }
 export async function isGateway(requestOptions) {

package/dist/mjs/utils/http.js

@@ -1,28 +1,16 @@
-import axios from 'axios';
-import { Dates, Objects, Strings, System } from 'cafe-utility';
+import { Objects, Strings, System } from 'cafe-utility';
 import _debug from 'debug';
 import { BeeResponseError } from "../index.js";
 const debug = _debug('bee-js:http');
-const {
-  AxiosError
-} = axios;
 const MAX_FAILED_ATTEMPTS = 100000;
 const DELAY_FAST = 200;
 const DELAY_SLOW = 1000;
-const DELAY_THRESHOLD = Dates.minutes(1) / DELAY_FAST;
-const ABORT_ERROR_MESSAGE = 'Request aborted';
+const FAST_RETRY_COUNT = 300;
 export const DEFAULT_HTTP_CONFIG = {
   headers: {
     accept: 'application/json, text/plain, */*'
-  },
-  maxBodyLength: Infinity,
-  maxContentLength: Infinity
-};
-function throwIfAborted(signal, config, responseData, responseStatus) {
-  if (signal?.aborted) {
-    throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', ABORT_ERROR_MESSAGE, responseData, responseStatus, 'ERR_CANCELED');
   }
-}
+};
 /**
  * Main function to make HTTP requests.
  * @param options User defined settings
@@ -32,68 +20,118 @@ export async function http(options, config) {
   const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
   if (options.signal) {
     requestConfig.signal = options.signal;
-    throwIfAborted(options.signal, config);
   }
-  maybeReplaceBodyBuffers(requestConfig);
+  attachBody(requestConfig);
   if (requestConfig.params) {
-    const keys = Object.keys(requestConfig.params);
-    for (const key of keys) {
-      const value = requestConfig.params[key];
-      if (value === undefined) {
-        delete requestConfig.params[key];
-      }
+    for (const k of Object.keys(requestConfig.params)) {
+      if (requestConfig.params[k] === undefined) delete requestConfig.params[k];
     }
   }
+  const url = buildUrl(requestConfig);
+  const method = (requestConfig.method || 'GET').toUpperCase();
+  requestConfig.method = method;
+  options.onRequest?.({
+    method,
+    url,
+    headers: {
+      ...requestConfig.headers
+    },
+    params: requestConfig.params
+  });
   let failedAttempts = 0;
   while (failedAttempts < MAX_FAILED_ATTEMPTS) {
-    throwIfAborted(options.signal, config);
     try {
-      debug(`${requestConfig.method || 'get'} ${Strings.joinUrl([requestConfig.baseURL, requestConfig.url])}`, {
-        headers: {
-          ...requestConfig.headers
-        },
+      debug(`${method} ${url}`, {
+        headers: requestConfig.headers,
         params: requestConfig.params
       });
-      maybeRunOnRequestHook(options, requestConfig);
-      const response = await axios(requestConfig);
-      return response;
+      const res = await fetch(url, requestConfig);
+      if (!res.ok) await throwHttpError(method, url, res, requestConfig.responseType);
+      return toBeeResponse(res, requestConfig.responseType);
     } catch (e) {
-      if (e instanceof AxiosError) {
-        if (e.code === 'ERR_CANCELED') {
-          throwIfAborted({
-            aborted: true
-          }, config, e.response?.data, e.response?.status);
-        }
-        if (e.code === 'ECONNABORTED' && options.endlesslyRetry) {
-          failedAttempts++;
-          await System.sleepMillis(failedAttempts < DELAY_THRESHOLD ? DELAY_FAST : DELAY_SLOW);
-        } else {
-          throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.response?.statusText);
-        }
+      if (e instanceof BeeResponseError) throw e;
+      const err = e;
+      if (err.name === 'TimeoutError' && options.endlesslyRetry) {
+        failedAttempts++;
+        await System.sleepMillis(failedAttempts < FAST_RETRY_COUNT ? DELAY_FAST : DELAY_SLOW);
       } else {
-        throw e;
+        throw toBeeError(err, method, url);
       }
     }
   }
   throw Error('Max number of failed attempts reached');
 }
-function maybeRunOnRequestHook(options, requestConfig) {
-  if (options.onRequest) {
-    options.onRequest({
-      method: requestConfig.method || 'GET',
-      url: Strings.joinUrl([requestConfig.baseURL, requestConfig.url]),
-      headers: {
-        ...requestConfig.headers
-      },
-      params: requestConfig.params
-    });
+function attachBody(config) {
+  if (config.data === undefined) return;
+  const data = config.data;
+  const isJsonShape = data !== null && typeof data === 'object' && data.constructor === Object || Array.isArray(data);
+  if (isJsonShape) {
+    config.body = JSON.stringify(data);
+    config.headers = {
+      'content-type': 'application/json',
+      ...config.headers
+    };
+  } else {
+    config.body = data;
+    config.duplex = 'half';
+    const ct = data instanceof Blob && data.type ? data.type : 'application/octet-stream';
+    config.headers = {
+      'content-type': ct,
+      ...config.headers
+    };
   }
 }
-function maybeReplaceBodyBuffers(config) {
-  if (config.data && config.data instanceof Uint8Array) {
-    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+async function throwHttpError(method, url, res, responseType) {
+  const errBody = await toBeeResponse(res, responseType).catch(() => ({
+    data: undefined
+  }));
+  const bodyMsg = typeof errBody.data === 'string' ? errBody.data : JSON.stringify(errBody.data);
+  const message = bodyMsg && bodyMsg !== 'undefined' ? `${res.statusText}: ${bodyMsg}` : res.statusText;
+  throw new BeeResponseError(method, url, message, errBody.data, res.status, res.statusText);
+}
+function toBeeError(err, method, url) {
+  if (err.name === 'AbortError') {
+    return new BeeResponseError(method, url, 'Request aborted', undefined, undefined, 'ERR_CANCELED');
   }
-  if (config.data && typeof Buffer !== 'undefined' && Buffer.isBuffer(config.data)) {
-    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+  const cause = err.cause;
+  const message = cause?.message ? `${err.message}: ${cause.message}` : err.message;
+  return new BeeResponseError(method, url, message);
+}
+export async function toBeeResponse(res, responseType = 'json') {
+  let data;
+  switch (responseType) {
+    case 'arraybuffer':
+      data = await res.arrayBuffer();
+      break;
+    case 'text':
+      data = await res.text();
+      break;
+    case 'blob':
+      data = await res.blob();
+      break;
+    case 'stream':
+      data = res.body;
+      break;
+    case 'json':
+    default:
+      {
+        const text = await res.text();
+        data = text ? JSON.parse(text) : null;
+      }
+  }
+  return {
+    data: data,
+    status: res.status,
+    statusText: res.statusText,
+    headers: Object.fromEntries(res.headers.entries()),
+    raw: res
+  };
+}
+function buildUrl(config) {
+  let url = Strings.joinUrl([config.baseURL ?? '', config.url ?? '']);
+  if (config.params) {
+    const qs = new URLSearchParams(Object.entries(config.params).filter(([, v]) => v !== undefined).map(([k, v]) => [k, String(v)])).toString();
+    if (qs) url += `?${qs}`;
   }
+  return url;
 }

package/dist/mjs/utils/tar.browser.js

@@ -12,10 +12,20 @@ export class TarStream {
     });
   }
   beginFile(path, size) {
-    if (path.length > 100) {
-      throw new Error(`File name too long: ${path}`);
+    const {
+      name,
+      prefix,
+      longLink
+    } = splitPath(path);
+    if (longLink) {
+      const encoder = new TextEncoder();
+      const pathData = encoder.encode(path + '\0');
+      this.pieces.push(createLongLinkHeader(pathData.length));
+      this.pieces.push(pathData);
+      const padding = pathData.length % 512 === 0 ? 0 : 512 - pathData.length % 512;
+      if (padding > 0) this.pieces.push(new Uint8Array(padding));
     }
-    const header = createHeader(path, size);
+    const header = createHeader(name, prefix, size);
     this.pieces.push(header);
     this.currentFileSize = 0;
   }
@@ -33,7 +43,55 @@ export class TarStream {
     this.pieces.push(createEndOfArchive());
   }
 }
-function createHeader(path, size) {
+function splitPath(path) {
+  if (path.length <= 100) return {
+    name: path,
+    prefix: '',
+    longLink: false
+  };
+  for (let i = path.length - 1; i >= 0; i--) {
+    if (path[i] === '/') {
+      const name = path.substring(i + 1);
+      const prefix = path.substring(0, i);
+      if (name.length <= 100 && prefix.length <= 155) return {
+        name,
+        prefix,
+        longLink: false
+      };
+    }
+  }
+  // Filename itself is > 100 chars or path > 255 chars — use GNU LongLink
+  const lastSlash = path.lastIndexOf('/');
+  const truncatedName = (lastSlash >= 0 ? path.substring(lastSlash + 1) : path).slice(0, 100);
+  return {
+    name: truncatedName,
+    prefix: '',
+    longLink: true
+  };
+}
+function createLongLinkHeader(size) {
+  const encoder = new TextEncoder();
+  function writeToBuffer(str, offset, length) {
+    const bytes = encoder.encode(str);
+    header.set(bytes.slice(0, length), offset);
+  }
+  const header = new Uint8Array(512);
+  header.fill(0);
+  writeToBuffer('././@LongLink', 0, 100);
+  writeToBuffer('0000644\0', 100, 8);
+  writeToBuffer('0000000\0', 108, 8);
+  writeToBuffer('0000000\0', 116, 8);
+  writeToBuffer(size.toString(8).padStart(11, '0') + '\0', 124, 12);
+  writeToBuffer('00000000000\0', 136, 12);
+  writeToBuffer('        ', 148, 8);
+  writeToBuffer('L', 156, 1);
+  writeToBuffer('ustar\0\0', 257, 8);
+  let checksum = 0;
+  for (let i = 0; i < 512; i++) checksum += header[i];
+  writeToBuffer(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8);
+  return header;
+}
+function createHeader(name, prefix, size) {
   const encoder = new TextEncoder();
   function writeToBuffer(str, offset, length) {
     const bytes = encoder.encode(str);
@@ -43,7 +101,7 @@ function createHeader(path, size) {
   const header = new Uint8Array(512);
   header.fill(0, 0, 512);
   // File name, truncated to 100 characters if necessary
-  writeToBuffer(path.slice(0, 100).padEnd(100, '\0'), 0, 100);
+  writeToBuffer(name.slice(0, 100).padEnd(100, '\0'), 0, 100);
   // File mode (octal) and null-terminated
   writeToBuffer('0000777\0', 100, 8);
   // UID and GID (octal) and null-terminated
@@ -60,11 +118,11 @@ function createHeader(path, size) {
   writeToBuffer('0', 156, 1);
   // USTAR magic and version
   writeToBuffer('ustar\0\0', 257, 8);
+  // UStar prefix field (offset 345, 155 bytes) — used when path > 100 but fits split
+  if (prefix) writeToBuffer(prefix.slice(0, 155).padEnd(155, '\0'), 345, 155);
   // Calculate checksum
   let checksum = 0;
-  for (let i = 0; i < 512; i++) {
-    checksum += header[i];
-  }
+  for (let i = 0; i < 512; i++) checksum += header[i];
   writeToBuffer(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8);
   return header;
 }

package/dist/mjs/utils/tar.js

@@ -5,10 +5,19 @@ export class TarStream {
     this.currentFileSize = 0;
   }
   beginFile(path, size) {
-    if (path.length > 100) {
-      throw new Error(`File name too long: ${path}`);
+    const {
+      name,
+      prefix,
+      longLink
+    } = splitPath(path);
+    if (longLink) {
+      const pathData = Buffer.from(path + '\0');
+      this.output.write(createLongLinkHeader(pathData.length));
+      this.output.write(pathData);
+      const padding = pathData.length % 512 === 0 ? 0 : 512 - pathData.length % 512;
+      if (padding > 0) this.output.write(Buffer.alloc(padding, 0));
     }
-    const header = createHeader(path, size);
+    const header = createHeader(name, prefix, size);
     this.output.write(header);
     this.currentFileSize = 0;
   }
@@ -39,11 +48,53 @@ export class TarStream {
     });
   }
 }
-function createHeader(path, size) {
+function splitPath(path) {
+  if (path.length <= 100) return {
+    name: path,
+    prefix: '',
+    longLink: false
+  };
+  for (let i = path.length - 1; i >= 0; i--) {
+    if (path[i] === '/') {
+      const name = path.substring(i + 1);
+      const prefix = path.substring(0, i);
+      if (name.length <= 100 && prefix.length <= 155) return {
+        name,
+        prefix,
+        longLink: false
+      };
+    }
+  }
+  // Filename itself is > 100 chars or path > 255 chars — use GNU LongLink
+  const lastSlash = path.lastIndexOf('/');
+  const truncatedName = (lastSlash >= 0 ? path.substring(lastSlash + 1) : path).slice(0, 100);
+  return {
+    name: truncatedName,
+    prefix: '',
+    longLink: true
+  };
+}
+function createLongLinkHeader(size) {
+  const header = Buffer.alloc(512, 0);
+  header.write('././@LongLink', 0, 100);
+  header.write('0000644\0', 100, 8);
+  header.write('0000000\0', 108, 8);
+  header.write('0000000\0', 116, 8);
+  header.write(size.toString(8).padStart(11, '0') + '\0', 124, 12);
+  header.write('00000000000\0', 136, 12);
+  header.write('        ', 148, 8);
+  header.write('L', 156, 1);
+  header.write('ustar\0\0', 257, 8);
+  let checksum = 0;
+  for (let i = 0; i < 512; i++) checksum += header[i];
+  header.write(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8);
+  return header;
+}
+function createHeader(name, prefix, size) {
   // Initialize header with zeros
   const header = Buffer.alloc(512, 0);
   // File name, truncated to 100 characters if necessary
-  header.write(path.slice(0, 100).padEnd(100, '\0'), 0, 100);
+  header.write(name.slice(0, 100).padEnd(100, '\0'), 0, 100);
   // File mode (octal) and null-terminated
   header.write('0000777\0', 100, 8);
   // UID and GID (octal) and null-terminated
@@ -60,11 +111,11 @@ function createHeader(path, size) {
   header.write('0', 156, 1);
   // USTAR magic and version
   header.write('ustar\0\0', 257, 8);
+  // UStar prefix field (offset 345, 155 bytes) — used when path > 100 but fits split
+  if (prefix) header.write(prefix.slice(0, 155).padEnd(155, '\0'), 345, 155);
   // Calculate checksum
   let checksum = 0;
-  for (let i = 0; i < 512; i++) {
-    checksum += header[i];
-  }
+  for (let i = 0; i < 512; i++) checksum += header[i];
   header.write(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8);
   return header;
 }

package/dist/mjs/utils/tokens.js

@@ -9,6 +9,9 @@ export class BZZ {
   static fromPLUR(plur) {
     return new BZZ(new FixedPointNumber(plur, BZZ.DIGITS));
   }
+  static fromFloat(float) {
+    return new BZZ(FixedPointNumber.fromFloat(float, BZZ.DIGITS));
+  }
   toPLURString() {
     return this.state.toString();
   }
@@ -18,6 +21,9 @@ export class BZZ {
   toDecimalString() {
     return this.state.toDecimalString();
   }
+  toFloat() {
+    return this.state.toFloat();
+  }
   toSignificantDigits(digits) {
     return this.toDecimalString().slice(0, this.toDecimalString().indexOf('.') + digits + 1);
   }
@@ -78,6 +84,9 @@ export class DAI {
   static fromWei(wei) {
     return new DAI(new FixedPointNumber(wei, DAI.DIGITS));
   }
+  static fromFloat(float) {
+    return new DAI(FixedPointNumber.fromFloat(float, DAI.DIGITS));
+  }
   toWeiString() {
     return this.state.toString();
   }
@@ -90,6 +99,9 @@ export class DAI {
   toSignificantDigits(digits) {
     return this.toDecimalString().slice(0, this.toDecimalString().indexOf('.') + digits + 1);
   }
+  toFloat() {
+    return this.state.toFloat();
+  }
   /**
    * Does not mutate the current DAI instance.
    *

package/dist/types/bee.d.ts

@@ -1074,7 +1074,7 @@ export declare class Bee {
      * @param erasureCodeLevel Assume the future uploaded data is erasure coded, which skews the capacity of the postage batch.
      * @returns
      */
-    extendStorage(postageBatchId: BatchId | Uint8Array | string, size: Size, duration: Duration, requestOptions?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<BatchId>;
+    extendStorage(postageBatchId: BatchId | Uint8Array | string, size: Size, duration: Duration, requestOptions?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<TransactionId | BatchId>;
     /**
      * Extends the storage size of a postage batch by increasing its depth.
      *
@@ -1157,12 +1157,12 @@ export declare class Bee {
     /**
      * Calculates the `amount` and expected duration extension for topping up a postage batch with a given BZZ value.
      *
-     * @param postageBatchId
+     * @param depth Depth of the postage batch to top up.
      * @param bzz The amount of BZZ to spend on the top-up.
      * @param requestOptions Options for making requests, such as timeouts, custom HTTP agents, headers, etc.
      * @returns An object with `amount` (to pass to {@link topUpBatch}) and `duration` (the expected TTL extension).
      */
-    calculateTopUpForBzz(postageBatchId: BatchId | Uint8Array | string, bzz: BZZ, requestOptions?: BeeRequestOptions): Promise<{
+    calculateTopUpForBzz(depth: number, bzz: BZZ, requestOptions?: BeeRequestOptions): Promise<{
         amount: bigint;
         duration: Duration;
     }>;

package/dist/types/index.d.ts

@@ -1,5 +1,4 @@
 import { Bee } from './bee';
-import { BeeDev } from './bee-dev';
 import { Stamper } from './stamper/stamper';
 export { MerkleTree } from 'cafe-utility';
 export type { Chunk } from './chunk/cac';
@@ -16,12 +15,11 @@ export { Size } from './utils/size';
 export * from './utils/tokens';
 export * from './utils/typed-bytes';
 export type { UploadProgress } from './utils/upload-progress';
-export { Bee, BeeDev, Stamper };
+export { Bee, Stamper };
 declare global {
     interface Window {
         BeeJs: {
             Bee: typeof import('./bee').Bee;
-            BeeDev: typeof import('./bee-dev').BeeDev;
             Stamper: typeof import('./stamper/stamper').Stamper;
             Utils: typeof import('./utils/expose');
             Duration: typeof import('./utils/duration').Duration;

package/dist/types/utils/http.d.ts

@@ -1,9 +1,24 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { BeeRequestOptions } from '../index';
-export declare const DEFAULT_HTTP_CONFIG: AxiosRequestConfig;
+export declare const DEFAULT_HTTP_CONFIG: BeeRequestConfig;
+export type BeeResponseType = 'json' | 'arraybuffer' | 'text' | 'blob' | 'stream';
+export interface BeeResponse<T> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    raw: Response;
+}
+export interface BeeRequestConfig extends RequestInit {
+    url?: string;
+    baseURL?: string;
+    params?: Record<string, unknown>;
+    data?: unknown;
+    responseType?: BeeResponseType;
+}
 /**
  * Main function to make HTTP requests.
  * @param options User defined settings
  * @param config Internal settings and/or Bee settings
  */
-export declare function http<T>(options: BeeRequestOptions, config: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+export declare function http<T>(options: BeeRequestOptions, config: BeeRequestConfig): Promise<BeeResponse<T>>;
+export declare function toBeeResponse<T>(res: Response, responseType?: BeeResponseType): Promise<BeeResponse<T>>;

package/dist/types/utils/tar-uploader.browser.d.ts

@@ -1,3 +1,3 @@
 import { BeeRequestOptions, Collection, CollectionUploadOptions } from '..';
 import { BatchId } from './typed-bytes';
-export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any, {}>>;
+export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("./http").BeeResponse<unknown>>;

package/dist/types/utils/tar-uploader.d.ts

@@ -1,3 +1,3 @@
 import { BeeRequestOptions, Collection, CollectionUploadOptions } from '..';
 import { BatchId } from './typed-bytes';
-export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any, {}>>;
+export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("./http").BeeResponse<unknown>>;

package/dist/types/utils/tokens.d.ts

@@ -5,9 +5,11 @@ export declare class BZZ {
     private constructor();
     static fromDecimalString(string: string): BZZ;
     static fromPLUR(plur: NumberString | string | bigint): BZZ;
+    static fromFloat(float: number): BZZ;
     toPLURString(): string;
     toPLURBigInt(): bigint;
     toDecimalString(): string;
+    toFloat(): number;
     toSignificantDigits(digits: number): string;
     /**
      * Does not mutate the current BZZ instance.
@@ -43,10 +45,12 @@ export declare class DAI {
     private constructor();
     static fromDecimalString(string: string): DAI;
     static fromWei(wei: NumberString | string | bigint): DAI;
+    static fromFloat(float: number): DAI;
     toWeiString(): string;
     toWeiBigInt(): bigint;
     toDecimalString(): string;
     toSignificantDigits(digits: number): string;
+    toFloat(): number;
     /**
      * Does not mutate the current DAI instance.
      *