@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/cjs/utils/stamps.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.marshalStamp = exports.convertEnvelopeToMarshaledStamp = exports.getDepthForCapacity = exports.getAmountForTtl = exports.getStampTtlSeconds = exports.getStampCostInBzz = exports.getStampCostInPlur = exports.getStampEffectiveBytes = exports.getStampMaximumCapacityBytes = exports.getStampUsage = void 0;
+exports.marshalStamp = exports.convertEnvelopeToMarshaledStamp = exports.getDepthForSize = exports.getAmountForDuration = exports.getStampDuration = exports.getStampCost = exports.getStampEffectiveBytesBreakpoints = exports.getStampEffectiveBytes = exports.getStampTheoreticalBytes = exports.getStampUsage = void 0;
 const cafe_utility_1 = require("cafe-utility");
+const bytes_1 = require("./bytes");
+const duration_1 = require("./duration");
+const tokens_1 = require("./tokens");
+const type_1 = require("./type");
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
  *
@@ -14,16 +18,16 @@ function getStampUsage(utilization, depth, bucketDepth) {
 }
 exports.getStampUsage = getStampUsage;
 /**
- * Utility function that calculates the theoritical maximum capacity of a postage batch based on its depth.
+ * Utility function that calculates the theoritical maximum size of a postage batch based on its depth.
  *
- * For smaller depths (up to 20), this may provide less accurate results.
+ * For smaller depths (up to 22), this may provide less accurate results.
  *
- * @returns {number} The maximum capacity of the postage batch in bytes.
+ * @returns {number} The maximum theoretical size of the postage batch in bytes.
  */
