@ethersphere/bee-js 3.3.0 → 3.3.2-pre.1

package/dist/mjs/chunk/bmt.js

@@ -1,6 +1,10 @@
-import { keccak256 } from 'js-sha3';
-import { BeeArgumentError } from '../utils/error';
-import { keccak256Hash } from '../utils/hash';
+// For ESM compatibility
+import pkg from 'js-sha3';
+const {
+  keccak256
+} = pkg;
+import { BeeArgumentError } from "../utils/error.js";
+import { keccak256Hash } from "../utils/hash.js";
 const MAX_CHUNK_PAYLOAD_SIZE = 4096;
 const SEGMENT_SIZE = 32;
 const SEGMENT_PAIR_SIZE = 2 * SEGMENT_SIZE;
@@ -19,28 +23,34 @@ const HASH_SIZE = 32;
  *
  * @returns the keccak256 hash in a byte array
  */
+
 export function bmtHash(chunkContent) {
-    const span = chunkContent.slice(0, 8);
-    const payload = chunkContent.slice(8);
-    const rootHash = bmtRootHash(payload);
-    const chunkHashInput = new Uint8Array([...span, ...rootHash]);
-    const chunkHash = keccak256Hash(chunkHashInput);
-    return chunkHash;
+  const span = chunkContent.slice(0, 8);
+  const payload = chunkContent.slice(8);
+  const rootHash = bmtRootHash(payload);
+  const chunkHashInput = new Uint8Array([...span, ...rootHash]);
+  const chunkHash = keccak256Hash(chunkHashInput);
+  return chunkHash;
 }
+
 function bmtRootHash(payload) {
-    if (payload.length > MAX_CHUNK_PAYLOAD_SIZE) {
-        throw new BeeArgumentError('invalid data length', payload);
+  if (payload.length > MAX_CHUNK_PAYLOAD_SIZE) {
+    throw new BeeArgumentError('invalid data length', payload);
+  } // create an input buffer padded with zeros
+
+
+  let input = new Uint8Array([...payload, ...new Uint8Array(MAX_CHUNK_PAYLOAD_SIZE - payload.length)]);
+
+  while (input.length !== HASH_SIZE) {
+    const output = new Uint8Array(input.length / 2); // in each round we hash the segment pairs together
+
+    for (let offset = 0; offset < input.length; offset += SEGMENT_PAIR_SIZE) {
+      const hashNumbers = keccak256.array(input.slice(offset, offset + SEGMENT_PAIR_SIZE));
+      output.set(hashNumbers, offset / 2);
     }
-    // create an input buffer padded with zeros
-    let input = new Uint8Array([...payload, ...new Uint8Array(MAX_CHUNK_PAYLOAD_SIZE - payload.length)]);
-    while (input.length !== HASH_SIZE) {
-        const output = new Uint8Array(input.length / 2);
-        // in each round we hash the segment pairs together
-        for (let offset = 0; offset < input.length; offset += SEGMENT_PAIR_SIZE) {
-            const hashNumbers = keccak256.array(input.slice(offset, offset + SEGMENT_PAIR_SIZE));
-            output.set(hashNumbers, offset / 2);
-        }
-        input = output;
-    }
-    return input;
-}
+
+    input = output;
+  }
+
+  return input;
+}

package/dist/mjs/chunk/cac.js

@@ -1,8 +1,8 @@
-import { BeeError } from '../utils/error';
-import { bmtHash } from './bmt';
-import { bytesEqual, flexBytesAtOffset, assertFlexBytes } from '../utils/bytes';
-import { serializeBytes } from './serialize';
-import { makeSpan, SPAN_SIZE } from './span';
+import { BeeError } from "../utils/error.js";
+import { bmtHash } from "./bmt.js";
+import { bytesEqual, flexBytesAtOffset, assertFlexBytes } from "../utils/bytes.js";
+import { serializeBytes } from "./serialize.js";
+import { makeSpan, SPAN_SIZE } from "./span.js";
 export const MIN_PAYLOAD_SIZE = 1;
 export const MAX_PAYLOAD_SIZE = 4096;
 const CAC_SPAN_OFFSET = 0;
@@ -12,16 +12,17 @@ const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + SPAN_SIZE;
  *
  * @param payloadBytes the data to be stored in the chunk
  */
