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

package/dist/cjs/utils/typed-bytes.js

@@ -1,186 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeedIndex = exports.Topic = exports.Signature = exports.BatchId = exports.PeerAddress = exports.Span = exports.TransactionId = exports.Reference = exports.Identifier = exports.EthAddress = exports.PublicKey = exports.PrivateKey = void 0;
-const cafe_utility_1 = require("cafe-utility");
-const bytes_1 = require("./bytes");
-const cid_1 = require("./cid");
-// TODO: add JSdocs for each class
-const ENCODER = new TextEncoder();
-class PrivateKey extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 32);
-    }
-    publicKey() {
-        const [x, y] = cafe_utility_1.Elliptic.privateKeyToPublicKey(cafe_utility_1.Binary.uint256ToNumber(this.bytes, 'BE'));
-        return new PublicKey(cafe_utility_1.Binary.concatBytes(cafe_utility_1.Binary.numberToUint256(x, 'BE'), cafe_utility_1.Binary.numberToUint256(y, 'BE')));
-    }
-    sign(data) {
-        const digest = cafe_utility_1.Binary.concatBytes(ENCODER.encode(`\x19Ethereum Signed Message:\n32`), cafe_utility_1.Binary.keccak256(data instanceof Uint8Array ? data : ENCODER.encode(data)));
-        const [r, s, v] = cafe_utility_1.Elliptic.signMessage(digest, cafe_utility_1.Binary.uint256ToNumber(this.bytes, 'BE'));
-        return new Signature(cafe_utility_1.Binary.concatBytes(cafe_utility_1.Binary.numberToUint256(r, 'BE'), cafe_utility_1.Binary.numberToUint256(s, 'BE'), new Uint8Array([Number(v)])));
-    }
-}
-exports.PrivateKey = PrivateKey;
-PrivateKey.LENGTH = 32;
-class PublicKey extends bytes_1.Bytes {
-    constructor(bytes) {
-        const b = new bytes_1.Bytes(bytes);
-        if (b.length === 33) {
-            const [x, y] = cafe_utility_1.Elliptic.publicKeyFromCompressed(b.toUint8Array());
-            super(cafe_utility_1.Binary.concatBytes(cafe_utility_1.Binary.numberToUint256(x, 'BE'), cafe_utility_1.Binary.numberToUint256(y, 'BE')), 64);
-        }
-        else {
-            super(bytes, 64);
-        }
-    }
-    address() {
-        const x = cafe_utility_1.Binary.uint256ToNumber(this.bytes.slice(0, 32), 'BE');
-        const y = cafe_utility_1.Binary.uint256ToNumber(this.bytes.slice(32, 64), 'BE');
-        return new EthAddress(cafe_utility_1.Elliptic.publicKeyToAddress([x, y]));
-    }
-    toCompressedUint8Array() {
-        const x = cafe_utility_1.Binary.uint256ToNumber(this.bytes.slice(0, 32), 'BE');
-        const y = cafe_utility_1.Binary.uint256ToNumber(this.bytes.slice(32, 64), 'BE');
-        return cafe_utility_1.Elliptic.compressPublicKey([x, y]);
-    }
-    toCompressedHex() {
-        return cafe_utility_1.Binary.uint8ArrayToHex(this.toCompressedUint8Array());
-    }
-}
-exports.PublicKey = PublicKey;
-PublicKey.LENGTH = 64;
-class EthAddress extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 20);
-    }
-    toChecksum() {
-        return cafe_utility_1.Elliptic.checksumEncode(this.bytes);
-    }
-}
-exports.EthAddress = EthAddress;
-EthAddress.LENGTH = 20;
-class Identifier extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 32);
-    }
-    static fromString(value) {
-        return new Identifier(cafe_utility_1.Binary.keccak256(ENCODER.encode(value)));
-    }
-}
-exports.Identifier = Identifier;
-Identifier.LENGTH = 32;
-class Reference extends bytes_1.Bytes {
-    constructor(bytes) {
-        if (typeof bytes === 'string' && bytes.startsWith('bah5')) {
-            const decoded = (0, cid_1.convertCidToReference)(bytes);
-            super(decoded.reference.bytes, 32);
-        }
-        else {
-            super(bytes, [32, 64]);
-        }
-    }
-    toCid(type) {
-        return (0, cid_1.convertReferenceToCid)(this.bytes, type);
-    }
-    static isValid(value) {
-        try {
-            new Reference(value);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}
-exports.Reference = Reference;
-Reference.LENGTH = 32;
-class TransactionId extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 32);
-    }
-}
-exports.TransactionId = TransactionId;
-TransactionId.LENGTH = 32;
-class Span extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 8);
-    }
-    static fromBigInt(number) {
-        return new Span(cafe_utility_1.Binary.numberToUint64(number, 'LE'));
-    }
-    toBigInt() {
-        return cafe_utility_1.Binary.uint64ToNumber(this.bytes, 'LE');
-    }
-    static fromSlice(bytes, start) {
-        return new Span(bytes.slice(start, start + Span.LENGTH));
-    }
-}
-exports.Span = Span;
-Span.LENGTH = 8;
-class PeerAddress extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 32);
-    }
-}
-exports.PeerAddress = PeerAddress;
-PeerAddress.LENGTH = 32;
-class BatchId extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 32);
-    }
-}
-exports.BatchId = BatchId;
-BatchId.LENGTH = 32;
-class Signature extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 65);
-    }
-    static fromSlice(bytes, start) {
-        return new Signature(bytes.slice(start, start + Signature.LENGTH));
-    }
-    recoverPublicKey(digest) {
-        const r = cafe_utility_1.Binary.uint256ToNumber(this.bytes.slice(0, 32), 'BE');
-        const s = cafe_utility_1.Binary.uint256ToNumber(this.bytes.slice(32, 64), 'BE');
-        const v = BigInt(this.bytes[64]);
-        const [x, y] = cafe_utility_1.Elliptic.recoverPublicKey(cafe_utility_1.Binary.concatBytes(ENCODER.encode(`\x19Ethereum Signed Message:\n32`), cafe_utility_1.Binary.keccak256(digest instanceof Uint8Array ? digest : ENCODER.encode(digest))), r, s, v);
-        return new PublicKey(cafe_utility_1.Binary.concatBytes(cafe_utility_1.Binary.numberToUint256(x, 'BE'), cafe_utility_1.Binary.numberToUint256(y, 'BE')));
-    }
-    isValid(digest, expectedAddress) {
-        const publicKey = this.recoverPublicKey(digest);
-        const address = publicKey.address();
-        return address.equals(expectedAddress);
-    }
-}
-exports.Signature = Signature;
-Signature.LENGTH = 65;
-class Topic extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 32);
-    }
-    static fromString(value) {
-        return new Topic(cafe_utility_1.Binary.keccak256(ENCODER.encode(value)));
-    }
-}
-exports.Topic = Topic;
-Topic.LENGTH = 32;
-const MAX_UINT64 = new Uint8Array(8).fill(0xff, 0, 8);
-class FeedIndex extends bytes_1.Bytes {
-    constructor(bytes) {
-        super(bytes, 8);
-    }
-    static fromBigInt(number) {
-        return new FeedIndex(cafe_utility_1.Binary.numberToUint64(number, 'BE'));
-    }
-    toBigInt() {
-        return cafe_utility_1.Binary.uint64ToNumber(this.bytes, 'BE');
-    }
-    next() {
-        if (cafe_utility_1.Binary.equals(this.bytes, MAX_UINT64)) {
-            return FeedIndex.fromBigInt(0n);
-        }
-        return FeedIndex.fromBigInt(this.toBigInt() + 1n);
-    }
-}
-exports.FeedIndex = FeedIndex;
-FeedIndex.LENGTH = 8;
-FeedIndex.MINUS_ONE = new FeedIndex(MAX_UINT64);

