@ethersphere/bee-js 1.2.1 → 3.0.0

package/src/chunk/bmt.ts

@@ -1,55 +0,0 @@
-import { keccak256 } from 'js-sha3'
-import { BeeArgumentError } from '../utils/error'
-import { Bytes } from '../utils/bytes'
-import { keccak256Hash } from '../utils/hash'
-
-const MAX_CHUNK_PAYLOAD_SIZE = 4096
-const SEGMENT_SIZE = 32
-const SEGMENT_PAIR_SIZE = 2 * SEGMENT_SIZE
-const HASH_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 bmtHash(chunkContent: Uint8Array): Bytes<32> {
-  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: Uint8Array): Uint8Array {
-  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)
-    }
-
-    input = output
-  }
-
-  return input
-}

package/src/chunk/cac.ts

@@ -1,79 +0,0 @@
-import { BrandedType } from '../types'
-import { BeeError } from '../utils/error'
-import { bmtHash } from './bmt'
-import { Bytes, bytesEqual, FlexBytes, flexBytesAtOffset, assertFlexBytes } from '../utils/bytes'
-import { serializeBytes } from './serialize'
-import { makeSpan, SPAN_SIZE } from './span'
-
-export const MIN_PAYLOAD_SIZE = 1
-export const MAX_PAYLOAD_SIZE = 4096
-
-const CAC_SPAN_OFFSET = 0
-const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + SPAN_SIZE
-
-export type ChunkAddress = Bytes<32>
-
-/**
- * General chunk interface for Swarm
- *
- * It stores the serialized data and provides functions to access
- * the fields of a chunk.
- *
- * It also provides an address function to calculate the address of
- * the chunk that is required for the Chunk API.
- */
-export interface Chunk {
-  readonly data: Uint8Array
-  span(): Bytes<8>
-  payload(): FlexBytes<1, 4096>
-
-  address(): ChunkAddress
-}
-
-type ValidChunkData = BrandedType<Uint8Array, 'ValidChunkData'>
-
-/**
- * Creates a content addressed chunk and verifies the payload size.
- *
- * @param payloadBytes the data to be stored in the chunk
- */
-export function makeContentAddressedChunk(payloadBytes: Uint8Array): Chunk {
-  const span = makeSpan(payloadBytes.length)
-  assertFlexBytes(payloadBytes, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE)
-  const data = serializeBytes(span, payloadBytes) as ValidChunkData
-
-  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
- *
- * @param data          The chunk data
- * @param chunkAddress  The address of the chunk
- */
-export function isValidChunkData(data: unknown, chunkAddress: ChunkAddress): data is ValidChunkData {
-  if (!(data instanceof Uint8Array)) return false
-
-  const address = bmtHash(data)
-
-  return bytesEqual(address, chunkAddress)
-}
-
-/**
- * Asserts if data are representing given address of its chunk.
- *
- * @param data          The chunk data
- * @param chunkAddress  The address of the chunk
- *
- * @returns a valid content addressed chunk or throws error
- */
-export function assertValidChunkData(data: unknown, chunkAddress: ChunkAddress): asserts data is ValidChunkData {
-  if (!isValidChunkData(data, chunkAddress)) {
-    throw new BeeError('Address of content address chunk does not match given data!')
-  }
-}

package/src/chunk/serialize.ts

@@ -1,16 +0,0 @@
-/**
- * Helper function for serialize byte arrays
- *
- * @param arrays Any number of byte array arguments
- */
-export function serializeBytes(...arrays: Uint8Array[]): Uint8Array {
-  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/src/chunk/signer.ts

@@ -1,141 +0,0 @@
-import { ec, curve } from 'elliptic'
-import { BeeError } from '../utils/error'
-import { Bytes, isBytes, assertBytes, wrapBytesWithHelpers } from '../utils/bytes'
-import { keccak256Hash } from '../utils/hash'
-import { hexToBytes, makeHexString } from '../utils/hex'
-import { EthAddress } from '../utils/eth'
-import { Data, PrivateKeyBytes, Signature, SIGNATURE_BYTES_LENGTH, SIGNATURE_HEX_LENGTH, Signer } from '../types'
-import { isStrictlyObject } from '../utils/type'
-
-type EllipticPublicKey = curve.base.BasePoint
-const UNCOMPRESSED_RECOVERY_ID = 27
-
-function hashWithEthereumPrefix(data: Uint8Array): Bytes<32> {
-  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: Uint8Array, privateKey: PrivateKeyBytes): 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 as Signature
-}
-
-function publicKeyToAddress(pubKey: EllipticPublicKey): EthAddress {
-  const pubBytes = pubKey.encode('array', false)
-
-  return keccak256Hash(pubBytes.slice(1)).slice(12) as EthAddress
-}
-
-/**
- * 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: Signature, digest: Uint8Array): EthAddress {
-  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: PrivateKeyBytes): Signer {
-  const curve = new ec('secp256k1')
-  const keyPair = curve.keyFromPrivate(privateKey)
-  const address = publicKeyToAddress(keyPair.getPublic())
-
-  return {
-    sign: (digest: Data) => defaultSign(digest, privateKey),
-    address,
-  }
-}
-
-export function assertSigner(signer: unknown): asserts signer is Signer {
-  if (!isStrictlyObject(signer)) {
-    throw new TypeError('Signer must be an object!')
-  }
-
-  const typedSigner = signer as 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: Signer | Uint8Array | string | unknown): Signer {
-  if (typeof signer === 'string') {
-    const hexKey = makeHexString(signer, 64)
-    const keyBytes = hexToBytes<32>(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: Signer, data: Uint8Array): Promise<Signature> {
-  const result = await signer.sign(wrapBytesWithHelpers(data))
-
-  if (typeof result === 'string') {
-    const hexString = makeHexString(result, SIGNATURE_HEX_LENGTH)
-
-    return hexToBytes<65>(hexString)
-  }
-
-  if (result instanceof Uint8Array) {
-    assertBytes(result, SIGNATURE_BYTES_LENGTH)
-
-    return result
-  }
-
-  throw new TypeError('Invalid output of sign function!')
-}

package/src/chunk/soc.ts

@@ -1,190 +0,0 @@
-import { Bytes, 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 {
-  Chunk,
-  ChunkAddress,
-  makeContentAddressedChunk,
-  MAX_PAYLOAD_SIZE,
-  MIN_PAYLOAD_SIZE,
-  assertValidChunkData,
-} from './cac'
-import { UploadOptions, Signature, Signer, BatchId, Reference } from '../types'
-import { bytesToHex } from '../utils/hex'
-import * as socAPI from '../modules/soc'
-import * as chunkAPI from '../modules/chunk'
-import { EthAddress } from '../utils/eth'
-import { assertAddress } from '../utils/type'
-
-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
-
-export type Identifier = Bytes<32>
-
-/**
- * With single owner chunks, a user can assign arbitrary data to an
- * address and attest chunk integrity with their digital signature.
- *
- * This interface extends the Chunk interface so it has the same
- * properties, but the address calculation is based on the identifier
- * and the owner of the chunk.
- */
-export interface SingleOwnerChunk extends Chunk {
-  identifier: () => Identifier
-  signature: () => Signature
-  owner: () => EthAddress
-}
-
-function recoverChunkOwner(data: Uint8Array): EthAddress {
-  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
- *
- * @param data    The chunk data
- * @param address The address of the single owner chunk
- *
- * @returns a single owner chunk or throws error
- */
-export function makeSingleOwnerChunkFromData(data: Uint8Array, address: ChunkAddress): SingleOwnerChunk {
-  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: Identifier, address: EthAddress): ChunkAddress {
-  return keccak256Hash(identifier, address)
-}
-
-/**
- * Creates a single owner chunk object
- *
- * @param chunk       A chunk object used for the span and payload
- * @param identifier  The identifier of the chunk
- * @param signer      The singer interface for signing the chunk
- */
-export async function makeSingleOwnerChunk(
-  chunk: Chunk,
-  identifier: Identifier,
-  signer: Signer,
-): Promise<SingleOwnerChunk> {
-  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.
- *
- * It uses the Chunk API and calculates the address before uploading.
- *
- * @param url             The url of the Bee service
- * @param chunk           A chunk object
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param options         Upload options
- */
-export async function uploadSingleOwnerChunk(
-  url: string,
-  chunk: SingleOwnerChunk,
-  postageBatchId: BatchId,
-  options?: UploadOptions,
-): Promise<Reference> {
-  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(url, owner, identifier, signature, data, postageBatchId, options)
-}
-
-/**
- * Helper function to create and upload SOC.
- *
- * @param url             The url of the Bee service
- * @param signer          The singer interface for signing the chunk
- * @param postageBatchId
- * @param identifier      The identifier of the chunk
- * @param data            The chunk data
- * @param options
- */
-export async function uploadSingleOwnerChunkData(
-  url: string,
-  signer: Signer,
-  postageBatchId: BatchId | string,
-  identifier: Identifier,
-  data: Uint8Array,
-  options?: UploadOptions,
-): Promise<Reference> {
-  assertAddress(postageBatchId)
-  const cac = makeContentAddressedChunk(data)
-  const soc = await makeSingleOwnerChunk(cac, identifier, signer)
-
-  return uploadSingleOwnerChunk(url, soc, postageBatchId, options)
-}
-
-/**
- * Helper function to download SOC.
- *
- * @param url           The url of the Bee service
- * @param ownerAddress  The singer interface for signing the chunk
- * @param identifier    The identifier of the chunk
- */
-export async function downloadSingleOwnerChunk(
-  url: string,
-  ownerAddress: EthAddress,
-  identifier: Identifier,
-): Promise<SingleOwnerChunk> {
-  const address = makeSOCAddress(identifier, ownerAddress)
-  const data = await chunkAPI.download(url, bytesToHex(address))
-
-  return makeSingleOwnerChunkFromData(data, address)
-}

package/src/chunk/span.ts

@@ -1,33 +0,0 @@
-import { BeeArgumentError } from '../../src/utils/error'
-import { Bytes } from '../utils/bytes'
-
-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: number): Bytes<8> {
-  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 as Bytes<8>
-}