@ethersphere/bee-js 8.3.1 → 9.0.2

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

@@ -1,4 +1,7 @@
+import { Types } from 'cafe-utility';
 import { http } from "../../utils/http.js";
+import { BZZ } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
 const balancesEndpoint = 'balances';
 const consumedEndpoint = 'consumed';
 /**
@@ -11,7 +14,24 @@ export async function getAllBalances(requestOptions) {
     url: balancesEndpoint,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const balances = Types.asArray(body.balances, {
+    name: 'balances'
+  }).map(x => Types.asObject(x, {
+    name: 'balance'
+  }));
+  return {
+    balances: balances.map(x => ({
+      peer: Types.asString(x.peer, {
+        name: 'peer'
+      }),
+      balance: BZZ.fromPLUR(asNumberString(x.balance, {
+        name: 'balance'
+      }))
+    }))
+  };
 }
 /**
  * Get the balances with a specific peer including prepaid services
@@ -24,7 +44,17 @@ export async function getPeerBalance(requestOptions, address) {
     url: `${balancesEndpoint}/${address}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    peer: Types.asString(body.peer, {
+      name: 'peer'
+    }),
+    balance: BZZ.fromPLUR(asNumberString(body.balance, {
+      name: 'balance'
+    }))
+  };
 }
 /**
  * Get the past due consumption balances with all known peers
@@ -36,7 +66,24 @@ export async function getPastDueConsumptionBalances(requestOptions) {
     url: consumedEndpoint,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const balances = Types.asArray(body.balances, {
+    name: 'balances'
+  }).map(x => Types.asObject(x, {
+    name: 'balance'
+  }));
+  return {
+    balances: balances.map(x => ({
+      peer: Types.asString(x.peer, {
+        name: 'peer'
+      }),
+      balance: BZZ.fromPLUR(asNumberString(x.balance, {
+        name: 'balance'
+      }))
+    }))
+  };
 }
 /**
  * Get the past due consumption balance with a specific peer
@@ -49,5 +96,15 @@ export async function getPastDueConsumptionPeerBalance(requestOptions, address)
     url: `${consumedEndpoint}/${address}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    peer: Types.asString(body.peer, {
+      name: 'peer'
+    }),
+    balance: BZZ.fromPLUR(asNumberString(body.balance, {
+      name: 'balance'
+    }))
+  };
 }

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

@@ -1,4 +1,9 @@
+import { Types } from 'cafe-utility';
+import { prepareRequestHeaders } from "../../utils/headers.js";
 import { http } from "../../utils/http.js";
+import { BZZ } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+import { EthAddress, TransactionId } from "../../utils/typed-bytes.js";
 const chequebookEndpoint = 'chequebook';
 /**
  * Get the address of the chequebook contract used
@@ -10,7 +15,14 @@ export async function getChequebookAddress(requestOptions) {
     url: chequebookEndpoint + '/address',
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    chequebookAddress: Types.asString(body.chequebookAddress, {
+      name: 'chequebookAddress'
+    })
+  };
 }
 /**
  * Get the balance of the chequebook
@@ -22,7 +34,17 @@ export async function getChequebookBalance(requestOptions) {
     url: chequebookEndpoint + '/balance',
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    availableBalance: BZZ.fromPLUR(asNumberString(body.availableBalance, {
+      name: 'availableBalance'
+    })),
+    totalBalance: BZZ.fromPLUR(asNumberString(body.totalBalance, {
+      name: 'totalBalance'
+    }))
+  };
 }
 /**
  * Get last cashout action for the peer
@@ -35,7 +57,20 @@ export async function getLastCashoutAction(requestOptions, peer) {
     url: chequebookEndpoint + `/cashout/${peer}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    peer: Types.asString(body.peer, {
+      name: 'peer'
+    }),
+    uncashedAmount: BZZ.fromPLUR(asNumberString(body.uncashedAmount, {
+      name: 'uncashedAmount'
+    })),
+    transactionHash: Types.asNullableString(body.transactionHash),
+    lastCashedCheque: Types.asNullable(x => asCheque(x), body.lastCashedCheque),
+    result: Types.asNullable(x => asCashoutResult(x), body.result)
+  };
 }
 /**
  * Cashout the last cheque for the peer
@@ -45,20 +80,18 @@ export async function getLastCashoutAction(requestOptions, peer) {
  * @param options
  */
 export async function cashoutLastCheque(requestOptions, peer, options) {
-  const headers = {};
-  if (options?.gasPrice) {
-    headers['gas-price'] = options.gasPrice.toString();
-  }
-  if (options?.gasLimit) {
-    headers['gas-limit'] = options.gasLimit.toString();
-  }
   const response = await http(requestOptions, {
     method: 'post',
     url: chequebookEndpoint + `/cashout/${peer}`,
     responseType: 'json',
-    headers
+    headers: prepareRequestHeaders(null, options)
+  });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
   });
