@ethersphere/bee-js 3.3.4 → 4.1.0

package/dist/types/{chunk → src/chunk}/cac.d.ts

@@ -1,8 +1,7 @@
-import { BrandedType } from '../types';
+import { BrandedType, PlainBytesReference } from '../types';
 import { Bytes, FlexBytes } from '../utils/bytes';
 export declare const MIN_PAYLOAD_SIZE = 1;
 export declare const MAX_PAYLOAD_SIZE = 4096;
-export declare type ChunkAddress = Bytes<32>;
 /**
  * General chunk interface for Swarm
  *
@@ -16,7 +15,7 @@ export interface Chunk {
     readonly data: Uint8Array;
     span(): Bytes<8>;
     payload(): FlexBytes<1, 4096>;
-    address(): ChunkAddress;
+    address(): PlainBytesReference;
 }
 declare type ValidChunkData = BrandedType<Uint8Array, 'ValidChunkData'>;
 /**
@@ -31,7 +30,7 @@ export declare function makeContentAddressedChunk(payloadBytes: Uint8Array): Chu
  * @param data          The chunk data
  * @param chunkAddress  The address of the chunk
  */
-export declare function isValidChunkData(data: unknown, chunkAddress: ChunkAddress): data is ValidChunkData;
+export declare function isValidChunkData(data: unknown, chunkAddress: PlainBytesReference): data is ValidChunkData;
 /**
  * Asserts if data are representing given address of its chunk.
  *
@@ -40,5 +39,5 @@ export declare function isValidChunkData(data: unknown, chunkAddress: ChunkAddre
  *
  * @returns a valid content addressed chunk or throws error
  */
-export declare function assertValidChunkData(data: unknown, chunkAddress: ChunkAddress): asserts data is ValidChunkData;
+export declare function assertValidChunkData(data: unknown, chunkAddress: PlainBytesReference): asserts data is ValidChunkData;
 export {};

package/dist/types/{chunk → src/chunk}/soc.d.ts

@@ -1,6 +1,6 @@
 import { Bytes } from '../utils/bytes';
-import { Chunk, ChunkAddress } from './cac';
-import { UploadOptions, Signature, Signer, BatchId, Reference, Ky } from '../types';
+import { Chunk } from './cac';
+import { UploadOptions, Signature, Signer, BatchId, Reference, Ky, PlainBytesReference } from '../types';
 import { EthAddress } from '../utils/eth';
 export declare type Identifier = Bytes<32>;
 /**
@@ -24,8 +24,8 @@ export interface SingleOwnerChunk extends Chunk {
  *
  * @returns a single owner chunk or throws error
  */
