@ethersphere/bee-js 10.3.0 → 10.4.0

package/dist/mjs/modules/debug/stamps.js

@@ -1,11 +1,8 @@
 import { Types } from 'cafe-utility';
-import { Duration } from "../../utils/duration.js";
 import { http } from "../../utils/http.js";
-import { Size } from "../../utils/size.js";
-import { getStampEffectiveBytes, getStampTheoreticalBytes, getStampUsage } from "../../utils/stamps.js";
+import { mapPostageBatch } from "../../utils/stamps.js";
 import { asNumberString } from "../../utils/type.js";
 import { BatchId, EthAddress } from "../../utils/typed-bytes.js";
-import { normalizeBatchTTL } from "../../utils/workaround.js";
 const STAMPS_ENDPOINT = 'stamps';
 const BATCHES_ENDPOINT = 'batches';
 export async function getGlobalPostageBatches(requestOptions) {
@@ -63,60 +60,7 @@ export async function getAllPostageBatches(requestOptions) {
   }).map(x => Types.asObject(x, {
     name: 'stamp'
   }));
-  return stamps.map(x => {
-    const utilization = Types.asNumber(x.utilization, {
-      name: 'utilization'
-    });
-    const depth = Types.asNumber(x.depth, {
-      name: 'depth'
-    });
-    const bucketDepth = Types.asNumber(x.bucketDepth, {
-      name: 'bucketDepth'
-    });
-    const usage = getStampUsage(utilization, depth, bucketDepth);
-    const batchTTL = normalizeBatchTTL(Types.asNumber(x.batchTTL, {
-      name: 'batchTTL'
-    }));
-    const duration = Duration.fromSeconds(batchTTL);
-    const effectiveBytes = getStampEffectiveBytes(depth);
-    return {
-      batchID: new BatchId(Types.asString(x.batchID, {
-        name: 'batchID'
-      })),
-      utilization,
-      usable: Types.asBoolean(x.usable, {
-        name: 'usable'
-      }),
-      label: Types.asEmptiableString(x.label, {
-        name: 'label'
-      }),
-      depth,
-      amount: asNumberString(x.amount, {
-        name: 'amount'
-      }),
-      bucketDepth,
-      blockNumber: Types.asNumber(x.blockNumber, {
-        name: 'blockNumber'
-      }),
-      immutableFlag: Types.asBoolean(x.immutableFlag, {
-        name: 'immutableFlag'
-      }),
-      usage,
-      usageText: `${Math.round(usage * 100)}%`,
-      size: Size.fromBytes(effectiveBytes),
-      remainingSize: Size.fromBytes(Math.ceil(effectiveBytes * (1 - usage))),
-      theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(depth)),
-      duration,
-      calculateSize(encryption, redundancyLevel) {
-        const effectiveBytes = getStampEffectiveBytes(this.depth, encryption, redundancyLevel);
-        return Size.fromBytes(effectiveBytes);
-      },
-      calculateRemainingSize(encryption, redundancyLevel) {
-        const effectiveBytes = getStampEffectiveBytes(this.depth, encryption, redundancyLevel);
-        return Size.fromBytes(Math.ceil(effectiveBytes * (1 - this.usage)));
-      }
-    };
-  });
+  return stamps.map(x => mapPostageBatch(validateRawPostageBatch(x)));
 }
 export async function getPostageBatch(requestOptions, postageBatchId, encryption, erasureCodeLevel) {
   const response = await http(requestOptions, {
@@ -127,58 +71,7 @@ export async function getPostageBatch(requestOptions, postageBatchId, encryption
   const body = Types.asObject(response.data, {
     name: 'response.data'
   });
-  const utilization = Types.asNumber(body.utilization, {
-    name: 'utilization'
-  });
-  const depth = Types.asNumber(body.depth, {
-    name: 'depth'
-  });
-  const bucketDepth = Types.asNumber(body.bucketDepth, {
-    name: 'bucketDepth'
-  });
-  const usage = getStampUsage(utilization, depth, bucketDepth);
-  const batchTTL = normalizeBatchTTL(Types.asNumber(body.batchTTL, {
-    name: 'batchTTL'
-  }));
-  const duration = Duration.fromSeconds(batchTTL);
-  const effectiveBytes = getStampEffectiveBytes(depth, encryption, erasureCodeLevel);
-  return {
-    batchID: new BatchId(Types.asString(body.batchID, {
-      name: 'batchID'
-    })),
-    utilization,
-    usable: Types.asBoolean(body.usable, {
-      name: 'usable'
-    }),
-    label: Types.asEmptiableString(body.label, {
-      name: 'label'
-    }),
-    depth,
-    amount: asNumberString(body.amount, {
-      name: 'amount'
-    }),
-    bucketDepth,
-    blockNumber: Types.asNumber(body.blockNumber, {
-      name: 'blockNumber'
-    }),
-    immutableFlag: Types.asBoolean(body.immutableFlag, {
-      name: 'immutableFlag'
-    }),
-    usage,
-    usageText: `${Math.round(usage * 100)}%`,
-    size: Size.fromBytes(effectiveBytes),
-    remainingSize: Size.fromBytes(Math.ceil(effectiveBytes * (1 - usage))),
-    theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(depth)),
-    duration,
-    calculateSize(encryption, redundancyLevel) {
-      const effectiveBytes = getStampEffectiveBytes(depth, encryption, redundancyLevel);
-      return Size.fromBytes(effectiveBytes);
-    },
-    calculateRemainingSize(encryption, redundancyLevel) {
-      const effectiveBytes = getStampEffectiveBytes(depth, encryption, redundancyLevel);
-      return Size.fromBytes(Math.ceil(effectiveBytes * (1 - usage)));
-    }
-  };
+  return mapPostageBatch(validateRawPostageBatch(body), encryption, erasureCodeLevel);
 }
 export async function getPostageBatchBuckets(requestOptions, postageBatchId) {
   const response = await http(requestOptions, {
@@ -262,4 +155,38 @@ export async function diluteBatch(requestOptions, id, depth) {
   return new BatchId(Types.asString(body.batchID, {
     name: 'batchID'
   }));
+}
+function validateRawPostageBatch(raw) {
+  return {
+    amount: asNumberString(raw.amount, {
+      name: 'amount'
+    }),
+    batchID: Types.asString(raw.batchID, {
+      name: 'batchID'
+    }),
+    batchTTL: Types.asNumber(raw.batchTTL, {
+      name: 'batchTTL'
+    }),
+    bucketDepth: Types.asNumber(raw.bucketDepth, {
+      name: 'bucketDepth'
+    }),
+    blockNumber: Types.asNumber(raw.blockNumber, {
+      name: 'blockNumber'
+    }),
+    depth: Types.asNumber(raw.depth, {
+      name: 'depth'
+    }),
+    immutableFlag: Types.asBoolean(raw.immutableFlag, {
+      name: 'immutableFlag'
+    }),
+    label: Types.asEmptiableString(raw.label, {
+      name: 'label'
+    }),
+    usable: Types.asBoolean(raw.usable, {
+      name: 'usable'
+    }),
+    utilization: Types.asNumber(raw.utilization, {
+      name: 'utilization'
+    })
+  };
 }

package/dist/mjs/utils/expose.js

@@ -2,4 +2,4 @@ export { getCollectionSize, makeCollectionFromFileList } from "./collection.js";
 export { getFolderSize } from "./collection.node.js";
 export { makeMaxTarget } from "./pss.js";
 export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from "./redundancy.js";
-export { getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage } from "./stamps.js";
+export { getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage, mapPostageBatch, unmapPostageBatch } from "./stamps.js";

package/dist/mjs/utils/stamps.js

@@ -2,8 +2,11 @@ import { Binary } from 'cafe-utility';
 import { capacityBreakpoints } from "../types/index.js";
 import { Bytes, parseSizeToBytes } from "./bytes.js";
 import { Duration } from "./duration.js";
+import { Size } from "./size.js";
 import { BZZ } from "./tokens.js";
 import { asNumberString } from "./type.js";
+import { BatchId } from "./typed-bytes.js";
+import { normalizeBatchTTL } from "./workaround.js";
 const MAX_UTILIZATION = 0.9;
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
@@ -137,4 +140,49 @@ export function marshalStamp(signature, batchId, timestamp, index) {
     throw Error('invalid index length');
   }
   return new Bytes(Binary.concatBytes(batchId, index, timestamp, signature));
+}
+export function mapPostageBatch(raw, encryption, erasureCodeLevel) {
+  const usage = getStampUsage(raw.utilization, raw.depth, raw.bucketDepth);
+  const batchTTL = normalizeBatchTTL(raw.batchTTL);
+  const duration = Duration.fromSeconds(batchTTL);
+  const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, erasureCodeLevel);
+  return {
+    batchID: new BatchId(raw.batchID),
+    utilization: raw.utilization,
+    usable: raw.usable,
+    label: raw.label,
+    depth: raw.depth,
+    amount: asNumberString(raw.amount),
+    bucketDepth: raw.bucketDepth,
+    blockNumber: raw.blockNumber,
+    immutableFlag: raw.immutableFlag,
+    usage,
+    usageText: `${Math.round(usage * 100)}%`,
+    size: Size.fromBytes(effectiveBytes),
+    remainingSize: Size.fromBytes(Math.ceil(effectiveBytes * (1 - usage))),
+    theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(raw.depth)),
+    duration,
+    calculateSize(encryption, redundancyLevel) {
+      const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, redundancyLevel);
+      return Size.fromBytes(effectiveBytes);
+    },
+    calculateRemainingSize(encryption, redundancyLevel) {
+      const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, redundancyLevel);
+      return Size.fromBytes(Math.ceil(effectiveBytes * (1 - this.usage)));
+    }
+  };
+}
+export function unmapPostageBatch(batch) {
+  return {
+    batchID: batch.batchID.toHex(),
+    utilization: batch.utilization,
+    usable: batch.usable,
+    label: batch.label,
+    depth: batch.depth,
+    amount: batch.amount,
+    bucketDepth: batch.bucketDepth,
+    blockNumber: batch.blockNumber,
+    immutableFlag: batch.immutableFlag,
+    batchTTL: batch.duration.toSeconds()
+  };
 }