package/dist/mjs/chunk/bmt.js

@@ -1,34 +0,0 @@
-import { Binary } from 'cafe-utility';
-import { BeeArgumentError } from "../utils/error.js";
-import { Reference, Span } from "../utils/typed-bytes.js";
-const MAX_CHUNK_PAYLOAD_SIZE = 4096;
-const SEGMENT_SIZE = 32;
-/**
- * Calculate a Binary Merkle Tree hash for a chunk
- *
- * The BMT chunk address is the hash of the 8 byte span and the root
- * hash of a binary Merkle tree (BMT) built on the 32-byte segments
- * of the underlying data.
- *
- * If the chunk content is less than 4k, the hash is calculated as
- * if the chunk was padded with all zeros up to 4096 bytes.
- *
- * @param chunkContent Chunk data including span and payload as well
- *
- * @returns the keccak256 hash in a byte array
- */
-export function calculateChunkAddress(chunkContent) {
-  const span = chunkContent.slice(0, Span.LENGTH);
-  const payload = chunkContent.slice(Span.LENGTH);
-  const rootHash = calculateBmtRootHash(payload);
-  const chunkHash = Binary.keccak256(Binary.concatBytes(span, rootHash));
-  return new Reference(chunkHash);
-}
-function calculateBmtRootHash(payload) {
-  if (payload.length > MAX_CHUNK_PAYLOAD_SIZE) {
-    throw new BeeArgumentError(`payload size ${payload.length} exceeds maximum chunk payload size ${MAX_CHUNK_PAYLOAD_SIZE}`, payload);
-  }
-  const input = new Uint8Array(MAX_CHUNK_PAYLOAD_SIZE);
-  input.set(payload);
-  return Binary.log2Reduce(Binary.partition(input, SEGMENT_SIZE), (a, b) => Binary.keccak256(Binary.concatBytes(a, b)));
-}