+
 export function makeContentAddressedChunk(payloadBytes) {
-    const span = makeSpan(payloadBytes.length);
-    assertFlexBytes(payloadBytes, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
-    const data = serializeBytes(span, payloadBytes);
-    return {
-        data,
-        span: () => span,
-        payload: () => flexBytesAtOffset(data, CAC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE),
-        address: () => bmtHash(data),
-    };
+  const span = makeSpan(payloadBytes.length);
+  assertFlexBytes(payloadBytes, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
+  const data = serializeBytes(span, payloadBytes);
+  return {
+    data,
+    span: () => span,
+    payload: () => flexBytesAtOffset(data, CAC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE),
+    address: () => bmtHash(data)
+  };
 }
 /**
  * Type guard for valid content addressed chunk data
@@ -29,11 +30,11 @@ export function makeContentAddressedChunk(payloadBytes) {
  * @param data          The chunk data
  * @param chunkAddress  The address of the chunk
  */
+
 export function isValidChunkData(data, chunkAddress) {
-    if (!(data instanceof Uint8Array))
-        return false;
-    const address = bmtHash(data);
-    return bytesEqual(address, chunkAddress);
+  if (!(data instanceof Uint8Array)) return false;
+  const address = bmtHash(data);
+  return bytesEqual(address, chunkAddress);
 }
 /**
  * Asserts if data are representing given address of its chunk.
@@ -43,8 +44,9 @@ export function isValidChunkData(data, chunkAddress) {
  *
  * @returns a valid content addressed chunk or throws error
  */
+
 export function assertValidChunkData(data, chunkAddress) {
-    if (!isValidChunkData(data, chunkAddress)) {
-        throw new BeeError('Address of content address chunk does not match given data!');
-    }
-}
+  if (!isValidChunkData(data, chunkAddress)) {
+    throw new BeeError('Address of content address chunk does not match given data!');
+  }
+}

package/dist/mjs/chunk/serialize.js

@@ -4,12 +4,12 @@
  * @param arrays Any number of byte array arguments
  */
 export function serializeBytes(...arrays) {
-    const length = arrays.reduce((prev, curr) => prev + curr.length, 0);
-    const buffer = new Uint8Array(length);
-    let offset = 0;
-    arrays.forEach(arr => {
-        buffer.set(arr, offset);
-        offset += arr.length;
-    });
-    return buffer;
-}
+  const length = arrays.reduce((prev, curr) => prev + curr.length, 0);
+  const buffer = new Uint8Array(length);
+  let offset = 0;
+  arrays.forEach(arr => {
+    buffer.set(arr, offset);
+    offset += arr.length;
+  });
+  return buffer;
+}

package/dist/mjs/chunk/signer.js

@@ -1,15 +1,20 @@
-import { ec } from 'elliptic';
-import { BeeError } from '../utils/error';
-import { isBytes, assertBytes, wrapBytesWithHelpers } from '../utils/bytes';
-import { keccak256Hash } from '../utils/hash';
-import { hexToBytes, makeHexString } from '../utils/hex';
-import { SIGNATURE_BYTES_LENGTH, SIGNATURE_HEX_LENGTH } from '../types';
-import { isStrictlyObject } from '../utils/type';
+// For ESM compatibility
+import pkg from 'elliptic';
+const {
+  ec
+} = pkg;
+import { BeeError } from "../utils/error.js";
+import { isBytes, assertBytes, wrapBytesWithHelpers } from "../utils/bytes.js";
+import { keccak256Hash } from "../utils/hash.js";
+import { hexToBytes, makeHexString } from "../utils/hex.js";
+import { SIGNATURE_BYTES_LENGTH, SIGNATURE_HEX_LENGTH } from "../types/index.js";
+import { isStrictlyObject } from "../utils/type.js";
 const UNCOMPRESSED_RECOVERY_ID = 27;
