@ethersphere/bee-js 12.2.2 → 12.3.1

package/dist/mjs/modules/pinning.js

@@ -1,4 +1,5 @@
-import { Types } from 'cafe-utility';
+import { GetAllPinsResponse } from "../types/schema/pinning.js";
+import { UploadResultBody } from "../types/schema/upload.js";
 import { http } from "../utils/http.js";
 import { Reference } from "../utils/typed-bytes.js";
 const PINNING_ENDPOINT = 'pins';
@@ -41,14 +42,7 @@ export async function getPin(requestOptions, reference) {
     responseType: 'json',
     url: `${PINNING_ENDPOINT}/${reference}`
   });
-  const body = Types.asObject(response.data, {
-    name: 'response.data'
-  });
-  return {
-    reference: new Reference(Types.asString(body.reference, {
-      name: 'reference'
-    }))
-  };
+  return UploadResultBody.parse(response.data);
 }
 /**
  * Get list of all pins
@@ -61,17 +55,9 @@ export async function getAllPins(requestOptions) {
     responseType: 'json',
     url: `${PINNING_ENDPOINT}`
   });
-  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));
+  const {
+    references
+  } = GetAllPinsResponse.parse(response.data);
+  return (references ?? []).map(x => new Reference(x));
 }

package/dist/mjs/modules/rchash.js

@@ -1,4 +1,4 @@
-import { Types } from 'cafe-utility';
+import { RchashResponse } from "../types/schema/rchash.js";
 import { http } from "../utils/http.js";
 const RCHASH_ENDPOINT = 'rchash';
 export async function rchash(requestOptions, depth, anchor1, anchor2) {
@@ -6,10 +6,5 @@ export async function rchash(requestOptions, depth, anchor1, anchor2) {
     responseType: 'json',
     url: `${RCHASH_ENDPOINT}/${depth}/${anchor1}/${anchor2}`
   });
-  const body = Types.asObject(response.data, {
-    name: 'response.data'
-  });
-  return Types.asNumber(body.durationSeconds, {
-    name: 'durationSeconds'
-  });
+  return RchashResponse.parse(response.data).durationSeconds;
 }

package/dist/mjs/modules/soc.js

@@ -1,4 +1,5 @@
-import { Optional, Types } from 'cafe-utility';
+import { Optional } from 'cafe-utility';
+import { UploadResultBody } from "../types/schema/upload.js";
 import { prepareRequestHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 import { makeTagUid } from "../utils/type.js";
@@ -29,11 +30,9 @@ export async function upload(requestOptions, owner, identifier, signature, data,
       sig: signature.toHex()
     }
   });
-  const body = Types.asObject(response.data, {
-    name: 'response.data'
-  });
+  const body = UploadResultBody.parse(response.data);
   return {
-    reference: new Reference(Types.asHexString(body.reference)),
+    reference: body.reference,
     tagUid: response.headers['swarm-tag'] ? makeTagUid(response.headers['swarm-tag']) : undefined,
     historyAddress: response.headers['swarm-act-history-address'] ? Optional.of(new Reference(response.headers['swarm-act-history-address'])) : Optional.empty()
   };

package/dist/mjs/modules/status.js

@@ -1,4 +1,4 @@
-import { Types } from 'cafe-utility';
+import { IsGatewayResponse } from "../types/schema/status.js";
 import { http } from "../utils/http.js";
 /**
  * Ping the base bee URL. If connection was not successful throw error
@@ -7,7 +7,8 @@ import { http } from "../utils/http.js";
  */
 export async function checkConnection(requestOptions) {
   await http(requestOptions, {
-    url: ''
+    url: '',
+    responseType: 'text'
   });
 }
 export async function isGateway(requestOptions) {
@@ -15,8 +16,7 @@ export async function isGateway(requestOptions) {
     const response = await http(requestOptions, {
       url: '/gateway'
     });
-    const data = Types.asObject(response.data);
-    return Types.asBoolean(data.gateway);
+    return IsGatewayResponse.parse(response.data).gateway;
   } catch (error) {
     return false;
   }

package/dist/mjs/modules/stewardship.js

@@ -1,4 +1,4 @@
-import { Types } from 'cafe-utility';
+import { IsRetrievableResponse } from "../types/schema/stewardship.js";
 import { http } from "../utils/http.js";
 import { Reference } from "../utils/typed-bytes.js";
 const stewardshipEndpoint = 'stewardship';
@@ -24,10 +24,5 @@ export async function isRetrievable(requestOptions, reference) {
     responseType: 'json',
     url: `${stewardshipEndpoint}/${reference}`
   });