package/dist/mjs/chunk/cac.js

@@ -1,34 +0,0 @@
-import { Binary } from 'cafe-utility';
-import { z } from 'zod';
-import { Bytes } from "../utils/bytes.js";
-import { Span } from "../utils/typed-bytes.js";
-import { calculateChunkAddress } from "./bmt.js";
-import { makeSingleOwnerChunk } from "./soc.js";
-export const MIN_PAYLOAD_SIZE = 1;
-export const MAX_PAYLOAD_SIZE = 4096;
-export function unmarshalContentAddressedChunk(data) {
-  data = new Bytes(data);
-  return makeContentAddressedChunk(data.toUint8Array().slice(Span.LENGTH), Span.fromSlice(data.toUint8Array(), 0));
-}
-export function makeContentAddressedChunk(rawPayload, span) {
-  const asString = z.string().safeParse(rawPayload);
-  if (asString.success) {
-    rawPayload = Bytes.fromUtf8(asString.data);
-  }
-  if (rawPayload.length < MIN_PAYLOAD_SIZE || rawPayload.length > MAX_PAYLOAD_SIZE) {
-    throw new RangeError(`payload size ${rawPayload.length} exceeds limits [${MIN_PAYLOAD_SIZE}, ${MAX_PAYLOAD_SIZE}]`);
-  }
-  const typedSpan = span ? typeof span === 'bigint' ? Span.fromBigInt(span) : span : Span.fromBigInt(BigInt(rawPayload.length));
-  const payload = new Bytes(rawPayload);
-  const data = Binary.concatBytes(typedSpan.toUint8Array(), payload.toUint8Array());
-  const address = calculateChunkAddress(data);
-  return {
-    data,
-    span: typedSpan,
-    payload,
-    address,
-    toSingleOwnerChunk: (identifier, signer) => {
-      return makeSingleOwnerChunk(address, typedSpan, payload, identifier, signer);
-    }
-  };
-}

package/dist/mjs/stamper/stamper.js

@@ -1,40 +0,0 @@
-import { Binary } from 'cafe-utility';
-import { BatchId, PrivateKey } from "../utils/typed-bytes.js";
-export class Stamper {
-  constructor(signer, batchId, buckets, depth) {
-    this.signer = new PrivateKey(signer);
-    this.batchId = new BatchId(batchId);
-    this.buckets = buckets;
-    this.depth = depth;
-    this.maxSlot = 2 ** (this.depth - 16);
-  }
-  static fromBlank(signer, batchId, depth) {
-    return new Stamper(signer, batchId, new Uint32Array(65536), depth);
-  }
-  static fromState(signer, batchId, buckets, depth) {
-    return new Stamper(signer, batchId, buckets, depth);
-  }
-  stamp(chunk) {
-    const address = chunk.hash();
-    const bucket = Binary.uint16ToNumber(address, 'BE');
-    const height = this.buckets[bucket];
-    if (height >= this.maxSlot) {
-      throw Error('Bucket is full');
-    }
-    this.buckets[bucket]++;
-    const index = Binary.concatBytes(Binary.numberToUint32(bucket, 'BE'), Binary.numberToUint32(height, 'BE'));
-    const currentTimeNs = BigInt(Date.now()) * 1000000n; // Bee uses unix timestamp in nanoseconds
-    const timestamp = Binary.numberToUint64(currentTimeNs, 'BE');
-    const signature = this.signer.sign(Binary.concatBytes(address, this.batchId.toUint8Array(), index, timestamp));
-    return {
-      batchId: this.batchId,
-      index,
-      issuer: this.signer.publicKey().address().toUint8Array(),
-      signature: signature.toUint8Array(),
-      timestamp
-    };
-  }
-  getState() {
-    return this.buckets;
-  }
-}

