@ethersphere/bee-js 12.3.2-upcoming.116 → 13.0.0-upcoming.gcfb9756

package/dist/cjs/api/balance.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBalances = getBalances;
+exports.getPeerBalance = getPeerBalance;
+const balance_1 = require("../types/schema/balance");
+const http_1 = require("../utils/http");
+const balancesEndpoint = 'balances';
+/**
+ * Raw HTTP calls for the `/balances` endpoint.
+ */
+async function getBalances(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: balancesEndpoint,
+        responseType: 'json',
+    });
+    return balance_1.GetAllBalancesResponse.parse(response.data);
+}
+async function getPeerBalance(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${balancesEndpoint}/${peer}`,
+        responseType: 'json',
+    });
+    return balance_1.GetPeerBalanceResponse.parse(response.data);
+}

package/dist/cjs/api/batches.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalPostageBatch = getGlobalPostageBatch;
+exports.getAllGlobalPostageBatches = getAllGlobalPostageBatches;
+const stamps_1 = require("../types/schema/stamps");
+const http_1 = require("../utils/http");
+const batchesEndpoint = 'batches';
+/**
+ * Raw HTTP calls for the `/batches` endpoint.
+ */
+async function getGlobalPostageBatch(requestOptions, id) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'get',
+        url: `${batchesEndpoint}/${id}`,
+        responseType: 'json',
+    });
+    return stamps_1.GetGlobalPostageBatchResponse.parse(response.data);
+}
+async function getAllGlobalPostageBatches(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'get',
+        url: batchesEndpoint,
+        responseType: 'json',
+    });
+    return stamps_1.GetGlobalPostageBatchesResponse.parse(response.data).batches;
+}

package/dist/cjs/{modules → api}/bytes.js

@@ -14,12 +14,7 @@ const type_1 = require("../utils/type");
 const typed_bytes_1 = require("../utils/typed-bytes");
 const endpoint = 'bytes';
 /**
- * Upload data to a Bee node
- *
- * @param requestOptions Options for making requests
- * @param data            Data to be uploaded
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param options         Additional options like tag, encryption, pinning
+ * Raw HTTP calls for the `/bytes` endpoint.
  */
 async function upload(requestOptions, data, postageBatchId, options) {
     const response = await (0, http_1.http)(requestOptions, {
@@ -41,14 +36,7 @@ async function upload(requestOptions, data, postageBatchId, options) {
             : cafe_utility_1.Optional.empty(),
     };
 }
-/**
- * Requests content length for a reference
- *
- * @param requestOptions Options for making requests
- * @param hash Bee content reference
- */
 async function head(requestOptions, reference) {
-    reference = new typed_bytes_1.Reference(reference);
     const response = await (0, http_1.http)(requestOptions, {
         url: `${endpoint}/${reference}`,
         method: 'head',
@@ -58,12 +46,6 @@ async function head(requestOptions, reference) {
         contentLength: parseInt(response.headers['content-length']),
     };
 }
-/**
- * Download data as a byte array
- *
- * @param requestOptions Options for making requests
- * @param hash Bee content reference
- */
 async function download(requestOptions, resource, options) {
     if (options) {
         options = schema_1.DownloadOptionsSchema.parse(options);
@@ -75,12 +57,6 @@ async function download(requestOptions, resource, options) {
     });
     return new bytes_1.Bytes(response.data);
 }
-/**
- * Download data as a readable stream
- *
- * @param requestOptions Options for making requests
- * @param hash Bee content reference
- */
 async function downloadReadable(requestOptions, resource, options) {
     if (options) {
         options = schema_1.DownloadOptionsSchema.parse(options);

package/dist/cjs/{modules → api}/bzz.js

@@ -15,13 +15,7 @@ const type_1 = require("../utils/type");
 const typed_bytes_1 = require("../utils/typed-bytes");
 const bzzEndpoint = 'bzz';
 /**
- * Upload single file
- *
- * @param requestOptions Options for making requests
- * @param data Files data
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param name Name that will be attached to the uploaded file. Wraps the data into manifest with set index document.
- * @param options
+ * Raw HTTP calls for the `/bzz` endpoint.
  */
 async function uploadFile(requestOptions, data, postageBatchId, name, options) {
     if ((0, type_1.isReadable)(data) && !options?.contentType) {
@@ -47,13 +41,6 @@ async function uploadFile(requestOptions, data, postageBatchId, name, options) {
             : cafe_utility_1.Optional.empty(),
     };
 }
-/**
- * Download single file as a buffer
- *
- * @param requestOptions Options for making requests
- * @param hash Bee file or collection hash
- * @param path If hash is collection then this defines path to a single file in the collection
- */
 async function downloadFile(requestOptions, resource, path = '', options) {
     const response = await (0, http_1.http)(requestOptions, {
         method: 'GET',
@@ -67,13 +54,6 @@ async function downloadFile(requestOptions, resource, path = '', options) {
     };
     return file;
 }
-/**
- * Download single file as a readable stream
- *
- * @param requestOptions Options for making requests
- * @param hash Bee file or collection hash
- * @param path If hash is collection then this defines path to a single file in the collection
- */
 async function downloadFileReadable(requestOptions, reference, path = '', options) {
     reference = new typed_bytes_1.Reference(reference);
     const response = await (0, http_1.http)(requestOptions, {
@@ -90,13 +70,6 @@ async function downloadFileReadable(requestOptions, reference, path = '', option
 }
 /*******************************************************************************************************************/
 // Collections
-/**
- * Upload collection
- * @param requestOptions Options for making requests
- * @param collection Collection of Uint8Array buffers to upload
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param options
- */
 async function uploadCollection(requestOptions, collection, postageBatchId, options) {
     (0, collection_1.assertCollection)(collection);
     const response = await (0, tar_uploader_1.uploadTar)(requestOptions, collection, postageBatchId, options);

package/dist/cjs/{modules/debug → api}/chequebook.js

@@ -2,135 +2,96 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChequebookAddress = getChequebookAddress;
 exports.getChequebookBalance = getChequebookBalance;
-exports.getLastCashoutAction = getLastCashoutAction;
-exports.cashoutLastCheque = cashoutLastCheque;
-exports.getLastChequesForPeer = getLastChequesForPeer;
-exports.getLastCheques = getLastCheques;
 exports.depositTokens = depositTokens;
 exports.withdrawTokens = withdrawTokens;
-const chequebook_1 = require("../../types/schema/chequebook");
-const headers_1 = require("../../utils/headers");
-const http_1 = require("../../utils/http");
+exports.getLastCheques = getLastCheques;
+exports.getLastChequesForPeer = getLastChequesForPeer;
+exports.getLastCashoutAction = getLastCashoutAction;
+exports.cashoutLastCheque = cashoutLastCheque;
+const chequebook_1 = require("../types/schema/chequebook");
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
 const chequebookEndpoint = 'chequebook';
 /**
- * Get the address of the chequebook contract used
- *
- * @param requestOptions Options for making requests
+ * Raw HTTP calls for the `/chequebook` endpoint (chequebook + cheque operations).
  */
+/** Gets the address of the deployed chequebook. */
 async function getChequebookAddress(requestOptions) {
     const response = await (0, http_1.http)(requestOptions, {
-        url: chequebookEndpoint + '/address',
+        url: `${chequebookEndpoint}/address`,
         responseType: 'json',
     });
     return chequebook_1.GetChequebookAddressResponse.parse(response.data);
 }
-/**
- * Get the balance of the chequebook
- *
- * @param requestOptions Options for making requests
- */
+/** Gets the balance of the chequebook. */
 async function getChequebookBalance(requestOptions) {
     const response = await (0, http_1.http)(requestOptions, {
-        url: chequebookEndpoint + '/balance',
+        url: `${chequebookEndpoint}/balance`,
         responseType: 'json',
     });
     return chequebook_1.GetChequebookBalanceResponse.parse(response.data);
 }
-/**
- * Get last cashout action for the peer
- *
- * @param requestOptions Options for making requests
- * @param peer  Swarm address of peer
- */
-async function getLastCashoutAction(requestOptions, peer) {
+/** Deposits tokens from the node wallet into the chequebook. */
+async function depositTokens(requestOptions, amount, gasPrice) {
+    const headers = {};
+    if (gasPrice) {
+        headers['gas-price'] = gasPrice;
+    }
     const response = await (0, http_1.http)(requestOptions, {
-        url: chequebookEndpoint + `/cashout/${peer}`,
+        method: 'post',
+        url: `${chequebookEndpoint}/deposit`,
         responseType: 'json',
+        params: { amount },
+        headers,
     });
-    return chequebook_1.GetLastCashoutActionResponse.parse(response.data);
+    return chequebook_1.TransactionHashResponse.parse(response.data).transactionHash;
 }
-/**
- * Cashout the last cheque for the peer
- *
- * @param requestOptions Options for making requests
- * @param peer  Swarm address of peer
- * @param options
- */
-async function cashoutLastCheque(requestOptions, peer, options) {
+/** Withdraws tokens from the chequebook to the node wallet. */
+async function withdrawTokens(requestOptions, amount, gasPrice) {
+    const headers = {};
+    if (gasPrice) {
+        headers['gas-price'] = gasPrice;
+    }
     const response = await (0, http_1.http)(requestOptions, {
         method: 'post',
-        url: chequebookEndpoint + `/cashout/${peer}`,
+        url: `${chequebookEndpoint}/withdraw`,
         responseType: 'json',
-        headers: (0, headers_1.prepareRequestHeaders)(null, options),
+        params: { amount },
+        headers,
     });
     return chequebook_1.TransactionHashResponse.parse(response.data).transactionHash;
 }
-/**
- * Get last cheques for the peer
- *
- * @param requestOptions Options for making requests
- * @param peer  Swarm address of peer
- */
-async function getLastChequesForPeer(requestOptions, peer) {
+/** Gets the last cheques for all peers. */
+async function getLastCheques(requestOptions) {
     const response = await (0, http_1.http)(requestOptions, {
-        url: chequebookEndpoint + `/cheque/${peer}`,
+        url: `${chequebookEndpoint}/cheque`,
         responseType: 'json',
     });
-    return chequebook_1.GetLastChequesForPeerResponse.parse(response.data);
+    return chequebook_1.GetLastChequesResponse.parse(response.data);
 }
-/**
- * Get last cheques for all peers
- *
- * @param requestOptions Options for making requests
- */
-async function getLastCheques(requestOptions) {
+/** Gets the last cheques for a specific peer. */
+async function getLastChequesForPeer(requestOptions, peer) {
     const response = await (0, http_1.http)(requestOptions, {
-        url: chequebookEndpoint + '/cheque',
+        url: `${chequebookEndpoint}/cheque/${peer}`,
         responseType: 'json',
     });
-    return chequebook_1.GetLastChequesResponse.parse(response.data);
+    return chequebook_1.GetLastChequesForPeerResponse.parse(response.data);
 }
-/**
- * Deposit tokens from overlay address into chequebook
- *
- * @param requestOptions Options for making requests
- * @param amount   Amount of tokens to deposit
- * @param gasPrice Gas Price in WEI for the transaction call
- * @return string  Hash of the transaction
- */
-async function depositTokens(requestOptions, amount, gasPrice) {
-    const headers = {};
-    if (gasPrice) {
-        headers['gas-price'] = gasPrice.toString();
-    }
+/** Gets the last cashout action for a specific peer. */
+async function getLastCashoutAction(requestOptions, peer) {
     const response = await (0, http_1.http)(requestOptions, {
-        method: 'post',
-        url: chequebookEndpoint + '/deposit',
+        url: `${chequebookEndpoint}/cashout/${peer}`,
         responseType: 'json',
-        params: { amount: amount.toString(10) },
-        headers,
     });
-    return chequebook_1.TransactionHashResponse.parse(response.data).transactionHash;
+    return chequebook_1.GetLastCashoutActionResponse.parse(response.data);
 }
-/**
- * Withdraw tokens from the chequebook to the overlay address
- *
- * @param requestOptions Options for making requests
- * @param amount   Amount of tokens to withdraw
- * @param gasPrice Gas Price in WEI for the transaction call
- * @return string  Hash of the transaction
- */
-async function withdrawTokens(requestOptions, amount, gasPrice) {
-    const headers = {};
-    if (gasPrice) {
-        headers['gas-price'] = gasPrice.toString();
-    }
+/** Cashes out the last cheque for a specific peer. */
+async function cashoutLastCheque(requestOptions, peer, options) {
     const response = await (0, http_1.http)(requestOptions, {
         method: 'post',
-        url: chequebookEndpoint + '/withdraw',
+        url: `${chequebookEndpoint}/cashout/${peer}`,
         responseType: 'json',
-        params: { amount: amount.toString(10) },
-        headers,
+        headers: (0, headers_1.prepareRequestHeaders)(null, options),
     });
     return chequebook_1.TransactionHashResponse.parse(response.data).transactionHash;
 }

package/dist/cjs/api/chunk.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upload = upload;
+exports.download = download;
+const cafe_utility_1 = require("cafe-utility");
+const upload_1 = require("../types/schema/upload");
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
+const type_1 = require("../utils/type");
+const typed_bytes_1 = require("../utils/typed-bytes");
+const endpoint = 'chunks';
+/**
+ * Raw HTTP calls for the `/chunks` endpoint.
+ */
+async function upload(requestOptions, data, stamp, options) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: `${endpoint}`,
+        data,
+        headers: {
+            'content-type': 'application/octet-stream',
+            ...(0, headers_1.prepareRequestHeaders)(stamp, options),
+        },
+        responseType: 'json',
+    });
+    const body = upload_1.UploadResultBody.parse(response.data);
+    return {
+        reference: body.reference,
+        tagUid: response.headers['swarm-tag'] ? (0, type_1.makeTagUid)(response.headers['swarm-tag']) : undefined,
+        historyAddress: response.headers['swarm-act-history-address']
+            ? cafe_utility_1.Optional.of(new typed_bytes_1.Reference(response.headers['swarm-act-history-address']))
+            : cafe_utility_1.Optional.empty(),
+    };
+}
+async function download(requestOptions, reference, options) {
+    reference = new typed_bytes_1.Reference(reference);
+    const response = await (0, http_1.http)(requestOptions, {
+        responseType: 'arraybuffer',
+        url: `${endpoint}/${reference}`,
+        headers: (0, headers_1.prepareRequestHeaders)(null, options),
+    });
+    return new Uint8Array(response.data);
+}

package/dist/cjs/api/connectivity.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConnection = checkConnection;
+exports.isGateway = isGateway;
+exports.getNodeAddresses = getNodeAddresses;
+exports.getBlocklist = getBlocklist;
+exports.getPeers = getPeers;
+exports.removePeer = removePeer;
+exports.getTopology = getTopology;
+exports.ping = ping;
+const connectivity_1 = require("../types/schema/connectivity");
+const status_1 = require("../types/schema/status");
+const http_1 = require("../utils/http");
+const addressesEndpoint = 'addresses';
+const blocklistEndpoint = 'blocklist';
+const peersEndpoint = 'peers';
+const topologyEndpoint = 'topology';
+const pingpongEndpoint = 'pingpong';
+const gatewayEndpoint = '/gateway';
+/**
+ * Raw HTTP calls for the connectivity endpoints (`/addresses`, `/peers`, `/topology`, `/blocklist`, `/pingpong`, etc.).
+ */
+/** Pings the Bee node to see if there is a live Bee node on the given URL. */
+async function checkConnection(requestOptions) {
+    await (0, http_1.http)(requestOptions, {
+        url: '',
+        responseType: 'text',
+    });
+}
+/** Checks the `/gateway` endpoint to see if the remote API is a gateway. */
+async function isGateway(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: gatewayEndpoint,
+    });
+    return status_1.IsGatewayResponse.parse(response.data).gateway;
+}
+/** Fetches the overlay, underlay, Ethereum, and other addresses of the Bee node. */
+async function getNodeAddresses(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: addressesEndpoint,
+        responseType: 'json',
+    });
+    return connectivity_1.GetNodeAddressesResponse.parse(response.data);
+}
+/** Fetches the list of blocked peers for this node. */
+async function getBlocklist(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: blocklistEndpoint,
+        responseType: 'json',
+    });
+    return connectivity_1.GetBlocklistResponse.parse(response.data).peers;
+}
+/** Gets list of peers for this node. */
+async function getPeers(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: peersEndpoint,
+        responseType: 'json',
+    });
+    return connectivity_1.GetPeersResponse.parse(response.data).peers;
+}
+/** Disconnects from a specific peer. */
+async function removePeer(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${peersEndpoint}/${peer}`,
+        responseType: 'json',
+        method: 'DELETE',
+    });
+    return response.data;
+}
+/** Fetches topology and connectivity information of the Bee node. */
+async function getTopology(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: topologyEndpoint,
+        responseType: 'json',
+    });
+    return connectivity_1.GetTopologyResponse.parse(response.data);
+}
+/** Pings a specific peer to check its availability. */
+async function ping(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${pingpongEndpoint}/${peer}`,
+        responseType: 'json',
+        method: 'POST',
+    });
+    return response.data;
+}

package/dist/cjs/api/consumed.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPastDueConsumptionBalances = getPastDueConsumptionBalances;
+exports.getPastDueConsumptionPeerBalance = getPastDueConsumptionPeerBalance;
+const balance_1 = require("../types/schema/balance");
+const http_1 = require("../utils/http");
+const consumedEndpoint = 'consumed';
+/**
+ * Raw HTTP calls for the `/consumed` endpoint.
+ */
+async function getPastDueConsumptionBalances(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: consumedEndpoint,
+        responseType: 'json',
+    });
+    return balance_1.GetAllBalancesResponse.parse(response.data);
+}
+async function getPastDueConsumptionPeerBalance(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${consumedEndpoint}/${peer}`,
+        responseType: 'json',
+    });
+    return balance_1.GetPeerBalanceResponse.parse(response.data);
+}