-  return response.data.transactionHash;
+  return new TransactionId(Types.asString(body.transactionHash, {
+    name: 'transactionHash'
+  }));
 }
 /**
  * Get last cheques for the peer
@@ -71,7 +104,16 @@ export async function getLastChequesForPeer(requestOptions, peer) {
     url: chequebookEndpoint + `/cheque/${peer}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    peer: Types.asString(body.peer, {
+      name: 'peer'
+    }),
+    lastreceived: Types.asNullable(x => asCheque(x), body.lastreceived),
+    lastsent: Types.asNullable(x => asCheque(x), body.lastsent)
+  };
 }
 /**
  * Get last cheques for all peers
@@ -83,7 +125,55 @@ export async function getLastCheques(requestOptions) {
     url: chequebookEndpoint + '/cheque',
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const lastcheques = Types.asArray(body.lastcheques, {
+    name: 'lastcheques'
+  }).map(x => Types.asObject(x, {
+    name: 'lastcheque'
+  }));
+  return {
+    lastcheques: lastcheques.map(x => ({
+      peer: Types.asString(x.peer, {
+        name: 'peer'
+      }),
+      lastreceived: Types.asNullable(y => asCheque(y), x.lastreceived),
+      lastsent: Types.asNullable(y => asCheque(y), x.lastsent)
+    }))
+  };
+}
+function asCheque(x) {
+  const object = Types.asObject(x, {
+    name: 'cheque'
+  });
+  return {
+    beneficiary: new EthAddress(Types.asString(object.beneficiary, {
+      name: 'beneficiary'
+    })),
+    chequebook: new EthAddress(Types.asString(object.chequebook, {
+      name: 'chequebook'
+    })),
+    payout: BZZ.fromPLUR(asNumberString(object.payout, {
+      name: 'payout'
+    }))
+  };
+}
+function asCashoutResult(x) {
+  const object = Types.asObject(x, {
+    name: 'cashout result'
+  });
+  return {
+    recipient: Types.asString(object.recipient, {
+      name: 'recipient'
+    }),
+    lastPayout: BZZ.fromPLUR(asNumberString(object.lastPayout, {
+      name: 'lastPayout'
+    })),
+    bounced: Types.asBoolean(object.bounced, {
+      name: 'bounced'
+    })
+  };
 }
 /**
  * Deposit tokens from overlay address into chequebook
@@ -107,7 +197,12 @@ export async function depositTokens(requestOptions, amount, gasPrice) {
     },
     headers
   });
-  return response.data.transactionHash;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return new TransactionId(Types.asString(body.transactionHash, {
+    name: 'transactionHash'
+  }));
 }
 /**
  * Withdraw tokens from the chequebook to the overlay address
@@ -131,5 +226,10 @@ export async function withdrawTokens(requestOptions, amount, gasPrice) {
     },
     headers
   });
-  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/debug/connectivity.js

@@ -1,17 +1,56 @@
+import { Types } from 'cafe-utility';
 import { http } from "../../utils/http.js";
+import { EthAddress, PeerAddress, PublicKey } from "../../utils/typed-bytes.js";
 export async function getNodeAddresses(requestOptions) {
   const response = await http(requestOptions, {
     url: 'addresses',
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    overlay: new PeerAddress(Types.asString(body.overlay, {
+      name: 'overlay'
+    })),
+    underlay: Types.asArray(body.underlay, {
+      name: 'underlay'
+    }).map(x => Types.asString(x, {
+      name: 'underlay'
+    })),
+    ethereum: new EthAddress(Types.asString(body.ethereum, {
+      name: 'ethereum'
+    })),
+    publicKey: new PublicKey(Types.asString(body.publicKey, {
+      name: 'publicKey'
+    })),
+    pssPublicKey: new PublicKey(Types.asString(body.pssPublicKey, {
+      name: 'pssPublicKey'
+    }))
+  };
 }
 export async function getPeers(requestOptions) {
   const response = await http(requestOptions, {
     url: 'peers',
     responseType: 'json'
   });
-  return response.data.peers;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return Types.asArray(body.peers, {
+    name: 'peers'
+  }).map(x => ({
+    address: Types.asString(Types.asObject(x, {
+      name: 'peer'
+    }).address, {
+      name: 'address'
+    }),
+    fullNode: Types.asBoolean(Types.asObject(x, {
+      name: 'peer'
+    }).fullNode, {
+      name: 'fullNode'
+    })
+  }));
 }
 export async function getBlocklist(requestOptions) {
   const response = await http(requestOptions, {
@@ -33,7 +72,72 @@ export async function getTopology(requestOptions) {
     url: `topology`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const bins = Types.asObject(body.bins, {
+    name: 'bins'
+  });
+  return {
+    baseAddr: Types.asString(body.baseAddr, {
+      name: 'baseAddr'
+    }),
+    population: Types.asNumber(body.population, {
+      name: 'population'
+    }),
+    connected: Types.asNumber(body.connected, {
+      name: 'connected'
+    }),
+    timestamp: Types.asString(body.timestamp, {
+      name: 'timestamp'
+    }),
+    nnLowWatermark: Types.asNumber(body.nnLowWatermark, {
+      name: 'nnLowWatermark'
+    }),
+    depth: Types.asNumber(body.depth, {
+      name: 'depth'
+    }),
+    reachability: Types.asString(body.reachability, {
+      name: 'reachability'
+    }),
+    networkAvailability: Types.asString(body.networkAvailability, {
+      name: 'networkAvailability'
+    }),
+    bins: {
+      bin_0: asBin(bins.bin_0, 'bin_0'),
+      bin_1: asBin(bins.bin_1, 'bin_1'),
+      bin_2: asBin(bins.bin_2, 'bin_2'),
+      bin_3: asBin(bins.bin_3, 'bin_3'),
+      bin_4: asBin(bins.bin_4, 'bin_4'),
+      bin_5: asBin(bins.bin_5, 'bin_5'),
+      bin_6: asBin(bins.bin_6, 'bin_6'),
+      bin_7: asBin(bins.bin_7, 'bin_7'),
+      bin_8: asBin(bins.bin_8, 'bin_8'),
+      bin_9: asBin(bins.bin_9, 'bin_9'),
+      bin_10: asBin(bins.bin_10, 'bin_10'),
+      bin_11: asBin(bins.bin_11, 'bin_11'),
+      bin_12: asBin(bins.bin_12, 'bin_12'),
+      bin_13: asBin(bins.bin_13, 'bin_13'),
+      bin_14: asBin(bins.bin_14, 'bin_14'),
+      bin_15: asBin(bins.bin_15, 'bin_15'),
+      bin_16: asBin(bins.bin_16, 'bin_16'),
+      bin_17: asBin(bins.bin_17, 'bin_17'),
+      bin_18: asBin(bins.bin_18, 'bin_18'),
+      bin_19: asBin(bins.bin_19, 'bin_19'),
+      bin_20: asBin(bins.bin_20, 'bin_20'),
+      bin_21: asBin(bins.bin_21, 'bin_21'),
+      bin_22: asBin(bins.bin_22, 'bin_22'),
+      bin_23: asBin(bins.bin_23, 'bin_23'),
+      bin_24: asBin(bins.bin_24, 'bin_24'),
+      bin_25: asBin(bins.bin_25, 'bin_25'),
+      bin_26: asBin(bins.bin_26, 'bin_26'),
+      bin_27: asBin(bins.bin_27, 'bin_27'),
+      bin_28: asBin(bins.bin_28, 'bin_28'),
+      bin_29: asBin(bins.bin_29, 'bin_29'),
+      bin_30: asBin(bins.bin_30, 'bin_30'),
+      bin_31: asBin(bins.bin_31, 'bin_31')
+    }
+  };
 }
 export async function pingPeer(requestOptions, peer) {
   const response = await http(requestOptions, {
@@ -42,4 +146,41 @@ export async function pingPeer(requestOptions, peer) {
     method: 'POST'
   });
   return response.data;
+}
+export function asBin(value, name) {
+  const bin = Types.asObject(value, {
+    name
+  });
+  if (!bin.disconnectedPeers) {
+    bin.disconnectedPeers = [];
+  }
+  if (!bin.connectedPeers) {
+    bin.connectedPeers = [];
+  }
+  return {
+    population: Types.asNumber(bin.population, {
+      name: 'population'
+    }),
+    connected: Types.asNumber(bin.connected, {
+      name: 'connected'
+    }),
+    connectedPeers: Types.asArray(bin.connectedPeers, {
+      name: 'connectedPeers'
+    }).map(x => ({
+      address: Types.asString(Types.asObject(x, {
+        name: 'connectedPeer'
+      }).address, {
+        name: 'address'
+      })
+    })),
+    disconnectedPeers: Types.asArray(bin.disconnectedPeers, {
+      name: 'disconnectedPeers'
+    }).map(x => ({
+      address: Types.asString(Types.asObject(x, {
+        name: 'disconnectedPeer'
+      }).address, {
+        name: 'address'
+      })
+    }))
+  };
 }

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

@@ -1,4 +1,7 @@
+import { Types } from 'cafe-utility';
 import { http } from "../../utils/http.js";
+import { BZZ } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
 const settlementsEndpoint = 'settlements';
 /**
  * Get amount of sent and received from settlements with a peer
@@ -11,7 +14,20 @@ export async function getSettlements(requestOptions, peer) {
     url: `${settlementsEndpoint}/${peer}`,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    peer: Types.asString(body.peer, {
+      name: 'peer'
+    }),
+    sent: BZZ.fromPLUR(asNumberString(body.sent, {
+      name: 'sent'
+    })),
+    received: BZZ.fromPLUR(asNumberString(body.received, {
+      name: 'received'
+    }))
+  };
 }
 /**
  * Get settlements with all known peers and total amount sent or received
@@ -23,5 +39,33 @@ export async function getAllSettlements(requestOptions) {
     url: settlementsEndpoint,
     responseType: 'json'
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  const totalSent = BZZ.fromPLUR(asNumberString(body.totalSent, {
+    name: 'totalSent'
+  }));
+  const totalReceived = BZZ.fromPLUR(asNumberString(body.totalReceived, {
+    name: 'totalReceived'
+  }));
+  const settlements = Types.asArray(body.settlements, {
+    name: 'settlements'
+  }).map(x => Types.asObject(x, {
+    name: 'settlement'
+  }));
+  return {
+    totalSent,
+    totalReceived,
+    settlements: settlements.map(x => ({
+      peer: Types.asString(x.peer, {
+        name: 'peer'
+      }),
+      sent: BZZ.fromPLUR(asNumberString(x.sent, {
+        name: 'sent'
+      })),
+      received: BZZ.fromPLUR(asNumberString(x.received, {
+        name: 'received'
+      }))
+    }))
+  };
 }

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

@@ -1,4 +1,9 @@
+import { Types } from 'cafe-utility';
+import { prepareRequestHeaders } from "../../utils/headers.js";
 import { http } from "../../utils/http.js";
+import { BZZ, DAI } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+import { TransactionId } from "../../utils/typed-bytes.js";
 const STAKE_ENDPOINT = 'stake';
 const REDISTRIBUTION_ENDPOINT = 'redistributionstate';
 /**
@@ -12,7 +17,12 @@ export async function getStake(requestOptions) {
     responseType: 'json',
     url: `${STAKE_ENDPOINT}`
   });
-  return response.data.stakedAmount.toString();
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return BZZ.fromPLUR(asNumberString(body.stakedAmount, {
+    name: 'stakedAmount'
+  }));
 }
 /**
  * Stake given amount of tokens.
@@ -22,19 +32,18 @@ export async function getStake(requestOptions) {
  * @param options
  */
 export async function stake(requestOptions, amount, options) {
-  const headers = {};
-  if (options?.gasPrice) {
-    headers['gas-price'] = options.gasPrice.toString();
-  }
-  if (options?.gasLimit) {
-    headers['gas-limit'] = options.gasLimit.toString();
-  }
-  await http(requestOptions, {
+  const repsonse = await http(requestOptions, {
     method: 'post',
     responseType: 'json',
     url: `${STAKE_ENDPOINT}/${amount}`,
-    headers
+    headers: prepareRequestHeaders(null, options)
+  });
+  const body = Types.asObject(repsonse.data, {
+    name: 'response.data'
   });
+  return new TransactionId(Types.asHexString(body.txHash, {
+    name: 'txHash'
+  }));
 }
 /**
  * Get current status of node in redistribution game
@@ -47,5 +56,54 @@ export async function getRedistributionState(requestOptions) {
     responseType: 'json',
     url: REDISTRIBUTION_ENDPOINT
   });
-  return response.data;
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
+  return {
+    minimumGasFunds: DAI.fromWei(asNumberString(body.minimumGasFunds, {
+      name: 'minimumGasFunds'
+    })),
+    hasSufficientFunds: Types.asBoolean(body.hasSufficientFunds, {
+      name: 'hasSufficientFunds'
+    }),
+    isFrozen: Types.asBoolean(body.isFrozen, {
+      name: 'isFrozen'
+    }),
+    isFullySynced: Types.asBoolean(body.isFullySynced, {
+      name: 'isFullySynced'
+    }),
+    phase: Types.asString(body.phase, {
+      name: 'phase'
+    }),
+    round: Types.asNumber(body.round, {
+      name: 'round'
+    }),
+    lastWonRound: Types.asNumber(body.lastWonRound, {
+      name: 'lastWonRound'
+    }),
+    lastPlayedRound: Types.asNumber(body.lastPlayedRound, {
+      name: 'lastPlayedRound'
+    }),
+    lastFrozenRound: Types.asNumber(body.lastFrozenRound, {
+      name: 'lastFrozenRound'
+    }),
+    lastSelectedRound: Types.asNumber(body.lastSelectedRound, {
+      name: 'lastSelectedRound'
+    }),
+    lastSampleDurationSeconds: Types.asNumber(body.lastSampleDurationSeconds, {
+      name: 'lastSampleDurationSeconds'
+    }),
+    block: Types.asNumber(body.block, {
+      name: 'block'
+    }),
+    reward: BZZ.fromPLUR(asNumberString(body.reward, {
+      name: 'reward'
+    })),
+    fees: DAI.fromWei(asNumberString(body.fees, {
+      name: 'fees'
+    })),
+    isHealthy: Types.asBoolean(body.isHealthy, {
+      name: 'isHealthy'
+    })
+  };
 }