@ethersphere/bee-js 1.2.1 → 3.0.0

package/src/modules/debug/balance.ts

@@ -1,63 +0,0 @@
-import { safeAxios } from '../../utils/safe-axios'
-import { PeerBalance, BalanceResponse } from '../../types'
-
-const balancesEndpoint = '/balances'
-const consumedEndpoint = '/consumed'
-
-/**
- * Get the balances with all known peers including prepaid services
- *
- * @param url Bee debug url
- */
-export async function getAllBalances(url: string): Promise<BalanceResponse> {
-  const response = await safeAxios<BalanceResponse>({
-    url: url + balancesEndpoint,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the balances with a specific peer including prepaid services
- *
- * @param url     Bee debug url
- * @param address Swarm address of peer
- */
-export async function getPeerBalance(url: string, address: string): Promise<PeerBalance> {
-  const response = await safeAxios<PeerBalance>({
-    url: url + `${balancesEndpoint}/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the past due consumption balances with all known peers
- *
- * @param url Bee debug url
- */
-export async function getPastDueConsumptionBalances(url: string): Promise<BalanceResponse> {
-  const response = await safeAxios<BalanceResponse>({
-    url: url + consumedEndpoint,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the past due consumption balance with a specific peer
- *
- * @param url     Bee debug url
- * @param address Swarm address of peer
- */
-export async function getPastDueConsumptionPeerBalance(url: string, address: string): Promise<PeerBalance> {
-  const response = await safeAxios<PeerBalance>({
-    url: url + `${consumedEndpoint}/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/chequebook.ts

@@ -1,174 +0,0 @@
-import { safeAxios } from '../../utils/safe-axios'
-import type {
-  ChequebookAddressResponse,
-  ChequebookBalanceResponse,
-  LastCashoutActionResponse,
-  TransactionResponse,
-  LastChequesForPeerResponse,
-  LastChequesResponse,
-  NumberString,
-  TransactionHash,
-} from '../../types'
-import { CashoutOptions } from '../../types'
-
-const chequebookEndpoint = '/chequebook'
-
-/**
- * Get the address of the chequebook contract used
- *
- * @param url Bee debug url
- */
-export async function getChequebookAddress(url: string): Promise<ChequebookAddressResponse> {
-  const response = await safeAxios<ChequebookAddressResponse>({
-    url: url + chequebookEndpoint + '/address',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the balance of the chequebook
- *
- * @param url Bee debug url
- */
-export async function getChequebookBalance(url: string): Promise<ChequebookBalanceResponse> {
-  const response = await safeAxios<ChequebookBalanceResponse>({
-    url: url + chequebookEndpoint + '/balance',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get last cashout action for the peer
- *
- * @param url   Bee debug url
- * @param peer  Swarm address of peer
- */
-export async function getLastCashoutAction(url: string, peer: string): Promise<LastCashoutActionResponse> {
-  const response = await safeAxios<LastCashoutActionResponse>({
-    url: url + chequebookEndpoint + `/cashout/${peer}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Cashout the last cheque for the peer
- *
- * @param url   Bee debug url
- * @param peer  Swarm address of peer
- * @param options
- */
-export async function cashoutLastCheque(url: string, peer: string, options?: CashoutOptions): Promise<TransactionHash> {
-  const headers: Record<string, string> = {}
-
-  if (options?.gasPrice) {
-    headers['gas-price'] = options.gasPrice.toString()
-  }
-
-  if (options?.gasLimit) {
-    headers['gas-limit'] = options.gasLimit.toString()
-  }
-
-  const response = await safeAxios<TransactionResponse>({
-    method: 'post',
-    url: url + chequebookEndpoint + `/cashout/${peer}`,
-    responseType: 'json',
-    headers,
-  })
-
-  return response.data.transactionHash
-}
-
-/**
- * Get last cheques for the peer
- *
- * @param url   Bee debug url
- * @param peer  Swarm address of peer
- */
-export async function getLastChequesForPeer(url: string, peer: string): Promise<LastChequesForPeerResponse> {
-  const response = await safeAxios<LastChequesForPeerResponse>({
-    url: url + chequebookEndpoint + `/cheque/${peer}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get last cheques for all peers
- *
- * @param url   Bee debug url
- */
-export async function getLastCheques(url: string): Promise<LastChequesResponse> {
-  const response = await safeAxios<LastChequesResponse>({
-    url: url + chequebookEndpoint + '/cheque',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Deposit tokens from overlay address into chequebook
- *
- * @param url      Bee debug url
- * @param amount   Amount of tokens to deposit
- * @param gasPrice Gas Price in WEI for the transaction call
- * @return string  Hash of the transaction
- */
-export async function depositTokens(
-  url: string,
-  amount: number | NumberString,
-  gasPrice?: NumberString,
-): Promise<TransactionHash> {
-  const headers: Record<string, string> = {}
-
-  if (gasPrice) {
-    headers['gas-price'] = gasPrice.toString()
-  }
-
-  const response = await safeAxios<TransactionResponse>({
-    method: 'post',
-    url: url + chequebookEndpoint + '/deposit',
-    responseType: 'json',
-    params: { amount: amount.toString(10) },
-    headers,
-  })
-
-  return response.data.transactionHash
-}
-
-/**
- * Withdraw tokens from the chequebook to the overlay address
- *
- * @param url      Bee debug url
- * @param amount   Amount of tokens to withdraw
- * @param gasPrice Gas Price in WEI for the transaction call
- * @return string  Hash of the transaction
- */
-export async function withdrawTokens(
-  url: string,
-  amount: number | NumberString,
-  gasPrice?: NumberString,
-): Promise<TransactionHash> {
-  const headers: Record<string, string> = {}
-
-  if (gasPrice) {
-    headers['gas-price'] = gasPrice.toString()
-  }
-
-  const response = await safeAxios<TransactionResponse>({
-    method: 'post',
-    url: url + chequebookEndpoint + '/withdraw',
-    responseType: 'json',
-    params: { amount: amount.toString(10) },
-    headers,
-  })
-
-  return response.data.transactionHash
-}

package/src/modules/debug/chunk.ts

@@ -1,39 +0,0 @@
-import { BeeGenericResponse } from '../../types'
-import { safeAxios } from '../../utils/safe-axios'
-
-const endpoint = '/chunks'
-
-/**
- * Check if chunk at address exists locally
- *
- * @param url      Bee debug url
- * @param address  Swarm address of chunk
- *
- * @returns BeeGenericResponse if chunk is found or throws an exception
- */
-export async function checkIfChunkExistsLocally(url: string, address: string): Promise<BeeGenericResponse> {
-  const response = await safeAxios<BeeGenericResponse>({
-    url: url + endpoint + `/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Delete a chunk from local storage
- *
- * @param url      Bee debug url
- * @param address  Swarm address of chunk
- *
- * @returns BeeGenericResponse if chunk was deleted or throws an exception
- */
-export async function deleteChunkFromLocalStorage(url: string, address: string): Promise<BeeGenericResponse> {
-  const response = await safeAxios<BeeGenericResponse>({
-    method: 'delete',
-    url: url + endpoint + `/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/connectivity.ts

@@ -1,61 +0,0 @@
-import { safeAxios } from '../../utils/safe-axios'
-import type { NodeAddresses, Peer, PingResponse, RemovePeerResponse, Topology } from '../../types'
-
-export async function getNodeAddresses(url: string): Promise<NodeAddresses> {
-  const response = await safeAxios<NodeAddresses>({
-    url: url + '/addresses',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-interface Peers {
-  peers: Peer[]
-}
-
-export async function getPeers(url: string): Promise<Peer[]> {
-  const response = await safeAxios<Peers>({
-    url: url + '/peers',
-    responseType: 'json',
-  })
-
-  return response.data.peers || []
-}
-
-export async function getBlocklist(url: string): Promise<Peer[]> {
-  const response = await safeAxios<Peers>({
-    url: url + '/blocklist',
-    responseType: 'json',
-  })
-
-  return response.data.peers || []
-}
-
-export async function removePeer(url: string, peer: string): Promise<RemovePeerResponse> {
-  const response = await safeAxios<RemovePeerResponse>({
-    url: `${url}/peers/${peer}`,
-    responseType: 'json',
-    method: 'DELETE',
-  })
-
-  return response.data
-}
-
-export async function getTopology(url: string): Promise<Topology> {
-  const response = await safeAxios<Topology>({
-    url: `${url}/topology`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-export async function pingPeer(url: string, peer: string): Promise<PingResponse> {
-  const response = await safeAxios<PingResponse>({
-    url: `${url}/pingpong/${peer}`,
-    responseType: 'json',
-    method: 'POST',
-  })
-
-  return response.data
-}

package/src/modules/debug/settlements.ts

@@ -1,33 +0,0 @@
-import { safeAxios } from '../../utils/safe-axios'
-import { Settlements, AllSettlements } from '../../types'
-
-const settlementsEndpoint = '/settlements'
-
-/**
- * Get amount of sent and received from settlements with a peer
- *
- * @param url   Bee debug url
- * @param peer  Swarm address of peer
- */
-export async function getSettlements(url: string, peer: string): Promise<Settlements> {
-  const response = await safeAxios<Settlements>({
-    url: url + `${settlementsEndpoint}/${peer}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get settlements with all known peers and total amount sent or received
- *
- * @param url   Bee debug url
- */
-export async function getAllSettlements(url: string): Promise<AllSettlements> {
-  const response = await safeAxios<AllSettlements>({
-    url: url + settlementsEndpoint,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/stamps.ts

@@ -1,69 +0,0 @@
-import { BatchId, DebugPostageBatch, NumberString, PostageBatchBuckets, PostageBatchOptions } from '../../types'
-import { safeAxios } from '../../utils/safe-axios'
-
-const STAMPS_ENDPOINT = '/stamps'
-
-interface GetAllStampsResponse {
-  stamps: DebugPostageBatch[]
-}
-
-interface CreateStampResponse {
-  batchID: BatchId
-}
-
-export async function getAllPostageBatches(url: string): Promise<DebugPostageBatch[]> {
-  const response = await safeAxios<GetAllStampsResponse>({
-    method: 'get',
-    url: `${url}${STAMPS_ENDPOINT}`,
-    responseType: 'json',
-  })
-
-  return response.data.stamps || []
-}
-
-export async function getPostageBatch(url: string, postageBatchId: BatchId): Promise<DebugPostageBatch> {
-  const response = await safeAxios<DebugPostageBatch>({
-    method: 'get',
-    url: `${url}${STAMPS_ENDPOINT}/${postageBatchId}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-export async function getPostageBatchBuckets(url: string, postageBatchId: BatchId): Promise<PostageBatchBuckets> {
-  const response = await safeAxios<PostageBatchBuckets>({
-    method: 'get',
-    url: `${url}${STAMPS_ENDPOINT}/${postageBatchId}/buckets`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-export async function createPostageBatch(
-  url: string,
-  amount: NumberString,
-  depth: number,
-  options?: PostageBatchOptions,
-): Promise<BatchId> {
-  const headers: Record<string, string> = {}
-
-  if (options?.gasPrice) {
-    headers['gas-price'] = options.gasPrice.toString()
-  }
-
-  if (options?.immutableFlag !== undefined) {
-    headers.immutable = String(options.immutableFlag)
-  }
-
-  const response = await safeAxios<CreateStampResponse>({
-    method: 'post',
-    url: `${url}${STAMPS_ENDPOINT}/${amount}/${depth}`,
-    responseType: 'json',
-    params: { label: options?.label },
-    headers,
-  })
-
-  return response.data.batchID
-}

package/src/modules/debug/states.ts

@@ -1,35 +0,0 @@
-import { safeAxios } from '../../utils/safe-axios'
-import { ChainState, ReserveState } from '../../types'
-
-const RESERVE_STATE_ENDPOINT = '/reservestate'
-const CHAIN_STATE_ENDPOINT = '/chainstate'
-
-/**
- * Get state of reserve
- *
- * @param url Bee debug URL
- */
-export async function getReserveState(url: string): Promise<ReserveState> {
-  const response = await safeAxios<ReserveState>({
-    method: 'get',
-    url: `${url}${RESERVE_STATE_ENDPOINT}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get state of reserve
- *
- * @param url Bee debug URL
- */
-export async function getChainState(url: string): Promise<ChainState> {
-  const response = await safeAxios<ChainState>({
-    method: 'get',
-    url: `${url}${CHAIN_STATE_ENDPOINT}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/status.ts

@@ -1,34 +0,0 @@
-import { safeAxios } from '../../utils/safe-axios'
-import type { Health } from '../../types/debug'
-import { engines } from '../../../package.json'
-export const SUPPORTED_BEE_VERSION_EXACT = engines.bee
-export const SUPPORTED_BEE_VERSION = engines.bee.substr(0, engines.bee.indexOf('-'))
-
-/**
- * Get health of node
- *
- * @param url Bee debug URL
- */
-export async function getHealth(url: string): Promise<Health> | never {
-  const response = await safeAxios<Health>({
-    method: 'get',
-    url: `${url}/health`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Connnects to a node and checks if it is a supported Bee version by the bee-js
- *
- * @param url Bee debug URL
- *
- * @returns true if the Bee node version is supported
- */
-export async function isSupportedVersion(url: string): Promise<boolean> | never {
-  const { version } = await getHealth(url)
-
-  // TODO: Remove this workaround when new Bee version is out https://github.com/ethersphere/bee-js/issues/400
-  return version === SUPPORTED_BEE_VERSION_EXACT || version === '1.1.0-dev'
-}

package/src/modules/debug/tag.ts

@@ -1,19 +0,0 @@
-import { ExtendedTag } from '../../types'
-import { safeAxios } from '../../utils/safe-axios'
-
-const endpoint = '/tags'
-
-/**
- * Retrieve tag with extended information from Bee node
- *
- * @param url Bee tag URL
- * @param uid UID of tag to be retrieved
- */
-export async function retrieveExtendedTag(url: string, uid: number): Promise<ExtendedTag> {
-  const response = await safeAxios<ExtendedTag>({
-    url: `${url}${endpoint}/${uid}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/transactions.ts

@@ -1,79 +0,0 @@
-import { safeAxios } from '../../utils/safe-axios'
-import { NumberString, TransactionHash, TransactionInfo } from '../../types'
-
-const transactionsEndpoint = '/transactions'
-
-interface PendingTransactionsResponse {
-  pendingTransactions: TransactionInfo[]
-}
-
-interface TransactionResponse {
-  transactionHash: TransactionHash
-}
-
-/**
- * Get list of all pending transactions
- *
- * @param url   Bee debug url
- */
-export async function getAllTransactions(url: string): Promise<TransactionInfo[]> {
-  const response = await safeAxios<PendingTransactionsResponse>({
-    url: `${url}${transactionsEndpoint}`,
-    responseType: 'json',
-  })
-
-  return response.data.pendingTransactions
-}
-
-/**
- * Get information for specific pending transactions
- *
- * @param url   Bee debug url
- * @param transactionHash Hash of the transaction
- */
-export async function getTransaction(url: string, transactionHash: TransactionHash): Promise<TransactionInfo> {
-  const response = await safeAxios<TransactionInfo>({
-    url: `${url}${transactionsEndpoint}/${transactionHash}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Rebroadcast existing transaction
- *
- * @param url   Bee debug url
- * @param transactionHash Hash of the transaction
- */
-export async function rebroadcastTransaction(url: string, transactionHash: TransactionHash): Promise<TransactionHash> {
-  const response = await safeAxios<TransactionResponse>({
-    method: 'post',
-    url: `${url}${transactionsEndpoint}/${transactionHash}`,
-    responseType: 'json',
-  })
-
-  return response.data.transactionHash
-}
-
-/**
- * Cancel existing transaction
- *
- * @param url   Bee debug url
- * @param transactionHash Hash of the transaction
- * @param gasPrice Optional gas price
- */
-export async function cancelTransaction(
-  url: string,
-  transactionHash: TransactionHash,
-  gasPrice?: NumberString,
-): Promise<TransactionHash> {
-  const response = await safeAxios<TransactionResponse>({
-    method: 'delete',
-    headers: { 'gas-price': gasPrice },
-    url: `${url}${transactionsEndpoint}/${transactionHash}`,
-    responseType: 'json',
-  })
-
-  return response.data.transactionHash
-}

package/src/modules/feed.ts

@@ -1,92 +0,0 @@
-import { BatchId, Dictionary, Reference, ReferenceResponse, Topic } from '../types'
-import { safeAxios } from '../utils/safe-axios'
-import { FeedType } from '../feed/type'
-import { HexEthAddress } from '../utils/eth'
-import { extractUploadHeaders } from '../utils/headers'
-
-const feedEndpoint = '/feeds'
-
-export interface CreateFeedOptions {
-  type?: FeedType
-}
-
-export interface FeedUpdateOptions {
-  /**
-   * Specifies the start date as unix time stamp
-   */
-  at?: number
-  /**
-   * Can be 'epoch' or 'sequence' (default: 'sequence')
-   */
-  type?: FeedType
-}
-
-interface FeedUpdateHeaders {
-  feedIndex: string
-  feedIndexNext: string
-}
-export interface FetchFeedUpdateResponse extends ReferenceResponse, FeedUpdateHeaders {}
-
-/**
- * Create an initial feed root manifest
- *
- * @param url             Bee URL
- * @param owner           Owner's ethereum address in hex
- * @param topic           Topic in hex
- * @param postageBatchId  Postage BatchId to be used to create the Feed Manifest
- * @param options         Additional options, like type (default: 'sequence')
- */
-export async function createFeedManifest(
-  url: string,
-  owner: HexEthAddress,
-  topic: Topic,
-  postageBatchId: BatchId,
-  options?: CreateFeedOptions,
-): Promise<Reference> {
-  const response = await safeAxios<ReferenceResponse>({
-    method: 'post',
-    url: `${url}${feedEndpoint}/${owner}/${topic}`,
-    params: options,
-    headers: extractUploadHeaders(postageBatchId),
-  })
-
-  return response.data.reference
-}
-
-function readFeedUpdateHeaders(headers: Dictionary<string>): FeedUpdateHeaders {
-  return {
-    feedIndex: headers['swarm-feed-index'],
-    feedIndexNext: headers['swarm-feed-index-next'],
-  }
-}
-
-/**
- * Find and retrieve feed update
- *
- * The feed consists of updates. This endpoint looks up an
- * update that matches the provided parameters and returns
- * the reference it contains along with its index and the
- * index of the subsequent update.
- *
- * @param url         Bee URL
- * @param owner       Owner's ethereum address in hex
- * @param topic       Topic in hex
- * @param options     Additional options, like index, at, type
- */
-export async function fetchFeedUpdate(
-  url: string,
-  owner: HexEthAddress,
-  topic: Topic,
-  options?: FeedUpdateOptions,
-): Promise<FetchFeedUpdateResponse> {
-  const response = await safeAxios<ReferenceResponse>({
-    url: `${url}${feedEndpoint}/${owner}/${topic}`,
-    params: options,
-  })
-  const findFeedUpdateResponse = {
-    ...response.data,
-    ...readFeedUpdateHeaders(response.headers),
-  }
-
-  return findFeedUpdateResponse
-}