@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/cjs/utils/reference.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeBytesReference = void 0;
-const types_1 = require("../types");
-const bytes_1 = require("./bytes");
-const hex_1 = require("./hex");
-function makeBytesReference(reference, offset = 0) {
-    if (typeof reference === 'string') {
-        if (offset) {
-            throw new Error('Offset property can be set only for UintArray reference!');
-        }
-        try {
-            // Non-encrypted chunk hex string reference
-            const hexReference = (0, hex_1.makeHexString)(reference, types_1.REFERENCE_HEX_LENGTH);
-            return (0, hex_1.hexToBytes)(hexReference);
-        }
-        catch (e) {
-            if (!(e instanceof TypeError)) {
-                throw e;
-            }
-            // Encrypted chunk hex string reference
-            const hexReference = (0, hex_1.makeHexString)(reference, types_1.ENCRYPTED_REFERENCE_HEX_LENGTH);
-            return (0, hex_1.hexToBytes)(hexReference);
-        }
-    }
-    else if (reference instanceof Uint8Array) {
-        if ((0, bytes_1.hasBytesAtOffset)(reference, offset, types_1.ENCRYPTED_REFERENCE_BYTES_LENGTH)) {
-            return (0, bytes_1.bytesAtOffset)(reference, offset, types_1.ENCRYPTED_REFERENCE_BYTES_LENGTH);
-        }
-        else if ((0, bytes_1.hasBytesAtOffset)(reference, offset, types_1.REFERENCE_BYTES_LENGTH)) {
-            return (0, bytes_1.bytesAtOffset)(reference, offset, types_1.REFERENCE_BYTES_LENGTH);
-        }
-    }
-    throw new TypeError('invalid chunk reference');
-}
-exports.makeBytesReference = makeBytesReference;

package/dist/index.browser.min.js.LICENSE.txt

@@ -1,8 +0,0 @@
-/**
- * [js-sha3]{@link https://github.com/emn178/js-sha3}
- *
- * @version 0.8.0
- * @author Chen, Yi-Cyuan [emn178@gmail.com]
- * @copyright Chen, Yi-Cyuan 2015-2018
- * @license MIT
- */

package/dist/mjs/chunk/signer.js

@@ -1,114 +0,0 @@
-// 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);
-}
-/**
- * The default signer function that can be used for integrating with
- * other applications (e.g. wallets).
- *
- * @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;
-}
-function publicKeyToAddress(pubKey) {
-  const pubBytes = pubKey.encode('array', false);
-  return keccak256Hash(pubBytes.slice(1)).slice(12);
-}
-/**
- * Recovers the ethereum address from a given signature.
- *
- * Can be used for verifying a piece of data when the public key is
- * known.
- *
- * @param signature The signature
- * @param digest    The digest of the data
- *
- * @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);
-}
-/**
- * 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
-  };
-}
-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!');
-  }
-}
-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;
-}
-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!');
-}

package/dist/mjs/chunk/span.js

@@ -1,21 +0,0 @@
-import { Binary } from 'cafe-utility';
-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
- *
- * The length is encoded in 64-bit little endian.
- *
- * @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);
-  }
-  return Binary.numberToUint64LE(length);
-}

package/dist/mjs/feed/json.js

@@ -1,26 +0,0 @@
-import { isError } from "../utils/type.js";
-function serializeJson(data) {
-  try {
-    const jsonString = JSON.stringify(data);
-    return new TextEncoder().encode(jsonString);
-  } catch (e) {
-    if (isError(e)) {
-      e.message = `JsonFeed: ${e.message}`;
-    }
-    throw e;
-  }
-}
-export async function getJsonData(bee, reader) {
-  const feedUpdate = await reader.download();
-  const retrievedData = await bee.downloadData(feedUpdate.reference);
-  return retrievedData.json();
-}
-export async function setJsonData(bee, writer, postageBatchId, data, options, requestOptions) {
-  const serializedData = serializeJson(data);
-  const {
-    reference
-  } = await bee.uploadData(postageBatchId, serializedData, options, requestOptions);
-  return writer.upload(postageBatchId, reference, {
-    pin: options?.pin
-  });
-}

package/dist/mjs/feed/topic.js

@@ -1,19 +0,0 @@
-import { keccak256Hash } from "../utils/hash.js";
-import { assertBytes } from "../utils/bytes.js";
-import { makeHexString, bytesToHex } from "../utils/hex.js";
-import { TOPIC_BYTES_LENGTH, TOPIC_HEX_LENGTH } from "../types/index.js";
-export function makeTopic(topic) {
-  if (typeof topic === 'string') {
-    return makeHexString(topic, TOPIC_HEX_LENGTH);
-  } else if (topic instanceof Uint8Array) {
-    assertBytes(topic, TOPIC_BYTES_LENGTH);
-    return bytesToHex(topic, TOPIC_HEX_LENGTH);
-  }
-  throw new TypeError('invalid topic');
-}
-export function makeTopicFromString(s) {
-  if (typeof s !== 'string') {
-    throw new TypeError('topic has to be string!');
-  }
-  return bytesToHex(keccak256Hash(s), TOPIC_HEX_LENGTH);
-}

package/dist/mjs/feed/type.js

@@ -1,10 +0,0 @@
-const feedTypes = ['sequence', 'epoch'];
-export const DEFAULT_FEED_TYPE = 'sequence';
-export function isFeedType(type) {
-  return typeof type === 'string' && feedTypes.includes(type);
-}
-export function assertFeedType(type) {
-  if (!isFeedType(type)) {
-    throw new TypeError('invalid feed type');
-  }
-}

package/dist/mjs/modules/debug/chunk.js

@@ -1,17 +0,0 @@
-import { http } from "../../utils/http.js";
-const endpoint = 'chunks';
-/**
- * Check if chunk at address exists locally
- *
- * @param requestOptions Options for making requests
- * @param address  Swarm address of chunk
- *
- * @returns BeeGenericResponse if chunk is found or throws an exception
- */
-export async function checkIfChunkExistsLocally(requestOptions, address) {
-  const response = await http(requestOptions, {
-    url: `${endpoint}/${address}`,
-    responseType: 'json'
-  });
-  return response.data;
-}