package/dist/mjs/utils/bytes.js

@@ -1,102 +0,0 @@
-import { Binary, Objects } from 'cafe-utility';
-import _debug from 'debug';
-import { z } from 'zod';
-import { HexStringSchema } from "./hex-schema.js";
-const debug = _debug('bee-js:bytes');
-const DECODER = new TextDecoder();
-const ENCODER = new TextEncoder();
-export class Bytes {
-  constructor(bytes, byteLength) {
-    if (!bytes) {
-      throw Error(`Bytes#constructor: constructor parameter is falsy: ${bytes}`);
-    }
-    if (bytes instanceof Bytes) {
-      this.bytes = bytes.bytes;
-    } else if (typeof bytes === 'string') {
-      this.bytes = Binary.hexToUint8Array(HexStringSchema.parse(bytes));
-    } else if (bytes instanceof ArrayBuffer) {
-      this.bytes = new Uint8Array(bytes);
-    } else if (bytes instanceof Uint8Array) {
-      this.bytes = bytes;
-    } else {
-      const unknownInput = bytes;
-      const toHex = Objects.getDeep(unknownInput, 'toHex');
-      if (z.function().safeParse(toHex).success) {
-        const hex = toHex.call(unknownInput);
-        this.bytes = Binary.hexToUint8Array(HexStringSchema.parse(hex));
-      } else {
-        debug('bytes', bytes);
-        throw new Error(`Bytes#constructor: unsupported type: ${typeof bytes}`);
-      }
-    }
-    this.length = this.bytes.length;
-    if (byteLength) {
-      if (Array.isArray(byteLength)) {
-        if (!byteLength.includes(this.length)) {
-          throw new Error(`Bytes#checkByteLength: bytes length is ${this.length} but expected ${byteLength.join(' or ')}`);
-        }
-      } else if (this.length !== byteLength) {
-        throw new Error(`Bytes#checkByteLength: bytes length is ${this.length} but expected ${byteLength}`);
-      }
-    }
-  }
-  static keccak256(bytes) {
-    return new Bytes(Binary.keccak256(new Bytes(bytes).toUint8Array()));
-  }
-  static fromUtf8(utf8) {
-    return new Bytes(ENCODER.encode(utf8));
-  }
-  static fromSlice(bytes, start, length) {
-    if (length === undefined) {
-      return new Bytes(bytes.slice(start));
-    }
-    return new Bytes(bytes.slice(start, start + length));
-  }
-  offset(index) {
-    return new Uint8Array(this.bytes.slice(index));
-  }
-  toUint8Array() {
-    return new Uint8Array(this.bytes);
-  }
-  toHex() {
-    return Binary.uint8ArrayToHex(this.bytes);
-  }
-  toBase64() {
-    return Binary.uint8ArrayToBase64(this.bytes);
-  }
-  toBase32() {
-    return Binary.uint8ArrayToBase32(this.bytes);
-  }
-  toString() {
-    return this.toHex();
-  }
-  toUtf8() {
-    return DECODER.decode(this.bytes);
-  }
-  toJSON() {
-    return JSON.parse(this.toUtf8());
-  }
-  equals(other) {
-    return this.toHex() === new Bytes(other).toHex();
-  }
-  represent() {
-    return this.toHex();
-  }
-}
-export function parseSizeToBytes(sizeStr) {
-  const units = {
-    B: 1,
-    kB: 1000,
-    MB: 1000 ** 2,
-    GB: 1000 ** 3,
-    TB: 1000 ** 4,
-    PB: 1000 ** 5
-  };
-  const match = sizeStr.match(/^([\d.]+)\s*(B|kB|MB|GB|TB|PB)$/);
-  if (!match) {
-    throw new Error(`Invalid size format: ${sizeStr}`);
-  }
-  const value = parseFloat(match[1]);
-  const unit = match[2];
-  return Math.ceil(value * units[unit]);
-}