package/dist/cjs/api/feed.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeedManifest = createFeedManifest;
+exports.fetchLatestFeedUpdate = fetchLatestFeedUpdate;
+exports.probeFeed = probeFeed;
+const upload_1 = require("../types/schema/upload");
+const bytes_1 = require("../utils/bytes");
+const error_1 = require("../utils/error");
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
+const typed_bytes_1 = require("../utils/typed-bytes");
+const feedEndpoint = 'feeds';
+async function createFeedManifest(requestOptions, owner, topic, stamp, options) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        responseType: 'json',
+        url: `${feedEndpoint}/${owner}/${topic}`,
+        headers: (0, headers_1.prepareRequestHeaders)(stamp, options),
+    });
+    return upload_1.UploadResultBody.parse(response.data).reference;
+}
+function readFeedUpdateHeaders(headers) {
+    const feedIndex = headers['swarm-feed-index'];
+    const feedIndexNext = headers['swarm-feed-index-next'];
+    if (!feedIndex) {
+        throw new error_1.BeeError('Response did not contain expected swarm-feed-index!');
+    }
+    if (!feedIndexNext) {
+        throw new error_1.BeeError('Response did not contain expected swarm-feed-index-next!');
+    }
+    return {
+        feedIndex: new typed_bytes_1.FeedIndex(feedIndex),
+        feedIndexNext: new typed_bytes_1.FeedIndex(feedIndexNext),
+    };
+}
+async function fetchLatestFeedUpdate(requestOptions, owner, topic, options) {
+    const response = await (0, http_1.http)(requestOptions, {
+        responseType: 'arraybuffer',
+        url: `${feedEndpoint}/${owner}/${topic}`,
+        params: { ...options },
+    });
+    return {
+        payload: new bytes_1.Bytes(response.data),
+        ...readFeedUpdateHeaders(response.headers),
+    };
+}
+async function probeFeed(requestOptions, owner, topic) {
+    const response = await (0, http_1.http)(requestOptions, {
+        responseType: 'arraybuffer',
+        url: `${feedEndpoint}/${owner}/${topic}`,
+        params: {
+            'Swarm-Only-Root-Chunk': true,
+        },
+    });
+    return readFeedUpdateHeaders(response.headers);
+}