+
 function hashWithEthereumPrefix(data) {
-    const ethereumSignedMessagePrefix = `\x19Ethereum Signed Message:\n${data.length}`;
-    const prefixBytes = new TextEncoder().encode(ethereumSignedMessagePrefix);
-    return keccak256Hash(prefixBytes, data);
+  const ethereumSignedMessagePrefix = `\x19Ethereum Signed Message:\n${data.length}`;
+  const prefixBytes = new TextEncoder().encode(ethereumSignedMessagePrefix);
+  return keccak256Hash(prefixBytes, data);
 }
 /**
  * The default signer function that can be used for integrating with
@@ -18,24 +23,28 @@ function hashWithEthereumPrefix(data) {
  * @param data      The data to be signed
  * @param privateKey  The private key used for signing the data
  */
+
+
 export function defaultSign(data, privateKey) {
-    const curve = new ec('secp256k1');
-    const keyPair = curve.keyFromPrivate(privateKey);
-    const hashedDigest = hashWithEthereumPrefix(data);
-    const sigRaw = curve.sign(hashedDigest, keyPair, { canonical: true, pers: undefined });
-    if (sigRaw.recoveryParam === null) {
-        throw new BeeError('signDigest recovery param was null');
-    }
-    const signature = new Uint8Array([
-        ...sigRaw.r.toArray('be', 32),
-        ...sigRaw.s.toArray('be', 32),
-        sigRaw.recoveryParam + UNCOMPRESSED_RECOVERY_ID,
-    ]);
-    return signature;
+  const curve = new ec('secp256k1');
+  const keyPair = curve.keyFromPrivate(privateKey);
+  const hashedDigest = hashWithEthereumPrefix(data);
+  const sigRaw = curve.sign(hashedDigest, keyPair, {
+    canonical: true,
+    pers: undefined
+  });
+
+  if (sigRaw.recoveryParam === null) {
+    throw new BeeError('signDigest recovery param was null');
+  }
+
+  const signature = new Uint8Array([...sigRaw.r.toArray('be', 32), ...sigRaw.s.toArray('be', 32), sigRaw.recoveryParam + UNCOMPRESSED_RECOVERY_ID]);
+  return signature;
 }
+
 function publicKeyToAddress(pubKey) {
-    const pubBytes = pubKey.encode('array', false);
-    return keccak256Hash(pubBytes.slice(1)).slice(12);
+  const pubBytes = pubKey.encode('array', false);
+  return keccak256Hash(pubBytes.slice(1)).slice(12);
 }
 /**
  * Recovers the ethereum address from a given signature.
@@ -48,65 +57,75 @@ function publicKeyToAddress(pubKey) {
  *
  * @returns the recovered address
  */
+
+
 export function recoverAddress(signature, digest) {
-    const curve = new ec('secp256k1');
-    const sig = {
-        r: signature.slice(0, 32),
-        s: signature.slice(32, 64),
-    };
-    const recoveryParam = signature[64] - UNCOMPRESSED_RECOVERY_ID;
-    const hash = hashWithEthereumPrefix(digest);
-    const recPubKey = curve.recoverPubKey(hash, sig, recoveryParam);
-    return publicKeyToAddress(recPubKey);
+  const curve = new ec('secp256k1');
+  const sig = {
+    r: signature.slice(0, 32),
+    s: signature.slice(32, 64)
+  };
+  const recoveryParam = signature[64] - UNCOMPRESSED_RECOVERY_ID;
+  const hash = hashWithEthereumPrefix(digest);
+  const recPubKey = curve.recoverPubKey(hash, sig, recoveryParam);
+  return publicKeyToAddress(recPubKey);
 }
 /**
  * Creates a singer object that can be used when the private key is known.
  *
  * @param privateKey The private key
  */