-export declare function makeSingleOwnerChunkFromData(data: Uint8Array, address: ChunkAddress): SingleOwnerChunk;
-export declare function makeSOCAddress(identifier: Identifier, address: EthAddress): ChunkAddress;
+export declare function makeSingleOwnerChunkFromData(data: Uint8Array, address: PlainBytesReference): SingleOwnerChunk;
+export declare function makeSOCAddress(identifier: Identifier, address: EthAddress): PlainBytesReference;
 /**
  * Creates a single owner chunk object
  *

package/dist/types/src/feed/identifier.d.ts

@@ -0,0 +1,4 @@
+import { Topic } from '../types';
+import { Identifier } from '../chunk/soc';
+import { Index } from './index';
+export declare function makeFeedIdentifier(topic: Topic, index: Index): Identifier;

package/dist/types/src/feed/index.d.ts

@@ -0,0 +1,28 @@
+import { FeedUpdateOptions } from '../modules/feed';
+import { BatchId, BytesReference, FEED_INDEX_HEX_LENGTH, FeedReader, FeedWriter, Ky, PlainBytesReference, Reference, Signer, Topic, UploadOptions } from '../types';
+import { Bytes } from '../utils/bytes';
+import { HexString } from '../utils/hex';
+import { EthAddress, HexEthAddress } from '../utils/eth';
+import type { FeedType } from './type';
+export interface Epoch {
+    time: number;
+    level: number;
+}
+/**
+ * Bytes of Feed's Index.
+ * For Sequential Feeds this is numeric value in big-endian.
+ */
+export declare type IndexBytes = Bytes<8>;
+export declare type Index = number | Epoch | IndexBytes | string;
+export interface FeedUploadOptions extends UploadOptions, FeedUpdateOptions {
+}
+export interface FeedUpdate {
+    timestamp: number;
+    reference: BytesReference;
+}
+export declare function findNextIndex(ky: Ky, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<HexString<typeof FEED_INDEX_HEX_LENGTH>>;
+export declare function updateFeed(ky: Ky, signer: Signer, topic: Topic, reference: BytesReference, postageBatchId: BatchId, options?: FeedUploadOptions, index?: Index): Promise<Reference>;
+export declare function getFeedUpdateChunkReference(owner: EthAddress, topic: Topic, index: Index): PlainBytesReference;
+export declare function downloadFeedUpdate(ky: Ky, owner: EthAddress, topic: Topic, index: Index): Promise<FeedUpdate>;
+export declare function makeFeedReader(ky: Ky, type: FeedType, topic: Topic, owner: HexEthAddress): FeedReader;
+export declare function makeFeedWriter(ky: Ky, type: FeedType, topic: Topic, signer: Signer): FeedWriter;

package/dist/types/src/feed/retrievable.d.ts

@@ -0,0 +1,5 @@
+import { Bee } from '../bee';
+import { EthAddress } from '../utils/eth';
+import { RequestOptions, Topic } from '../types';
+import { Index } from './index';
+export declare function areAllSequentialFeedsUpdateRetrievable(bee: Bee, owner: EthAddress, topic: Topic, index: Index, options?: RequestOptions): Promise<boolean>;

package/dist/types/{modules → src/modules}/bytes.d.ts

@@ -1,4 +1,4 @@
-import type { BatchId, Data, Ky, Reference, UploadOptions } from '../types';
+import type { BatchId, Data, Ky, ReferenceOrEns, UploadOptions } from '../types';
 import { UploadResult } from '../types';
 /**
  * Upload data to a Bee node
@@ -15,11 +15,11 @@ export declare function upload(ky: Ky, data: string | Uint8Array, postageBatchId
  * @param ky
  * @param hash Bee content reference
  */
-export declare function download(ky: Ky, hash: Reference): Promise<Data>;
+export declare function download(ky: Ky, hash: ReferenceOrEns): Promise<Data>;
 /**
  * Download data as a readable stream
  *
  * @param ky
  * @param hash Bee content reference
  */
-export declare function downloadReadable(ky: Ky, hash: Reference): Promise<ReadableStream<Uint8Array>>;
+export declare function downloadReadable(ky: Ky, hash: ReferenceOrEns): Promise<ReadableStream<Uint8Array>>;

package/dist/types/{modules → src/modules}/bzz.d.ts

@@ -1,4 +1,4 @@
-import { BatchId, Collection, CollectionUploadOptions, Data, FileData, FileUploadOptions, Ky, Readable, UploadResult } from '../types';
+import { BatchId, Collection, CollectionUploadOptions, Data, FileData, FileUploadOptions, Ky, Readable, ReferenceOrEns, UploadResult } from '../types';
 /**
  * Upload single file
  *
@@ -16,7 +16,7 @@ export declare function uploadFile(ky: Ky, data: string | Uint8Array | Readable
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export declare function downloadFile(ky: Ky, hash: string, path?: string): Promise<FileData<Data>>;
+export declare function downloadFile(ky: Ky, hash: ReferenceOrEns, path?: string): Promise<FileData<Data>>;
 /**
  * Download single file as a readable stream
  *
@@ -24,7 +24,7 @@ export declare function downloadFile(ky: Ky, hash: string, path?: string): Promi
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export declare function downloadFileReadable(ky: Ky, hash: string, path?: string): Promise<FileData<ReadableStream<Uint8Array>>>;
+export declare function downloadFileReadable(ky: Ky, hash: ReferenceOrEns, path?: string): Promise<FileData<ReadableStream<Uint8Array>>>;
 /**
  * Upload collection
  * @param ky Ky instance for given Bee class instance

package/dist/types/{modules → src/modules}/chunk.d.ts

@@ -1,4 +1,4 @@
-import type { BatchId, Data, Ky, Reference, UploadOptions } from '../types';
+import type { BatchId, Data, Ky, Reference, ReferenceOrEns, UploadOptions } from '../types';
 /**
  * Upload chunk to a Bee node
  *
@@ -19,4 +19,4 @@ export declare function upload(ky: Ky, data: Uint8Array, postageBatchId: BatchId
  * @param hash Bee content reference
  *
  */
-export declare function download(ky: Ky, hash: string): Promise<Data>;
+export declare function download(ky: Ky, hash: ReferenceOrEns): Promise<Data>;

package/dist/types/{modules → src/modules}/debug/states.d.ts

@@ -1,4 +1,4 @@
-import { ChainState, Ky, ReserveState } from '../../types';
+import { ChainState, Ky, ReserveState, WalletBalance } from '../../types';
 /**
  * Get state of reserve
  *
@@ -11,3 +11,9 @@ export declare function getReserveState(ky: Ky): Promise<ReserveState>;
  * @param ky Ky debug instance
  */
 export declare function getChainState(ky: Ky): Promise<ChainState>;
+/**
+ * Get wallet balances for xDai and BZZ of the node
+ *
+ * @param ky Ky debug instance
+ */
+export declare function getWalletBalance(ky: Ky): Promise<WalletBalance>;

package/dist/types/{modules → src/modules}/debug/status.d.ts

@@ -1,9 +1,9 @@
 import type { Health, NodeInfo } from '../../types/debug';
 import { Ky } from '../../types';
 import { BeeVersions } from '../../types/debug';
-export declare const SUPPORTED_BEE_VERSION_EXACT = "1.5.1-d0a77598";
-export declare const SUPPORTED_API_VERSION = "3.0.0";
-export declare const SUPPORTED_DEBUG_API_VERSION = "2.0.0";
+export declare const SUPPORTED_BEE_VERSION_EXACT = "1.6.0-6ceadd35";
+export declare const SUPPORTED_API_VERSION = "3.0.1";
+export declare const SUPPORTED_DEBUG_API_VERSION = "2.0.1";
 export declare const SUPPORTED_BEE_VERSION: string;
 /**
  * Get health of node

package/dist/types/{modules → src/modules}/feed.d.ts

@@ -13,9 +13,20 @@ export interface FeedUpdateOptions {
      * Can be 'epoch' or 'sequence' (default: 'sequence')
      */
     type?: FeedType;
+    /**
+     * Fetch specific previous Feed's update (default fetches latest update)
+     */
+    index?: string;
 }
 interface FeedUpdateHeaders {
+    /**
+     * The current feed's index
+     */
     feedIndex: string;
+    /**
+     * The feed's index for next update.
+     * Only set for the latest update. If update is fetched using previous index, then this is an empty string.
+     */
     feedIndexNext: string;
 }
 export interface FetchFeedUpdateResponse extends ReferenceResponse, FeedUpdateHeaders {
@@ -43,5 +54,5 @@ export declare function createFeedManifest(ky: Ky, owner: HexEthAddress, topic:
  * @param topic       Topic in hex
  * @param options     Additional options, like index, at, type
  */
-export declare function fetchFeedUpdate(ky: Ky, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<FetchFeedUpdateResponse>;
+export declare function fetchLatestFeedUpdate(ky: Ky, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<FetchFeedUpdateResponse>;
 export {};

package/dist/types/{modules → src/modules}/stewardship.d.ts

@@ -1,4 +1,4 @@
-import type { Ky, Reference } from '../types';
+import type { Ky, ReferenceOrEns } from '../types';
 /**
  * Reupload locally pinned data
  * @param ky Ky instance
@@ -6,5 +6,5 @@ import type { Ky, Reference } from '../types';
  * @param options
  * @throws BeeResponseError if not locally pinned or invalid data
  */
-export declare function reupload(ky: Ky, reference: Reference): Promise<void>;
-export declare function isRetrievable(ky: Ky, reference: Reference): Promise<boolean>;
+export declare function reupload(ky: Ky, reference: ReferenceOrEns): Promise<void>;
+export declare function isRetrievable(ky: Ky, reference: ReferenceOrEns): Promise<boolean>;

package/dist/types/{types → src/types}/debug.d.ts

@@ -207,13 +207,29 @@ export interface PingResponse {
 }
 export interface ReserveState {
     radius: number;
+    commitment: number;
     storageRadius: number;
-    available: number;
-    outer: NumberString;
-    inner: NumberString;
 }
 export interface ChainState {
     block: number;
     totalAmount: NumberString;
     currentPrice: NumberString;
 }
+export interface WalletBalance {
+    /**
+     * Balance of BZZ tokens
+     */
+    bzz: NumberString;
+    /**
+     * Balance of xDai
+     */
+    xDai: NumberString;
+    /**
+     * Chain network ID to which the Bee node is connected
+     */
+    chainID: number;
+    /**
+     * Chequebook contract address
+     */
+    contractAddress: string;
+}

package/dist/types/{types → src/types}/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { Identifier, SingleOwnerChunk } from '../chunk/soc';
-import type { ChunkReference, FeedUploadOptions } from '../feed';
+import type { FeedUploadOptions } from '../feed';
 import type { FeedType } from '../feed/type';
 import type { FeedUpdateOptions, FetchFeedUpdateResponse } from '../modules/feed';
 import type { Bytes } from '../utils/bytes';
@@ -39,6 +39,7 @@ export declare const STAMPS_DEPTH_MIN = 17;
 export declare const STAMPS_DEPTH_MAX = 255;
 export declare const TAGS_LIMIT_MIN = 1;
 export declare const TAGS_LIMIT_MAX = 1000;
+export declare const FEED_INDEX_HEX_LENGTH = 16;
 /**
  * Generic reference that can be either non-encrypted reference which is a hex string of length 64 or encrypted
  * reference which is a hex string of length 128.
@@ -48,6 +49,17 @@ export declare const TAGS_LIMIT_MAX = 1000;
  * @see [Bee docs - Store with Encryption](https://docs.ethswarm.org/docs/access-the-swarm/store-with-encryption)
  */
 export declare type Reference = HexString<typeof REFERENCE_HEX_LENGTH> | HexString<typeof ENCRYPTED_REFERENCE_HEX_LENGTH>;
+/**
+ * Type that represents either Swarm's reference in hex string or ESN domain (something.eth).
+ */
+export declare type ReferenceOrEns = Reference | string;
+/**
+ * Type that represents either Swarm's reference in hex string, ESN domain (something.eth) or CID using one of the Swarm's codecs.
+ */
+export declare type ReferenceCidOrEns = ReferenceOrEns | string;
+export declare type PlainBytesReference = Bytes<typeof REFERENCE_BYTES_LENGTH>;
+export declare type EncryptedBytesReference = Bytes<typeof ENCRYPTED_REFERENCE_BYTES_LENGTH>;
+export declare type BytesReference = PlainBytesReference | EncryptedBytesReference;
 export declare type PublicKey = HexString<typeof PUBKEY_HEX_LENGTH>;
 export declare type Address = HexString<typeof ADDRESS_HEX_LENGTH>;
 /**
@@ -111,6 +123,9 @@ export interface BeeOptions extends RequestOptions {
      */
     onResponse?: HookCallback<BeeResponse>;
 }
+export interface UploadResultWithCid extends UploadResult {
+    cid: string;
+}
 /**
  * Result of upload calls.
  */
@@ -356,7 +371,7 @@ export interface FeedWriter extends FeedReader {
      *
      * @returns Reference that points at Single Owner Chunk that contains the new update and pointer to the updated chunk reference.
      */
-    upload(postageBatchId: string | BatchId, reference: ChunkReference | Reference, options?: FeedUploadOptions): Promise<Reference>;
+    upload(postageBatchId: string | BatchId, reference: BytesReference | Reference, options?: FeedUploadOptions): Promise<Reference>;
 }
 /**
  * Interface for downloading single owner chunks
@@ -441,6 +456,22 @@ export interface PostageBatchOptions extends RequestOptions {
      */
     gasPrice?: NumberString;
     immutableFlag?: boolean;
+    /**
+     * The returned Promise will await until the purchased Postage Batch is usable.
+     * In other word, it has to have enough block confirmations that Bee pronounce it usable.
+     * If turned on, this significantly prolong the creation of postage batch!
+     * If you plan to use the stamp right away for some action with Bee (like uploading using this stamp) it is
+     * highly recommended to use this option, otherwise you might get errors "stamp not usable" from Bee.
+     *
+     * In next breaking release this option will be turned on by default.
+     * @default false
+     */
+    waitForUsable?: boolean;
+    /**
+     * When waiting for the postage stamp to become usable, this specify the timeout for the waiting.
+     * Default: 120s
+     */
+    waitForUsableTimeout?: number;
 }
 /**
  * With this type a number should be represented in a string

package/dist/types/{utils → src/utils}/bytes.d.ts

@@ -28,6 +28,13 @@ export interface FlexBytes<Min extends number, Max extends number> extends Uint8
  * @param length  The length of the byte array
  */
 export declare function isBytes<Length extends number>(b: unknown, length: Length): b is Bytes<Length>;
+/**
+ * Function that verifies if passed data are Bytes and if the array has "length" number of bytes under given offset.
+ * @param data
+ * @param offset
+ * @param length
+ */
+export declare function hasBytesAtOffset(data: unknown, offset: number, length: number): boolean;
 /**
  * Verifies if a byte array has a certain length
  *

package/dist/types/src/utils/reference.d.ts

@@ -0,0 +1,2 @@
+import { BytesReference, Reference } from '../types';
+export declare function makeBytesReference(reference: Uint8Array | BytesReference | Reference, offset?: number): BytesReference;

package/dist/types/{utils → src/utils}/type.d.ts

@@ -1,4 +1,5 @@
-import { Address, AddressPrefix, AllTagsOptions, BatchId, CollectionUploadOptions, FileUploadOptions, NumberString, PssMessageHandler, PublicKey, Readable, Reference, Tag, UploadOptions, TransactionHash, RequestOptions, PostageBatchOptions, CashoutOptions } from '../types';
+import { Address, AddressPrefix, AllTagsOptions, BatchId, CollectionUploadOptions, FileUploadOptions, NumberString, PssMessageHandler, PublicKey, Readable, Reference, Tag, UploadOptions, TransactionHash, RequestOptions, PostageBatchOptions, CashoutOptions, ReferenceOrEns, UploadResult, UploadResultWithCid } from '../types';
+import { ReferenceType } from '@ethersphere/swarm-cid';
 export declare function isUint8Array(obj: unknown): obj is Uint8Array;
 export declare function isInteger(value: unknown): value is number | NumberString;
 export declare function isObject(value: unknown): value is Record<string, unknown>;
@@ -22,7 +23,22 @@ export declare function assertStrictlyObject(value: unknown, name?: string): ass
 export declare function assertBoolean(value: unknown, name?: string): asserts value is boolean;
 export declare function assertInteger(value: unknown, name?: string): asserts value is number | NumberString;
 export declare function assertNonNegativeInteger(value: unknown, name?: string): asserts value is number | NumberString;
+export declare function assertPositiveInteger(value: unknown, name?: string): asserts value is number | NumberString;
 export declare function assertReference(value: unknown): asserts value is Reference;
+export declare function assertReferenceOrEns(value: unknown): asserts value is ReferenceOrEns;
+/**
+ * Function that mainly converts Swarm CID into hex encoded Swarm Reference
+ *
+ * @param value
+ * @param expectedCidType
+ */
+export declare function makeReferenceOrEns(value: unknown, expectedCidType: ReferenceType): ReferenceOrEns;
+/**
+ * Function that adds getter which converts the reference into CID base32 encoded string.
+ * @param result
+ * @param cidType Type as described in the @ethersphere/swarm-cids-js -> ReferenceType
+ */
+export declare function addCidConversionFunction(result: UploadResult, cidType: ReferenceType): UploadResultWithCid;
 export declare function assertAddress(value: unknown): asserts value is Address;
 export declare function assertBatchId(value: unknown): asserts value is BatchId;
 export declare function assertRequestOptions(value: unknown, name?: string): asserts value is RequestOptions;

package/dist/types/test/utils.d.ts

@@ -0,0 +1,119 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import type { Ky, BeeGenericResponse, Reference, Address, BatchId, PostageBatch, PlainBytesReference } from '../src/types';
+import { HexString } from '../src/utils/hex';
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeHashReference(): R;
+            toBeBeeResponse(expectedStatusCode: number): R;
+            toBeOneOf(el: unknown[]): R;
+            toBeType(type: string): R;
+            toBeNumberString(): R;
+        }
+    }
+}
+/**
+ * Load common own Jest Matchers which can be used to check particular return values.
+ */
+export declare function commonMatchers(): void;
+/**
+ * Sleep for N miliseconds
+ *
+ * @param ms Number of miliseconds to sleep
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Helper function that reads whole content of ReadableStream
+ * @param stream
+ */
+export declare function readWholeUint8ArrayReadableStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
+export declare function createRandomNodeReadable(totalSize: number, chunkSize?: number): Readable;
+export declare function createReadableStream(iterable: Iterable<Uint8Array>): ReadableStream;
+/**
+ * Utility function for generating random Buffer
+ * !!! IT IS NOT CRYPTO SAFE !!!
+ * For that use `crypto.randomBytes()`
+ *
+ * @param length Number of bytes to generate
+ * @param seed Seed for the pseudo-random generator
+ */
+export declare function randomByteArray(length: number, seed?: number): Uint8Array;
+/**
+ * Returns a url for testing the Bee public API
+ */
+export declare function beeUrl(): string;
+export declare function beeKy(): Ky;
+/**
+ * Returns a url of another peer for testing the Bee public API
+ */
+export declare function beePeerUrl(): string;
+export declare function beePeerKy(): Ky;
+/**
+ * Helper function that create monster batch for all the tests.
+ * There is semaphore mechanism that allows only creation of one batch across all the
+ * parallel running tests that have to wait until it is created.
+ */
+export declare function getPostageBatch(url?: string): BatchId;
+/**
+ * Returns a url for testing the Bee Debug API
+ */
+export declare function beeDebugUrl(): string;
+export declare function beeDebugKy(): Ky;
+/**
+ * Returns a url for testing the Bee Debug API
+ */
+export declare function beePeerDebugUrl(): string;
+export declare function beePeerDebugKy(): Ky;
+/**
+ * Try to delete a chunk from local storage, ignoring all errors
+ *
+ * @param address  Swarm address of chunk
+ */
+export declare function tryDeleteChunkFromLocalStorage(address: string | PlainBytesReference): Promise<void>;
+/**
+ * Formatting utility for displaying long strings like hexstrings.
+ *
+ * @param inputStr
+ * @param len
+ */
+export declare function shorten(inputStr: unknown, len?: number): string;
+export declare function waitForBatchToBeUsable(batchId: string, pollingInterval?: number): Promise<void>;
+/**
+ * Returns already existing batch or will create one.
+ *
+ * If some specification is passed then it is guaranteed that the batch will have this property(ies)
+ *
+ * @param amount
+ * @param depth
+ * @param immutable
+ */
+export declare function getOrCreatePostageBatch(amount?: string, depth?: number, immutable?: boolean): Promise<PostageBatch>;
+export declare function makeTestTarget(target: string): string;
+export declare const invalidReference: Reference;
+export declare const okResponse: BeeGenericResponse;
+export declare const createdResponse: BeeGenericResponse;
+export declare const ERR_TIMEOUT = 40000;
+export declare const BIG_FILE_TIMEOUT = 100000;
+export declare const PSS_TIMEOUT = 120000;
+export declare const FEED_TIMEOUT = 120000;
+export declare const BLOCKCHAIN_TRANSACTION_TIMEOUT = 40000;
+export declare const WAITING_USABLE_STAMP_TIMEOUT = 130000;
+export declare const testChunkPayload: Uint8Array;
+export declare const testChunkSpan: Uint8Array;
+export declare const testChunkData: Uint8Array;
+export declare const testChunkHash: Reference;
+export declare const testAddress: Address;
+export declare const testBatchId: BatchId;
+export declare const testJsonPayload: {
+    some: string;
+}[];
+export declare const testJsonStringPayload: string;
+export declare const testJsonHash = "872a858115b8bee4408b1427b49e472883fdc2512d5a8f2d428b97ecc8f7ccfa";
+export declare const testJsonCid = "bah5acgzaq4vilaivxc7oiqelcqt3jhshfcb73qsrfvni6lkcrol6zshxzt5a";
+export declare const testJsonEns = "testing.eth";
+export declare const testIdentity: {
+    privateKey: HexString<number>;
+    publicKey: HexString<number>;
+    address: HexString<number>;
+};