package/dist/mjs/utils/workaround.js

@@ -6,8 +6,11 @@ export function normalizeBatchTTL(batchTTL) {
   if (batchTTL < 1) {
     return 1;
   }
-  if (batchTTL > 315569260) {
-    return 315569260;
+  // Cap `batchTTL` (represents seconds) to 100 years.
+  // We can assume `storagePrice` is invalid (e.g. 1).
+  // This is needed to prevent Date objects breaking.
+  if (batchTTL > 3155695200) {
+    return 3155695200;
   }
   return batchTTL;
 }

package/dist/types/index.d.ts

@@ -2,8 +2,8 @@ import { Bee } from './bee';
 import { BeeDev } from './bee-dev';
 import { Stamper } from './stamper/stamper';
 export { MerkleTree } from 'cafe-utility';
-export { Chunk } from './chunk/cac';
-export { SingleOwnerChunk } from './chunk/soc';
+export type { Chunk } from './chunk/cac';
+export type { SingleOwnerChunk } from './chunk/soc';
 export { MantarayNode } from './manifest/manifest';
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
 export * from './types';

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

@@ -2,4 +2,4 @@ export { getCollectionSize, makeCollectionFromFileList } from './collection';
 export { getFolderSize } from './collection.node';
 export { makeMaxTarget } from './pss';
 export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from './redundancy';
-export { getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage, } from './stamps';
+export { getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage, mapPostageBatch, unmapPostageBatch, } from './stamps';

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

@@ -1,4 +1,4 @@
-import { EnvelopeWithBatchId, NumberString, RedundancyLevel } from '../types';
+import { EnvelopeWithBatchId, NumberString, PostageBatch, RedundancyLevel } from '../types';
 import { Bytes } from './bytes';
 import { Duration } from './duration';
 import { Size } from './size';
@@ -58,3 +58,17 @@ export declare function getAmountForDuration(duration: Duration, pricePerBlock:
 export declare function getDepthForSize(size: Size, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): number;
 export declare function convertEnvelopeToMarshaledStamp(envelope: EnvelopeWithBatchId): Bytes;
 export declare function marshalStamp(signature: Uint8Array, batchId: Uint8Array, timestamp: Uint8Array, index: Uint8Array): Bytes;
+export interface RawPostageBatch {
+    batchID: string;
+    utilization: number;
+    usable: boolean;
+    label: string;
+    depth: number;
+    amount: string;
+    bucketDepth: number;
+    blockNumber: number;
+    immutableFlag: boolean;
+    batchTTL: number;
+}
+export declare function mapPostageBatch(raw: RawPostageBatch, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): PostageBatch;
+export declare function unmapPostageBatch(batch: PostageBatch): RawPostageBatch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethersphere/bee-js",
-  "version": "10.3.0",
+  "version": "10.4.0",
   "description": "Javascript client for Bee",
   "keywords": [
     "bee",