+
 export function makePrivateKeySigner(privateKey) {
-    const curve = new ec('secp256k1');
-    const keyPair = curve.keyFromPrivate(privateKey);
-    const address = publicKeyToAddress(keyPair.getPublic());
-    return {
-        sign: (digest) => defaultSign(digest, privateKey),
-        address,
-    };
+  const curve = new ec('secp256k1');
+  const keyPair = curve.keyFromPrivate(privateKey);
+  const address = publicKeyToAddress(keyPair.getPublic());
+  return {
+    sign: digest => defaultSign(digest, privateKey),
+    address
+  };
 }
 export function assertSigner(signer) {
-    if (!isStrictlyObject(signer)) {
-        throw new TypeError('Signer must be an object!');
-    }
-    const typedSigner = signer;
-    if (!isBytes(typedSigner.address, 20)) {
-        throw new TypeError("Signer's address must be Uint8Array with 20 bytes!");
-    }
-    if (typeof typedSigner.sign !== 'function') {
-        throw new TypeError('Signer sign property needs to be function!');
-    }
+  if (!isStrictlyObject(signer)) {
+    throw new TypeError('Signer must be an object!');
+  }
+
+  const typedSigner = signer;
+
+  if (!isBytes(typedSigner.address, 20)) {
+    throw new TypeError("Signer's address must be Uint8Array with 20 bytes!");
+  }
+
+  if (typeof typedSigner.sign !== 'function') {
+    throw new TypeError('Signer sign property needs to be function!');
+  }
 }
 export function makeSigner(signer) {
-    if (typeof signer === 'string') {
-        const hexKey = makeHexString(signer, 64);
-        const keyBytes = hexToBytes(hexKey); // HexString is verified for 64 length => 32 is guaranteed
-        return makePrivateKeySigner(keyBytes);
-    }
-    else if (signer instanceof Uint8Array) {
-        assertBytes(signer, 32);
-        return makePrivateKeySigner(signer);
-    }
-    assertSigner(signer);
-    return signer;
+  if (typeof signer === 'string') {
+    const hexKey = makeHexString(signer, 64);
+    const keyBytes = hexToBytes(hexKey); // HexString is verified for 64 length => 32 is guaranteed
+
+    return makePrivateKeySigner(keyBytes);
+  } else if (signer instanceof Uint8Array) {
+    assertBytes(signer, 32);
+    return makePrivateKeySigner(signer);
+  }
+
+  assertSigner(signer);
+  return signer;
 }
 export async function sign(signer, data) {
-    const result = await signer.sign(wrapBytesWithHelpers(data));
-    if (typeof result === 'string') {
-        const hexString = makeHexString(result, SIGNATURE_HEX_LENGTH);
-        return hexToBytes(hexString);
-    }
-    if (result instanceof Uint8Array) {
-        assertBytes(result, SIGNATURE_BYTES_LENGTH);
-        return result;
-    }
-    throw new TypeError('Invalid output of sign function!');
-}
+  const result = await signer.sign(wrapBytesWithHelpers(data));
+
+  if (typeof result === 'string') {
+    const hexString = makeHexString(result, SIGNATURE_HEX_LENGTH);
+    return hexToBytes(hexString);
+  }
+
+  if (result instanceof Uint8Array) {
+    assertBytes(result, SIGNATURE_BYTES_LENGTH);
+    return result;
+  }
+
+  throw new TypeError('Invalid output of sign function!');
+}

package/dist/mjs/chunk/soc.js

@@ -1,29 +1,30 @@
-import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from '../utils/bytes';
-import { bmtHash } from './bmt';
-import { recoverAddress, sign } from './signer';
-import { keccak256Hash } from '../utils/hash';
-import { SPAN_SIZE } from './span';
-import { serializeBytes } from './serialize';
-import { BeeError } from '../utils/error';
-import { makeContentAddressedChunk, MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE, assertValidChunkData, } from './cac';
-import { bytesToHex } from '../utils/hex';
-import * as socAPI from '../modules/soc';
-import * as chunkAPI from '../modules/chunk';
-import { assertAddress } from '../utils/type';
+import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
+import { bmtHash } from "./bmt.js";
+import { recoverAddress, sign } from "./signer.js";
+import { keccak256Hash } from "../utils/hash.js";
+import { SPAN_SIZE } from "./span.js";
+import { serializeBytes } from "./serialize.js";
+import { BeeError } from "../utils/error.js";
+import { makeContentAddressedChunk, MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE, assertValidChunkData } from "./cac.js";
+import { bytesToHex } from "../utils/hex.js";
+import * as socAPI from "../modules/soc.js";
+import * as chunkAPI from "../modules/chunk.js";
+import { assertAddress } from "../utils/type.js";
 const IDENTIFIER_SIZE = 32;
 const SIGNATURE_SIZE = 65;
 const SOC_IDENTIFIER_OFFSET = 0;
 const SOC_SIGNATURE_OFFSET = SOC_IDENTIFIER_OFFSET + IDENTIFIER_SIZE;
 const SOC_SPAN_OFFSET = SOC_SIGNATURE_OFFSET + SIGNATURE_SIZE;
 const SOC_PAYLOAD_OFFSET = SOC_SPAN_OFFSET + SPAN_SIZE;