package/dist/mjs/utils/cid.js

@@ -1,32 +0,0 @@
-import { Binary } from 'cafe-utility';
-import { Reference } from "./typed-bytes.js";
-export const SWARM_MANIFEST_CODEC = 0xfa;
-export const SWARM_FEED_CODEC = 0xfb;
-const CODEC_TABLE = {
-  [SWARM_MANIFEST_CODEC]: 'manifest',
-  [SWARM_FEED_CODEC]: 'feed'
-};
-export function convertReferenceToCid(reference, type) {
-  reference = new Reference(reference);
-  const base32 = 'b';
-  const version = new Uint8Array([1]);
-  const codec = new Uint8Array([type === 'feed' ? SWARM_FEED_CODEC : SWARM_MANIFEST_CODEC]);
-  const unknown = new Uint8Array([1]);
-  const sha256 = new Uint8Array([27]);
-  const size = new Uint8Array([32]);
-  const header = Binary.uint8ArrayToBase32(Binary.concatBytes(version, codec, unknown, sha256, size)).replace(/\=+$/, '');
-  const hash = reference.toBase32().replace(/\=+$/, '');
-  return `${base32}${header}${hash}`.toLowerCase();
-}
-export function convertCidToReference(cid) {
-  const bytes = Binary.base32ToUint8Array(cid.toUpperCase().slice(1));
-  const codec = bytes[1];
-  if (!CODEC_TABLE[codec]) {
-    throw new Error('Unknown codec');
-  }
-  const reference = new Reference(bytes.slice(-32));
-  return {
-    type: CODEC_TABLE[codec],
-    reference
-  };
-}

package/dist/mjs/utils/redundancy.js

@@ -1,98 +0,0 @@
-import { RedundancyLevel } from "../index.js";
-const mediumTable = [[94, 68, 46, 28, 14, 5, 1], [9, 8, 7, 6, 5, 4, 3]];
-const encMediumTable = [[47, 34, 23, 14, 7, 2], [9, 8, 7, 6, 5, 4]];
-const strongTable = [[104, 95, 86, 77, 69, 61, 53, 46, 39, 32, 26, 20, 15, 10, 6, 3, 1], [21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5]];
-const encStrongTable = [[52, 47, 43, 38, 34, 30, 26, 23, 19, 16, 13, 10, 7, 5, 3, 1], [21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6]];
-const insaneTable = [[92, 87, 82, 77, 73, 68, 63, 59, 54, 50, 45, 41, 37, 33, 29, 26, 22, 19, 16, 13, 10, 8, 5, 3, 2, 1], [31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6]];
-const encInsaneTable = [[46, 43, 41, 38, 36, 34, 31, 29, 27, 25, 22, 20, 18, 16, 14, 13, 11, 9, 8, 6, 5, 4, 2, 1], [31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 7]];
-const paranoidTable = [[37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1], [90, 88, 87, 85, 84, 82, 81, 79, 77, 76, 74, 72, 71, 69, 67, 66, 64, 62, 60, 59, 57, 55, 53, 51, 49, 48, 46, 44, 41, 39, 37, 35, 32, 30, 27, 24, 20]];
-const encParanoidTable = [[18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1], [88, 85, 82, 79, 76, 72, 69, 66, 62, 59, 55, 51, 48, 44, 39, 35, 30, 24]];
-/**
- * Returns an approximate multiplier for the overhead of a given redundancy level.
- * Redundancy level is a tradeoff between storage overhead and fault tolerance.
- * Use this number to estimate the amount of chunks that will be stored for a given
- * redundancy level.
- */
-export function approximateOverheadForRedundancyLevel(chunks, level, encrypted) {
-  if (level === RedundancyLevel.OFF) {
-    return 0;
-  }
-  const table = selectTable(level, encrypted);
-  const [supportedChunks, parities] = table;
-  for (let i = 0; i < supportedChunks.length; i++) {
-    if (chunks >= supportedChunks[i]) {
-      return parities[i] / supportedChunks[i];
-    }
-  }
-  return parities[parities.length - 1] / supportedChunks[supportedChunks.length - 1];
-}
-function selectTable(level, encrypted) {
-  switch (level) {
-    case RedundancyLevel.MEDIUM:
-      return encrypted ? encMediumTable : mediumTable;
-    case RedundancyLevel.STRONG:
-      return encrypted ? encStrongTable : strongTable;
-    case RedundancyLevel.INSANE:
-      return encrypted ? encInsaneTable : insaneTable;
-    case RedundancyLevel.PARANOID:
-      return encrypted ? encParanoidTable : paranoidTable;
-    default:
-      throw new Error(`Unknown redundancy level ${level}`);
-  }
-}
-const medium = {
-  label: 'medium',
-  value: RedundancyLevel.MEDIUM,
-  errorTolerance: 0.01
-};
-const strong = {
-  label: 'strong',
-  value: RedundancyLevel.STRONG,
-  errorTolerance: 0.05
-};
-const insane = {
-  label: 'insane',
-  value: RedundancyLevel.INSANE,
-  errorTolerance: 0.1
-};
-const paranoid = {
-  label: 'paranoid',
-  value: RedundancyLevel.PARANOID,
-  errorTolerance: 0.5
-};
-export function getRedundancyStats() {
-  return {
-    medium,
-    strong,
-    insane,
-    paranoid
-  };
-}
-export function getRedundancyStat(level) {
-  if (typeof level === 'string') {
-    switch (level.toLowerCase()) {
-      case 'medium':
-        return medium;
-      case 'strong':
-        return strong;
-      case 'insane':
-        return insane;
-      case 'paranoid':
-        return paranoid;
-      default:
-        throw new Error(`Unknown redundancy level '${level}'`);
-    }
-  }
-  switch (level) {
-    case RedundancyLevel.MEDIUM:
-      return medium;
-    case RedundancyLevel.STRONG:
-      return strong;
-    case RedundancyLevel.INSANE:
-      return insane;
-    case RedundancyLevel.PARANOID:
-      return paranoid;
-    default:
-      throw new Error(`Unknown redundancy level '${level}'`);
-  }
-}

