@ethersphere/bee-js 12.2.2 → 12.3.1

package/dist/cjs/types/schema/stewardship.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsRetrievableResponse = void 0;
+const zod_1 = require("zod");
+exports.IsRetrievableResponse = zod_1.z.object({
+    isRetrievable: zod_1.z.boolean(),
+});

package/dist/cjs/types/schema/tag.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAllTagsResponse = exports.TagSchema = void 0;
+const zod_1 = require("zod");
+exports.TagSchema = zod_1.z.object({
+    address: zod_1.z
+        .string()
+        .nullish()
+        .transform(v => v ?? ''),
+    seen: zod_1.z.number(),
+    sent: zod_1.z.number(),
+    split: zod_1.z.number(),
+    startedAt: zod_1.z.string(),
+    stored: zod_1.z.number(),
+    synced: zod_1.z.number(),
+    uid: zod_1.z.number(),
+});
+exports.GetAllTagsResponse = zod_1.z.object({
+    tags: zod_1.z.array(exports.TagSchema),
+});

package/dist/cjs/types/schema/transactions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionHashResponse = exports.GetTransactionResponse = exports.GetAllTransactionsResponse = void 0;
+const zod_1 = require("zod");
+const type_1 = require("../../utils/type");
+const typed_bytes_1 = require("../../utils/typed-bytes");
+const TransactionInfoSchema = zod_1.z.object({
+    transactionHash: zod_1.z.string().transform(s => new typed_bytes_1.TransactionId(s)),
+    to: zod_1.z.string(),
+    nonce: zod_1.z.number(),
+    gasPrice: zod_1.z.string().transform(s => (0, type_1.asNumberString)(s, { name: 'gasPrice' })),
+    gasLimit: zod_1.z.number(),
+    data: zod_1.z.string(),
+    created: zod_1.z.string(),
+    description: zod_1.z.string(),
+    value: zod_1.z.string().transform(s => (0, type_1.asNumberString)(s, { name: 'value' })),
+});
+exports.GetAllTransactionsResponse = zod_1.z.object({
+    pendingTransactions: zod_1.z.array(TransactionInfoSchema),
+});
+exports.GetTransactionResponse = TransactionInfoSchema;
+exports.TransactionHashResponse = zod_1.z.object({
+    transactionHash: zod_1.z.string().transform(s => new typed_bytes_1.TransactionId(s)),
+});

package/dist/cjs/types/schema/upload.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadResultBody = void 0;
+const zod_1 = require("zod");
+const typed_bytes_1 = require("../../utils/typed-bytes");
+exports.UploadResultBody = zod_1.z.object({
+    reference: zod_1.z.string().transform(s => new typed_bytes_1.Reference(s)),
+});

package/dist/cjs/utils/bad-ports.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BAD_PORTS = void 0;
+/**
+ * Ports blocked by the WHATWG Fetch spec for HTTP/HTTPS requests.
+ *
+ * See: https://fetch.spec.whatwg.org/#port-blocking
+ */
+exports.BAD_PORTS = [
+    '1',
+    '7',
+    '9',
+    '11',
+    '13',
+    '15',
+    '17',
+    '19',
+    '20',
+    '21',
+    '22',
+    '23',
+    '25',
+    '37',
+    '42',
+    '43',
+    '53',
+    '69',
+    '77',
+    '79',
+    '87',
+    '95',
+    '101',
+    '102',
+    '103',
+    '104',
+    '109',
+    '110',
+    '111',
+    '113',
+    '115',
+    '117',
+    '119',
+    '123',
+    '135',
+    '137',
+    '139',
+    '143',
+    '161',
+    '179',
+    '389',
+    '427',
+    '465',
+    '512',
+    '513',
+    '514',
+    '515',
+    '526',
+    '530',
+    '531',
+    '532',
+    '540',
+    '548',
+    '554',
+    '556',
+    '563',
+    '587',
+    '601',
+    '636',
+    '989',
+    '990',
+    '993',
+    '995',
+    '1719',
+    '1720',
+    '1723',
+    '2049',
+    '3659',
+    '4045',
+    '4190',
+    '5060',
+    '5061',
+    '6000',
+    '6566',
+    '6665',
+    '6666',
+    '6667',
+    '6668',
+    '6669',
+    '6679',
+    '6697',
+    '10080',
+];

