@upcoming/bee-js 0.10.1 → 0.12.0

package/dist/mjs/feed/index.js

@@ -1,7 +1,7 @@
-import { Binary } from 'cafe-utility';
+import { Binary, Optional, Types } from 'cafe-utility';
 import { makeSingleOwnerChunkFromData, uploadSingleOwnerChunkData } from "../chunk/soc.js";
 import * as chunkAPI from "../modules/chunk.js";
-import { fetchLatestFeedUpdate } from "../modules/feed.js";
+import { fetchLatestFeedUpdate, probeFeed } from "../modules/feed.js";
 import { Bytes } from "../utils/bytes.js";
 import { BeeResponseError } from "../utils/error.js";
 import { FeedIndex, Reference } from "../utils/typed-bytes.js";
@@ -23,7 +23,7 @@ export async function findNextIndex(requestOptions, owner, topic) {
     throw e;
   }
 }
-export async function updateFeed(requestOptions, signer, topic, reference, postageBatchId, options) {
+export async function updateFeedWithReference(requestOptions, signer, topic, reference, postageBatchId, options) {
   reference = new Reference(reference);
   const nextIndex = options?.index ?? (await findNextIndex(requestOptions, signer.publicKey().address(), topic));
   const identifier = makeFeedIdentifier(topic, nextIndex);
@@ -32,45 +32,87 @@ export async function updateFeed(requestOptions, signer, topic, reference, posta
   const payloadBytes = Binary.concatBytes(timestamp, reference.toUint8Array());
   return uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, payloadBytes, options);
 }
+export async function updateFeedWithPayload(requestOptions, signer, topic, data, postageBatchId, options) {
+  const nextIndex = options?.index ?? (await findNextIndex(requestOptions, signer.publicKey().address(), topic));
+  const identifier = makeFeedIdentifier(topic, nextIndex);
+  return uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, Types.isString(data) ? Bytes.fromUtf8(data).toUint8Array() : data, options);
+}
 export function getFeedUpdateChunkReference(owner, topic, index) {
   const identifier = makeFeedIdentifier(topic, index);
   return new Reference(Binary.keccak256(Binary.concatBytes(identifier.toUint8Array(), owner.toUint8Array())));
 }