package/dist/mjs/modules/debug/tag.js

@@ -1,15 +0,0 @@
-import { http } from "../../utils/http.js";
-const endpoint = 'tags';
-/**
- * Retrieve tag with extended information from Bee node
- *
- * @param requestOptions Options for making requests
- * @param uid UID of tag to be retrieved
- */
-export async function retrieveExtendedTag(requestOptions, uid) {
-  const response = await http(requestOptions, {
-    url: `${endpoint}/${uid}`,
-    responseType: 'json'
-  });
-  return response.data;
-}

package/dist/mjs/utils/eth.js

@@ -1,192 +0,0 @@
-// For ESM compatibility
-import pkg from 'js-sha3';
-const {
-  keccak256,
-  sha3_256
-} = pkg;
-import { assertBytes } from "./bytes.js";
-import { assertHexString, hexToBytes, intToHex, makeHexString } from "./hex.js";
-const ETH_ADDR_BYTES_LENGTH = 20;
-const ETH_ADDR_HEX_LENGTH = 40;
-export function capitalizeAddressERC55(address) {
-  if (address.startsWith('0x')) {
-    address = address.slice(2);
-  }
-  const addressHash = keccak256(address.toLowerCase());
-  let result = '0x';
-  for (let i = 0; i < address.length; i++) {
-    if (parseInt(addressHash[i], 16) > 7) {
-      result += address[i].toUpperCase();
-    } else {
-      result += address[i].toLowerCase();
-    }
-  }
-  return result;
-}
-export function makeEthAddress(address) {
-  if (typeof address === 'string') {
-    const hexAddr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
-    const ownerBytes = hexToBytes(hexAddr);
-    assertBytes(ownerBytes, ETH_ADDR_BYTES_LENGTH);
-    return ownerBytes;
-  } else if (address instanceof Uint8Array) {
-    assertBytes(address, ETH_ADDR_BYTES_LENGTH);
-    return address;
-  }
-  throw new TypeError('Invalid EthAddress');
-}
-export function makeHexEthAddress(address) {
-  try {
-    return makeHexString(address, ETH_ADDR_HEX_LENGTH);
-  } catch (e) {
-    if (e instanceof TypeError) {
-      e.message = `Invalid HexEthAddress: ${e.message}`;
-    }
-    throw e;
-  }
-}
-/**
- * Check if this is all caps or small caps eth address (=address without checksum)
- *
- * @param address Ethereum address as hex string
- */
-function isEthAddrCaseIns(address) {
-  // Check it's string, all small caps or all all caps hex and 40 chars long without the `0x` prefix
-  return typeof address === 'string' && (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address));
-}
-/**
- * Check if this is checksummed ethereum address
- *
- * @param address Ethereum address as hex string
- */
-function isValidChecksummedEthAddress(address) {
-  try {
-    // Check for valid case insensitive hex type string, 40 chars
-    const addr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
-    // Check the checksum
-    const addressHash = keccak256(addr.toLowerCase());
-    for (let i = 0; i < 40; i += 1) {
-      // the nth letter should be uppercase if the nth digit of casemap is 1
-      if (parseInt(addressHash[i], 16) > 7 && addr[i].toUpperCase() !== addr[i] || parseInt(addressHash[i], 16) <= 7 && addr[i].toLowerCase() !== addr[i]) {
-        return false;
-      }
-    }
-    return true;
-  } catch (e) {
-    if (e instanceof TypeError) {
-      return false;
-    }
-    throw e;
-  }
-}
-/**
- * Check if is valid ethereum address
- *
- * Pretty much typed version from web3js
- * https://github.com/ChainSafe/web3.js/blob/1.x/packages/web3-utils/src/utils.js
- *
- * @param address  Ethereum address as hex string
- *
- * @return True if is valid eth address
- */
-export function isHexEthAddress(address) {
-  return isEthAddrCaseIns(address) || isValidChecksummedEthAddress(address);
-}
-/**
- * Convert big-endian hex or number to little-endian.
- * Note: Before conversion it is automatically padded to even length hexstring
- *
- * @param bigEndian Big-endian hex string or number to convert
- * @param pad       Length to which the string should be padded before conversion (defaul: 2)
- *
- * @return little-endian encoded hexstring
- */
-export function toLittleEndian(bigEndian, pad = 2) {
-  if (!(Number.isInteger(pad) && pad >= 2 && pad % 2 === 0)) {
-    throw new TypeError('minimal padding for conversion needs to be positive even integer');
-  }
-  let hexRep;
-  if (typeof bigEndian === 'string') hexRep = makeHexString(bigEndian);else if (typeof bigEndian === 'number') hexRep = intToHex(bigEndian);else throw new TypeError('incorrect input type');
-  hexRep = hexRep.padStart(pad, '0');
-  // Extend to an even length hexstring
-  if (hexRep.length % 2 !== 0) hexRep = hexRep.padStart(hexRep.length + 1, '0');
-  // Match all two pairs in the hexstring, reverse the pairs and join it again
-  const littleEndian = hexRep.match(/../g)?.reverse().join('');
-  if (littleEndian) return littleEndian;
-  throw new Error('failed to convert');
-}
-/**
- * Convert little-endian hex or number to big-endian
- * Note: Before conversion it is automatically padded to even length hexstring
- *
- * @param littleEndian Little-endian hex string or number to convert
- * @param pad          Length to which the string should be padded before conversion (defaul: 2)
- *
- * @return big-endian encoded hexstring
- */
-export function fromLittleEndian(littleEndian, pad = 2) {
-  // It's a reversible function
-  return toLittleEndian(littleEndian, pad);
-}
-function assertEthAddress(ethAddress) {
-  if (!isHexEthAddress(ethAddress)) throw new TypeError('invalid ETH address');
-}
-function assertSwarmNetworkId(networkId) {
-  if (Number.isInteger(networkId && networkId > 0 && networkId < Number.MAX_SAFE_INTEGER)) {
-    throw new TypeError('swarm network id must be positive integer');
-  }
-}
-/**
- * Get swarm overlay address from public ethereum address and swarm network id
- *
- * @param ethAddress  Public ethereum address
- * @param networkId   Swarm network id
- *
- * @return Swarm overlay address
- */
-export function ethToSwarmAddress(ethAddress, networkId = 1) {
-  assertEthAddress(ethAddress);
-  assertSwarmNetworkId(networkId);
-  const hex = `${makeHexString(ethAddress)}${toLittleEndian(networkId, 16)}`;
-  assertHexString(hex);
-  const overlayAddress = sha3_256(hexToBytes(hex));
-  return overlayAddress;
-}
-/**
- * Function that takes Ethereum EIP-1193 compatible provider and create an Signer instance that
- * uses `personal_sign` method to sign requested data.
- *
- * @param provider Injected web3 provider like window.ethereum or other compatible with EIP-1193
- * @param ethAddress Optional address of the account which the data should be signed with. If not specified `eth_requestAccounts` request is used to get the account address.
- */
-export async function makeEthereumWalletSigner(provider, ethAddress) {
-  let executorFnc;
-  if (typeof provider !== 'object' || provider === null) {
-    throw new TypeError('We need JsonRPC provider object!');
-  }
-  if (provider.request) {
-    executorFnc = provider.request;
-  } else if (provider.sendAsync) {
-    executorFnc = provider.sendAsync;
-  } else {
-    throw new Error('Incompatible interface of given provider!');
-  }
-  if (!ethAddress) {
-    ethAddress = (await executorFnc({
-      method: 'eth_requestAccounts'
-    }))[0];
-  }
-  const bytesEthAddress = makeEthAddress(ethAddress);
-  const hexEthAddress = makeHexEthAddress(ethAddress);
-  return {
-    address: bytesEthAddress,
-    sign: async data => {
-      const result = await executorFnc({
-        jsonrpc: '2.0',
-        method: 'personal_sign',
-        params: ['0x' + data.hex(), '0x' + hexEthAddress]
-      });
-      return result;
-    }
-  };
-}