+
 function recoverChunkOwner(data) {
-    const cacData = data.slice(SOC_SPAN_OFFSET);
-    const chunkAddress = bmtHash(cacData);
-    const signature = bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
-    const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
-    const digest = keccak256Hash(identifier, chunkAddress);
-    const ownerAddress = recoverAddress(signature, digest);
-    return ownerAddress;
+  const cacData = data.slice(SOC_SPAN_OFFSET);
+  const chunkAddress = bmtHash(cacData);
+  const signature = bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
+  const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
+  const digest = keccak256Hash(identifier, chunkAddress);
+  const ownerAddress = recoverAddress(signature, digest);
+  return ownerAddress;
 }
 /**
  * Verifies if the data is a valid single owner chunk
@@ -33,28 +34,35 @@ function recoverChunkOwner(data) {
  *
  * @returns a single owner chunk or throws error
  */
+
+
 export function makeSingleOwnerChunkFromData(data, address) {
-    const ownerAddress = recoverChunkOwner(data);
-    const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
-    const socAddress = keccak256Hash(identifier, ownerAddress);
-    if (!bytesEqual(address, socAddress)) {
-        throw new BeeError('SOC Data does not match given address!');
-    }
-    const signature = () => bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
-    const span = () => bytesAtOffset(data, SOC_SPAN_OFFSET, SPAN_SIZE);
-    const payload = () => flexBytesAtOffset(data, SOC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
-    return {
-        data,
-        identifier: () => identifier,
-        signature,
-        span,
-        payload,
-        address: () => socAddress,
-        owner: () => ownerAddress,
-    };
+  const ownerAddress = recoverChunkOwner(data);
+  const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
+  const socAddress = keccak256Hash(identifier, ownerAddress);
+
+  if (!bytesEqual(address, socAddress)) {
+    throw new BeeError('SOC Data does not match given address!');
+  }
+
+  const signature = () => bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
+
+  const span = () => bytesAtOffset(data, SOC_SPAN_OFFSET, SPAN_SIZE);
+
+  const payload = () => flexBytesAtOffset(data, SOC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
+
+  return {
+    data,
+    identifier: () => identifier,
+    signature,
+    span,
+    payload,
+    address: () => socAddress,
+    owner: () => ownerAddress
+  };
 }
 export function makeSOCAddress(identifier, address) {
-    return keccak256Hash(identifier, address);
+  return keccak256Hash(identifier, address);
 }
 /**
  * Creates a single owner chunk object
@@ -63,22 +71,23 @@ export function makeSOCAddress(identifier, address) {
  * @param identifier  The identifier of the chunk
  * @param signer      The singer interface for signing the chunk
  */
+
 export async function makeSingleOwnerChunk(chunk, identifier, signer) {
-    const chunkAddress = chunk.address();
-    assertValidChunkData(chunk.data, chunkAddress);
-    const digest = keccak256Hash(identifier, chunkAddress);
-    const signature = await sign(signer, digest);
-    const data = serializeBytes(identifier, signature, chunk.span(), chunk.payload());
-    const address = makeSOCAddress(identifier, signer.address);
-    return {
-        data,
-        identifier: () => identifier,
-        signature: () => signature,
-        span: () => chunk.span(),
-        payload: () => chunk.payload(),
-        address: () => address,
-        owner: () => signer.address,
-    };
+  const chunkAddress = chunk.address();
+  assertValidChunkData(chunk.data, chunkAddress);
+  const digest = keccak256Hash(identifier, chunkAddress);
+  const signature = await sign(signer, digest);
+  const data = serializeBytes(identifier, signature, chunk.span(), chunk.payload());
+  const address = makeSOCAddress(identifier, signer.address);
+  return {
+    data,
+    identifier: () => identifier,
+    signature: () => signature,
+    span: () => chunk.span(),
+    payload: () => chunk.payload(),
+    address: () => address,
+    owner: () => signer.address
+  };
 }
 /**
  * Helper function to upload a chunk.
@@ -90,12 +99,13 @@ export async function makeSingleOwnerChunk(chunk, identifier, signer) {
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Upload options
  */
+
 export async function uploadSingleOwnerChunk(ky, chunk, postageBatchId, options) {
-    const owner = bytesToHex(chunk.owner());
-    const identifier = bytesToHex(chunk.identifier());
-    const signature = bytesToHex(chunk.signature());
-    const data = serializeBytes(chunk.span(), chunk.payload());
-    return socAPI.upload(ky, owner, identifier, signature, data, postageBatchId, options);
+  const owner = bytesToHex(chunk.owner());
+  const identifier = bytesToHex(chunk.identifier());
+  const signature = bytesToHex(chunk.signature());
+  const data = serializeBytes(chunk.span(), chunk.payload());
+  return socAPI.upload(ky, owner, identifier, signature, data, postageBatchId, options);
 }
 /**
  * Helper function to create and upload SOC.
@@ -107,11 +117,12 @@ export async function uploadSingleOwnerChunk(ky, chunk, postageBatchId, options)
  * @param data            The chunk data
  * @param options
  */
+
 export async function uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, data, options) {
-    assertAddress(postageBatchId);
-    const cac = makeContentAddressedChunk(data);
-    const soc = await makeSingleOwnerChunk(cac, identifier, signer);
-    return uploadSingleOwnerChunk(ky, soc, postageBatchId, options);
+  assertAddress(postageBatchId);
+  const cac = makeContentAddressedChunk(data);
+  const soc = await makeSingleOwnerChunk(cac, identifier, signer);
+  return uploadSingleOwnerChunk(ky, soc, postageBatchId, options);
 }
 /**
  * Helper function to download SOC.
@@ -120,8 +131,9 @@ export async function uploadSingleOwnerChunkData(ky, signer, postageBatchId, ide
  * @param ownerAddress  The singer interface for signing the chunk
  * @param identifier    The identifier of the chunk
  */
+
 export async function downloadSingleOwnerChunk(ky, ownerAddress, identifier) {
-    const address = makeSOCAddress(identifier, ownerAddress);
-    const data = await chunkAPI.download(ky, bytesToHex(address));
-    return makeSingleOwnerChunkFromData(data, address);
-}
+  const address = makeSOCAddress(identifier, ownerAddress);
+  const data = await chunkAPI.download(ky, bytesToHex(address));
+  return makeSingleOwnerChunkFromData(data, address);
+}

