hollowdb

import { Warp, Contract, ArWallet, CustomSignature, SortKeyCacheResult } from "warp-contracts"; import { SortKeyCacheRangeOptions } from "warp-contracts/lib/types/cache/SortKeyCacheRangeOptions"; /** * A type-utility to convert an array of `T`s into a mapped type, * that can be used for example as a mapping key type. * * If the array is empty, defaults to `T`. */ type OpitonalArray<A extends T[], T> = A extends [] ? T : A[number]; /** * A type to describe whitelists and proofs (circuits) used within a contract. */ type ContractMode = { whitelists: string[]; proofs: string[]; }; /** * A generic contract input. */ type ContractInputGeneric = { function: string; value: any; }; /** * A contract state. For example, HollowDB state is defined as: * * ```ts * ContractState<{circuits: ['auth']; whitelists: ['put', 'update']}> * ``` * * because we have an `auth` circuit, and we have two whitelists names `put` and `update`. * * @template M a type where whitelists and circuit names are specified. If none, pass in empty array `[]` to each. */ type ContractState<M extends ContractMode = ContractMode> = { version: string; canEvolve: boolean; evolve?: string; owner: string; isProofRequired: { [name in OpitonalArray<M['proofs'], string>]: boolean; }; verificationKeys: { [name in OpitonalArray<M['proofs'], string>]: any; }; whitelists: { [name in OpitonalArray<M['whitelists'], string>]: { [address: string]: boolean; }; }; isWhitelistRequired: { [name in OpitonalArray<M['whitelists'], string>]: boolean; }; }; declare class Base<M extends ContractMode> { readonly contract: Contract<ContractState<M>>; readonly warp: Warp; readonly signer: ArWallet | CustomSignature; constructor(signer: ArWallet | CustomSignature, contractTxId: string, warp: Warp); /** * Return the latest contract state. * * This is a good way to trigger Warp to fetch the latest data from Arweave. * Note that if the contract has many transactions, fetching up to the latest * state may take some time. * * @returns contract state along with corresponding sort key */ readState(): Promise<import("warp-contracts").SortKeyCacheResult<import("warp-contracts").EvalStateResult<ContractState<M>>>>; /** * A typed wrapper around `dryWrite`, which evaluates a given input * on the local state, without creating a transaction. This may provide * better UX for some use-cases. * @param input input in the form of `{function, value}` * @returns interaction result */ dryWrite(input: I): Promise<import("warp-contracts").InteractionResult<ContractState<M>, unknown>>; /** * A typed wrapper around `writeInteraction`, which creates a * transaction. You are likely to use this after `dryWrite`, or you * may directly call this function. * @param input input in the form of `{function, value}` * @returns interaction response */ writeInteraction(input: I): Promise<import("warp-contracts").WriteInteractionResponse | null>; /** * A typed wrapper around `dryWrite` followed by `writeInteraction`. This * function first executes the interaction locally via `dryWrite`, and if * there is an error, throws an error with an optional prefix in the message. * @param input input in the form of `{function, value}` * @param errorPrefix optional prefix for the error message */ dryWriteInteraction(input: I): Promise<void>; /** * A typed wrapper around `viewState` followed with a repsonse type check. * If response type is not `ok`, it will throw an error. * @param input input in the form of `{function, value}` * @returns interaction result */ safeReadInteraction(input: I): Promise<V>; /** * A typed wrapper around `viewState`, which is a read interaction. * @param input input in the form of `{function, value}` * @returns interaction result */ viewState(input: I): Promise<import("warp-contracts").InteractionResult<ContractState<M>, R>>; } declare class Admin<M extends ContractMode = ContractMode> { constructor(base: Base<M>); /** * Sets the owner as the given wallet address. * @param newOwner address of the new owner, make sure that this is correct! */ updateOwner(newOwner: string): Promise<void>; /** * Changes the whitelist for the selected list. * @param users an array of user addresses * @param name name of the list to be updated * @param op whether to `add` the users to whitelist or `remove` them */ updateWhitelist(users: string[], name: OpitonalArray<M['whitelists'], string>, op: 'add' | 'remove'): Promise<void>; /** * Update a verification key. * @param name name of the circuit that the verification key belongs to * @param verificationKey verification key */ updateVerificationKey(name: OpitonalArray<M['proofs'], string>, verificationKey: any): Promise<void>; /** * Disable or enable whitelist checks for a specific whitelist. * @param name name of the list * @param value a boolean */ updateWhitelistRequirement(name: OpitonalArray<M['whitelists'], string>, value: boolean): Promise<void>; /** * Disable or enable proof checks for a specific circuit. * @param name name of the circuit * @param value a boolean */ updateProofRequirement(name: OpitonalArray<M['proofs'], string>, value: boolean): Promise<void>; } export class BaseSDK<V = unknown, M extends ContractMode = ContractMode> { readonly base: Base<M>; readonly admin: Admin<M>; /** * Connects to the given contract via the provided Warp instance using the provided signer. * @param signer a Signer, such as Arweave wallet or Ethereum CustomSignature * @param contractTxId contract txId to connect to * @param warp a Warp instace, such as `WarpFactory.forMainnet()` */ constructor(signer: ArWallet | CustomSignature, contractTxId: string, warp: Warp); /** The smart-contract that we are connected to. */ get contract(): Contract<ContractState<M>>; /** Warp instance. */ get warp(): Warp; /** Contract transaction id. */ get contractTxId(): string; /** Signer. */ get signer(): ArWallet | CustomSignature; /** * Returns the latest contract state. * * For a more fine-grained state data, use `base.readState()`. * * @returns contract state object */ getState(): Promise<ContractState<M>>; /** * Alternative method of getting key values. Uses the underlying `getStorageValues` * function, returns a Map instead of an array. * * @param keys an array of keys * @returns `SortKeyCacheResult` of a key-value `Map` */ getStorageValues(keys: string[]): Promise<SortKeyCacheResult<Map<string, V | null>>>; /** * Returns keys with respect to a range option. * * If no option is provided, it will get all keys. * * @param options optional range * @returns an array of keys */ getKeys(options?: SortKeyCacheRangeOptions): Promise<string[]>; /** * Returns all keys in the database. * * @returns an array of all keys */ getAllKeys(): Promise<string[]>; /** * Returns a mapping of keys and values with respect to a range option. * If no option is provided, all values are returned. * * @param options optional range * @returns a key-value `Map` */ getKVMap(options?: SortKeyCacheRangeOptions): Promise<Map<string, V | null>>; /** * Gets the value of the given key. * @param key the key of the value to be returned * @returns the value of the given key */ get(key: string): Promise<V | null>; /** * Gets the values at the given keys as an array. * * If a value does not exist, it is returned as `null`. * * Note that the transaction limit may become a problem for too many keys. * * @param keys an array of keys * @returns an array of corresponding values */ getMany(keys: string[]): Promise<(V | null)[]>; /** * Inserts the given value into database. * * There must not be a value at the given key. * * @param key the key of the value to be inserted * @param value the value to be inserted */ put(key: string, value: V): Promise<void>; /** * Inserts an array of value into database. * * There must not be a value at the given key. * * @param keys the keys of the values to be inserted * @param values the values to be inserted */ putMany(keys: string[], values: V[]): Promise<void>; /** * Updates the value of given key. * @param key key of the value to be updated * @param value new value * @param proof optional zero-knowledge proof */ update(key: string, value: V, proof?: object): Promise<void>; /** * Removes the value of given key along with the key. * Checks if the proof is valid. * @param key key of the value to be removed * @param proof optional zero-knowledge proof */ remove(key: string, proof?: object): Promise<void>; } export class SDK<V = unknown> extends BaseSDK<V, { proofs: ['auth']; whitelists: ['put', 'update']; }> { } /** Just like HollowDB SDK, but supports `Set` and `SetMany` operations. * The user must be whitelisted for `set` separately to use them. * * A `set` operation is like a `put` but the key can exist already and will be overwritten. */ export class SetSDK<V = unknown> extends BaseSDK<V, { proofs: ['auth']; whitelists: ['put', 'update', 'set']; }> { /** * Inserts the given value into database. * * Overwrites the existing values at the given key. * * @param key the key of the value to be inserted * @param value the value to be inserted */ set(key: string, value: V): Promise<void>; /** * Inserts an array of value into database. * * Overwrites the existing values at the given keys. * * @param keys the keys of the values to be inserted * @param values the values to be inserted */ setMany(keys: string[], values: V[]): Promise<void>; /** * Overwrites the contract state. * * Note that this is an owner-only operation, and a wrongfully * overwritten state may break some of the contract methods. * * @param state the key of the value to be inserted */ setState(state: Awaited<ReturnType<this['getState']>>): Promise<void>; } //# sourceMappingURL=index.d.ts.map