-export async function downloadFeedUpdate(requestOptions, owner, topic, index) {
+export async function downloadFeedUpdate(requestOptions, owner, topic, index, hasTimestamp = false) {
   index = typeof index === 'number' ? FeedIndex.fromBigInt(BigInt(index)) : index;
   const address = getFeedUpdateChunkReference(owner, topic, index);
   const data = await chunkAPI.download(requestOptions, address.toHex());
   const soc = makeSingleOwnerChunkFromData(data, address);
-  const timestampBytes = Bytes.fromSlice(soc.payload.toUint8Array(), TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
-  const timestamp = Number(Binary.uint64ToNumber(timestampBytes.toUint8Array(), 'BE'));
+  let timestamp = Optional.empty();
+  if (hasTimestamp) {
+    const timestampBytes = Bytes.fromSlice(soc.payload.toUint8Array(), TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
+    timestamp = Optional.of(Number(Binary.uint64ToNumber(timestampBytes.toUint8Array(), 'BE')));
+  }
   return {
     timestamp,
-    payload: new Bytes(soc.payload.offset(REFERENCE_PAYLOAD_OFFSET))
+    payload: new Bytes(soc.payload.offset(hasTimestamp ? REFERENCE_PAYLOAD_OFFSET : 0))
   };
 }
 export function makeFeedReader(requestOptions, topic, owner) {
+  // TODO: remove after enough time has passed in deprecated version
+  const download = async options => {
+    if (options?.index === undefined) {
+      return fetchLatestFeedUpdate(requestOptions, owner, topic);
+    }
+    const update = await downloadFeedUpdate(requestOptions, owner, topic, options.index, options.hasTimestamp ?? true);
+    const feedIndex = typeof options.index === 'number' ? FeedIndex.fromBigInt(BigInt(options.index)) : options.index;
+    return {
+      payload: update.payload,
+      feedIndex
+    };
+  };
+  const downloadPayload = async options => {
+    if (options?.index === undefined) {
+      return fetchLatestFeedUpdate(requestOptions, owner, topic);
+    }
+    const update = await downloadFeedUpdate(requestOptions, owner, topic, options.index, options.hasTimestamp);
+    const feedIndex = typeof options.index === 'number' ? FeedIndex.fromBigInt(BigInt(options.index)) : options.index;
+    return {
+      payload: update.payload,
+      feedIndex
+    };
+  };
+  const downloadReference = async options => {
+    let index = options?.index;
+    if (index === undefined) {
+      index = (await probeFeed(requestOptions, owner, topic)).feedIndex;
+    }
+    const payload = await download({
+      ...options,
+      index: index
+    });
+    return {
+      reference: new Reference(payload.payload.toUint8Array()),
+      feedIndex: payload.feedIndex
+    };
+  };
   return {
+    download,
+    downloadPayload,
+    downloadReference,
     owner,
-    topic,
-    async download(options) {
-      if (options?.index === undefined) {
-        return fetchLatestFeedUpdate(requestOptions, owner, topic);
-      }
-      const update = await downloadFeedUpdate(requestOptions, owner, topic, options.index);
-      const feedIndex = typeof options.index === 'number' ? FeedIndex.fromBigInt(BigInt(options.index)) : options.index;
-      return {
-        payload: update.payload,
-        feedIndex
-      };
-    }
+    topic
   };
 }
 export function makeFeedWriter(requestOptions, topic, signer) {
   const upload = async (postageBatchId, reference, options) => {
-    return updateFeed(requestOptions, signer, topic, reference, postageBatchId, options);
+    return updateFeedWithReference(requestOptions, signer, topic, reference, postageBatchId, options);
+  };
+  const uploadPayload = async (postageBatchId, data, options) => {
+    return updateFeedWithPayload(requestOptions, signer, topic, data, postageBatchId, options);
   };
   return {
     ...makeFeedReader(requestOptions, topic, signer.publicKey().address()),
-    upload
+    upload,
+    uploadReference: upload,
+    uploadPayload
   };
 }

package/dist/mjs/index.js

@@ -1,5 +1,6 @@
 import { Bee } from "./bee.js";
 import { BeeDev } from "./bee-dev.js";
+import { Stamper } from "./stamper/stamper.js";
 export { MerkleTree } from 'cafe-utility';
 export { MantarayNode } from "./manifest/manifest.js";
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from "./modules/debug/status.js";
@@ -11,4 +12,4 @@ export * from "./utils/error.js";
 export * as Utils from "./utils/expose.js";
 export * from "./utils/tokens.js";
 export * from "./utils/typed-bytes.js";
-export { Bee, BeeDev };
+export { Bee, BeeDev, Stamper };

package/dist/mjs/modules/feed.js

@@ -49,8 +49,8 @@ function readFeedUpdateHeaders(headers) {
  * index of the subsequent update.
  *
  * @param requestOptions Options for making requests
- * @param owner          Owner's ethereum address in hex
- * @param topic          Topic in hex
+ * @param owner          Owner's ethereum address
+ * @param topic          Topic
  * @param options        Additional options, like index, at, type
  */
 export async function fetchLatestFeedUpdate(requestOptions, owner, topic, options) {
@@ -63,4 +63,14 @@ export async function fetchLatestFeedUpdate(requestOptions, owner, topic, option
     payload: new Bytes(response.data),
     ...readFeedUpdateHeaders(response.headers)
   };
+}
+export async function probeFeed(requestOptions, owner, topic) {
+  const response = await http(requestOptions, {
+    responseType: 'arraybuffer',
+    url: `${feedEndpoint}/${owner}/${topic}`,
+    params: {
+      'Swarm-Only-Root-Chunk': true
+    }
+  });
+  return readFeedUpdateHeaders(response.headers);
 }

package/dist/mjs/stamper/stamper.js

@@ -0,0 +1,39 @@
+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 timestamp = Binary.numberToUint64(BigInt(Date.now()), '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

@@ -61,4 +61,7 @@ export class Bytes {
   toJSON() {
     return JSON.parse(this.toUtf8());
   }
+  equals(other) {
+    return this.toHex() === new Bytes(other).toHex();
+  }
 }

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

@@ -55,6 +55,9 @@ 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 {
@@ -126,6 +129,11 @@ export class Signature extends Bytes {
     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 {
@@ -148,4 +156,5 @@ export class FeedIndex extends Bytes {
     return Binary.uint64ToNumber(this.bytes, 'BE');
   }
 }
-FeedIndex.LENGTH = 8;
+FeedIndex.LENGTH = 8;
+FeedIndex.MINUS_ONE = new FeedIndex(new Uint8Array(8).fill(0xff, 0, 8));

package/dist/types/bee.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Readable } from 'stream';
 import { Chunk } from './chunk/cac';
-import { FetchFeedUpdateResponse } from './modules/feed';
+import { FeedPayloadResult } from './modules/feed';
 import type { AllSettlements, BalanceResponse, BeeOptions, BeeRequestOptions, BeeVersions, ChainState, ChequebookAddressResponse, ChequebookBalanceResponse, CollectionUploadOptions, DebugStatus, DownloadOptions, EnvelopeWithBatchId, FeedReader, FeedWriter, FileData, FileUploadOptions, GetGranteesResult, GlobalPostageBatch, GranteesResult, GsocMessageHandler, GsocSubscription, Health, LastCashoutActionResponse, LastChequesForPeerResponse, LastChequesResponse, NodeAddresses, NodeInfo, NumberString, Peer, PeerBalance, Pin, PingResponse, PostageBatch, PostageBatchBuckets, PssMessageHandler, PssSubscription, Readiness, RedistributionState, RedundantUploadOptions, ReferenceInformation, RemovePeerResponse, ReserveState, SOCReader, SOCWriter, Settlements, Tag, Topology, TransactionInfo, UploadOptions, WalletBalance } from './types';
 import { AllTagsOptions, Collection, PostageBatchOptions, TransactionOptions, UploadResult } from './types';
 import { Bytes } from './utils/bytes';
@@ -456,7 +456,7 @@ export declare class Bee {
      * @see [Bee docs - Feeds](https://docs.ethswarm.org/docs/develop/tools-and-features/feeds)
      */
     makeFeedWriter(topic: Topic | Uint8Array | string, signer?: PrivateKey | Uint8Array | string, options?: BeeRequestOptions): FeedWriter;
-    fetchLatestFeedUpdate(topic: Topic | Uint8Array | string, owner: EthAddress | Uint8Array | string, requestOptions?: BeeRequestOptions): Promise<FetchFeedUpdateResponse>;
+    fetchLatestFeedUpdate(topic: Topic | Uint8Array | string, owner: EthAddress | Uint8Array | string, requestOptions?: BeeRequestOptions): Promise<FeedPayloadResult>;
     /**
      * Returns an object for reading single owner chunks
      *

package/dist/types/feed/index.d.ts

@@ -1,3 +1,4 @@
+import { Optional } from 'cafe-utility';
 import { FeedUpdateOptions } from '../modules/feed';
 import { BeeRequestOptions, FeedReader, FeedWriter, UploadOptions, UploadResult } from '../types';
 import { Bytes } from '../utils/bytes';
@@ -9,12 +10,13 @@ export interface Epoch {
 export interface FeedUploadOptions extends UploadOptions, FeedUpdateOptions {
 }
 export interface FeedUpdate {
-    timestamp: number;
+    timestamp: Optional<number>;
     payload: Bytes;
 }
 export declare function findNextIndex(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic): Promise<FeedIndex>;
-export declare function updateFeed(requestOptions: BeeRequestOptions, signer: PrivateKey, topic: Topic, reference: Reference | string | Uint8Array, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<UploadResult>;
+export declare function updateFeedWithReference(requestOptions: BeeRequestOptions, signer: PrivateKey, topic: Topic, reference: Reference | string | Uint8Array, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<UploadResult>;
+export declare function updateFeedWithPayload(requestOptions: BeeRequestOptions, signer: PrivateKey, topic: Topic, data: Uint8Array | string, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<UploadResult>;
 export declare function getFeedUpdateChunkReference(owner: EthAddress, topic: Topic, index: FeedIndex): Reference;
-export declare function downloadFeedUpdate(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic, index: FeedIndex | number): Promise<FeedUpdate>;
+export declare function downloadFeedUpdate(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic, index: FeedIndex | number, hasTimestamp?: boolean): Promise<FeedUpdate>;
 export declare function makeFeedReader(requestOptions: BeeRequestOptions, topic: Topic, owner: EthAddress): FeedReader;
 export declare function makeFeedWriter(requestOptions: BeeRequestOptions, topic: Topic, signer: PrivateKey): FeedWriter;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import { Bee } from './bee';
 import { BeeDev } from './bee-dev';
+import { Stamper } from './stamper/stamper';
 export { MerkleTree } from 'cafe-utility';
 export { MantarayNode } from './manifest/manifest';
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
@@ -11,12 +12,13 @@ export * from './utils/error';
 export * as Utils from './utils/expose';
 export * from './utils/tokens';
 export * from './utils/typed-bytes';
-export { Bee, BeeDev };
+export { Bee, BeeDev, Stamper };
 declare global {
     interface Window {
         BeeJs: {
             Bee: typeof import('./bee').Bee;
             BeeDev: typeof import('./bee-dev').BeeDev;
+            Stamper: typeof import('./stamper/stamper').Stamper;
             Utils: typeof import('./utils/expose');
             Duration: typeof import('./utils/duration').Duration;
             BeeError: typeof import('./utils/error').BeeError;

package/dist/types/manifest/manifest.d.ts

@@ -1,6 +1,6 @@
 import { Optional, Uint8ArrayReader } from 'cafe-utility';
 import { Bee, BeeRequestOptions, DownloadOptions, UploadOptions, UploadResult } from '..';
-import { FetchFeedUpdateResponse } from '../modules/feed';
+import { FeedPayloadResult } from '../modules/feed';
 import { Bytes } from '../utils/bytes';
 import { BatchId, Reference } from '../utils/typed-bytes';
 export declare class Fork {
@@ -44,7 +44,7 @@ export declare class MantarayNode {
     /**
      * Attempts to resolve the manifest as a feed, returning the latest update.
      */
-    resolveFeed(bee: Bee, requestOptions?: BeeRequestOptions): Promise<Optional<FetchFeedUpdateResponse>>;
+    resolveFeed(bee: Bee, requestOptions?: BeeRequestOptions): Promise<Optional<FeedPayloadResult>>;
     /**
      * Gets the binary representation of the node.
      */

package/dist/types/modules/feed.d.ts

@@ -10,6 +10,10 @@ export interface FeedUpdateOptions {
      * Fetch specific previous Feed's update (default fetches latest update)
      */
     index?: FeedIndex | number;
+    /**
+     * Whether the first 8 bytes of the payload are a timestamp
+     */
+    hasTimestamp?: boolean;
 }
 interface FeedUpdateHeaders {
     /**
@@ -22,9 +26,12 @@ interface FeedUpdateHeaders {
      */
     feedIndexNext?: FeedIndex;
 }
-export interface FetchFeedUpdateResponse extends FeedUpdateHeaders {
+export interface FeedPayloadResult extends FeedUpdateHeaders {
     payload: Bytes;
 }
+export interface FeedReferenceResult extends FeedUpdateHeaders {
+    reference: Reference;
+}
 /**
  * Create an initial feed root manifest
  *
@@ -44,9 +51,10 @@ export declare function createFeedManifest(requestOptions: BeeRequestOptions, ow
  * index of the subsequent update.
  *
  * @param requestOptions Options for making requests
- * @param owner          Owner's ethereum address in hex
- * @param topic          Topic in hex
+ * @param owner          Owner's ethereum address
+ * @param topic          Topic
  * @param options        Additional options, like index, at, type
  */
-export declare function fetchLatestFeedUpdate(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<FetchFeedUpdateResponse>;
+export declare function fetchLatestFeedUpdate(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<FeedPayloadResult>;
+export declare function probeFeed(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic): Promise<FeedUpdateHeaders>;
 export {};

package/dist/types/stamper/stamper.d.ts

@@ -0,0 +1,15 @@
+import { Chunk } from 'cafe-utility';
+import { EnvelopeWithBatchId } from '../types';
+import { BatchId, PrivateKey } from '../utils/typed-bytes';
+export declare class Stamper {
+    signer: PrivateKey;
+    batchId: BatchId;
+    buckets: Uint32Array;
+    depth: number;
+    maxSlot: number;
+    private constructor();
+    static fromBlank(signer: PrivateKey | Uint8Array | string, batchId: BatchId | Uint8Array | string, depth: number): Stamper;
+    static fromState(signer: PrivateKey | Uint8Array | string, batchId: BatchId | Uint8Array | string, buckets: Uint32Array, depth: number): Stamper;
+    stamp(chunk: Chunk): EnvelopeWithBatchId;
+    getState(): Uint32Array;
+}

package/dist/types/types/index.d.ts

@@ -1,7 +1,7 @@
 import { Optional } from 'cafe-utility';
 import type { SingleOwnerChunk } from '../chunk/soc';
 import type { FeedUploadOptions } from '../feed';
-import type { FeedUpdateOptions, FetchFeedUpdateResponse } from '../modules/feed';
+import type { FeedPayloadResult, FeedReferenceResult, FeedUpdateOptions } from '../modules/feed';
 import { Bytes } from '../utils/bytes';
 import { Duration } from '../utils/duration';
 import type { BeeError } from '../utils/error';
@@ -301,9 +301,17 @@ export interface FeedReader {
     readonly owner: EthAddress;
     readonly topic: Topic;
     /**
-     * Download the latest feed update
+     * @deprecated Use `downloadReference` or `downloadPayload` instead to disambiguate how the data should be interpreted.
      */
-    download(options?: FeedUpdateOptions): Promise<FetchFeedUpdateResponse>;
+    download(options?: FeedUpdateOptions): Promise<FeedPayloadResult>;
+    /**
+     * Downloads the feed update (latest if no index is specified) and returns it as a reference.
+     */
+    downloadReference(options?: FeedUpdateOptions): Promise<FeedReferenceResult>;
+    /**
+     * Downloads the feed update (latest if no index is specified) and returns it as a payload.
+     */
+    downloadPayload(options?: FeedUpdateOptions): Promise<FeedPayloadResult>;
 }
 /**
  * FeedWriter is an interface for updating feeds
@@ -312,6 +320,8 @@ export interface FeedWriter extends FeedReader {
     /**
      * Upload a new feed update
      *
+     * @deprecated Use `uploadReference` or `uploadPayload` instead to disambiguate how the data should be interpreted.
+     *
      * @param postageBatchId Postage BatchId to be used to upload the data with
      * @param reference The reference to be stored in the new update
      * @param options   Additional options like `at`
@@ -319,6 +329,8 @@ export interface FeedWriter extends FeedReader {
      * @returns UpdateResult that points at Single Owner Chunk that contains the new update and pointer to the updated chunk reference.
      */
     upload(postageBatchId: string | BatchId, reference: Reference | string | Uint8Array, options?: FeedUploadOptions): Promise<UploadResult>;
+    uploadReference(postageBatchId: string | BatchId, reference: Reference | string | Uint8Array, options?: FeedUploadOptions): Promise<UploadResult>;
+    uploadPayload(postageBatchId: string | BatchId, payload: Uint8Array | string, options?: FeedUploadOptions): Promise<UploadResult>;
 }
 /**
  * Interface for downloading single owner chunks

package/dist/types/utils/bytes.d.ts

@@ -13,4 +13,5 @@ export declare class Bytes {
     toString(): string;
     toUtf8(): string;
     toJSON(): unknown;
+    equals(other: Bytes | Uint8Array | string): boolean;
 }

package/dist/types/utils/typed-bytes.d.ts

@@ -20,6 +20,7 @@ export declare class EthAddress extends Bytes {
 export declare class Identifier extends Bytes {
     static readonly LENGTH = 32;
     constructor(bytes: Uint8Array | string | Bytes);
+    static fromString(value: string): Identifier;
 }
 export declare class Reference extends Bytes {
     static readonly LENGTH = 32;
@@ -51,6 +52,7 @@ export declare class Signature extends Bytes {
     constructor(bytes: Uint8Array | string | Bytes);
     static fromSlice(bytes: Uint8Array, start: number): Signature;
     recoverPublicKey(digest: Uint8Array | string): PublicKey;
+    isValid(digest: Uint8Array | string, expectedAddress: EthAddress | Uint8Array | string): boolean;
 }
 export declare class Topic extends Bytes {
     static readonly LENGTH = 32;
@@ -59,6 +61,7 @@ export declare class Topic extends Bytes {
 }
 export declare class FeedIndex extends Bytes {
     static readonly LENGTH = 8;
+    static readonly MINUS_ONE: FeedIndex;
     constructor(bytes: Uint8Array | string | Bytes);
     static fromBigInt(number: bigint): FeedIndex;
     toBigInt(): bigint;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upcoming/bee-js",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "Javascript client for Bee",
   "keywords": [
     "bee",