-function getStampMaximumCapacityBytes(depth) {
-    return 2 ** depth * 4096;
+function getStampTheoreticalBytes(depth) {
+    return 4096 * 2 ** depth;
 }
-exports.getStampMaximumCapacityBytes = getStampMaximumCapacityBytes;
+exports.getStampTheoreticalBytes = getStampTheoreticalBytes;
 /**
  * Based on https://docs.ethswarm.org/docs/learn/technology/contracts/postage-stamp/#effective-utilisation-table
  */
@@ -42,86 +46,98 @@ const utilisationRateMap = {
     33: 0.9842,
     34: 0.9889,
 };
+const effectiveSizeBreakpoints = [
+    [22, 4.93],
+    [23, 17.03],
+    [24, 44.21],
+    [25, 102.78],
+    [26, 225.87],
+    [27, 480.44],
+    [28, 1001.44],
+    [29, 2060.27],
+    [30, 4201.9],
+    [31, 8519.02],
+    [32, 17199.89],
+    [33, 34628.46],
+];
 /**
- * Utility function that calculates the effective volume of a postage batch based on its depth.
+ * Utility function that calculates the effective size of a postage batch based on its depth.
  *
- * Below 22 depth the effective volume is 0
+ * Below 22 depth the effective size is 0
  * Above 34 it's always > 99%
  *
- * @returns {number} The effective volume of the postage batch in bytes.
+ * @returns {number} The effective size of the postage batch in bytes.
  */
 function getStampEffectiveBytes(depth) {
     if (depth < 22) {
         return 0;
     }
     const utilRate = utilisationRateMap[depth] ?? 0.99;
-    return getStampMaximumCapacityBytes(depth) * utilRate;
+    return Math.ceil(getStampTheoreticalBytes(depth) * utilRate);
 }
 exports.getStampEffectiveBytes = getStampEffectiveBytes;
-/**
- * Utility function that calculates the cost of a postage batch based on its depth and amount.
- *
- * @returns {number} The cost of the postage batch in PLUR (10000000000000000 [1e16] PLUR = 1 BZZ)
- */
-function getStampCostInPlur(depth, amount) {
-    return 2 ** depth * amount;
+function getStampEffectiveBytesBreakpoints() {
+    const map = new Map();
+    for (let i = 22; i < 35; i++) {
+        map.set(i, getStampEffectiveBytes(i));
+    }
+    return map;
 }
-exports.getStampCostInPlur = getStampCostInPlur;
+exports.getStampEffectiveBytesBreakpoints = getStampEffectiveBytesBreakpoints;
 /**
  * Utility function that calculates the cost of a postage batch based on its depth and amount.
- *
- * @returns {number} The cost of the postage batch in BZZ (1 BZZ = 10000000000000000 [1e16] PLUR)
  */
-function getStampCostInBzz(depth, amount) {
-    const BZZ_UNIT = 10 ** 16;
-    return getStampCostInPlur(depth, amount) / BZZ_UNIT;
+function getStampCost(depth, amount) {
+    return tokens_1.BZZ.fromPLUR(2n ** BigInt(depth) * BigInt(amount));
 }
-exports.getStampCostInBzz = getStampCostInBzz;
+exports.getStampCost = getStampCost;
 /**
  * Utility function that calculates the TTL of a postage batch based on its amount, price per block and block time.
  *
  * For more accurate results, get the price per block and block time from the Bee node or the blockchain.
  *
- * @returns {number} The TTL of the postage batch in seconds.
+ * @returns {number} The TTL of the postage batch.
  */
-function getStampTtlSeconds(amount, pricePerBlock = 24000, blockTime = 5) {
-    return (amount * blockTime) / pricePerBlock;
+function getStampDuration(amount, pricePerBlock, blockTime = 5) {
+    const amountBigInt = BigInt((0, type_1.asNumberString)(amount));
+    return duration_1.Duration.fromSeconds(Number((amountBigInt * BigInt(blockTime)) / BigInt(pricePerBlock)));
 }
-exports.getStampTtlSeconds = getStampTtlSeconds;
+exports.getStampDuration = getStampDuration;
 /**
- * Utility function that calculates the amount of tokens required to maintain a given Time To Live (TTL) for a postage batch.
- *
- * This function estimates the required amount based on the provided TTL in days.
+ * Get the postage batch `amount` required for a given `duration`.
  *
- * @param {number} days - The Time To Live (TTL) in days.
- * @returns {NumberString} The estimated amount of tokens needed for the specified TTL.
+ * @param duration A duration object representing the duration of the storage.
+ * @param pricePerBlock The price per block in PLUR.
+ * @param blockTime The block time in seconds.
  */
-function getAmountForTtl(days) {
-    // 414720000 = (24 * 60 * 60 * 24_000) / 5
-    return ((days <= 0 ? 1 : days) * 414720000).toString();
+function getAmountForDuration(duration, pricePerBlock, blockTime = 5) {
+    return (BigInt(duration.toSeconds()) / BigInt(blockTime)) * BigInt(pricePerBlock);
 }
-exports.getAmountForTtl = getAmountForTtl;
+exports.getAmountForDuration = getAmountForDuration;
 /**
- * Utility function that calculates the depth required for a postage batch to achieve the specified capacity in gigabytes.
+ * Utility function that calculates the depth required for a postage batch to achieve the specified effective size
  *
- * The depth is determined based on the given gigabytes, and the result is adjusted to a minimum depth of 18.
- *
- * @param {number} gigabytes - The desired capacity of the postage batch in gigabytes.
- * @returns {number} The calculated depth necessary to achieve the specified capacity.
+ * @param size The effective size of the postage batch
+ * @returns
  */
-function getDepthForCapacity(gigabytes) {
-    return gigabytes <= 1 ? 18 : Math.ceil(Math.log2(Math.ceil(gigabytes)) + 18);
+function getDepthForSize(size) {
+    for (const [depth, sizeBreakpoint] of effectiveSizeBreakpoints) {
+        if (size.toGigabytes() <= sizeBreakpoint) {
+            return depth;
+        }
+    }
+    return 34;
 }
-exports.getDepthForCapacity = getDepthForCapacity;
-function convertEnvelopeToMarshaledStamp(batchID, envelope) {
-    return marshalStamp(envelope.signature, cafe_utility_1.Binary.hexToUint8Array(batchID), envelope.timestamp, envelope.index);
+exports.getDepthForSize = getDepthForSize;
+function convertEnvelopeToMarshaledStamp(envelope) {
+    return marshalStamp(envelope.signature, envelope.batchId.toUint8Array(), envelope.timestamp, envelope.index);
 }
 exports.convertEnvelopeToMarshaledStamp = convertEnvelopeToMarshaledStamp;
-function marshalStamp(signature, batchID, timestamp, index) {
+function marshalStamp(signature, batchId, timestamp, index) {
     if (signature.length !== 65) {
         throw Error('invalid signature length');
     }
-    if (batchID.length !== 32) {
+    if (batchId.length !== 32) {
         throw Error('invalid batch ID length');
     }
     if (timestamp.length !== 8) {
@@ -130,6 +146,6 @@ function marshalStamp(signature, batchID, timestamp, index) {
     if (index.length !== 8) {
         throw Error('invalid index length');
     }
-    return cafe_utility_1.Binary.concatBytes(batchID, index, timestamp, signature);
+    return new bytes_1.Bytes(cafe_utility_1.Binary.concatBytes(batchId, index, timestamp, signature));
 }
 exports.marshalStamp = marshalStamp;

package/dist/cjs/utils/tar-uploader.browser.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadTar = void 0;
-const bzz_1 = require("../modules/bzz");
+const headers_1 = require("./headers");
 const http_1 = require("./http");
 const tar_1 = require("./tar");
 const tar_writer_1 = require("./tar-writer");
@@ -18,7 +18,7 @@ async function uploadTar(requestOptions, collection, postageBatchId, options) {
         headers: {
             'content-type': 'application/x-tar',
             'swarm-collection': 'true',
-            ...(0, bzz_1.extractCollectionUploadHeaders)(postageBatchId, options),
+            ...(0, headers_1.prepareRequestHeaders)(postageBatchId, options),
         },
     });
     return response;

package/dist/cjs/utils/tar-uploader.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadTar = void 0;
-const bzz_1 = require("../modules/bzz");
+const headers_1 = require("./headers");
 const http_1 = require("./http");
 const tar_1 = require("./tar");
 const tar_writer_1 = require("./tar-writer");
@@ -16,7 +16,7 @@ async function uploadTar(requestOptions, collection, postageBatchId, options) {
         headers: {
             'content-type': 'application/x-tar',
             'swarm-collection': 'true',
-            ...(0, bzz_1.extractCollectionUploadHeaders)(postageBatchId, options),
+            ...(0, headers_1.prepareRequestHeaders)(postageBatchId, options),
         },
     });
     await (0, tar_writer_1.writeTar)(collection, tarStream);

package/dist/cjs/utils/tokens.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAI = exports.BZZ = void 0;
+const cafe_utility_1 = require("cafe-utility");
+class BZZ {
+    constructor(state) {
+        this.state = state;
+    }
+    static fromDecimalString(string) {
+        return new BZZ(cafe_utility_1.FixedPointNumber.fromDecimalString(string, BZZ.DIGITS));
+    }
+    static fromPLUR(plur) {
+        return new BZZ(new cafe_utility_1.FixedPointNumber(plur, BZZ.DIGITS));
+    }
+    toPLURString() {
+        return this.state.toString();
+    }
+    toPLURBigInt() {
+        return this.state.value;
+    }
+    toDecimalString() {
+        return this.state.toDecimalString();
+    }
+    toSignificantDigits(digits) {
+        return this.toDecimalString().slice(0, this.toDecimalString().indexOf('.') + digits + 1);
+    }
+    /**
+     * Does not mutate the current BZZ instance.
+     *
+     * @param other BZZ instance, or amount in PLUR
+     * @returns New BZZ instance
+     */
+    plus(other) {
+        return new BZZ(this.state.add(other instanceof BZZ ? other.state : new cafe_utility_1.FixedPointNumber(other, BZZ.DIGITS)));
+    }
+    /**
+     * Does not mutate the current BZZ instance.
+     *
+     * @param other BZZ instance, or amount in PLUR
+     * @returns New BZZ instance
+     */
+    minus(other) {
+        return new BZZ(this.state.subtract(other instanceof BZZ ? other.state : new cafe_utility_1.FixedPointNumber(other, BZZ.DIGITS)));
+    }
+    /**
+     * Does not mutate the current BZZ instance.
+     *
+     * @param other Divisor
+     * @returns New BZZ instance
+     */
+    divide(other) {
+        return new BZZ(this.state.divmod(other)[0]);
+    }
+    gt(other) {
+        return this.state.compare(other.state) === 1;
+    }
+    gte(other) {
+        return this.state.compare(other.state) !== -1;
+    }
+    lt(other) {
+        return this.state.compare(other.state) === -1;
+    }
+    lte(other) {
+        return this.state.compare(other.state) !== 1;
+    }
+    eq(other) {
+        return this.state.compare(other.state) === 0;
+    }
+    exchangeToDAI(daiPerBzz) {
+        return DAI.fromWei(this.state.exchange('*', new cafe_utility_1.FixedPointNumber(daiPerBzz.toWeiBigInt(), DAI.DIGITS), DAI.DIGITS).value);
+    }
+}
+exports.BZZ = BZZ;
+BZZ.DIGITS = 16;
+class DAI {
+    constructor(state) {
+        this.state = state;
+    }
+    static fromDecimalString(string) {
+        return new DAI(cafe_utility_1.FixedPointNumber.fromDecimalString(string, DAI.DIGITS));
+    }
+    static fromWei(wei) {
+        return new DAI(new cafe_utility_1.FixedPointNumber(wei, DAI.DIGITS));
+    }
+    toWeiString() {
+        return this.state.toString();
+    }
+    toWeiBigInt() {
+        return this.state.value;
+    }
+    toDecimalString() {
+        return this.state.toDecimalString();
+    }
+    toSignificantDigits(digits) {
+        return this.toDecimalString().slice(0, this.toDecimalString().indexOf('.') + digits + 1);
+    }
+    /**
+     * Does not mutate the current DAI instance.
+     *
+     * @param other DAI instance, or amount in PLUR
+     * @returns New DAI instance
+     */
+    plus(other) {
+        return new DAI(this.state.add(other instanceof DAI ? other.state : new cafe_utility_1.FixedPointNumber(other, DAI.DIGITS)));
+    }
+    /**
+     * Does not mutate the current DAI instance.
+     *
+     * @param other DAI instance, or amount in PLUR
+     * @returns New DAI instance
+     */
+    minus(other) {
+        return new DAI(this.state.subtract(other instanceof DAI ? other.state : new cafe_utility_1.FixedPointNumber(other, DAI.DIGITS)));
+    }
+    /**
+     * Does not mutate the current DAI instance.
+     *
+     * @param other Divisor
+     * @returns New DAI instance
+     */
+    divide(other) {
+        return new DAI(this.state.divmod(other)[0]);
+    }
+    gt(other) {
+        return this.state.compare(other.state) === 1;
+    }
+    gte(other) {
+        return this.state.compare(other.state) !== -1;
+    }
+    lt(other) {
+        return this.state.compare(other.state) === -1;
+    }
+    lte(other) {
+        return this.state.compare(other.state) !== 1;
+    }
+    eq(other) {
+        return this.state.compare(other.state) === 0;
+    }
+    exchangeToBZZ(daiPerBzz) {
+        return BZZ.fromPLUR(this.state.exchange('/', new cafe_utility_1.FixedPointNumber(daiPerBzz.toWeiBigInt(), DAI.DIGITS), BZZ.DIGITS).value);
+    }
+}
+exports.DAI = DAI;
+DAI.DIGITS = 18;