package/dist/mjs/chunk/span.js

@@ -1,6 +1,6 @@
-import { BeeArgumentError } from '../utils/error';
-export const SPAN_SIZE = 8;
-// we limit the maximum span size in 32 bits to avoid BigInt compatibility issues
+import { BeeArgumentError } from "../utils/error.js";
+export const SPAN_SIZE = 8; // we limit the maximum span size in 32 bits to avoid BigInt compatibility issues
+
 const MAX_SPAN_LENGTH = 2 ** 32 - 1;
 /**
  * Create a span for storing the length of the chunk
@@ -9,17 +9,20 @@ const MAX_SPAN_LENGTH = 2 ** 32 - 1;
  *
  * @param length The length of the span
  */
+
 export function makeSpan(length) {
-    if (length <= 0) {
-        throw new BeeArgumentError('invalid length for span', length);
-    }
-    if (length > MAX_SPAN_LENGTH) {
-        throw new BeeArgumentError('invalid length (> MAX_SPAN_LENGTH)', length);
-    }
-    const span = new Uint8Array(SPAN_SIZE);
-    const dataView = new DataView(span.buffer);
-    const littleEndian = true;
-    const lengthLower32 = length & 0xffffffff;
-    dataView.setUint32(0, lengthLower32, littleEndian);
-    return span;
-}
+  if (length <= 0) {
+    throw new BeeArgumentError('invalid length for span', length);
+  }
+
+  if (length > MAX_SPAN_LENGTH) {
+    throw new BeeArgumentError('invalid length (> MAX_SPAN_LENGTH)', length);
+  }
+
+  const span = new Uint8Array(SPAN_SIZE);
+  const dataView = new DataView(span.buffer);
+  const littleEndian = true;
+  const lengthLower32 = length & 0xffffffff;
+  dataView.setUint32(0, lengthLower32, littleEndian);
+  return span;
+}