@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/mjs/modules/feed.js

@@ -1,6 +1,9 @@
+import { Types } from 'cafe-utility';
+import { Bytes } from "../utils/bytes.js";
 import { BeeError } from "../utils/error.js";
-import { extractUploadHeaders } from "../utils/headers.js";
+import { prepareRequestHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
+import { FeedIndex, Reference } from "../utils/typed-bytes.js";
 const feedEndpoint = 'feeds';
 /**
  * Create an initial feed root manifest
@@ -11,14 +14,17 @@ const feedEndpoint = 'feeds';
  * @param postageBatchId  Postage BatchId to be used to create the Feed Manifest
  * @param options         Additional options, like type (default: 'sequence')
  */
-export async function createFeedManifest(requestOptions, owner, topic, stamp) {
+export async function createFeedManifest(requestOptions, owner, topic, stamp, options) {
   const response = await http(requestOptions, {
     method: 'post',
     responseType: 'json',
     url: `${feedEndpoint}/${owner}/${topic}`,
-    headers: extractUploadHeaders(stamp)
+    headers: prepareRequestHeaders(stamp, options)
   });
-  return response.data.reference;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return new Reference(Types.asHexString(body.reference));
 }
 function readFeedUpdateHeaders(headers) {
   const feedIndex = headers['swarm-feed-index'];
@@ -30,8 +36,8 @@ function readFeedUpdateHeaders(headers) {
     throw new BeeError('Response did not contain expected swarm-feed-index-next!');
   }
   return {
-    feedIndex,
-    feedIndexNext
+    feedIndex: new FeedIndex(feedIndex),
+    feedIndexNext: new FeedIndex(feedIndexNext)
   };
 }
 /**
@@ -43,18 +49,28 @@ 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) {
   const response = await http(requestOptions, {
-    responseType: 'json',
+    responseType: 'arraybuffer',
     url: `${feedEndpoint}/${owner}/${topic}`,
     params: options
   });
   return {
-    ...response.data,
+    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/modules/grantee.js

@@ -1,5 +1,7 @@
-import { extractRedundantUploadHeaders } from "../utils/headers.js";
+import { Types } from 'cafe-utility';
+import { prepareRequestHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
+import { PublicKey, Reference } from "../utils/typed-bytes.js";
 const granteeEndpoint = 'grantee';
 export async function getGrantees(reference, requestOptions) {
   const response = await http(requestOptions, {
@@ -7,10 +9,15 @@ export async function getGrantees(reference, requestOptions) {
     url: `${granteeEndpoint}/${reference}`,
     responseType: 'json'
   });
+  const body = Types.asArray(response.data, {
+    name: 'response.data'
+  }).map(x => new PublicKey(Types.asString(x, {
+    name: 'grantee'
+  })));
   return {
     status: response.status,
     statusText: response.statusText,
-    data: response.data
+    grantees: body
   };
 }
 export async function createGrantees(requestOptions, postageBatchId, grantees) {
@@ -18,35 +25,50 @@ export async function createGrantees(requestOptions, postageBatchId, grantees) {
     method: 'post',
     url: granteeEndpoint,
     data: {
-      grantees
-    },
-    headers: {
-      ...extractRedundantUploadHeaders(postageBatchId)
+      grantees: grantees.map(x => x.toCompressedHex())
     },
+    headers: prepareRequestHeaders(postageBatchId),
     responseType: 'json'
   });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
     status: response.status,
     statusText: response.statusText,
-    ref: response.data.ref,
-    historyref: response.data.historyref
+    ref: new Reference(Types.asString(body.ref, {
+      name: 'ref'
+    })),
+    historyref: new Reference(Types.asString(body.historyref, {
+      name: 'historyref'
+    }))
   };
 }
 export async function patchGrantees(postageBatchId, reference, historyRef, grantees, requestOptions) {
   const response = await http(requestOptions, {
     method: 'patch',
     url: `${granteeEndpoint}/${reference}`,
-    data: grantees,
+    data: {
+      add: grantees.add?.map(x => x.toCompressedHex()),
+      revoke: grantees.revoke?.map(x => x.toCompressedHex())
+    },
     headers: {
-      ...extractRedundantUploadHeaders(postageBatchId),
-      'swarm-act-history-address': historyRef
+      ...prepareRequestHeaders(postageBatchId),
+      'swarm-act-history-address': historyRef.toHex()
     },
     responseType: 'json'
   });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
     status: response.status,
     statusText: response.statusText,
-    ref: response.data.ref,
-    historyref: response.data.historyref
+    ref: new Reference(Types.asString(body.ref, {
+      name: 'ref'
+    })),
+    historyref: new Reference(Types.asString(body.historyref, {
+      name: 'historyref'
+    }))
   };
 }

package/dist/mjs/modules/gsoc.js

@@ -0,0 +1,16 @@
+import { System } from 'cafe-utility';
+import WebSocket from 'isomorphic-ws';
+import { uploadSingleOwnerChunk } from "../chunk/soc.js";
+const endpoint = 'gsoc';
+export async function send(requestOptions, soc, stamp, options) {
+  return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
+}
+export function subscribe(url, reference, headers) {
+  const wsUrl = url.replace(/^http/i, 'ws');
+  if (System.whereAmI() === 'browser') {
+    return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${reference.toHex()}`);
+  }
+  return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${reference.toHex()}`, {
+    headers
+  });
+}

package/dist/mjs/modules/pinning.js

@@ -1,4 +1,6 @@
+import { Types } from 'cafe-utility';
 import { http } from "../utils/http.js";
+import { Reference } from "../utils/typed-bytes.js";
 const PINNING_ENDPOINT = 'pins';
 /**
  * Pin data with given reference
@@ -39,7 +41,14 @@ export async function getPin(requestOptions, reference) {
     responseType: 'json',
     url: `${PINNING_ENDPOINT}/${reference}`
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    reference: new Reference(Types.asString(body.reference, {
+      name: 'reference'
+    }))
+  };
 }
 /**
  * Get list of all pins
@@ -52,5 +61,17 @@ export async function getAllPins(requestOptions) {
     responseType: 'json',
     url: `${PINNING_ENDPOINT}`
   });
-  return response.data.references || [];
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  // TODO: https://github.com/ethersphere/bee/issues/4964
+  if (body.references === null) {
+    return [];
+  }
+  const references = Types.asArray(body.references, {
+    name: 'references'
+  }).map(x => Types.asString(x, {
+    name: 'reference'
+  }));
+  return references.map(x => new Reference(x));
 }

package/dist/mjs/modules/pss.js

@@ -1,5 +1,6 @@
+import { System } from 'cafe-utility';
 import WebSocket from 'isomorphic-ws';
-import { extractUploadHeaders } from "../utils/headers.js";
+import { prepareRequestHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 const endpoint = 'pss';
 /**
@@ -22,7 +23,7 @@ export async function send(requestOptions, topic, target, data, postageBatchId,
     params: {
       recipient
     },
-    headers: extractUploadHeaders(postageBatchId)
+    headers: prepareRequestHeaders(postageBatchId)
   });
 }
 /**
@@ -31,7 +32,12 @@ export async function send(requestOptions, topic, target, data, postageBatchId,
  * @param url Bee node URL
  * @param topic Topic name
  */
-export function subscribe(url, topic) {
+export function subscribe(url, topic, headers) {
   const wsUrl = url.replace(/^http/i, 'ws');
-  return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${topic}`);
+  if (System.whereAmI() === 'browser') {
+    return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${topic.toHex()}`);
+  }
+  return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${topic.toHex()}`, {
+    headers
+  });
 }

package/dist/mjs/modules/soc.js

@@ -1,6 +1,8 @@
-import { extractUploadHeaders } from "../utils/headers.js";
+import { Optional, Types } from 'cafe-utility';
+import { prepareRequestHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 import { makeTagUid } from "../utils/type.js";
+import { Reference } from "../utils/typed-bytes.js";
 const socEndpoint = 'soc';
 /**
  * Upload single owner chunk (SOC) to a Bee node
@@ -20,16 +22,19 @@ export async function upload(requestOptions, owner, identifier, signature, data,
     data,
     headers: {
       'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(stamp, options)
+      ...prepareRequestHeaders(stamp, options)
     },
     responseType: 'json',
     params: {
-      sig: signature
+      sig: signature.toHex()
     }
   });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
-    reference: response.data.reference,
+    reference: new Reference(Types.asHexString(body.reference)),
     tagUid: response.headers['swarm-tag'] ? makeTagUid(response.headers['swarm-tag']) : undefined,
-    historyAddress: response.headers['swarm-act-history-address'] || ''
+    historyAddress: response.headers['swarm-act-history-address'] ? Optional.of(new Reference(response.headers['swarm-act-history-address'])) : Optional.empty()
   };
 }

package/dist/mjs/modules/stewardship.js

@@ -1,23 +1,33 @@
+import { Types } from 'cafe-utility';
 import { http } from "../utils/http.js";
+import { Reference } from "../utils/typed-bytes.js";
 const stewardshipEndpoint = 'stewardship';
 /**
  * Reupload locally pinned data
  * @param requestOptions Options for making requests
  * @param reference
- * @param options
  * @throws BeeResponseError if not locally pinned or invalid data
  */
-export async function reupload(requestOptions, reference) {
+export async function reupload(requestOptions, stamp, reference) {
   await http(requestOptions, {
     method: 'put',
-    url: `${stewardshipEndpoint}/${reference}`
+    url: `${stewardshipEndpoint}/${reference}`,
+    headers: {
+      'swarm-postage-batch-id': stamp.toHex()
+    }
   });
 }
 export async function isRetrievable(requestOptions, reference) {
+  reference = new Reference(reference);
   const response = await http(requestOptions, {
     method: 'get',
     responseType: 'json',
     url: `${stewardshipEndpoint}/${reference}`
   });
-  return response.data.isRetrievable;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return Types.asBoolean(body.isRetrievable, {
+    name: 'isRetrievable'
+  });
 }

package/dist/mjs/modules/tag.js

@@ -1,3 +1,4 @@
+import { Types } from 'cafe-utility';
 import { http } from "../utils/http.js";
 const endpoint = 'tags';
 /**
@@ -11,7 +12,35 @@ export async function createTag(requestOptions) {
     url: endpoint,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    address: Types.asEmptiableString(body.address, {
+      name: 'address'
+    }),
+    seen: Types.asNumber(body.seen, {
+      name: 'seen'
+    }),
+    sent: Types.asNumber(body.sent, {
+      name: 'sent'
+    }),
+    split: Types.asNumber(body.split, {
+      name: 'split'
+    }),
+    startedAt: Types.asString(body.startedAt, {
+      name: 'startedAt'
+    }),
+    stored: Types.asNumber(body.stored, {
+      name: 'stored'
+    }),
+    synced: Types.asNumber(body.synced, {
+      name: 'synced'
+    }),
+    uid: Types.asNumber(body.uid, {
+      name: 'uid'
+    })
+  };
 }
 /**
  * Retrieve tag information from Bee node
@@ -24,7 +53,35 @@ export async function retrieveTag(requestOptions, uid) {
     url: `${endpoint}/${uid}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    address: Types.asEmptiableString(body.address, {
+      name: 'address'
+    }),
+    seen: Types.asNumber(body.seen, {
+      name: 'seen'
+    }),
+    sent: Types.asNumber(body.sent, {
+      name: 'sent'
+    }),
+    split: Types.asNumber(body.split, {
+      name: 'split'
+    }),
+    startedAt: Types.asString(body.startedAt, {
+      name: 'startedAt'
+    }),
+    stored: Types.asNumber(body.stored, {
+      name: 'stored'
+    }),
+    synced: Types.asNumber(body.synced, {
+      name: 'synced'
+    }),
+    uid: Types.asNumber(body.uid, {
+      name: 'uid'
+    })
+  };
 }
 /**
  * Get limited listing of all tags.
@@ -42,7 +99,40 @@ export async function getAllTags(requestOptions, offset, limit) {
     },
     responseType: 'json'
   });
-  return response.data.tags;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const tags = Types.asArray(body.tags, {
+    name: 'tags'
+  }).map(x => Types.asObject(x, {
+    name: 'tag'
+  }));
+  return tags.map(x => ({
+    address: Types.asEmptiableString(x.address, {
+      name: 'address'
+    }),
+    seen: Types.asNumber(x.seen, {
+      name: 'seen'
+    }),
+    sent: Types.asNumber(x.sent, {
+      name: 'sent'
+    }),
+    split: Types.asNumber(x.split, {
+      name: 'split'
+    }),
+    startedAt: Types.asString(x.startedAt, {
+      name: 'startedAt'
+    }),
+    stored: Types.asNumber(x.stored, {
+      name: 'stored'
+    }),
+    synced: Types.asNumber(x.synced, {
+      name: 'synced'
+    }),
+    uid: Types.asNumber(x.uid, {
+      name: 'uid'
+    })
+  }));
 }
 /**
  * Removes tag from the Bee node.

package/dist/mjs/package.json

@@ -5,7 +5,8 @@
      "fs": false,
      "./utils/tar.js": "./utils/tar.browser.js",
      "./utils/tar-writer.js": "./utils/tar-writer.browser.js",
-      "./utils/tar-uploader.js": "./utils/tar-uploader.browser.js",
+     "./utils/tar-uploader.js": "./utils/tar-uploader.browser.js",
+     "./utils/chunk-stream.js": "./utils/chunk-stream.browser.js",
      "./utils/data.js": "./utils/data.browser.js",
      "./utils/collection.node.js": "./utils/collection.browser.js"
     }

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/types/debug.js

@@ -4,4 +4,18 @@ export var BeeModes;
   BeeModes["LIGHT"] = "light";
   BeeModes["ULTRA_LIGHT"] = "ultra-light";
   BeeModes["DEV"] = "dev";
-})(BeeModes || (BeeModes = {}));
+})(BeeModes || (BeeModes = {}));
+export function toBeeMode(value) {
+  switch (value) {
+    case 'full':
+      return BeeModes.FULL;
+    case 'light':
+      return BeeModes.LIGHT;
+    case 'ultra-light':
+      return BeeModes.ULTRA_LIGHT;
+    case 'dev':
+      return BeeModes.DEV;
+    default:
+      throw new Error(`Unknown Bee mode: ${value}`);
+  }
+}

package/dist/mjs/types/index.js

@@ -1,24 +1,12 @@
 export * from "./debug.js";
-export const SPAN_SIZE = 8;
 export const SECTION_SIZE = 32;
 export const BRANCHES = 128;
 export const CHUNK_SIZE = SECTION_SIZE * BRANCHES;
-export const ADDRESS_HEX_LENGTH = 64;
-export const PSS_TARGET_HEX_LENGTH_MAX = 6;
-export const PUBKEY_HEX_LENGTH = 66;
-export const BATCH_ID_HEX_LENGTH = 64;
-export const REFERENCE_HEX_LENGTH = 64;
-export const ENCRYPTED_REFERENCE_HEX_LENGTH = 128;
-export const REFERENCE_BYTES_LENGTH = 32;
-export const ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
+export const PSS_TARGET_HEX_LENGTH_MAX = 4;
 /**
  * Minimal depth that can be used for creation of postage batch
  */
 export const STAMPS_DEPTH_MIN = 17;
-/**
- * Minimal amount that can be used for creation of postage batch
- */
-export const STAMPS_AMOUNT_MIN = 24000 * 24 * 60 * 12;
 /**
  * Maximal depth that can be used for creation of postage batch
  */
@@ -54,14 +42,4 @@ export var RedundancyStrategy;
   RedundancyStrategy[RedundancyStrategy["DATA"] = 1] = "DATA";
   RedundancyStrategy[RedundancyStrategy["PROX"] = 2] = "PROX";
   RedundancyStrategy[RedundancyStrategy["RACE"] = 3] = "RACE";
-})(RedundancyStrategy || (RedundancyStrategy = {}));
-/*********************************************************
- * Writers and Readers interfaces
- */
-export const TOPIC_BYTES_LENGTH = 32;
-export const TOPIC_HEX_LENGTH = 64;
-/*********************************************************
- * Ethereum compatible signing interfaces and definitions
- */
-export const SIGNATURE_HEX_LENGTH = 130;
-export const SIGNATURE_BYTES_LENGTH = 65;
+})(RedundancyStrategy || (RedundancyStrategy = {}));