-  const body = Types.asObject(response.data, {
-    name: 'response.data'
-  });
-  return Types.asBoolean(body.isRetrievable, {
-    name: 'isRetrievable'
-  });
+  return IsRetrievableResponse.parse(response.data).isRetrievable;
 }

package/dist/mjs/modules/tag.js

@@ -1,4 +1,4 @@
-import { Types } from 'cafe-utility';
+import { GetAllTagsResponse, TagSchema } from "../types/schema/tag.js";
 import { http } from "../utils/http.js";
 const endpoint = 'tags';
 /**
@@ -12,35 +12,7 @@ export async function createTag(requestOptions) {
     url: endpoint,
     responseType: 'json'
   });
-  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'
-    })
-  };
+  return TagSchema.parse(response.data);
 }
 /**
  * Retrieve tag information from Bee node
@@ -53,35 +25,7 @@ export async function retrieveTag(requestOptions, uid) {
     url: `${endpoint}/${uid}`,
     responseType: 'json'
   });
-  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'
-    })
-  };
+  return TagSchema.parse(response.data);
 }
 /**
  * Get limited listing of all tags.
@@ -99,40 +43,7 @@ export async function getAllTags(requestOptions, offset, limit) {
     },
     responseType: 'json'
   });
-  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'
-    })
-  }));
+  return GetAllTagsResponse.parse(response.data).tags;
 }
 /**
  * Removes tag from the Bee node.

package/dist/mjs/stamper/stamper.js

@@ -23,7 +23,8 @@ export class Stamper {
     }
     this.buckets[bucket]++;
     const index = Binary.concatBytes(Binary.numberToUint32(bucket, 'BE'), Binary.numberToUint32(height, 'BE'));
-    const timestamp = Binary.numberToUint64(BigInt(Date.now()), 'BE');
+    const currentTimeNs = BigInt(Date.now()) * 1000000n; // Bee uses unix timestamp in nanoseconds
+    const timestamp = Binary.numberToUint64(currentTimeNs, 'BE');
     const signature = this.signer.sign(Binary.concatBytes(address, this.batchId.toUint8Array(), index, timestamp));
     return {
       batchId: this.batchId,

package/dist/mjs/types/schema/balance.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { BZZ } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+const PeerBalanceSchema = z.object({
+  peer: z.string(),
+  balance: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'balance'
+  })))
+});
+export const GetAllBalancesResponse = z.object({
+  balances: z.array(PeerBalanceSchema)
+});
+export const GetPeerBalanceResponse = PeerBalanceSchema;

package/dist/mjs/types/schema/chequebook.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { BZZ } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+import { EthAddress, TransactionId } from "../../utils/typed-bytes.js";
+const ChequeSchema = z.object({
+  beneficiary: z.string().transform(s => new EthAddress(s)),
+  chequebook: z.string().transform(s => new EthAddress(s)),
+  payout: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'payout'
+  })))
+});
+const CashoutResultSchema = z.object({
+  recipient: z.string(),
+  lastPayout: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'lastPayout'
+  }))),
+  bounced: z.boolean()
+});
+export const GetChequebookAddressResponse = z.object({
+  chequebookAddress: z.string().transform(s => new EthAddress(s))
+});
+export const GetChequebookBalanceResponse = z.object({
+  availableBalance: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'availableBalance'
+  }))),
+  totalBalance: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'totalBalance'
+  })))
+});
+export const GetLastCashoutActionResponse = z.object({
+  peer: z.string(),
+  uncashedAmount: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'uncashedAmount'
+  }))),
+  transactionHash: z.string().nullish().transform(v => v ?? null),
+  lastCashedCheque: ChequeSchema.nullish().transform(v => v ?? null),
+  result: CashoutResultSchema.nullish().transform(v => v ?? null)
+});
+export const GetLastChequesForPeerResponse = z.object({
+  peer: z.string(),
+  lastreceived: ChequeSchema.nullish().transform(v => v ?? null),
+  lastsent: ChequeSchema.nullish().transform(v => v ?? null)
+});
+export const GetLastChequesResponse = z.object({
+  lastcheques: z.array(z.object({
+    peer: z.string(),
+    lastreceived: ChequeSchema.nullish().transform(v => v ?? null),
+    lastsent: ChequeSchema.nullish().transform(v => v ?? null)
+  }))
+});
+export const TransactionHashResponse = z.object({
+  transactionHash: z.string().transform(s => new TransactionId(s))
+});

package/dist/mjs/types/schema/connectivity.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { EthAddress, PeerAddress, PublicKey } from "../../utils/typed-bytes.js";
+const PeerSchema = z.object({
+  address: z.string(),
+  fullNode: z.boolean()
+});
+const BinSchema = z.object({
+  population: z.number(),
+  connected: z.number(),
+  connectedPeers: z.array(z.object({
+    address: z.string()
+  })).nullish().transform(v => v ?? []),
+  disconnectedPeers: z.array(z.object({
+    address: z.string()
+  })).nullish().transform(v => v ?? [])
+});
+const BinRecord = z.record(z.string(), BinSchema);
+export const GetNodeAddressesResponse = z.object({
+  overlay: z.string().transform(s => new PeerAddress(s)),
+  underlay: z.array(z.string()),
+  ethereum: z.string().transform(s => new EthAddress(s)),
+  publicKey: z.string().transform(s => new PublicKey(s)),
+  pssPublicKey: z.string().transform(s => new PublicKey(s))
+});
+export const GetPeersResponse = z.object({
+  peers: z.array(PeerSchema)
+});
+export const GetBlocklistResponse = z.object({
+  peers: z.array(PeerSchema)
+});
+export const GetTopologyResponse = z.object({
+  baseAddr: z.string(),
+  population: z.number(),
+  connected: z.number(),
+  timestamp: z.string(),
+  nnLowWatermark: z.number(),
+  depth: z.number(),
+  reachability: z.string(),
+  networkAvailability: z.string(),
+  bins: BinRecord
+});

package/dist/mjs/types/schema/envelope.js

@@ -0,0 +1,8 @@
+import { Binary } from 'cafe-utility';
+import { z } from 'zod';
+export const PostEnvelopeBodyResponse = z.object({
+  issuer: z.string().transform(s => Binary.hexToUint8Array(s)),
+  index: z.string().transform(s => Binary.hexToUint8Array(s)),
+  timestamp: z.string().transform(s => Binary.hexToUint8Array(s)),
+  signature: z.string().transform(s => Binary.hexToUint8Array(s))
+});

package/dist/mjs/types/schema/grantee.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PublicKey, Reference } from "../../utils/typed-bytes.js";
+export const GetGranteesBodyResponse = z.array(z.string().transform(s => new PublicKey(s)));
+export const GranteesResultBodyResponse = z.object({
+  ref: z.string().transform(s => new Reference(s)),
+  historyref: z.string().transform(s => new Reference(s))
+});

package/dist/mjs/types/schema/pinning.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const GetAllPinsResponse = z.object({
+  references: z.array(z.string()).nullable()
+});

package/dist/mjs/types/schema/rchash.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const RchashResponse = z.object({
+  durationSeconds: z.number()
+});

package/dist/mjs/types/schema/settlements.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { BZZ } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+const SettlementSchema = z.object({
+  peer: z.string(),
+  sent: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'sent'
+  }))),
+  received: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'received'
+  })))
+});
+export const GetSettlementsResponse = SettlementSchema;
+export const GetAllSettlementsResponse = z.object({
+  totalSent: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'totalSent'
+  }))),
+  totalReceived: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'totalReceived'
+  }))),
+  settlements: z.array(SettlementSchema)
+});

package/dist/mjs/types/schema/stake.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { BZZ, DAI } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+import { TransactionId } from "../../utils/typed-bytes.js";
+export const GetStakeResponse = z.object({
+  stakedAmount: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'stakedAmount'
+  })))
+});
+export const GetWithdrawableStakeResponse = z.object({
+  withdrawableAmount: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'withdrawableAmount'
+  })))
+});
+export const TxHashResponse = z.object({
+  txHash: z.string().transform(s => new TransactionId(s))
+});
+export const GetRedistributionStateResponse = z.object({
+  minimumGasFunds: z.string().transform(s => DAI.fromWei(asNumberString(s, {
+    name: 'minimumGasFunds'
+  }))),
+  hasSufficientFunds: z.boolean(),
+  isFrozen: z.boolean(),
+  isFullySynced: z.boolean(),
+  phase: z.string(),
+  round: z.number(),
+  lastWonRound: z.number(),
+  lastPlayedRound: z.number(),
+  lastFrozenRound: z.number(),
+  lastSelectedRound: z.number(),
+  lastSampleDurationSeconds: z.number(),
+  block: z.number(),
+  reward: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'reward'
+  }))),
+  fees: z.string().transform(s => DAI.fromWei(asNumberString(s, {
+    name: 'fees'
+  }))),
+  isHealthy: z.boolean()
+});

package/dist/mjs/types/schema/stamps.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { asNumberString } from "../../utils/type.js";
+import { BatchId, EthAddress } from "../../utils/typed-bytes.js";
+export const RawPostageBatchSchema = z.object({
+  batchID: z.string(),
+  utilization: z.number(),
+  utilizationRatio: z.number().optional(),
+  usable: z.boolean(),
+  label: z.string(),
+  depth: z.number(),
+  amount: z.string(),
+  bucketDepth: z.number(),
+  blockNumber: z.number(),
+  immutableFlag: z.boolean(),
+  batchTTL: z.number()
+});
+export const GetGlobalPostageBatchResponse = z.object({
+  batchID: z.string().transform(s => new BatchId(s)),
+  batchTTL: z.number(),
+  bucketDepth: z.number(),
+  depth: z.number(),
+  immutable: z.boolean(),
+  owner: z.string().transform(s => new EthAddress(s)),
+  start: z.number(),
+  value: z.string().transform(s => asNumberString(s, {
+    name: 'value'
+  }))
+});
+export const GetGlobalPostageBatchesResponse = z.object({
+  batches: z.array(GetGlobalPostageBatchResponse)
+});
+export const GetAllPostageBatchesResponse = z.object({
+  stamps: z.array(RawPostageBatchSchema)
+});
+export const GetPostageBatchResponse = RawPostageBatchSchema;
+export const GetPostageBatchBucketsResponse = z.object({
+  depth: z.number(),
+  bucketDepth: z.number(),
+  bucketUpperBound: z.number(),
+  buckets: z.array(z.object({
+    bucketID: z.number(),
+    collisions: z.number()
+  }))
+});
+export const BatchIdResponse = z.object({
+  batchID: z.string().transform(s => new BatchId(s))
+});

package/dist/mjs/types/schema/states.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { BZZ, DAI } from "../../utils/tokens.js";
+import { asNumberString } from "../../utils/type.js";
+import { TransactionId } from "../../utils/typed-bytes.js";
+import { normalizeCurrentPrice } from "../../utils/workaround.js";
+export const GetReserveStateResponse = z.object({
+  commitment: z.number(),
+  radius: z.number(),
+  storageRadius: z.number(),
+  reserveCapacityDoubling: z.number()
+});
+export const GetChainStateResponse = z.object({
+  block: z.number(),
+  chainTip: z.number(),
+  totalAmount: z.string().transform(s => asNumberString(s, {
+    name: 'totalAmount'
+  })),
+  currentPrice: z.string().transform(Number).transform(s => normalizeCurrentPrice(s)),
+  minimumValidityBlocks: z.number().optional()
+});
+export const GetWalletBalanceResponse = z.object({
+  bzzBalance: z.string().transform(s => BZZ.fromPLUR(asNumberString(s, {
+    name: 'bzzBalance'
+  }))),
+  nativeTokenBalance: z.string().transform(s => DAI.fromWei(asNumberString(s, {
+    name: 'nativeTokenBalance'
+  }))),
+  chainID: z.number(),
+  chequebookContractAddress: z.string(),
+  walletAddress: z.string()
+});
+export const WithdrawResponse = z.object({
+  transactionHash: z.string().transform(s => new TransactionId(s))
+});

package/dist/mjs/types/schema/status.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { toBeeMode } from "../debug.js";
+export const GetDebugStatusResponse = z.object({
+  overlay: z.string(),
+  proximity: z.number(),
+  beeMode: z.string().transform(toBeeMode),
+  reserveSize: z.number(),
+  reserveSizeWithinRadius: z.number(),
+  pullsyncRate: z.number(),
+  storageRadius: z.number(),
+  connectedPeers: z.number(),
+  neighborhoodSize: z.number(),
+  batchCommitment: z.number(),
+  isReachable: z.boolean(),
+  lastSyncedBlock: z.number(),
+  committedDepth: z.number(),
+  isWarmingUp: z.boolean()
+});
+export const GetHealthResponse = z.object({
+  apiVersion: z.string(),
+  version: z.string(),
+  status: z.literal('ok')
+});
+export const GetReadinessResponse = z.object({
+  apiVersion: z.string(),
+  version: z.string(),
+  status: z.enum(['ready', 'notReady'])
+});
+export const GetNodeInfoResponse = z.object({
+  beeMode: z.string().transform(toBeeMode),
+  chequebookEnabled: z.boolean(),
+  swapEnabled: z.boolean()
+});
+export const IsGatewayResponse = z.object({
+  gateway: z.boolean()
+});

package/dist/mjs/types/schema/stewardship.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const IsRetrievableResponse = z.object({
+  isRetrievable: z.boolean()
+});

package/dist/mjs/types/schema/tag.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const TagSchema = z.object({
+  address: z.string().nullish().transform(v => v ?? ''),
+  seen: z.number(),
+  sent: z.number(),
+  split: z.number(),
+  startedAt: z.string(),
+  stored: z.number(),
+  synced: z.number(),
+  uid: z.number()
+});
+export const GetAllTagsResponse = z.object({
+  tags: z.array(TagSchema)
+});

package/dist/mjs/types/schema/transactions.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { asNumberString } from "../../utils/type.js";
+import { TransactionId } from "../../utils/typed-bytes.js";
+const TransactionInfoSchema = z.object({
+  transactionHash: z.string().transform(s => new TransactionId(s)),
+  to: z.string(),
+  nonce: z.number(),
+  gasPrice: z.string().transform(s => asNumberString(s, {
+    name: 'gasPrice'
+  })),
+  gasLimit: z.number(),
+  data: z.string(),
+  created: z.string(),
+  description: z.string(),
+  value: z.string().transform(s => asNumberString(s, {
+    name: 'value'
+  }))
+});
+export const GetAllTransactionsResponse = z.object({
+  pendingTransactions: z.array(TransactionInfoSchema)
+});
+export const GetTransactionResponse = TransactionInfoSchema;
+export const TransactionHashResponse = z.object({
+  transactionHash: z.string().transform(s => new TransactionId(s))
+});

package/dist/mjs/types/schema/upload.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { Reference } from "../../utils/typed-bytes.js";
+export const UploadResultBody = z.object({
+  reference: z.string().transform(s => new Reference(s))
+});

package/dist/mjs/utils/bad-ports.js

@@ -0,0 +1,6 @@
+/**
+ * Ports blocked by the WHATWG Fetch spec for HTTP/HTTPS requests.
+ *
+ * See: https://fetch.spec.whatwg.org/#port-blocking
+ */
+export const BAD_PORTS = ['1', '7', '9', '11', '13', '15', '17', '19', '20', '21', '22', '23', '25', '37', '42', '43', '53', '69', '77', '79', '87', '95', '101', '102', '103', '104', '109', '110', '111', '113', '115', '117', '119', '123', '135', '137', '139', '143', '161', '179', '389', '427', '465', '512', '513', '514', '515', '526', '530', '531', '532', '540', '548', '554', '556', '563', '587', '601', '636', '989', '990', '993', '995', '1719', '1720', '1723', '2049', '3659', '4045', '4190', '5060', '5061', '6000', '6566', '6665', '6666', '6667', '6668', '6669', '6679', '6697', '10080'];