package/dist/mjs/utils/typed-bytes.js

@@ -1,167 +0,0 @@
-import { Binary, Elliptic } from 'cafe-utility';
-import { Bytes } from "./bytes.js";
-import { convertCidToReference, convertReferenceToCid } from "./cid.js"; // TODO: add JSdocs for each class
-const ENCODER = new TextEncoder();
-export class PrivateKey extends Bytes {
-  constructor(bytes) {
-    super(bytes, 32);
-  }
-  publicKey() {
-    const [x, y] = Elliptic.privateKeyToPublicKey(Binary.uint256ToNumber(this.bytes, 'BE'));
-    return new PublicKey(Binary.concatBytes(Binary.numberToUint256(x, 'BE'), Binary.numberToUint256(y, 'BE')));
-  }
-  sign(data) {
-    const digest = Binary.concatBytes(ENCODER.encode(`\x19Ethereum Signed Message:\n32`), Binary.keccak256(data instanceof Uint8Array ? data : ENCODER.encode(data)));
-    const [r, s, v] = Elliptic.signMessage(digest, Binary.uint256ToNumber(this.bytes, 'BE'));
-    return new Signature(Binary.concatBytes(Binary.numberToUint256(r, 'BE'), Binary.numberToUint256(s, 'BE'), new Uint8Array([Number(v)])));
-  }
-}
-PrivateKey.LENGTH = 32;
-export class PublicKey extends Bytes {
-  constructor(bytes) {
-    const b = new Bytes(bytes);
-    if (b.length === 33) {
-      const [x, y] = Elliptic.publicKeyFromCompressed(b.toUint8Array());
-      super(Binary.concatBytes(Binary.numberToUint256(x, 'BE'), Binary.numberToUint256(y, 'BE')), 64);
-    } else {
-      super(bytes, 64);
-    }
-  }
-  address() {
-    const x = Binary.uint256ToNumber(this.bytes.slice(0, 32), 'BE');
-    const y = Binary.uint256ToNumber(this.bytes.slice(32, 64), 'BE');
-    return new EthAddress(Elliptic.publicKeyToAddress([x, y]));
-  }
-  toCompressedUint8Array() {
-    const x = Binary.uint256ToNumber(this.bytes.slice(0, 32), 'BE');
-    const y = Binary.uint256ToNumber(this.bytes.slice(32, 64), 'BE');
-    return Elliptic.compressPublicKey([x, y]);
-  }
-  toCompressedHex() {
-    return Binary.uint8ArrayToHex(this.toCompressedUint8Array());
-  }
-}
-PublicKey.LENGTH = 64;
-export class EthAddress extends Bytes {
-  constructor(bytes) {
-    super(bytes, 20);
-  }
-  toChecksum() {
-    return Elliptic.checksumEncode(this.bytes);
-  }
-}
-EthAddress.LENGTH = 20;
-export class Identifier extends Bytes {
-  constructor(bytes) {
-    super(bytes, 32);
-  }
-  static fromString(value) {
-    return new Identifier(Binary.keccak256(ENCODER.encode(value)));
-  }
-}
-Identifier.LENGTH = 32;
-export class Reference extends Bytes {
-  constructor(bytes) {
-    if (typeof bytes === 'string' && bytes.startsWith('bah5')) {
-      const decoded = convertCidToReference(bytes);
-      super(decoded.reference.bytes, 32);
-    } else {
-      super(bytes, [32, 64]);
-    }
-  }
-  toCid(type) {
-    return convertReferenceToCid(this.bytes, type);
-  }
-  static isValid(value) {
-    try {
-      new Reference(value);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-Reference.LENGTH = 32;
-export class TransactionId extends Bytes {
-  constructor(bytes) {
-    super(bytes, 32);
-  }
-}
-TransactionId.LENGTH = 32;
-export class Span extends Bytes {
-  constructor(bytes) {
-    super(bytes, 8);
-  }
-  static fromBigInt(number) {
-    return new Span(Binary.numberToUint64(number, 'LE'));
-  }
-  toBigInt() {
-    return Binary.uint64ToNumber(this.bytes, 'LE');
-  }
-  static fromSlice(bytes, start) {
-    return new Span(bytes.slice(start, start + Span.LENGTH));
-  }
-}
-Span.LENGTH = 8;
-export class PeerAddress extends Bytes {
-  constructor(bytes) {
-    super(bytes, 32);
-  }
-}
-PeerAddress.LENGTH = 32;
-export class BatchId extends Bytes {
-  constructor(bytes) {
-    super(bytes, 32);
-  }
-}
-BatchId.LENGTH = 32;
-export class Signature extends Bytes {
-  constructor(bytes) {
-    super(bytes, 65);
-  }
-  static fromSlice(bytes, start) {
-    return new Signature(bytes.slice(start, start + Signature.LENGTH));
-  }
-  recoverPublicKey(digest) {
-    const r = Binary.uint256ToNumber(this.bytes.slice(0, 32), 'BE');
-    const s = Binary.uint256ToNumber(this.bytes.slice(32, 64), 'BE');
-    const v = BigInt(this.bytes[64]);
-    const [x, y] = Elliptic.recoverPublicKey(Binary.concatBytes(ENCODER.encode(`\x19Ethereum Signed Message:\n32`), Binary.keccak256(digest instanceof Uint8Array ? digest : ENCODER.encode(digest))), r, s, v);
-    return new PublicKey(Binary.concatBytes(Binary.numberToUint256(x, 'BE'), Binary.numberToUint256(y, 'BE')));
-  }
-  isValid(digest, expectedAddress) {
-    const publicKey = this.recoverPublicKey(digest);
-    const address = publicKey.address();
-    return address.equals(expectedAddress);
-  }
-}
-Signature.LENGTH = 65;
-export class Topic extends Bytes {
-  constructor(bytes) {
-    super(bytes, 32);
-  }
-  static fromString(value) {
-    return new Topic(Binary.keccak256(ENCODER.encode(value)));
-  }
-}
-Topic.LENGTH = 32;
-const MAX_UINT64 = new Uint8Array(8).fill(0xff, 0, 8);
-export class FeedIndex extends Bytes {
-  constructor(bytes) {
-    super(bytes, 8);
-  }
-  static fromBigInt(number) {
-    return new FeedIndex(Binary.numberToUint64(number, 'BE'));
-  }
-  toBigInt() {
-    return Binary.uint64ToNumber(this.bytes, 'BE');
-  }
-  next() {
-    if (Binary.equals(this.bytes, MAX_UINT64)) {
-      return FeedIndex.fromBigInt(0n);
-    }
-    return FeedIndex.fromBigInt(this.toBigInt() + 1n);
-  }
-}
-FeedIndex.LENGTH = 8;
-FeedIndex.MINUS_ONE = new FeedIndex(MAX_UINT64);