@ethersphere/bee-js 13.0.0-upcoming.gcfb9756 → 13.0.0

package/dist/mjs/manifest/manifest.js

@@ -1,152 +1,98 @@
-import { Binary, MerkleTree, Optional, Uint8ArrayReader } from 'cafe-utility';
-import _debug from 'debug';
-import { NULL_ADDRESS } from "../index.js";
-import { Reference } from "../utils/typed-bytes.js";
-const debug = _debug('bee-js:manifest');
-const ENCODER = new TextEncoder();
-const DECODER = new TextDecoder();
-const TYPE_VALUE = 2;
-const TYPE_EDGE = 4;
-const TYPE_WITH_PATH_SEPARATOR = 8;
-const TYPE_WITH_METADATA = 16;
-const PATH_SEPARATOR = new Uint8Array([47]);
-const VERSION_02_HASH_HEX = '5768b3b6a7db56d21d1abff40d41cebfc83448fed8d7e9b06ec0d3b073f28f7b';
-const VERSION_02_HASH = Binary.hexToUint8Array(VERSION_02_HASH_HEX);
-export class Fork {
-  constructor(prefix, node) {
-    this.prefix = prefix;
-    this.node = node;
-  }
-  static split(a, b) {
-    const commonPart = Binary.commonPrefix(a.prefix, b.prefix);
-    if (commonPart.length === a.prefix.length) {
-      const remainingB = b.prefix.slice(commonPart.length);
-      b.node.path = b.prefix.slice(commonPart.length);
-      b.prefix = b.prefix.slice(commonPart.length);
-      b.node.parent = a.node;
-      a.node.forks.set(remainingB[0], b);
-      return a;
-    }
-    if (commonPart.length === b.prefix.length) {
-      const remainingA = a.prefix.slice(commonPart.length);
-      a.node.path = a.prefix.slice(commonPart.length);
-      a.prefix = a.prefix.slice(commonPart.length);
-      a.node.parent = b.node;
-      b.node.forks.set(remainingA[0], a);
-      return b;
-    }
-    const node = new MantarayNode({
-      path: commonPart
-    });
-    const newAFork = new Fork(a.prefix.slice(commonPart.length), a.node);
-    const newBFork = new Fork(b.prefix.slice(commonPart.length), b.node);
-    a.node.path = a.prefix.slice(commonPart.length);
-    b.node.path = b.prefix.slice(commonPart.length);
-    a.prefix = a.prefix.slice(commonPart.length);
-    b.prefix = b.prefix.slice(commonPart.length);
-    node.forks.set(newAFork.prefix[0], newAFork);
-    node.forks.set(newBFork.prefix[0], newBFork);
-    newAFork.node.parent = node;
-    newBFork.node.parent = node;
-    return new Fork(commonPart, node);
-  }
-  marshal() {
-    if (!this.node.selfAddress) {
-      throw Error('Fork#marshal node.selfAddress is not set');
-    }
-    const data = [];
-    // Re-emit the type byte read from the chunk when the node is untouched, so an
-    // unmarshal → marshal round-trip is byte-identical. determineType() can only
-    // recompute it correctly once the node's children are loaded/built in memory.
-    data.push(new Uint8Array([this.node.type ?? this.node.determineType()]));
-    data.push(Binary.numberToUint8(this.prefix.length));
-    data.push(this.prefix);
-    if (this.prefix.length < 30) {
-      data.push(new Uint8Array(30 - this.prefix.length));
-    }
-    data.push(this.node.selfAddress);
-    debug('marshalling fork', {
-      prefixLength: this.prefix.length,
-      prefix: DECODER.decode(this.prefix),
-      address: Binary.uint8ArrayToHex(this.node.selfAddress)
-    });
-    if (this.node.metadata) {
-      const metadataBytes = Binary.padEndToMultiple(new Uint8Array([0x00, 0x00, ...ENCODER.encode(JSON.stringify(this.node.metadata))]), 32, 0x0a);
-      const metadataLengthBytes = Binary.numberToUint16(metadataBytes.length - 2, 'BE');
-      metadataBytes.set(metadataLengthBytes, 0);
-      data.push(metadataBytes);
+import { Optional } from 'cafe-utility';
+import { Bytes, MantarayNode as CoreMantarayNode, Reference } from '@ethersphere/core-sdk';
+/**
+ * Uploads `node` and every node beneath it, updating each `selfAddress` in
+ * place. Only the network/ACT-history side is bee-js specific - the trie
+ * structure and marshaling live entirely in core-sdk's MantarayNode.
+ */
+async function saveRecursively(node, bee, postageBatchId, options, requestOptions) {
+  for (const fork of node.forks.values()) {
+    const uploadResult = await saveRecursively(fork.node, bee, postageBatchId, options, requestOptions);
+    if (options?.act) {
+      let historyAddress;
+      uploadResult.historyAddress.ifPresent(ref => historyAddress = ref);
+      if (historyAddress) {
+        if (!fork.node.metadata) {
+          fork.node.metadata = {};
+        }
+        fork.node.metadata['swarm-act-history-address'] = historyAddress.toHex();
+      }
     }
-    return Binary.concatBytes(...data);
   }
-  static unmarshal(reader, addressLength) {
-    const type = Binary.uint8ToNumber(reader.read(1));
-    const prefixLength = Binary.uint8ToNumber(reader.read(1));
-    const prefix = reader.read(prefixLength);
-    if (prefixLength < 30) {
-      reader.read(30 - prefixLength);
-    }
-    const selfAddress = reader.read(addressLength);
-    debug('unmarshalling fork', {
-      type,
-      prefixLength,
-      prefix: DECODER.decode(prefix),
-      addressLength,
-      address: Binary.uint8ArrayToHex(selfAddress)
-    });
-    let metadata = undefined;
-    if (isType(type, TYPE_WITH_METADATA)) {
-      const metadataLength = Binary.uint16ToNumber(reader.read(2), 'BE');
-      metadata = JSON.parse(DECODER.decode(reader.read(metadataLength)));
+  const result = await bee.data.upload(postageBatchId, await node.marshal(), options, requestOptions);
+  node.selfAddress = result.reference.toUint8Array();
+  return result;
+}
+/**
+ * Downloads and unmarshals every node beneath `node`, following ACT history
+ * metadata left by {@link saveRecursively} where present.
+ */
+async function loadRecursively(node, bee, options, requestOptions) {
+  for (const fork of node.forks.values()) {
+    if (!fork.node.selfAddress) {
+      throw Error('MantarayNode#loadRecursively fork.node.selfAddress is not set');
+    }
+    let downloadOptions = options;
+    if (fork.node.metadata && fork.node.metadata['swarm-act-history-address']) {
+      downloadOptions = {
+        ...options,
+        actHistoryAddress: fork.node.metadata['swarm-act-history-address']
+      };
     }
-    return new Fork(prefix, new MantarayNode({
-      selfAddress,
-      metadata,
-      path: prefix,
-      type
-    }));
+    const data = (await bee.data.download(fork.node.selfAddress, downloadOptions, requestOptions)).toUint8Array();
+    const loaded = CoreMantarayNode.unmarshalFromData(data, fork.node.selfAddress);
+    fork.node.targetAddress = loaded.targetAddress;
+    fork.node.forks = loaded.forks;
+    fork.node.path = fork.prefix;
+    fork.node.parent = node;
+    await loadRecursively(fork.node, bee, options, requestOptions);
   }
 }
+/**
+ * bee-js's Bee-client-coupled view of a Mantaray node: the trie structure,
+ * marshaling, and byte-level operations all delegate to core-sdk's
+ * `MantarayNode`; this class only adds what needs a live `Bee` instance
+ * (uploading/downloading, ACT history, feed resolution).
+ */
 export class MantarayNode {
-  constructor(options) {
-    this.obfuscationKey = new Uint8Array(32);
-    this.selfAddress = null;
-    this.targetAddress = new Uint8Array(32);
-    this.metadata = null;
-    this.path = new Uint8Array(0);
-    this.forks = new Map();
-    this.parent = null;
-    this.type = null;
-    if (options?.targetAddress) {
-      this.targetAddress = options.targetAddress;
-    }
-    if (options?.selfAddress) {
-      this.selfAddress = options.selfAddress;
-    }
-    if (options?.metadata) {
-      this.metadata = options.metadata;
-    }
-    if (options?.obfuscationKey) {
-      this.obfuscationKey = options.obfuscationKey;
-    }
-    if (options?.path) {
-      this.path = options.path;
-    }
-    if (options?.parent) {
-      this.parent = options.parent;
-    }
-    this.type = options?.type ?? null;
+  constructor(core = new CoreMantarayNode()) {
+    this.core = core;
+  }
+  get obfuscationKey() {
+    return this.core.obfuscationKey;
+  }
+  get selfAddress() {
+    return this.core.selfAddress;
+  }
+  get targetAddress() {
+    return this.core.targetAddress;
+  }
+  get metadata() {
+    return this.core.metadata;
+  }
+  get path() {
+    return this.core.path;
+  }
+  get forks() {
+    return this.core.forks;
+  }
+  get parent() {
+    return this.core.parent;
+  }
+  get type() {
+    return this.core.type;
   }
   get fullPath() {
-    return Binary.concatBytes(this.parent?.fullPath ?? new Uint8Array(0), this.path);
+    return this.core.fullPath;
   }
   get fullPathString() {
-    return DECODER.decode(this.fullPath);
+    return this.core.fullPathString;
   }
   /**
    * Returns the metadata at the `/` path to access idiomatic properties.
    */
   getRootMetadata() {
-    const node = this.find('/');
+    const node = this.core.find('/');
     if (node && node.metadata) {
       return Optional.of(node.metadata);
     }
@@ -156,7 +102,7 @@ export class MantarayNode {
    * Returns the `swarm-index-document` and `swarm-error-document` metadata values.
    */
   getDocsMetadata() {
-    const node = this.find('/');
+    const node = this.core.find('/');
     if (!node || !node.metadata) {
       return {
         indexDocument: null,
@@ -172,7 +118,7 @@ export class MantarayNode {
    * Attempts to resolve the manifest as a feed, returning the latest update.
    */
   async resolveFeed(bee, requestOptions) {
-    const node = this.find('/');
+    const node = this.core.find('/');
     if (!node || !node.metadata) {
       return Optional.empty();
     }
@@ -187,39 +133,7 @@ export class MantarayNode {
    * Gets the binary representation of the node.
    */
   async marshal() {
-    for (const fork of this.forks.values()) {
-      if (!fork.node.selfAddress) {
-        fork.node.selfAddress = (await fork.node.calculateSelfAddress()).toUint8Array();
-      }
-    }
-    const hasEntry = !Binary.equals(this.targetAddress, NULL_ADDRESS);
-    let refBytesSize = 0;
-    if (hasEntry) {
-      refBytesSize = this.targetAddress.length;
-    } else {
-      for (const fork of this.forks.values()) {
-        if (fork.node.selfAddress) {
-          refBytesSize = fork.node.selfAddress.length;
-          break;
-        }
-      }
-    }
-    const header = new Uint8Array(32);
-    header.set(VERSION_02_HASH, 0);
-    header.set(Binary.numberToUint8(refBytesSize), 31);
-    const entry = hasEntry ? this.targetAddress : new Uint8Array(refBytesSize);
-    const forkBitmap = new Uint8Array(32);
-    for (const fork of this.forks.keys()) {
-      Binary.setBit(forkBitmap, fork, 1, 'LE');
-    }
-    const forks = [];
-    for (let i = 0; i < 256; i++) {
-      if (Binary.getBit(forkBitmap, i, 'LE')) {
-        forks.push(this.forks.get(i).marshal());
-      }
-    }
-    const data = Binary.xorCypher(Binary.concatBytes(header, entry, forkBitmap, ...forks), this.obfuscationKey);
-    return Binary.concatBytes(this.obfuscationKey, data);
+    return this.core.marshal();
   }
   /**
    * Downloads and unmarshals a MantarayNode from the given reference.
@@ -237,173 +151,49 @@ export class MantarayNode {
    * Do not forget calling `loadRecursively` on the returned node to load the entire tree.
    */
   static unmarshalFromData(data, selfAddress) {
-    const obfuscationKey = data.subarray(0, 32);
-    const decrypted = Binary.xorCypher(data.subarray(32), obfuscationKey);
-    const reader = new Uint8ArrayReader(decrypted);
-    const versionHash = reader.read(31);
-    if (!Binary.equals(versionHash, VERSION_02_HASH.slice(0, 31))) {
-      throw new Error('MantarayNode#unmarshal invalid version hash');
-    }
-    const targetAddressLength = Binary.uint8ToNumber(reader.read(1));
-    const targetAddress = targetAddressLength ? reader.read(targetAddressLength) : NULL_ADDRESS;
-    const node = new MantarayNode({
-      selfAddress,
-      targetAddress,
-      obfuscationKey
-    });
-    const forkBitmap = reader.read(32);
-    if (targetAddressLength > 0) {
-      for (let i = 0; i < 256; i++) {
-        if (Binary.getBit(forkBitmap, i, 'LE')) {
-          const newFork = Fork.unmarshal(reader, selfAddress.length);
-          node.forks.set(i, newFork);
-          newFork.node.parent = node;
-        }
-      }
-    }
-    return node;
+    return new MantarayNode(CoreMantarayNode.unmarshalFromData(data, selfAddress));
   }
   /**
    * Adds a fork to the node.
    */
   addFork(path, reference, metadata) {
-    this.selfAddress = null;
-    this.type = null;
-    path = path instanceof Uint8Array ? path : ENCODER.encode(path);
-    debug('adding fork', {
-      path: DECODER.decode(path),
-      reference: new Reference(reference).represent()
-    });
-    // TODO: this should not be ignored
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let tip = this;
-    while (path.length) {
-      const prefix = path.slice(0, 30);
-      path = path.slice(30);
-      const isLast = path.length === 0;
-      const [bestMatch, matchedPath] = tip.findClosest(prefix);
-      const remainingPath = prefix.slice(matchedPath.length);
-      if (matchedPath.length) {
-        tip = bestMatch;
-      }
-      if (!remainingPath.length) {
-        continue;
-      }
-      const newFork = new Fork(remainingPath, new MantarayNode({
-        targetAddress: isLast ? new Reference(reference).toUint8Array() : undefined,
-        metadata: isLast ? metadata : undefined,
-        path: remainingPath
-      }));
-      const existing = bestMatch.forks.get(remainingPath[0]);
-      if (existing) {
-        const fork = Fork.split(newFork, existing);
-        tip.forks.set(remainingPath[0], fork);
-        fork.node.parent = tip;
-        tip.selfAddress = null;
-        tip.type = null;
-        tip = newFork.node;
-      } else {
-        tip.forks.set(remainingPath[0], newFork);
-        newFork.node.parent = tip;
-        tip.selfAddress = null;
-        tip.type = null;
-        tip = newFork.node;
-      }
-    }
+    this.core.addFork(path, reference instanceof Bytes ? reference.toUint8Array() : reference, metadata);
   }
   /**
    * Removes a fork from the node.
    */
   removeFork(path) {
-    this.selfAddress = null;
-    this.type = null;
-    path = path instanceof Uint8Array ? path : ENCODER.encode(path);
-    if (path.length === 0) {
-      throw Error('MantarayNode#removeFork [path] parameter cannot be empty');
-    }
-    const match = this.find(path);
-    if (!match) {
-      throw Error('MantarayNode#removeFork fork not found');
-    }
-    const [parent, matchedPath] = this.findClosest(path.slice(0, path.length - 1));
-    parent.forks.delete(path.slice(matchedPath.length)[0]);
-    for (const fork of match.forks.values()) {
-      parent.addFork(Binary.concatBytes(match.path, fork.prefix), fork.node.targetAddress, fork.node.metadata);
-    }
+    this.core.removeFork(path);
   }
   /**
    * Calculates the self address of the node.
    */
   async calculateSelfAddress() {
-    if (this.selfAddress) {
-      return new Reference(this.selfAddress);
-    }
-    return new Reference((await MerkleTree.root(await this.marshal())).hash());
+    return this.core.calculateSelfAddress();
   }
   /**
    * Saves the node and its children recursively.
    */
   async saveRecursively(bee, postageBatchId, options, requestOptions) {
-    for (const fork of this.forks.values()) {
-      const uploadResult = await fork.node.saveRecursively(bee, postageBatchId, options, requestOptions);
-      if (options?.act) {
-        let historyAddress;
-        uploadResult.historyAddress.ifPresent(ref => historyAddress = ref);
-        if (historyAddress) {
-          if (!fork.node.metadata) {
-            fork.node.metadata = {};
-          }
-          fork.node.metadata['swarm-act-history-address'] = historyAddress.toHex();
-        }
-      }
-    }
-    const result = await bee.data.upload(postageBatchId, await this.marshal(), options, requestOptions);
-    this.selfAddress = result.reference.toUint8Array();
-    return result;
+    return saveRecursively(this.core, bee, postageBatchId, options, requestOptions);
   }
   /**
    * Loads the node and its children recursively.
    */
   async loadRecursively(bee, options, requestOptions) {
-    for (const fork of this.forks.values()) {
-      if (!fork.node.selfAddress) {
-        throw Error('MantarayNode#loadRecursively fork.node.selfAddress is not set');
-      }
-      let downloadOptions = options;
-      if (fork.node.metadata && fork.node.metadata['swarm-act-history-address']) {
-        downloadOptions = {
-          ...options,
-          actHistoryAddress: fork.node.metadata['swarm-act-history-address']
-        };
-      }
-      const node = await MantarayNode.unmarshal(bee, fork.node.selfAddress, downloadOptions, requestOptions);
-      fork.node.targetAddress = node.targetAddress;
-      fork.node.forks = node.forks;
-      fork.node.path = fork.prefix;
-      fork.node.parent = this;
-      await fork.node.loadRecursively(bee, options, requestOptions);
-    }
+    return loadRecursively(this.core, bee, options, requestOptions);
   }
   /**
    * Finds a node in the tree by its path.
    */
   find(path) {
-    const [closest, match] = this.findClosest(path);
-    return match.length === path.length ? closest : null;
+    return this.core.find(path);
   }
   /**
    * Finds the closest node in the tree to the given path.
    */
-  findClosest(path, current = new Uint8Array()) {
-    path = path instanceof Uint8Array ? path : ENCODER.encode(path);
-    if (path.length === 0) {
-      return [this, current];
-    }
-    const fork = this.forks.get(path[0]);
-    if (fork && Binary.commonPrefix(fork.prefix, path).length === fork.prefix.length) {
-      return fork.node.findClosest(path.slice(fork.prefix.length), Binary.concatBytes(current, fork.prefix));
-    }
-    return [this, current];
+  findClosest(path, current) {
+    return this.core.findClosest(path, current);
   }
   /**
    * Returns an array of all nodes in the tree which have a target address set.
@@ -411,13 +201,7 @@ export class MantarayNode {
    * Must be called after `loadRecursively`.
    */
   collect(nodes = []) {
-    for (const fork of this.forks.values()) {
-      if (!Binary.equals(fork.node.targetAddress, NULL_ADDRESS)) {
-        nodes.push(fork.node);
-      }
-      fork.node.collect(nodes);
-    }
-    return nodes;
+    return this.core.collect(nodes);
   }
   /**
    * Returns a path:reference map of all nodes in the tree which have a target address set.
@@ -425,37 +209,9 @@ export class MantarayNode {
    * Must be called after `loadRecursively`.
    */
   collectAndMap() {
-    const nodes = this.collect();
-    const result = {};
-    for (const node of nodes) {
-      result[node.fullPathString] = new Reference(node.targetAddress).toHex();
-    }
-    return result;
+    return this.core.collectAndMap();
   }
   determineType() {
-    let type = 0;
-    // Mirror Bee (pkg/manifest/mantaray/node.go): Add() marks every explicitly
-    // added leaf as a value (makeValue), even one with a null entry such as a
-    // metadata-only "/" node. In final-state terms a leaf (no forks) is always an
-    // added entry, so it is a value; a node with forks is a value only when it also
-    // carries an entry. The path-separator flag is set only when a separator occurs
-    // past the first byte (IndexRune > 0), so a prefix that merely starts with '/'
-    // does not qualify.
-    if (!Binary.equals(this.targetAddress, NULL_ADDRESS) || this.forks.size === 0) {
-      type |= TYPE_VALUE;
-    }
-    if (this.forks.size > 0) {
-      type |= TYPE_EDGE;
-    }
-    if (Binary.indexOf(this.path, PATH_SEPARATOR) > 0) {
-      type |= TYPE_WITH_PATH_SEPARATOR;
-    }
-    if (this.metadata) {
-      type |= TYPE_WITH_METADATA;
-    }
-    return type;
+    return this.core.determineType();
   }
-}
-function isType(value, type) {
-  return (value & type) === type;
 }

package/dist/mjs/modules/balance.js

@@ -1,6 +1,6 @@
+import { PeerAddress } from '@ethersphere/core-sdk';
 import * as balanceApi from "../api/balance.js";
 import * as consumedApi from "../api/consumed.js";
-import { PeerAddress } from "../utils/typed-bytes.js";
 /**
  * SWAP balance operations. Related to the bandwidth incentives and the chequebook.
  *

package/dist/mjs/modules/cheque.js

@@ -1,5 +1,5 @@
+import { PeerAddress } from '@ethersphere/core-sdk';
 import { TransactionOptionsSchema } from "../utils/schema.js";
-import { PeerAddress } from "../utils/typed-bytes.js";
 import * as api from "../api/chequebook.js";
 /**
  * Cheque operations (last cheques and cashouts).

package/dist/mjs/modules/chunk.js

@@ -1,7 +1,7 @@
+import { Identifier, Reference, Signature, Span } from '@ethersphere/core-sdk';
 import { CHUNK_SIZE } from "../types/index.js";
 import { BeeArgumentError } from "../utils/error.js";
 import { DownloadOptionsSchema, UploadOptionsSchema } from "../utils/schema.js";
-import { Identifier, Reference, Signature, Span } from "../utils/typed-bytes.js";
 import * as api from "../api/chunk.js";
 /**
  * Chunk operations backed by the `/chunks` endpoint.

package/dist/mjs/modules/collection.js

@@ -1,8 +1,8 @@
+import { BatchId } from '@ethersphere/core-sdk';
 import { hashDirectory as hashDirectoryImpl, streamDirectory as streamDirectoryImpl, streamFiles as streamFilesImpl } from "../utils/chunk-stream.js";
 import { assertCollection, makeCollectionFromFileList } from "../utils/collection.js";
 import { makeCollectionFromFS } from "../utils/collection.node.js";
 import { CollectionUploadOptionsSchema } from "../utils/schema.js";
-import { BatchId } from "../utils/typed-bytes.js";
 import * as api from "../api/bzz.js";
 /**
  * Collection (multi-file) operations backed by the `/bzz` endpoint.

package/dist/mjs/modules/connectivity.js

@@ -1,4 +1,4 @@
-import { PeerAddress } from "../utils/typed-bytes.js";
+import { PeerAddress } from '@ethersphere/core-sdk';
 import * as api from "../api/connectivity.js";
 /**
  * Peer, topology and network connectivity operations.

package/dist/mjs/modules/data.js

@@ -1,9 +1,9 @@
+import { BatchId, Reference } from '@ethersphere/core-sdk';
+import * as bytes from "../api/bytes.js";
+import * as stewardship from "../api/stewardship.js";
 import { ResourceLocator } from "../utils/resource-locator.js";
 import { DownloadOptionsSchema, RedundantUploadOptionsSchema } from "../utils/schema.js";
 import { assertData } from "../utils/type.js";
-import { BatchId, Reference } from "../utils/typed-bytes.js";
-import * as bytes from "../api/bytes.js";
-import * as stewardship from "../api/stewardship.js";
 /**
  * Raw data operations backed by the `/bytes` endpoint.
  *

package/dist/mjs/modules/feed.js

@@ -1,9 +1,9 @@
+import { BatchId, EthAddress, PrivateKey, Topic } from '@ethersphere/core-sdk';
 import { Objects } from 'cafe-utility';
 import { createFeedManifest, fetchLatestFeedUpdate } from "../api/feed.js";
 import { makeFeedReader, makeFeedWriter } from "../feed/index.js";
 import { areAllSequentialFeedsUpdateRetrievable } from "../feed/retrievable.js";
 import { DownloadOptionsSchema, UploadOptionsSchema } from "../utils/schema.js";
-import { BatchId, EthAddress, PrivateKey, Topic } from "../utils/typed-bytes.js";
 /**
  * Feed operations.
  *

package/dist/mjs/modules/file.js

@@ -1,8 +1,8 @@
+import { BatchId, Reference } from '@ethersphere/core-sdk';
 import { fileArrayBuffer, isFile } from "../utils/file.js";
 import { ResourceLocator } from "../utils/resource-locator.js";
 import { DownloadOptionsSchema, FileUploadOptionsSchema } from "../utils/schema.js";
 import { assertFileData } from "../utils/type.js";
-import { BatchId, Reference } from "../utils/typed-bytes.js";
 import * as api from "../api/bzz.js";
 /**
  * Single-file operations backed by the `/bzz` endpoint.

package/dist/mjs/modules/grantee.js

@@ -1,5 +1,5 @@
+import { BatchId, PublicKey, Reference } from '@ethersphere/core-sdk';
 import * as api from "../api/grantee.js";
-import { BatchId, PublicKey, Reference } from "../utils/typed-bytes.js";
 /**
  * Grantee (access control) operations.
  *

package/dist/mjs/modules/messaging.js

@@ -1,14 +1,12 @@
 import { Binary, System } from 'cafe-utility';
 import WebSocket from 'isomorphic-ws';
-import { makeContentAddressedChunk } from "../chunk/cac.js";
-import { makeSOCAddress, uploadSingleOwnerChunk } from "../chunk/soc.js";
+import { BatchId, Bytes, EthAddress, Identifier, makeContentAddressedChunk, numberToUint256, PeerAddress, PrivateKey, PublicKey } from '@ethersphere/core-sdk';
 import * as pssApi from "../api/pss.js";
-import { Bytes } from "../utils/bytes.js";
+import { makeSOCAddress, uploadSingleOwnerChunk } from "../chunk/soc.js";
 import { prepareWebsocketData } from "../utils/data.js";
 import { BeeError } from "../utils/error.js";
 import { GsocMessageHandlerSchema, PssMessageHandlerSchema } from "../utils/schema.js";
 import { assertData } from "../utils/type.js";
-import { BatchId, EthAddress, Identifier, PeerAddress, PrivateKey, PublicKey } from "../utils/typed-bytes.js";
 const PSS_ENDPOINT = 'pss';
 const GSOC_ENDPOINT = 'gsoc';
 /**
@@ -122,7 +120,7 @@ export class Messaging {
     const id = new Identifier(identifier);
     const start = 0xb33n;
     for (let i = 0n; i < 0xffffn; i++) {
-      const signer = new PrivateKey(Binary.numberToUint256(start + i, 'BE'));
+      const signer = new PrivateKey(numberToUint256(start + i, 'BE'));
       const socAddress = makeSOCAddress(id, signer.publicKey().address());
       // TODO: test the significance of the hardcoded 256
       const actualProximity = 256 - Binary.proximity(socAddress.toUint8Array(), overlay.toUint8Array());

package/dist/mjs/modules/pin.js

@@ -1,6 +1,6 @@
+import { BatchId, Reference } from '@ethersphere/core-sdk';
 import * as pinApi from "../api/pin.js";
 import * as stewardshipApi from "../api/stewardship.js";
-import { BatchId, Reference } from "../utils/typed-bytes.js";
 /**
  * Local pinning operations.
  *

package/dist/mjs/modules/settlement.js

@@ -1,4 +1,4 @@
-import { PeerAddress } from "../utils/typed-bytes.js";
+import { PeerAddress } from '@ethersphere/core-sdk';
 import * as api from "../api/settlement.js";
 /**
  * Settlement operations. Related to the bandwidth incentives and the chequebook.