package/dist/mjs/utils/hash.js

@@ -1,16 +0,0 @@
-// For ESM compatibility
-import pkg from 'js-sha3';
-const {
-  keccak256
-} = pkg;
-/**
- * Helper function for calculating the keccak256 hash with
- * correct types.
- *
- * @param messages Any number of messages (strings, byte arrays etc.)
- */
-export function keccak256Hash(...messages) {
-  const hasher = keccak256.create();
-  messages.forEach(bytes => hasher.update(bytes));
-  return Uint8Array.from(hasher.digest());
-}

package/dist/mjs/utils/hex.js

@@ -1,135 +0,0 @@
-import { makeBytes } from "./bytes.js";
-/**
- * Creates unprefixed hex string from wide range of data.
- *
- * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
- *
- * @param input
- * @param len of the resulting HexString WITHOUT prefix!
- */
-export function makeHexString(input, len) {
-  if (typeof input === 'number') {
-    return intToHex(input, len);
-  }
-  if (input instanceof Uint8Array) {
-    return bytesToHex(input, len);
-  }
-  if (typeof input === 'string') {
-    if (isPrefixedHexString(input)) {
-      const hex = input.slice(2);
-      if (len && hex.length !== len) {
-        throw new TypeError(`Length mismatch for valid hex string. Expecting length ${len}: ${hex}`);
-      }
-      return hex;
-    } else {
-      // We use assertHexString() as there might be more reasons why a string is not valid hex string
-      // and usage of isHexString() would not give enough information to the user on what is going
-      // wrong.
-      assertHexString(input, len);
-      return input;
-    }
-  }
-  throw new TypeError('Not HexString compatible type!');
-}
-/**
- * Converts a hex string to Uint8Array
- *
- * @param hex string input without 0x prefix!
- */
-export function hexToBytes(hex) {
-  assertHexString(hex);
-  const bytes = makeBytes(hex.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    const hexByte = hex.substr(i * 2, 2);
-    bytes[i] = parseInt(hexByte, 16);
-  }
-  return bytes;
-}
-/**
- * Converts array of number or Uint8Array to HexString without prefix.
- *
- * @param bytes   The input array
- * @param len     The length of the non prefixed HexString
- */
-export function bytesToHex(bytes, len) {
-  const hexByte = n => n.toString(16).padStart(2, '0');
-  const hex = Array.from(bytes, hexByte).join('');
-  // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
-  if (len && hex.length !== len) {
-    throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
-  }
-  return hex;
-}
-/**
- * Converts integer number to hex string.
- *
- * Optionally provides '0x' prefix or padding
- *
- * @param int         The positive integer to be converted
- * @param len     The length of the non prefixed HexString
- */
-export function intToHex(int, len) {
-  if (!Number.isInteger(int)) throw new TypeError('the value provided is not integer');
-  if (int > Number.MAX_SAFE_INTEGER) throw new TypeError('the value provided exceeds safe integer');
-  if (int < 0) throw new TypeError('the value provided is a negative integer');
-  const hex = int.toString(16);
-  // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
-  if (len && hex.length !== len) {
-    throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
-  }
-  return hex;
-}
-/**
- * Type guard for HexStrings.
- * Requires no 0x prefix!
- *
- * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
- *
- * @param s string input
- * @param len expected length of the HexString
- */
-export function isHexString(s, len) {
-  return typeof s === 'string' && /^[0-9a-f]+$/i.test(s) && (!len || s.length === len);
-}
-/**
- * Type guard for PrefixedHexStrings.
- * Does enforce presence of 0x prefix!
- *
- * @param s string input
- */
-export function isPrefixedHexString(s) {
-  return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
-}
-/**
- * Verifies if the provided input is a HexString.
- *
- * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
- *
- * @param s string input
- * @param len expected length of the HexString
- * @param name optional name for the asserted value
- * @returns HexString or throws error
- */
-export function assertHexString(s, len, name = 'value') {
-  if (!isHexString(s, len)) {
-    if (isPrefixedHexString(s)) {
-      throw new TypeError(`${name} not valid non prefixed hex string (has 0x prefix): ${s}`);
-    }
-    // Don't display length error if no length specified in order not to confuse user
-    const lengthMsg = len ? ` of length ${len}` : '';
-    throw new TypeError(`${name} not valid hex string${lengthMsg}: ${s}`);
-  }
-}
-/**
- * Verifies if the provided input is a PrefixedHexString.
- *
- * @param s string input
- * @param len expected length of the HexString
- * @param name optional name for the asserted value
- * @returns HexString or throws error
- */
-export function assertPrefixedHexString(s, name = 'value') {
-  if (!isPrefixedHexString(s)) {
-    throw new TypeError(`${name} not valid prefixed hex string: ${s}`);
-  }
-}