package/dist/cjs/utils/bytes.js

@@ -7,6 +7,8 @@ exports.Bytes = void 0;
 exports.parseSizeToBytes = parseSizeToBytes;
 const cafe_utility_1 = require("cafe-utility");
 const debug_1 = __importDefault(require("debug"));
+const zod_1 = require("zod");
+const hex_schema_1 = require("./hex-schema");
 const debug = (0, debug_1.default)('bee-js:bytes');
 const DECODER = new TextDecoder();
 const ENCODER = new TextEncoder();
@@ -19,7 +21,7 @@ class Bytes {
             this.bytes = bytes.bytes;
         }
         else if (typeof bytes === 'string') {
-            this.bytes = cafe_utility_1.Binary.hexToUint8Array(cafe_utility_1.Types.asHexString(bytes, { name: 'Bytes#constructor(bytes)' }));
+            this.bytes = cafe_utility_1.Binary.hexToUint8Array(hex_schema_1.HexStringSchema.parse(bytes));
         }
         else if (bytes instanceof ArrayBuffer) {
             this.bytes = new Uint8Array(bytes);
@@ -30,9 +32,9 @@ class Bytes {
         else {
             const unknownInput = bytes;
             const toHex = cafe_utility_1.Objects.getDeep(unknownInput, 'toHex');
-            if (cafe_utility_1.Types.isFunction(toHex)) {
+            if (zod_1.z.function().safeParse(toHex).success) {
                 const hex = toHex.call(unknownInput);
-                this.bytes = cafe_utility_1.Binary.hexToUint8Array(cafe_utility_1.Types.asHexString(hex, { name: 'Bytes#constructor(bytes)' }));
+                this.bytes = cafe_utility_1.Binary.hexToUint8Array(hex_schema_1.HexStringSchema.parse(hex));
             }
             else {
                 debug('bytes', bytes);

package/dist/cjs/utils/error.js

@@ -22,6 +22,7 @@ class BeeResponseError extends BeeError {
         this.responseBody = responseBody;
         this.status = status;
         this.statusText = statusText;
+        this.response = { status, data: responseBody, statusText };
     }
 }
 exports.BeeResponseError = BeeResponseError;

package/dist/cjs/utils/headers.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFileHeaders = readFileHeaders;
 exports.prepareRequestHeaders = prepareRequestHeaders;
-const cafe_utility_1 = require("cafe-utility");
+const zod_1 = require("zod");
 const error_1 = require("./error");
 const stamps_1 = require("./stamps");
 const typed_bytes_1 = require("./typed-bytes");
@@ -46,7 +46,7 @@ function prepareRequestHeaders(stamp, nullableOptions) {
     if (!nullableOptions) {
         return headers;
     }
-    const options = cafe_utility_1.Types.asObject(nullableOptions);
+    const options = nullableOptions;
     if (options.size) {
         headers['content-length'] = String(options.size);
     }
@@ -56,26 +56,31 @@ function prepareRequestHeaders(stamp, nullableOptions) {
     if (options.redundancyLevel) {
         headers['swarm-redundancy-level'] = String(options.redundancyLevel);
     }
-    if (cafe_utility_1.Types.isBoolean(options.act)) {
-        headers['swarm-act'] = String(options.act);
+    const act = zod_1.z.boolean().safeParse(options.act);
+    if (act.success) {
+        headers['swarm-act'] = String(act.data);
     }
-    if (cafe_utility_1.Types.isBoolean(options.pin)) {
-        headers['swarm-pin'] = String(options.pin);
+    const pin = zod_1.z.boolean().safeParse(options.pin);
+    if (pin.success) {
+        headers['swarm-pin'] = String(pin.data);
     }
-    if (cafe_utility_1.Types.isBoolean(options.encrypt)) {
-        headers['swarm-encrypt'] = options.encrypt.toString();
+    const encrypt = zod_1.z.boolean().safeParse(options.encrypt);
+    if (encrypt.success) {
+        headers['swarm-encrypt'] = String(encrypt.data);
     }
     if (options.tag) {
         headers['swarm-tag'] = String(options.tag);
     }
-    if (cafe_utility_1.Types.isBoolean(options.deferred)) {
-        headers['swarm-deferred-upload'] = options.deferred.toString();
+    const deferred = zod_1.z.boolean().safeParse(options.deferred);
+    if (deferred.success) {
+        headers['swarm-deferred-upload'] = String(deferred.data);
     }
     if (options.redundancyStrategy) {
         headers['swarm-redundancy-strategy'] = String(options.redundancyStrategy);
     }
-    if (cafe_utility_1.Types.isBoolean(options.fallback)) {
-        headers['swarm-redundancy-fallback-mode'] = options.fallback.toString();
+    const fallback = zod_1.z.boolean().safeParse(options.fallback);
+    if (fallback.success) {
+        headers['swarm-redundancy-fallback-mode'] = String(fallback.data);
     }
     if (options.timeoutMs) {
         headers['swarm-chunk-retrieval-timeout'] = String(options.timeoutMs);
@@ -107,7 +112,8 @@ function prepareRequestHeaders(stamp, nullableOptions) {
     return headers;
 }
 function isEnvelopeWithBatchId(value) {
-    if (!cafe_utility_1.Types.isObject(value)) {
+    const result = zod_1.z.object({}).safeParse(value);
+    if (!result.success) {
         return false;
     }
     const envelope = value;

package/dist/cjs/utils/hex-schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HexStringSchema = void 0;
+const zod_1 = require("zod");
+exports.HexStringSchema = zod_1.z
+    .string()
+    .regex(/^(?:0x)?[0-9a-fA-F]*$/i, 'expected hex string')
+    .refine(s => s.replace(/^0x/i, '').length % 2 === 0, 'expected even-length hex string');

package/dist/cjs/utils/http.js

@@ -5,29 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_HTTP_CONFIG = void 0;
 exports.http = http;
-const axios_1 = __importDefault(require("axios"));
+exports.toBeeResponse = toBeeResponse;
 const cafe_utility_1 = require("cafe-utility");
 const debug_1 = __importDefault(require("debug"));
 const index_1 = require("../index");
 const debug = (0, debug_1.default)('bee-js:http');
-const { AxiosError } = axios_1.default;
 const MAX_FAILED_ATTEMPTS = 100000;
 const DELAY_FAST = 200;
 const DELAY_SLOW = 1000;
-const DELAY_THRESHOLD = cafe_utility_1.Dates.minutes(1) / DELAY_FAST;
-const ABORT_ERROR_MESSAGE = 'Request aborted';
+const FAST_RETRY_COUNT = 300;
 exports.DEFAULT_HTTP_CONFIG = {
     headers: {
         accept: 'application/json, text/plain, */*',
     },
-    maxBodyLength: Infinity,
-    maxContentLength: Infinity,
 };
-function throwIfAborted(signal, config, responseData, responseStatus) {
-    if (signal?.aborted) {
-        throw new index_1.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
@@ -37,65 +28,114 @@ async function http(options, config) {
     const requestConfig = cafe_utility_1.Objects.deepMerge3(exports.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: cafe_utility_1.Strings.joinUrl([requestConfig.baseURL ?? '', requestConfig.url ?? '']),
+        headers: { ...requestConfig.headers },
+        params: requestConfig.params,
+    });
     let failedAttempts = 0;
     while (failedAttempts < MAX_FAILED_ATTEMPTS) {
-        throwIfAborted(options.signal, config);
         try {
-            debug(`${requestConfig.method || 'get'} ${cafe_utility_1.Strings.joinUrl([
-                requestConfig.baseURL,
-                requestConfig.url,
-            ])}`, { headers: { ...requestConfig.headers }, params: requestConfig.params });
-            maybeRunOnRequestHook(options, requestConfig);
-            const response = await (0, axios_1.default)(requestConfig);
-            return response;
+            debug(`${method} ${url}`, { headers: requestConfig.headers, params: requestConfig.params });
+            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 cafe_utility_1.System.sleepMillis(failedAttempts < DELAY_THRESHOLD ? DELAY_FAST : DELAY_SLOW);
-                }
-                else {
-                    throw new index_1.BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.response?.statusText);
-                }
+            if (e instanceof index_1.BeeResponseError)
+                throw e;
+            const err = e;
+            if (err.name === 'TimeoutError' && options.endlesslyRetry) {
+                failedAttempts++;
+                await cafe_utility_1.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: cafe_utility_1.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 index_1.BeeResponseError(method, url, message, errBody.data, res.status, res.statusText);
+}
+function toBeeError(err, method, url) {
+    if (err.name === 'AbortError') {
+        return new index_1.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 index_1.BeeResponseError(method, url, message);
+}
+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 = cafe_utility_1.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/cjs/utils/resource-locator.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceLocator = void 0;
-const cafe_utility_1 = require("cafe-utility");
+const zod_1 = require("zod");
 const typed_bytes_1 = require("./typed-bytes");
 class ResourceLocator {
     constructor(raw) {
         this.raw = raw;
     }
     toString() {
-        if (cafe_utility_1.Types.isString(this.raw) && this.raw.includes('.eth')) {
-            return this.raw;
+        const asString = zod_1.z.string().safeParse(this.raw);
+        if (asString.success && asString.data.includes('.eth')) {
+            return asString.data;
         }
         return new typed_bytes_1.Reference(this.raw).toHex();
     }

package/dist/cjs/utils/schema.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllTagsOptionsSchema = exports.TransactionOptionsSchema = exports.PostageBatchOptionsSchema = exports.GsocMessageHandlerSchema = exports.PssMessageHandlerSchema = exports.TagUidSchema = exports.TagInputSchema = exports.CollectionUploadOptionsSchema = exports.FileUploadOptionsSchema = exports.RedundantUploadOptionsSchema = exports.UploadOptionsSchema = exports.DownloadOptionsSchema = exports.BeeRequestOptionsSchema = exports.HexStringSchema = void 0;
+const zod_1 = require("zod");
+const types_1 = require("../types");
+const typed_bytes_1 = require("./typed-bytes");
+var hex_schema_1 = require("./hex-schema");
+Object.defineProperty(exports, "HexStringSchema", { enumerable: true, get: function () { return hex_schema_1.HexStringSchema; } });
+const fnField = zod_1.z.any().refine(v => zod_1.z.function().safeParse(v).success, 'expected a function');
+const integerStringField = zod_1.z.any().transform((v) => {
+    if (zod_1.z.bigint().safeParse(v).success)
+        v = String(v);
+    return zod_1.z
+        .string()
+        .regex(/^-?\d+$/, 'expected integer string')
+        .parse(v);
+});
+const nonNegativeIntegerStringField = zod_1.z.any().transform((v) => {
+    if (zod_1.z.bigint().safeParse(v).success)
+        v = String(v);
+    return zod_1.z.string().regex(/^\d+$/, 'expected non-negative integer string').parse(v);
+});
+exports.BeeRequestOptionsSchema = zod_1.z.object({
+    baseURL: zod_1.z.string().optional(),
+    timeout: zod_1.z.number().int().min(0).optional(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    onRequest: fnField.optional(),
+    httpAgent: zod_1.z.unknown().optional(),
+    httpsAgent: zod_1.z.unknown().optional(),
+    endlesslyRetry: zod_1.z.boolean().optional(),
+    signal: zod_1.z.any().optional(),
+});
+exports.DownloadOptionsSchema = zod_1.z.object({
+    redundancyStrategy: zod_1.z.number().int().optional(),
+    fallback: zod_1.z.boolean().optional(),
+    timeoutMs: zod_1.z.number().int().min(0).optional(),
+    actPublisher: zod_1.z.optional(zod_1.z.any().transform((v) => new typed_bytes_1.PublicKey(v))),
+    actHistoryAddress: zod_1.z.optional(zod_1.z.any().transform((v) => new typed_bytes_1.Reference(v))),
+    actTimestamp: zod_1.z.coerce.number().optional(),
+});
+exports.UploadOptionsSchema = zod_1.z.object({
+    act: zod_1.z.boolean().optional(),
+    actHistoryAddress: zod_1.z.optional(zod_1.z.any().transform((v) => new typed_bytes_1.Reference(v))),
+    deferred: zod_1.z.boolean().optional(),
+    encrypt: zod_1.z.boolean().optional(),
+    pin: zod_1.z.boolean().optional(),
+    tag: zod_1.z.number().int().min(0).optional(),
+});
+exports.RedundantUploadOptionsSchema = exports.UploadOptionsSchema.extend({
+    redundancyLevel: zod_1.z.number().int().min(0).optional(),
+});
+exports.FileUploadOptionsSchema = exports.UploadOptionsSchema.extend({
+    size: zod_1.z.number().int().min(0).optional(),
+    contentType: zod_1.z.string().optional(),
+    redundancyLevel: zod_1.z.number().int().min(0).optional(),
+});
+exports.CollectionUploadOptionsSchema = exports.UploadOptionsSchema.extend({
+    errorDocument: zod_1.z.string().optional(),
+    indexDocument: zod_1.z.string().optional(),
+    redundancyLevel: zod_1.z.number().int().min(0).optional(),
+});
+exports.TagInputSchema = zod_1.z.object({ uid: zod_1.z.number().int() });
+exports.TagUidSchema = zod_1.z.coerce.number().min(0);
+exports.PssMessageHandlerSchema = zod_1.z.object({
+    onMessage: fnField,
+    onError: fnField,
+    onClose: fnField,
+});
+exports.GsocMessageHandlerSchema = zod_1.z.object({
+    onMessage: fnField,
+    onError: fnField,
+    onClose: fnField,
+});
+exports.PostageBatchOptionsSchema = zod_1.z.object({
+    gasPrice: integerStringField.optional(),
+    immutableFlag: zod_1.z.boolean().optional(),
+    label: zod_1.z.string().optional(),
+    waitForUsable: zod_1.z.boolean().optional(),
+    waitForUsableTimeout: zod_1.z.number().int().min(0).optional(),
+});
+exports.TransactionOptionsSchema = zod_1.z.object({
+    gasLimit: nonNegativeIntegerStringField.optional(),
+    gasPrice: nonNegativeIntegerStringField.optional(),
+});
+exports.AllTagsOptionsSchema = zod_1.z.object({
+    limit: zod_1.z.number().int().min(types_1.TAGS_LIMIT_MIN).max(types_1.TAGS_LIMIT_MAX).optional(),
+    offset: zod_1.z.number().int().min(0).optional(),
+});

package/dist/cjs/utils/stamps.js

@@ -177,10 +177,10 @@ function marshalStamp(signature, batchId, timestamp, index) {
     return new bytes_1.Bytes(cafe_utility_1.Binary.concatBytes(batchId, index, timestamp, signature));
 }
 function mapPostageBatch(raw, encryption, erasureCodeLevel) {
-    const usage = getStampUsage(raw.utilization, raw.depth, raw.bucketDepth);
     const batchTTL = (0, workaround_1.normalizeBatchTTL)(raw.batchTTL);
     const duration = duration_1.Duration.fromSeconds(batchTTL);
     const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, erasureCodeLevel);
+    const usage = raw.utilizationRatio ?? getStampUsage(raw.utilization, raw.depth, raw.bucketDepth);
     return {
         batchID: new typed_bytes_1.BatchId(raw.batchID),
         utilization: raw.utilization,
@@ -211,6 +211,7 @@ function unmapPostageBatch(batch) {
     return {
         batchID: batch.batchID.toHex(),
         utilization: batch.utilization,
+        utilizationRatio: batch.usage,
         usable: batch.usable,
         label: batch.label,
         depth: batch.depth,