@ethersphere/bee-js 8.3.1 → 9.0.2

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

@@ -1,4 +1,11 @@
+import { Types } from 'cafe-utility';
+import { Duration } from "../../utils/duration.js";
 import { http } from "../../utils/http.js";
+import { Size } from "../../utils/size.js";
+import { getStampEffectiveBytes, getStampTheoreticalBytes, getStampUsage } from "../../utils/stamps.js";
+import { asNumberString } from "../../utils/type.js";
+import { BatchId, EthAddress } from "../../utils/typed-bytes.js";
+import { normalizeBatchTTL } from "../../utils/workaround.js";
 const STAMPS_ENDPOINT = 'stamps';
 const BATCHES_ENDPOINT = 'batches';
 export async function getGlobalPostageBatches(requestOptions) {
@@ -7,7 +14,40 @@ export async function getGlobalPostageBatches(requestOptions) {
     url: `${BATCHES_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.data.stamps;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const batches = Types.asArray(body.batches, {
+    name: 'batches'
+  }).map(x => Types.asObject(x, {
+    name: 'batch'
+  }));
+  return batches.map(x => ({
+    batchID: new BatchId(Types.asString(x.batchID, {
+      name: 'batchID'
+    })),
+    batchTTL: Types.asNumber(x.batchTTL, {
+      name: 'batchTTL'
+    }),
+    bucketDepth: Types.asNumber(x.bucketDepth, {
+      name: 'bucketDepth'
+    }),
+    depth: Types.asNumber(x.depth, {
+      name: 'depth'
+    }),
+    immutable: Types.asBoolean(x.immutable, {
+      name: 'immutable'
+    }),
+    owner: new EthAddress(Types.asString(x.owner, {
+      name: 'owner'
+    })),
+    start: Types.asNumber(x.start, {
+      name: 'start'
+    }),
+    value: asNumberString(x.value, {
+      name: 'value'
+    })
+  }));
 }
 export async function getAllPostageBatches(requestOptions) {
   const response = await http(requestOptions, {
@@ -15,7 +55,59 @@ export async function getAllPostageBatches(requestOptions) {
     url: `${STAMPS_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.data.stamps;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const stamps = Types.asArray(body.stamps, {
+    name: 'stamps'
+  }).map(x => Types.asObject(x, {
+    name: 'stamp'
+  }));
+  return stamps.map(x => {
+    const utilization = Types.asNumber(x.utilization, {
+      name: 'utilization'
+    });
+    const depth = Types.asNumber(x.depth, {
+      name: 'depth'
+    });
+    const bucketDepth = Types.asNumber(x.bucketDepth, {
+      name: 'bucketDepth'
+    });
+    const usage = getStampUsage(utilization, depth, bucketDepth);
+    const batchTTL = normalizeBatchTTL(Types.asNumber(x.batchTTL, {
+      name: 'batchTTL'
+    }));
+    const duration = Duration.fromSeconds(batchTTL);
+    return {
+      batchID: new BatchId(Types.asString(x.batchID, {
+        name: 'batchID'
+      })),
+      utilization,
+      usable: Types.asBoolean(x.usable, {
+        name: 'usable'
+      }),
+      label: Types.asEmptiableString(x.label, {
+        name: 'label'
+      }),
+      depth,
+      amount: asNumberString(x.amount, {
+        name: 'amount'
+      }),
+      bucketDepth,
+      blockNumber: Types.asNumber(x.blockNumber, {
+        name: 'blockNumber'
+      }),
+      immutableFlag: Types.asBoolean(x.immutableFlag, {
+        name: 'immutableFlag'
+      }),
+      usage,
+      usageText: `${Math.round(usage * 100)}%`,
+      size: Size.fromBytes(getStampEffectiveBytes(depth)),
+      remainingSize: Size.fromBytes(Math.ceil(getStampEffectiveBytes(depth) * (1 - usage))),
+      theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(depth)),
+      duration
+    };
+  });
 }
 export async function getPostageBatch(requestOptions, postageBatchId) {
   const response = await http(requestOptions, {
@@ -23,7 +115,52 @@ export async function getPostageBatch(requestOptions, postageBatchId) {
     url: `${STAMPS_ENDPOINT}/${postageBatchId}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const utilization = Types.asNumber(body.utilization, {
+    name: 'utilization'
+  });
+  const depth = Types.asNumber(body.depth, {
+    name: 'depth'
+  });
+  const bucketDepth = Types.asNumber(body.bucketDepth, {
+    name: 'bucketDepth'
+  });
+  const usage = getStampUsage(utilization, depth, bucketDepth);
+  const batchTTL = normalizeBatchTTL(Types.asNumber(body.batchTTL, {
+    name: 'batchTTL'
+  }));
+  const duration = Duration.fromSeconds(batchTTL);
+  return {
+    batchID: new BatchId(Types.asString(body.batchID, {
+      name: 'batchID'
+    })),
+    utilization,
+    usable: Types.asBoolean(body.usable, {
+      name: 'usable'
+    }),
+    label: Types.asEmptiableString(body.label, {
+      name: 'label'
+    }),
+    depth,
+    amount: asNumberString(body.amount, {
+      name: 'amount'
+    }),
+    bucketDepth,
+    blockNumber: Types.asNumber(body.blockNumber, {
+      name: 'blockNumber'
+    }),
+    immutableFlag: Types.asBoolean(body.immutableFlag, {
+      name: 'immutableFlag'
+    }),
+    usage,
+    usageText: `${Math.round(usage * 100)}%`,
+    size: Size.fromBytes(getStampEffectiveBytes(depth)),
+    remainingSize: Size.fromBytes(Math.ceil(getStampEffectiveBytes(depth) * (1 - usage))),
+    theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(depth)),
+    duration
+  };
 }
 export async function getPostageBatchBuckets(requestOptions, postageBatchId) {
   const response = await http(requestOptions, {
@@ -31,7 +168,32 @@ export async function getPostageBatchBuckets(requestOptions, postageBatchId) {
     url: `${STAMPS_ENDPOINT}/${postageBatchId}/buckets`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    depth: Types.asNumber(body.depth, {
+      name: 'depth'
+    }),
+    bucketDepth: Types.asNumber(body.bucketDepth, {
+      name: 'bucketDepth'
+    }),
+    bucketUpperBound: Types.asNumber(body.bucketUpperBound, {
+      name: 'bucketUpperBound'
+    }),
+    buckets: Types.asArray(body.buckets, {
+      name: 'buckets'
+    }).map(x => Types.asObject(x, {
+      name: 'bucket'
+    })).map(x => ({
+      bucketID: Types.asNumber(x.bucketID, {
+        name: 'bucketID'
+      }),
+      collisions: Types.asNumber(x.collisions, {
+        name: 'collisions'
+      })
+    }))
+  };
 }
 export async function createPostageBatch(requestOptions, amount, depth, options) {
   const headers = {};
@@ -50,7 +212,12 @@ export async function createPostageBatch(requestOptions, amount, depth, options)
     },
     headers
   });
-  return response.data.batchID;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return new BatchId(Types.asString(body.batchID, {
+    name: 'batchID'
+  }));
 }
 export async function topUpBatch(requestOptions, id, amount) {
   const response = await http(requestOptions, {
@@ -58,7 +225,12 @@ export async function topUpBatch(requestOptions, id, amount) {
     url: `${STAMPS_ENDPOINT}/topup/${id}/${amount}`,
     responseType: 'json'
   });
-  return response.data.batchID;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return new BatchId(Types.asString(body.batchID, {
+    name: 'batchID'
+  }));
 }
 export async function diluteBatch(requestOptions, id, depth) {
   const response = await http(requestOptions, {
@@ -66,5 +238,10 @@ export async function diluteBatch(requestOptions, id, depth) {
     url: `${STAMPS_ENDPOINT}/dilute/${id}/${depth}`,
     responseType: 'json'
   });
-  return response.data.batchID;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return new BatchId(Types.asString(body.batchID, {
+    name: 'batchID'
+  }));
 }

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

@@ -1,4 +1,8 @@
+import { Types } from 'cafe-utility';
 import { http } from "../../utils/http.js";
+import { BZZ, DAI } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+import { normalizeCurrentPrice } from "../../utils/workaround.js";
 const RESERVE_STATE_ENDPOINT = 'reservestate';
 const WALLET_ENDPOINT = 'wallet';
 const CHAIN_STATE_ENDPOINT = 'chainstate';
@@ -13,7 +17,20 @@ export async function getReserveState(requestOptions) {
     url: `${RESERVE_STATE_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    commitment: Types.asNumber(body.commitment, {
+      name: 'commitment'
+    }),
+    radius: Types.asNumber(body.radius, {
+      name: 'radius'
+    }),
+    storageRadius: Types.asNumber(body.storageRadius, {
+      name: 'storageRadius'
+    })
+  };
 }
 /**
  * Get state of reserve
@@ -26,7 +43,23 @@ export async function getChainState(requestOptions) {
     url: `${CHAIN_STATE_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    block: Types.asNumber(body.block, {
+      name: 'block'
+    }),
+    chainTip: Types.asNumber(body.chainTip, {
+      name: 'chainTip'
+    }),
+    totalAmount: asNumberString(body.totalAmount, {
+      name: 'totalAmount'
+    }),
+    currentPrice: normalizeCurrentPrice(Types.asNumber(body.currentPrice, {
+      name: 'currentPrice'
+    }))
+  };
 }
 /**
  * Get wallet balances for xDai and BZZ of the node
@@ -39,5 +72,24 @@ export async function getWalletBalance(requestOptions) {
     url: `${WALLET_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    bzzBalance: BZZ.fromPLUR(asNumberString(body.bzzBalance, {
+      name: 'bzzBalance'
+    })),
+    nativeTokenBalance: DAI.fromWei(asNumberString(body.nativeTokenBalance, {
+      name: 'nativeTokenBalance'
+    })),
+    chainID: Types.asNumber(body.chainID, {
+      name: 'chainID'
+    }),
+    chequebookContractAddress: Types.asString(body.chequebookContractAddress, {
+      name: 'chequebookContractAddress'
+    }),
+    walletAddress: Types.asString(body.walletAddress, {
+      name: 'walletAddress'
+    })
+  };
 }

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

@@ -1,9 +1,10 @@
+import { Types } from 'cafe-utility';
 import getMajorSemver from 'semver/functions/major.js';
-import { http } from "../../utils/http.js"; // Following lines bellow are automatically updated with GitHub Action when Bee version is updated
-// so if you are changing anything about them change the `update_bee` action accordingly!
-export const SUPPORTED_BEE_VERSION_EXACT = '2.2.0-06a0aca7';
-export const SUPPORTED_API_VERSION = '7.1.0';
+import { toBeeMode } from "../../types/debug.js";
+import { http } from "../../utils/http.js";
+export const SUPPORTED_BEE_VERSION_EXACT = '2.4.0-390a402e';
 export const SUPPORTED_BEE_VERSION = SUPPORTED_BEE_VERSION_EXACT.split('-')[0];
+export const SUPPORTED_API_VERSION = '7.2.0';
 const NODE_INFO_URL = 'node';
 const STATUS_URL = 'status';
 const HEALTH_URL = 'health';
@@ -14,7 +15,50 @@ export async function getDebugStatus(requestOptions) {
     url: STATUS_URL,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    overlay: Types.asString(body.overlay, {
+      name: 'overlay'
+    }),
+    proximity: Types.asNumber(body.proximity, {
+      name: 'proximity'
+    }),
+    beeMode: toBeeMode(Types.asString(body.beeMode, {
+      name: 'beeMode'
+    })),
+    reserveSize: Types.asNumber(body.reserveSize, {
+      name: 'reserveSize'
+    }),
+    reserveSizeWithinRadius: Types.asNumber(body.reserveSizeWithinRadius, {
+      name: 'reserveSizeWithinRadius'
+    }),
+    pullsyncRate: Types.asNumber(body.pullsyncRate, {
+      name: 'pullsyncRate'
+    }),
+    storageRadius: Types.asNumber(body.storageRadius, {
+      name: 'storageRadius'
+    }),
+    connectedPeers: Types.asNumber(body.connectedPeers, {
+      name: 'connectedPeers'
+    }),
+    neighborhoodSize: Types.asNumber(body.neighborhoodSize, {
+      name: 'neighborhoodSize'
+    }),
+    batchCommitment: Types.asNumber(body.batchCommitment, {
+      name: 'batchCommitment'
+    }),
+    isReachable: Types.asBoolean(body.isReachable, {
+      name: 'isReachable'
+    }),
+    lastSyncedBlock: Types.asNumber(body.lastSyncedBlock, {
+      name: 'lastSyncedBlock'
+    }),
+    committedDepth: Types.asNumber(body.committedDepth, {
+      name: 'committedDepth'
+    })
+  };
 }
 /**
  * Get health of node
@@ -27,7 +71,20 @@ export async function getHealth(requestOptions) {
     url: HEALTH_URL,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    apiVersion: Types.asString(body.apiVersion, {
+      name: 'apiVersion'
+    }),
+    version: Types.asString(body.version, {
+      name: 'version'
+    }),
+    status: Types.asString(body.status, {
+      name: 'status'
+    })
+  };
 }
 /**
  * Get readiness of node
@@ -35,15 +92,24 @@ export async function getHealth(requestOptions) {
  * @param requestOptions Options for making requests
  */
 export async function getReadiness(requestOptions) {
-  try {
-    const response = await http(requestOptions, {
-      method: 'get',
-      url: READINESS_URL
-    });
-    return response.status === 200;
-  } catch {
-    return false;
-  }
+  const response = await http(requestOptions, {
+    method: 'get',
+    url: READINESS_URL
+  });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    apiVersion: Types.asString(body.apiVersion, {
+      name: 'apiVersion'
+    }),
+    version: Types.asString(body.version, {
+      name: 'version'
+    }),
+    status: Types.asString(body.status, {
+      name: 'status'
+    })
+  };
 }
 /**
  * Get information about Bee node
@@ -56,26 +122,26 @@ export async function getNodeInfo(requestOptions) {
     url: NODE_INFO_URL,
     responseType: 'json'
   });
-  return response.data;
-}
-/**
- * Connects to a node and checks if it is a supported Bee version by the bee-js
- *
- * @param requestOptions Options for making requests
- * @returns true if the Bee node version is supported
- * @deprecated Use `isSupportedExactVersion` instead
- */
-// TODO: Remove on break
-export async function isSupportedVersion(requestOptions) {
-  return isSupportedExactVersion(requestOptions);
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    beeMode: toBeeMode(Types.asString(body.beeMode, {
+      name: 'beeMode'
+    })),
+    chequebookEnabled: Types.asBoolean(body.chequebookEnabled, {
+      name: 'chequebookEnabled'
+    }),
+    swapEnabled: Types.asBoolean(body.swapEnabled, {
+      name: 'swapEnabled'
+    })
+  };
 }
 /**
  * Connects to a node and checks if its version matches with the one that bee-js supports.
  *
- * Be aware that this is the most strict version check and most probably
- * you will want to use more relaxed API-versions based checks like
- * `isSupportedApiVersion`, `isSupportedMainApiVersion` or `isSupportedDebugApiVersion`
- * based on your use-case.
+ * This is the most strict version check and most probably you will
+ * want to use the relaxed API-versions check `isSupportedApiVersion`.
  *
  * @param requestOptions Options for making requests
  */
@@ -85,20 +151,6 @@ export async function isSupportedExactVersion(requestOptions) {
   } = await getHealth(requestOptions);
   return version === SUPPORTED_BEE_VERSION_EXACT;
 }
-/**
- * Connects to a node and checks if its main's API version matches with the one that bee-js supports.
- *
- * This is useful if you are not using `Bee` class (for anything else then this check)
- * and want to make sure about compatibility.
- *
- * @param requestOptions Options for making requests
- */
-export async function isSupportedMainApiVersion(requestOptions) {
-  const {
-    apiVersion
-  } = await getHealth(requestOptions);
-  return getMajorSemver(apiVersion) === getMajorSemver(SUPPORTED_API_VERSION);
-}
 /**
  * Connects to a node and checks if its Main API versions matches with the one that bee-js supports.
  *

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

@@ -1,4 +1,7 @@
+import { Types } from 'cafe-utility';
 import { http } from "../../utils/http.js";
+import { asNumberString } from "../../utils/type.js";
+import { TransactionId } from "../../utils/typed-bytes.js";
 const transactionsEndpoint = 'transactions';
 /**
  * Get list of all pending transactions
@@ -10,7 +13,13 @@ export async function getAllTransactions(requestOptions) {
     url: transactionsEndpoint,
     responseType: 'json'
   });
-  return response.data.pendingTransactions;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const pendingTransactions = Types.asArray(body.pendingTransactions, {
+    name: 'pendingTransactions'
+  });
+  return pendingTransactions.map(toTransaction);
 }
 /**
  * Get information for specific pending transactions
@@ -23,7 +32,44 @@ export async function getTransaction(requestOptions, transactionHash) {
     url: `${transactionsEndpoint}/${transactionHash}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return toTransaction(body);
+}
+function toTransaction(value) {
+  const object = Types.asObject(value, {
+    name: 'transaction'
+  });
+  return {
+    transactionHash: new TransactionId(Types.asString(object.transactionHash, {
+      name: 'transactionHash'
+    })),
+    to: Types.asString(object.to, {
+      name: 'to'
+    }),
+    nonce: Types.asNumber(object.nonce, {
+      name: 'nonce'
+    }),
+    gasPrice: asNumberString(object.gasPrice, {
+      name: 'gasPrice'
+    }),
+    gasLimit: Types.asNumber(object.gasLimit, {
+      name: 'gasLimit'
+    }),
+    data: Types.asString(object.data, {
+      name: 'data'
+    }),
+    created: Types.asString(object.created, {
+      name: 'created'
+    }),
+    description: Types.asString(object.description, {
+      name: 'description'
+    }),
+    value: asNumberString(object.value, {
+      name: 'value'
+    })
+  };
 }
 /**
  * Rebroadcast existing transaction
@@ -37,7 +83,12 @@ export async function rebroadcastTransaction(requestOptions, transactionHash) {
     url: `${transactionsEndpoint}/${transactionHash}`,
     responseType: 'json'
   });
-  return response.data.transactionHash;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return new TransactionId(Types.asString(body.transactionHash, {
+    name: 'transactionHash'
+  }));
 }
 /**
  * Cancel existing transaction
@@ -49,7 +100,7 @@ export async function rebroadcastTransaction(requestOptions, transactionHash) {
 export async function cancelTransaction(requestOptions, transactionHash, gasPrice) {
   const headers = {};
   if (gasPrice) {
-    headers['gas-price'] = gasPrice;
+    headers['gas-price'] = gasPrice.toString();
   }
   const response = await http(requestOptions, {
     method: 'delete',
@@ -57,5 +108,10 @@ export async function cancelTransaction(requestOptions, transactionHash, gasPric
     url: `${transactionsEndpoint}/${transactionHash}`,
     responseType: 'json'
   });
-  return response.data.transactionHash;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return new TransactionId(Types.asString(body.transactionHash, {
+    name: 'transactionHash'
+  }));
 }

package/dist/mjs/modules/envelope.js

@@ -2,32 +2,34 @@ import { Binary, Types } from 'cafe-utility';
 import { http } from "../utils/http.js";
 const ENVELOPE_ENDPOINT = 'envelope';
 export async function postEnvelope(requestOptions, postageBatchId, reference) {
-  const {
-    data
-  } = await http(requestOptions, {
+  const response = await http(requestOptions, {
     method: 'post',
     responseType: 'json',
     url: `${ENVELOPE_ENDPOINT}/${reference}`,
     headers: {
-      'swarm-postage-batch-id': postageBatchId
+      'swarm-postage-batch-id': postageBatchId.toHex()
     }
   });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
-    issuer: Binary.hexToUint8Array(Types.asHexString(data.issuer, {
+    issuer: Binary.hexToUint8Array(Types.asHexString(body.issuer, {
       name: 'issuer',
       byteLength: 20
     })),
-    index: Binary.hexToUint8Array(Types.asHexString(data.index, {
+    index: Binary.hexToUint8Array(Types.asHexString(body.index, {
       name: 'index',
       byteLength: 8
     })),
-    timestamp: Binary.hexToUint8Array(Types.asHexString(data.timestamp, {
+    timestamp: Binary.hexToUint8Array(Types.asHexString(body.timestamp, {
       name: 'timestamp',
       byteLength: 8
     })),
-    signature: Binary.hexToUint8Array(Types.asHexString(data.signature, {
+    signature: Binary.hexToUint8Array(Types.asHexString(body.signature, {
       name: 'signature',
       byteLength: 65
-    }))
+    })),
+    batchId: postageBatchId
   };
 }