package/dist/cjs/api/grantee.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGrantees = createGrantees;
+exports.getGrantees = getGrantees;
+exports.patchGrantees = patchGrantees;
+const grantee_1 = require("../types/schema/grantee");
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
+const granteeEndpoint = 'grantee';
+/** Creates grantees for a postage batch. */
+async function createGrantees(requestOptions, batchId, publicKeys) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: granteeEndpoint,
+        data: { grantees: publicKeys.map(x => x.toCompressedHex()) },
+        headers: (0, headers_1.prepareRequestHeaders)(batchId),
+        responseType: 'json',
+    });
+    const body = grantee_1.GranteesResultBodyResponse.parse(response.data);
+    return {
+        status: response.status,
+        statusText: response.statusText,
+        ref: body.ref,
+        historyref: body.historyref,
+    };
+}
+/** Retrieves the grantees for a given reference. */
+async function getGrantees(requestOptions, reference) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'get',
+        url: `${granteeEndpoint}/${reference}`,
+        responseType: 'json',
+    });
+    return {
+        status: response.status,
+        statusText: response.statusText,
+        grantees: grantee_1.GetGranteesBodyResponse.parse(response.data),
+    };
+}
+/** Updates the grantees of a specific reference and history. */
+async function patchGrantees(requestOptions, batchId, reference, history, publicKeys) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'patch',
+        url: `${granteeEndpoint}/${reference}`,
+        data: {
+            add: publicKeys.add.map(x => x.toCompressedHex()),
+            revoke: publicKeys.revoke.map(x => x.toCompressedHex()),
+        },
+        headers: {
+            ...(0, headers_1.prepareRequestHeaders)(batchId),
+            'swarm-act-history-address': history.toHex(),
+        },
+        responseType: 'json',
+    });
+    const body = grantee_1.GranteesResultBodyResponse.parse(response.data);
+    return {
+        status: response.status,
+        statusText: response.statusText,
+        ref: body.ref,
+        historyref: body.historyref,
+    };
+}