package/dist/mjs/utils/reference.js

@@ -1,29 +0,0 @@
-import { ENCRYPTED_REFERENCE_BYTES_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, REFERENCE_BYTES_LENGTH, REFERENCE_HEX_LENGTH } from "../types/index.js";
-import { bytesAtOffset, hasBytesAtOffset } from "./bytes.js";
-import { hexToBytes, makeHexString } from "./hex.js";
-export function makeBytesReference(reference, offset = 0) {
-  if (typeof reference === 'string') {
-    if (offset) {
-      throw new Error('Offset property can be set only for UintArray reference!');
-    }
-    try {
-      // Non-encrypted chunk hex string reference
-      const hexReference = makeHexString(reference, REFERENCE_HEX_LENGTH);
-      return hexToBytes(hexReference);
-    } catch (e) {
-      if (!(e instanceof TypeError)) {
-        throw e;
-      }
-      // Encrypted chunk hex string reference
-      const hexReference = makeHexString(reference, ENCRYPTED_REFERENCE_HEX_LENGTH);
-      return hexToBytes(hexReference);
-    }
-  } else if (reference instanceof Uint8Array) {
-    if (hasBytesAtOffset(reference, offset, ENCRYPTED_REFERENCE_BYTES_LENGTH)) {
-      return bytesAtOffset(reference, offset, ENCRYPTED_REFERENCE_BYTES_LENGTH);
-    } else if (hasBytesAtOffset(reference, offset, REFERENCE_BYTES_LENGTH)) {
-      return bytesAtOffset(reference, offset, REFERENCE_BYTES_LENGTH);
-    }
-  }
-  throw new TypeError('invalid chunk reference');
-}

package/dist/types/chunk/signer.d.ts

@@ -1,31 +0,0 @@
-import { EthAddress } from '../utils/eth';
-import { PrivateKeyBytes, Signature, Signer } from '../types';
-/**
- * The default signer function that can be used for integrating with
- * other applications (e.g. wallets).
- *
- * @param data      The data to be signed
- * @param privateKey  The private key used for signing the data
- */
-export declare function defaultSign(data: Uint8Array, privateKey: PrivateKeyBytes): Signature;
-/**
- * Recovers the ethereum address from a given signature.
- *
- * Can be used for verifying a piece of data when the public key is
- * known.
- *
- * @param signature The signature
- * @param digest    The digest of the data
- *
- * @returns the recovered address
- */
-export declare function recoverAddress(signature: Signature, digest: Uint8Array): EthAddress;
-/**
- * Creates a singer object that can be used when the private key is known.
- *
- * @param privateKey The private key
- */
-export declare function makePrivateKeySigner(privateKey: PrivateKeyBytes): Signer;
-export declare function assertSigner(signer: unknown): asserts signer is Signer;
-export declare function makeSigner(signer: Signer | Uint8Array | string | unknown): Signer;
-export declare function sign(signer: Signer, data: Uint8Array): Promise<Signature>;