@audius/sdk 0.0.0 → 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,2431 @@
+import * as axios from 'axios';
+import { AxiosResponse, AxiosRequestConfig, Method, AxiosError } from 'axios';
+import { PathArg } from 'proper-url-join';
+import * as BN from 'bn.js';
+import BN__default from 'bn.js';
+import * as Web3 from 'web3';
+import Web3__default from 'web3';
+import { AbiItem } from 'web3-utils';
+import * as web3_core from 'web3-core';
+import { Log, TransactionReceipt, HttpProvider, EventLog } from 'web3-core';
+import Wallet from 'ethereumjs-wallet';
+import abiDecoder from 'abi-decoder';
+import { Hedgehog } from '@audius/hedgehog';
+import { EIP712TypedData } from 'eth-sig-util';
+import * as web3_eth_contract from 'web3-eth-contract';
+import { Contract } from 'web3-eth-contract';
+import { UserImporterOptions, ImportCandidate } from 'ipfs-unixfs-importer';
+import * as ipfs_unixfs_importer_types_src_types from 'ipfs-unixfs-importer/types/src/types';
+import FormData from 'form-data';
+
+declare type Content = ReadableStream | Buffer | string;
+interface ImageHasher {
+    options: UserImporterOptions;
+    content: ImportCandidate;
+}
+interface NonImageHasher {
+    options: UserImporterOptions;
+    content: Uint8Array;
+}
+interface HashedImage {
+    path: string | undefined;
+    cid: string;
+    size: number;
+}
+
+type ContractABI = {
+  abi: AbiItem[]
+  contractName: string
+}
+
+declare class Utils {
+    static importDataContractABI(pathStr: string): ContractABI;
+    static importEthContractABI(pathStr: string): ContractABI;
+    static utf8ToHex(utf8Str: string): string;
+    static padRight(hexStr: string, size: number): string;
+    static hexToUtf8(hexStr: string): string;
+    static keccak256(utf8Str: string): string;
+    static isBN(number: number | string): boolean;
+    static toBN(number: number, base?: number): BN;
+    static BN(): typeof BN;
+    static checkStrLen(str: string, maxLen: number, minLen?: number): void;
+    static wait(milliseconds: number): Promise<void>;
+    static isFQDN(url: string): boolean;
+    static isHttps(url: string): boolean;
+    static isHealthy(url: string): Promise<any>;
+    static formatOptionalMultihash(multihash: string): string;
+    static decodeMultihash(multihash: string): {
+        digest: string;
+        hashFn: number;
+        size: number;
+    };
+    /**
+     * Given a digest value (written on chain, obtained through AudiusABIDecoder.decodeMethod),
+     * convert back to a IFPS CIDv0
+     * @param multihashDigest digest value from decodeMultihash
+     * @returns String CID value
+     */
+    static encodeMultihash(multihashDigest: string): string;
+    static parseDataFromResponse(response: AxiosResponse): any;
+    static configureWeb3(web3Provider: string, chainNetworkId: string, requiresAccount?: boolean): Promise<false | Web3.default>;
+    static get zeroAddress(): string;
+    static isZeroAddress(address: string): boolean;
+    static makeUuid(): string;
+    /**
+     * Decodes a string id into an int. Returns null if an invalid ID.
+     */
+    static decodeHashId(id: string): number | null;
+    /**
+     * Encodes an int to a string based hashid
+     */
+    static encodeHashId(id: number | null): string | null;
+    /**
+     * If `promise` responds before `timeoutMs`,
+     * this function returns its response; else rejects with `timeoutMessage`
+     */
+    static racePromiseWithTimeout(promise: Promise<void>, timeoutMs: number, timeoutMessage: string): Promise<unknown>;
+    static fileHasher: {
+        convertNanosToMillis(nanoSeconds: bigint): bigint;
+        initImageHasher(content: ipfs_unixfs_importer_types_src_types.ImportCandidate, options: ipfs_unixfs_importer_types_src_types.UserImporterOptions): ImageHasher;
+        initNonImageHasher(content: Uint8Array, options: ipfs_unixfs_importer_types_src_types.UserImporterOptions): NonImageHasher;
+        convertToBuffer(content: Content, logger: any): Promise<Buffer>;
+        hashNonImages(content: Uint8Array, options?: ipfs_unixfs_importer_types_src_types.UserImporterOptions): Promise<string>;
+        hashImages(content: ipfs_unixfs_importer_types_src_types.ImportCandidate, options?: ipfs_unixfs_importer_types_src_types.UserImporterOptions): Promise<HashedImage[]>;
+        generateNonImageCid(content: Content, logger?: any): Promise<string>;
+        generateImageCids(content: ipfs_unixfs_importer_types_src_types.ImportCandidate, logger?: any): Promise<HashedImage[]>;
+    };
+}
+
+declare global {
+    interface Window {
+        grecaptcha: {
+            ready: (callback: () => void) => Promise<void>;
+            execute: (siteKey: string, config: {
+                action: string;
+            }) => Promise<string>;
+        };
+    }
+}
+interface CaptchaConfig {
+    siteKey: string;
+    serviceKey: string;
+}
+declare class Captcha {
+    siteKey: string;
+    serviceKey: string;
+    constructor({ siteKey, serviceKey }: CaptchaConfig);
+    /**
+     * Intended to be called by clients. Will generate a token used to calculate recaptcha score.
+     * @param action name for this "action" for grouping
+     */
+    generate(action: string): Promise<string>;
+    /**
+     * Intended to be called by services. According to recaptcha v3 docs:
+     * A score of 1.0 is very likely a good interaction, 0.0 is very likely a bot
+     * @param token
+     * @param minScore score must be >= minScore to be ok
+     * @returns
+     *    {boolean | null} ok - whether score > minScore (false if something went wrong)
+     *    {number | null} score - the raw score [0, 1] (or null if a score was not computed)
+     */
+    verify(token: string, minScore?: number): Promise<{
+        score: any;
+        ok: boolean;
+        hostname: any;
+    }>;
+}
+
+interface ContractMethod {
+    arguments: string[];
+    estimateGas: (config: {
+        from: Wallet | string | undefined;
+        gas: number | undefined;
+    }) => Promise<number>;
+    _method: {
+        name: string;
+        inputs: Array<{
+            type: string;
+        }>;
+    };
+    encodeABI: () => string;
+    send: <Tx>(config: {
+        from: Wallet | string | undefined;
+        gas: number;
+        gasPrice?: number;
+    }) => Tx;
+}
+
+declare type ServiceName = string;
+interface ServiceWithEndpoint {
+    endpoint: string;
+    spID?: string;
+}
+declare type Service = ServiceName | ServiceWithEndpoint;
+
+declare type Maybe<T> = T | undefined;
+declare type Nullable<T> = T | null;
+interface Logger {
+    /**
+     * Write a 'log' level log.
+     */
+    log: (message: any, ...optionalParams: any[]) => any;
+    /**
+     * Write a 'info' level log.
+     */
+    info: (message: any, ...optionalParams: any[]) => any;
+    /**
+     * Write an 'error' level log.
+     */
+    error: (message: any, ...optionalParams: any[]) => any;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn: (message: any, ...optionalParams: any[]) => any;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?: (message: any, ...optionalParams: any[]) => any;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose?: (message: any, ...optionalParams: any[]) => any;
+}
+
+declare type GetServicesInput = (() => Promise<ServiceName[]>) | ((config: {
+    verbose: false;
+}) => Promise<ServiceName[]>) | ((config: {
+    verbose: true;
+}) => Promise<ServiceWithEndpoint[]>) | ((config: {
+    verbose: boolean;
+}) => Promise<ServiceName[] | ServiceWithEndpoint[]>);
+interface GetServices {
+    (): Promise<ServiceName[]>;
+    (config: {
+        verbose: false;
+    }): Promise<ServiceName[]>;
+    (config: {
+        verbose: true;
+    }): Promise<ServiceWithEndpoint[]>;
+    (config: {
+        verbose: boolean;
+    }): Promise<Service[]>;
+}
+interface Decision {
+    stage: string;
+    val?: unknown;
+}
+declare type Backup = {
+    block_difference: number;
+    version: string;
+};
+interface ServiceSelectionConfig {
+    blacklist?: Set<string> | undefined | null;
+    whitelist?: Set<string> | undefined | null;
+    getServices: GetServicesInput;
+    maxConcurrentRequests?: number;
+    requestTimeout?: Maybe<number>;
+    unhealthyTTL?: number;
+    backupsTTL?: number;
+}
+/**
+ * A class that assists with autoselecting services.
+ * `ServiceSelection` is intended to be overridden with further
+ * business logic that a particular sevice might preference.
+ *
+ * The general use case is as follows:
+ *
+ * ```
+ *
+ * const selector = new ServiceSelection({
+ *   getServices: ethContracts.getDiscoveryProviders()
+ * })
+ *
+ * const service = await selector.select()
+ *
+ * ```
+ *
+ * This class operates by taking a list of services and
+ * round-robin makes requests at them until a suitable one is found.
+ *
+ * Two types of "bad" services are defined below:
+ *  - Unhealthy: this service is bad and should not be used
+ *  - Backup: this service is bad, but if we can't find anything better, maybe use it
+ *
+ * Classes that extend `ServiceSelection` can choose to implement custom logic on top
+ * of them and is generally how this class is intended to be used.
+ */
+declare class ServiceSelection {
+    blacklist: Set<string> | undefined | null;
+    whitelist: Set<string> | undefined | null;
+    getServices: GetServices;
+    maxConcurrentRequests: number;
+    requestTimeout: number;
+    unhealthyTTL: number;
+    backupsTTL: number;
+    unhealthy: Set<string>;
+    backups: Record<string, Backup>;
+    totalAttempts: number;
+    decisionTree: Decision[];
+    unhealthyCleanupTimeout: NodeJS.Timeout | null;
+    backupCleanupTimeout: NodeJS.Timeout | null;
+    constructor({ blacklist, whitelist, getServices, maxConcurrentRequests, requestTimeout, // 30s
+    unhealthyTTL, // 1 hour
+    backupsTTL }: ServiceSelectionConfig);
+    /**
+     * Selects a service
+     * @param reset if reset is true, clear the decision tree
+     */
+    select(reset?: any): Promise<any>;
+    /**
+     * Finds all selectable services (respecting whitelist, health checks & timeouts).
+     * Note: this method is potentially slow.
+     * If you need just a single service, prefer calling `.select()`
+     * @param {boolean} verbose whether or not to return full services metadata
+     * @param {Set} whitelist a whitelist to override the set of endpoints
+     */
+    findAll({ verbose, whitelist }?: {
+        verbose?: boolean | undefined;
+        whitelist?: Set<string> | null | undefined;
+    }): Promise<(Service | null)[]>;
+    /** Triggers a clean up of unhealthy and backup services so they can be retried later */
+    triggerCleanup(): void;
+    clearUnhealthy(): void;
+    clearBackups(): void;
+    /** A short-circuit. If overriden, can be used to skip selection (which could be slow) */
+    shortcircuit(): null | string;
+    /**
+     * Filter out services that are in the blacklist
+     * @param services endpoints
+     */
+    filterFromBlacklist(services: string[]): string[];
+    /** Filter down services to those in the whitelist */
+    filterToWhitelist(services: string[]): string[];
+    /** Filter out known unhealthy services from the provided */
+    filterOutKnownUnhealthy(services: string[]): string[];
+    /** Given a list of services, samples maxConcurrentRequests from them */
+    getSelectionRound(services: string[]): string[];
+    /** Gets the total number of attempts we've made this instantiation */
+    getTotalAttempts(): number;
+    /** Where does the health check for this type of service live */
+    static getHealthCheckEndpoint(service: string): string;
+    /**
+     * What the criteria is for a healthy service
+     * @param response axios response
+     * @param {{ [key: string]: string}} urlMap health check urls mapped to their cannonical url
+     * e.g. https://discoveryprovider.audius.co/health_check => https://discoveryprovider.audius.co
+     */
+    isHealthy(response: AxiosResponse, _urlMap: Record<string, Service>): boolean;
+    /** Races requests against each other with provided timeouts and health checks */
+    race(services: string[]): Promise<{
+        best: null;
+        errored: (string | undefined)[];
+    }>;
+    /** Adds a service to the unhealthy set */
+    addUnhealthy(service: ServiceName): void;
+    /** Gets unhealthy set size */
+    getUnhealthySize(): number;
+    /**
+     * Removes from unhealthy set
+     * @param key service endpoint
+     */
+    removeFromUnhealthy(key: string): void;
+    /**
+     * Adds a service to the list of backups
+     * @param service the service to add
+     * @param response the services response. This can be used to weigh various
+     * backups against eachother
+     */
+    addBackup(service: string, response: Backup): void;
+    /**
+     * Controls how a backup is picked. Overriding methods may choose to use the backup's response.
+     * e.g. pick a backup that's the fewest versions behind
+     */
+    selectFromBackups(): Promise<string | undefined>;
+    /**
+     * Removes from backups
+     * @param key service endpoint
+     */
+    removeFromBackups(key: string): void;
+    /**
+     * Returns the size of backups
+     */
+    getBackupsSize(): number;
+}
+
+declare type TimeFrame = 'day' | 'week' | 'month' | 'year' | 'millennium';
+
+declare type Web3Config$1 = {
+    useExternalWeb3: boolean;
+    internalWeb3Config: {
+        web3ProviderEndpoints: string[];
+        privateKey?: string;
+    };
+    externalWeb3Config?: {
+        web3: Web3__default;
+        ownerWallet: Wallet;
+    };
+};
+
+declare class AudiusABIDecoder {
+    static decodeMethod(contractName: string, encodedABI: string): abiDecoder.DecodedMethod;
+    static decodeLogs(_: string, logs: Log[]): abiDecoder.DecodedLog;
+}
+
+declare type Web3ManagerConfig = {
+    web3Config: Web3Config$1;
+    identityService: IdentityService;
+    hedgehog: Hedgehog;
+    isServer?: boolean;
+};
+/** singleton class to be instantiated and persisted with every AudiusLibs */
+declare class Web3Manager {
+    web3Config: Web3Config$1;
+    isServer: boolean;
+    identityService: IdentityService;
+    hedgehog: Hedgehog;
+    AudiusABIDecoder: typeof AudiusABIDecoder;
+    web3: Web3__default | undefined;
+    useExternalWeb3: boolean | undefined;
+    ownerWallet: Wallet;
+    constructor({ web3Config, identityService, hedgehog, isServer }: Web3ManagerConfig);
+    init(): Promise<void>;
+    getWeb3(): Web3__default;
+    setWeb3(web3: Web3__default): void;
+    getWalletAddress(): any;
+    setOwnerWallet(ownerWallet: Wallet): void;
+    web3IsExternal(): boolean | undefined;
+    getOwnerWalletPrivateKey(): Buffer;
+    /**
+     * Signs provided string data (should be timestamped).
+     * @param data
+     */
+    sign(data: string): Promise<string | undefined>;
+    /**
+     * Given a data payload and signature, verifies that signature is valid, and returns
+     * Ethereum wallet address used to sign data.
+     * @param data information that was signed
+     * @param signature hex-formatted signature of data generated by web3 personalSign method
+     */
+    verifySignature(data: string, signature: string): Promise<string>;
+    signTypedData(signatureData: EIP712TypedData): Promise<unknown>;
+    sendTransaction(contractMethod: ContractMethod, contractRegistryKey?: string | null, contractAddress?: string | null, txRetries?: number, txGasLimit?: number): Promise<TransactionReceipt>;
+    provider(url: string, timeout: number): HttpProvider;
+    monkeyPatchProvider(httpProvider: HttpProvider): HttpProvider;
+}
+
+declare type Data = Record<string, unknown>;
+declare type RelayTransaction = {
+    resp: {
+        txHash: string;
+        txParams: {
+            data: string;
+            gasLimit: string;
+            gasPrice: number;
+            nonce: string;
+            to: string;
+            value: string;
+        };
+    };
+};
+declare type TransactionData = {
+    recentBlockhash: string;
+    secpInstruction?: {
+        publicKey: string;
+        message: string;
+        signature: any;
+        recoveryId: number;
+    };
+    instruction: {
+        keys: Array<{
+            pubkey: string;
+            isSigner?: boolean;
+            isWritable?: boolean;
+        }>;
+        programId: string;
+        data: Record<string, unknown>;
+    };
+};
+declare type AttestationResult = {
+    status: string;
+    userId: string;
+    challengeId: string;
+    amount: number;
+    source: string;
+    specifier: string;
+    error?: string;
+    phase?: string;
+    reason?: string;
+};
+declare type IdentityServiceConfig = {
+    identityServiceEndpoint: string;
+    captcha?: Captcha;
+};
+declare class IdentityService {
+    identityServiceEndpoint: string;
+    captcha: Captcha | undefined;
+    web3Manager: Web3Manager | null;
+    constructor({ identityServiceEndpoint, captcha }: IdentityServiceConfig);
+    setWeb3Manager(web3Manager: Web3Manager): void;
+    getFn(params: {
+        lookupKey: string;
+        username: string;
+    }): Promise<{
+        iv: string;
+        cipherText: string;
+    }>;
+    setAuthFn(obj: Data): Promise<unknown>;
+    setUserFn(obj: Data & {
+        token?: string;
+    }): Promise<unknown>;
+    getUserEvents(walletAddress: string): Promise<unknown>;
+    sendRecoveryInfo(obj: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Check if an email address has been previously registered.
+     */
+    checkIfEmailRegistered(email: string): Promise<{
+        exists: boolean;
+    }>;
+    getUserEmail(): Promise<{
+        email: string | undefined | null;
+    }>;
+    /**
+     * Associates a user with a twitter uuid.
+     * @param uuid from the Twitter API
+     * @param userId
+     * @param handle User handle
+     */
+    associateTwitterUser(uuid: string, userId: number, handle: string): Promise<unknown>;
+    /**
+     * Associates a user with an instagram uuid.
+     * @param uuid from the Instagram API
+     * @param userId
+     * @param handle
+     */
+    associateInstagramUser(uuid: string, userId: number, handle: string): Promise<unknown>;
+    /**
+     * Logs a track listen for a given user id.
+     * @param trackId
+     * @param userId
+     * @param listenerAddress if logging this listen on behalf of another IP address, pass through here
+     * @param signatureData if logging this listen via a 3p service, a signed piece of data proving authenticity
+     */
+    logTrackListen(trackId: number, userId: number, listenerAddress: string, signatureData?: {
+        signature: string;
+        timestamp: string;
+    }, solanaListen?: boolean): Promise<unknown>;
+    /**
+     * Return listen history tracks for a given user id.
+     * @param userId - User ID
+     * @param limit - max # of items to return
+     * @param offset - offset into list to return from (for pagination)
+     */
+    getListenHistoryTracks(userId: number, limit?: number, offset?: number): Promise<unknown>;
+    /**
+     * Looks up a Twitter account by handle.
+     * @returns twitter API response.
+     */
+    lookupTwitterHandle(handle: string): Promise<unknown>;
+    /**
+     * Gets tracks trending on Audius.
+     * @param timeFrame one of day, week, month, or year
+     * @param idsArray track ids
+     * @param limit
+     * @param offset
+     */
+    getTrendingTracks(timeFrame?: string | null, idsArray?: number[] | null, limit?: number | null, offset?: number | null): Promise<{
+        listenCounts: Array<{
+            trackId: number;
+            listens: number;
+        }>;
+    }>;
+    /**
+     * Gets listens for tracks bucketted by timeFrame.
+     * @param timeFrame one of day, week, month, or year
+     * @param idsArray track ids
+     * @param startTime parseable by Date.parse
+     * @param endTime parseable by Date.parse
+     * @param limit
+     * @param offset
+     */
+    getTrackListens(timeFrame?: TimeFrame | null, idsArray?: number[] | null, startTime?: string | null, endTime?: string | null, limit?: number | null, offset?: number | null): Promise<{
+        bucket: Array<{
+            trackId: number;
+            date: string;
+            listens: number;
+        }>;
+    }>;
+    createUserRecord(email: string, walletAddress: string): Promise<unknown>;
+    relay(contractRegistryKey: string | null | undefined, contractAddress: string | null | undefined, senderAddress: string, encodedABI: string, gasLimit: number): Promise<{
+        receipt: TransactionReceipt;
+    }>;
+    ethRelay(contractAddress: string, senderAddress: Wallet | string, encodedABI: string, gasLimit: string): Promise<RelayTransaction>;
+    wormholeRelay({ senderAddress, permit, transferTokens }: {
+        senderAddress: string;
+        permit: string;
+        transferTokens: string[];
+    }): Promise<unknown>;
+    /**
+     * Gets the correct wallet that will relay a txn for `senderAddress`
+     * @param senderAddress wallet
+     */
+    getEthRelayer(senderAddress: string): Promise<unknown>;
+    getRandomFeePayer(): Promise<unknown>;
+    solanaRelay(transactionData: TransactionData): Promise<unknown>;
+    solanaRelayRaw(transactionData: TransactionData): Promise<unknown>;
+    getMinimumDelegationAmount(wallet: string): Promise<unknown>;
+    updateMinimumDelegationAmount(wallet: string, minimumDelegationAmount: number, signedData: AxiosRequestConfig['headers']): Promise<unknown>;
+    /**
+     * Sends an attestation result to identity.
+     *
+     */
+    sendAttestationResult(data: AttestationResult): Promise<unknown>;
+    _makeRequest<T = unknown>(axiosRequestObj: AxiosRequestConfig): Promise<T>;
+    _signData(): Promise<{
+        "Encoded-Data-Message": string;
+        "Encoded-Data-Signature": string | undefined;
+    } | {
+        "Encoded-Data-Message"?: undefined;
+        "Encoded-Data-Signature"?: undefined;
+    }>;
+}
+
+declare type EthWeb3Config = {
+    ownerWallet: Wallet | string;
+    providers: string[];
+};
+declare type EthWeb3ManagerConfig = {
+    web3Config: EthWeb3Config;
+    identityService: IdentityService;
+    hedgehog?: Hedgehog;
+};
+/** Singleton state-manager for Audius Eth Contracts */
+declare class EthWeb3Manager {
+    web3Config: EthWeb3Config;
+    web3: Web3__default;
+    identityService: IdentityService;
+    hedgehog?: Hedgehog;
+    ownerWallet: Maybe<Wallet | string>;
+    constructor({ web3Config, identityService, hedgehog }: EthWeb3ManagerConfig);
+    getWeb3(): Web3__default;
+    getWalletAddress(): any;
+    /**
+     * Signs provided string data (should be timestamped).
+     */
+    sign(data: string): Promise<string>;
+    sendTransaction(contractMethod: ContractMethod, contractAddress?: string | null, privateKey?: string | null, txRetries?: number, txGasLimit?: number | null): Promise<TransactionReceipt>;
+    /**
+     * Relays an eth transaction via the identity service with retries
+     * The relay pays for the transaction fee on behalf of the user
+     * The gas Limit is estimated if not provided
+     */
+    relayTransaction(contractMethod: ContractMethod, contractAddress: string, ownerWallet: Wallet | string, relayerWallet?: Wallet | string, txRetries?: number, txGasLimit?: number | null): Promise<Maybe<RelayTransaction['resp']>>;
+    getRelayMethodParams(contractAddress: string, contractMethod: ContractMethod, relayerWallet: Wallet): Promise<{
+        contractAddress: string;
+        encodedABI: string;
+        gasLimit: number;
+    }>;
+}
+
+declare class AudiusTokenClient {
+    ethWeb3Manager: EthWeb3Manager;
+    contractABI: AbiItem[];
+    contractAddress: string;
+    web3: Web3__default;
+    AudiusTokenContract: Contract;
+    bustCacheNonce: number;
+    constructor(ethWeb3Manager: EthWeb3Manager, contractABI: AbiItem[], contractAddress: string);
+    bustCache(): Promise<void>;
+    balanceOf(account: string): Promise<BN__default>;
+    name(): Promise<any>;
+    nonces(wallet: string): Promise<number>;
+    transfer(recipient: string, amount: BN__default): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+    }>;
+    transferFrom(owner: string, recipient: string, relayer: string, amount: BN__default): Promise<{
+        txReceipt: Maybe<{
+            txHash: string;
+            txParams: {
+                data: string;
+                gasLimit: string;
+                gasPrice: number;
+                nonce: string;
+                to: string;
+                value: string;
+            };
+        }>;
+    }>;
+    permit(owner: string, // address
+    spender: string, // address
+    value: BN__default, // uint
+    deadline: number, // uint
+    v: number, // uint8
+    r: Uint8Array | Buffer, // bytes32
+    s: Uint8Array | Buffer): Promise<Maybe<{
+        txHash: string;
+        txParams: {
+            data: string;
+            gasLimit: string;
+            gasPrice: number;
+            nonce: string;
+            to: string;
+            value: string;
+        };
+    }>>;
+    approve(spender: string, value: BN__default, privateKey?: null): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+    }>;
+    approveProxyTokens(owner: string, spender: string, value: BN__default, relayer: string): Promise<{
+        txReceipt: Maybe<{
+            txHash: string;
+            txParams: {
+                data: string;
+                gasLimit: string;
+                gasPrice: number;
+                nonce: string;
+                to: string;
+                value: string;
+            };
+        }>;
+    }>;
+}
+
+declare class RegistryClient {
+    web3Manager: EthWeb3Manager;
+    contractABI: AbiItem[];
+    contractAddress: string;
+    web3: Web3__default;
+    Registry: Contract;
+    constructor(web3Manager: EthWeb3Manager, contractABI: AbiItem[], contractAddress: string);
+    getContract(contractRegistryKey: string): Promise<string>;
+}
+
+/**
+ * This class provides the logic to select a healthy gateway
+ */
+declare class ProviderSelection extends ServiceSelection {
+    services: string[];
+    constructor(services?: string[]);
+    /**
+     * Filters out previously tried providers, and then initializes the client
+     * (ContractClient, RegistryClient) with a healthy POA provider.
+     *
+     * @param client object used for making transaction calls
+     */
+    select(client: {
+        web3Manager: Web3Manager | EthWeb3Manager;
+    }): Promise<void>;
+    getServicesSize(): number;
+}
+
+declare type GetRegistryAddress = (key: string) => Promise<string>;
+declare class ContractClient {
+    web3Manager: Web3Manager | EthWeb3Manager;
+    contractABI: ContractABI['abi'];
+    contractRegistryKey: string;
+    getRegistryAddress: GetRegistryAddress;
+    _contractAddress: Nullable<string>;
+    _contract: Nullable<Contract>;
+    _isInitialized: boolean;
+    _isInitializing: boolean;
+    _initAttempts: number;
+    providerSelector: Nullable<ProviderSelection>;
+    logger: Logger;
+    constructor(web3Manager: Web3Manager | EthWeb3Manager, contractABI: ContractABI['abi'], contractRegistryKey: string, getRegistryAddress: GetRegistryAddress, logger?: Logger, contractAddress?: Nullable<string>);
+    /** Inits the contract if necessary */
+    init(): Promise<void>;
+    retryInit(selectNewEndpoint?: boolean): Promise<void>;
+    /**
+     * Adds current provider into unhealthy set and selects the next healthy provider
+     */
+    selectNewEndpoint(): Promise<void>;
+    /** Gets the contract address and ensures that the contract has initted. */
+    getAddress(): Promise<string>;
+    /**
+     * Gets a contract method and ensures that the contract has initted
+     * The contract can then be invoked with .call() or be passed to a sendTransaction.
+     * @param methodName the name of the contract method
+     */
+    getMethod(methodName: string, ...args: any[]): Promise<any>;
+    getEthNetId(): Promise<number>;
+    getContract(): Promise<Contract>;
+}
+
+declare class StakingProxyClient extends ContractClient {
+    audiusTokenClient: AudiusTokenClient;
+    toBN: (value: string | number) => BN__default;
+    constructor(ethWeb3Manager: EthWeb3Manager, contractABI: ContractABI['abi'], contractRegistryKey: string, getRegistryAddress: GetRegistryAddress, audiusTokenClient: AudiusTokenClient, logger?: Logger);
+    token(): Promise<any>;
+    totalStaked(): Promise<BN__default>;
+    supportsHistory(): Promise<any>;
+    totalStakedFor(account: string): Promise<BN__default>;
+    totalStakedForAt(account: string, blockNumber: string): Promise<BN__default>;
+    totalStakedAt(blockNumber: number): Promise<BN__default>;
+    isStaker(account: string): Promise<any>;
+    getDelegateManagerAddress(): Promise<any>;
+    getClaimsManagerAddress(): Promise<any>;
+    getServiceProviderFactoryAddress(): Promise<any>;
+    getGovernanceAddress(): Promise<any>;
+    getLastClaimedBlockForUser(): Promise<any>;
+}
+
+declare type ProposalTxn = {
+    proposalId: string;
+    proposer: string;
+    submissionBlockNumber: string;
+    targetContractRegistryKey: string;
+    targetContractAddress: string;
+    callValue: string;
+    functionSignature: string;
+    callData: string;
+    outcome: string;
+    numVotes: string;
+    voteMagnitudeYes: string;
+    voteMagnitudeNo: string;
+};
+declare class GovernanceClient extends ContractClient {
+    audiusTokenClient: AudiusTokenClient;
+    stakingProxyClient: StakingProxyClient;
+    isDebug: boolean;
+    constructor(ethWeb3Manager: EthWeb3Manager, contractABI: ContractABI['abi'], contractRegistryKey: string, getRegistryAddress: GetRegistryAddress, audiusTokenClient: AudiusTokenClient, stakingProxyClient: StakingProxyClient, logger?: Logger, isDebug?: boolean);
+    /**
+     * Gets the function signature and call data for a contract method.
+     * The signature and call data are passed to other contracts (like governance)
+     * as arguments.
+     * @param methodName
+     * @param contractMethod
+     */
+    getSignatureAndCallData(methodName: string, contractMethod: ContractMethod): {
+        signature: string;
+        callData: string;
+    };
+    guardianExecuteTransaction(contractRegistryKey: string, functionSignature: string, callData: string): Promise<ContractMethod>;
+    getVotingPeriod(): Promise<number>;
+    setVotingPeriod(period: string): Promise<web3_core.TransactionReceipt>;
+    getVotingQuorumPercent(): Promise<number>;
+    getExecutionDelay(): Promise<number>;
+    setExecutionDelay(delay: number): Promise<web3_core.TransactionReceipt>;
+    getProposalById(id: number): Promise<{
+        proposalId: number;
+        proposer: string;
+        submissionBlockNumber: number;
+        targetContractRegistryKey: string;
+        targetContractAddress: string;
+        callValue: number;
+        functionSignature: string;
+        callData: string;
+        outcome: number;
+        numVotes: number;
+        voteMagnitudeYes: BN;
+        voteMagnitudeNo: BN;
+    }>;
+    getProposalTargetContractHash(id: string): Promise<any>;
+    getProposals(queryStartBlock?: number): Promise<{
+        proposalId: number;
+        proposer: any;
+        description: any;
+        name: any;
+        blockNumber: number;
+    }[]>;
+    getProposalsForAddresses(addresses: string[], queryStartBlock?: number): Promise<{
+        proposalId: number;
+        proposer: any;
+        description: any;
+        name: any;
+        blockNumber: number;
+    }[]>;
+    getProposalSubmission(proposalId: number, queryStartBlock?: number): Promise<{
+        proposalId: number;
+        proposer: any;
+        description: any;
+        name: any;
+        blockNumber: number;
+    }>;
+    getInProgressProposals(): Promise<any>;
+    submitProposal({ targetContractRegistryKey, callValue, functionSignature, callData, // array of args, e.g. [slashAmount, targetAddress]
+    name, description }: {
+        targetContractRegistryKey: string;
+        callValue: string;
+        functionSignature: string;
+        callData: string[];
+        name: string;
+        description: string;
+    }): Promise<any>;
+    submitVote({ proposalId, vote }: {
+        proposalId: number;
+        vote: string;
+    }): Promise<void>;
+    updateVote({ proposalId, vote }: {
+        proposalId: number;
+        vote: string;
+    }): Promise<void>;
+    evaluateProposalOutcome(proposalId: number): Promise<web3_core.TransactionReceipt>;
+    getProposalEvaluation(proposalId: number, queryStartBlock?: number): Promise<web3_eth_contract.EventData[]>;
+    getVotes({ proposalId, queryStartBlock }: {
+        proposalId: number;
+        queryStartBlock: number;
+    }): Promise<{
+        proposalId: number;
+        voter: any;
+        vote: number;
+        voterStake: BN;
+        blockNumber: number;
+    }[]>;
+    getVoteUpdates({ proposalId, queryStartBlock }: {
+        proposalId: number;
+        queryStartBlock: number;
+    }): Promise<{
+        proposalId: number;
+        voter: any;
+        vote: number;
+        voterStake: BN;
+        blockNumber: number;
+    }[]>;
+    getVoteSubmissionsByAddress({ addresses, queryStartBlock }: {
+        addresses: string[];
+        queryStartBlock: number;
+    }): Promise<{
+        proposalId: number;
+        voter: any;
+        vote: number;
+        voterStake: BN;
+        blockNumber: number;
+    }[]>;
+    getVoteUpdatesByAddress({ addresses, queryStartBlock }: {
+        addresses: string[];
+        queryStartBlock: number;
+    }): Promise<{
+        proposalId: number;
+        voter: any;
+        vote: number;
+        voterStake: BN;
+        blockNumber: number;
+    }[]>;
+    getVoteByProposalAndVoter({ proposalId, voterAddress }: {
+        proposalId: number[];
+        voterAddress: number;
+    }): Promise<number>;
+    /**
+     * ABI encodes argument types and values together into one encoded string
+     */
+    abiEncode(types: string[], values: string[]): string;
+    toBN(val: string): BN;
+    /**
+     * Prune off extraneous fields from proposal returned by txn
+     */
+    formatProposal(proposal: ProposalTxn): {
+        proposalId: number;
+        proposer: string;
+        submissionBlockNumber: number;
+        targetContractRegistryKey: string;
+        targetContractAddress: string;
+        callValue: number;
+        functionSignature: string;
+        callData: string;
+        outcome: number;
+        numVotes: number;
+        voteMagnitudeYes: BN;
+        voteMagnitudeNo: BN;
+    };
+    /**
+     * Formats a proposal event
+     */
+    formatProposalEvent(proposalEvent: EventLog): {
+        proposalId: number;
+        proposer: any;
+        description: any;
+        name: any;
+        blockNumber: number;
+    };
+    /**
+     * Prune off extraneous fields from vote event
+     */
+    formatVote(voteEvent: EventLog): {
+        proposalId: number;
+        voter: any;
+        vote: number;
+        voterStake: BN;
+        blockNumber: number;
+    };
+    /**
+     *
+     * @param {Number} proposalId id of the governance proposal
+     * @returns {BN} amount of tokens in wei required to reach quorum
+     */
+    calculateQuorum(proposalId: number): Promise<any>;
+}
+
+/**
+ * Contract class that extends a ContractClient and provides an interface
+ * to retrieve governed methods that cannot be executed directly.
+ */
+declare class GovernedContractClient extends ContractClient {
+    governanceClient: GovernanceClient;
+    constructor(web3Manager: Web3Manager | EthWeb3Manager, contractABI: ContractABI['abi'], contractRegistryKey: string, getRegistryAddress: GetRegistryAddress, governanceClient: GovernanceClient, logger?: Logger);
+    /**
+     * Gets a governed version of a method and allows a single transaction
+     * to be sent to the governance client with the appropriate payload.
+     * Similar to `getMethod`
+     */
+    getGovernedMethod(methodName: string, ...args: unknown[]): Promise<ContractMethod>;
+}
+
+declare class ServiceTypeManagerClient extends GovernedContractClient {
+    /**
+     *
+     * @param serviceType Type of service to set the version, either `discovery-node` or `content-node`
+     * @param serviceVersion Version string to set on chain
+     * @param privateKey Optional privateKey to pass along to web3Manager sendTransaction
+     * @param dryRun Optional parameter to return the generated parameters without sending tx
+     * @returns comma-separated String of serviceType and serviceVersion if dryRun; else response from web3Manager.sendTransaction
+     */
+    setServiceVersion(serviceType: string, serviceVersion: string, privateKey?: string | null, dryRun?: boolean): Promise<string | web3_core.TransactionReceipt>;
+    addServiceType(serviceType: string, serviceTypeMin: string, serviceTypeMax: string, privateKey?: string | null): Promise<web3_core.TransactionReceipt>;
+    getValidServiceTypes(): Promise<string[]>;
+    getCurrentVersion(serviceType: string): Promise<string>;
+    getVersion(serviceType: string, serviceTypeIndex: number): Promise<string>;
+    getNumberOfVersions(serviceType: string): Promise<number>;
+    /**
+     * @notice Add a new service type
+     * @returns {
+     *  isValid: Is the types type is isValid
+     *  minStake: minimum stake for service type
+     *  maxStake: minimum stake for service type
+     * }
+     */
+    getServiceTypeInfo(serviceType: string): Promise<{
+        isValid: any;
+        minStake: BN;
+        maxStake: BN;
+    }>;
+}
+
+declare type GetEvent$1 = {
+    serviceType: string;
+    owner: string;
+    queryStartBlock: number;
+};
+declare class ServiceProviderFactoryClient extends GovernedContractClient {
+    audiusTokenClient: AudiusTokenClient;
+    stakingProxyClient: StakingProxyClient;
+    isDebug: boolean;
+    constructor(ethWeb3Manager: EthWeb3Manager, contractABI: ContractABI['abi'], contractRegistryKey: string, getRegistryAddress: GetRegistryAddress, audiusTokenClient: AudiusTokenClient, stakingProxyClient: StakingProxyClient, governanceClient: GovernanceClient, logger?: Logger, isDebug?: boolean);
+    registerWithDelegate(serviceType: string, endpoint: string, amount: number | string | BN__default, delegateOwnerWallet: string): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+        spID: number;
+        serviceType: string;
+        owner: any;
+        endpoint: any;
+        tokenApproveReceipt: {
+            txReceipt: web3_core.TransactionReceipt;
+        };
+    }>;
+    register(serviceType: string, endpoint: string, amount: BN__default): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+        spID: number;
+        serviceType: string;
+        owner: any;
+        endpoint: any;
+        tokenApproveReceipt: {
+            txReceipt: web3_core.TransactionReceipt;
+        };
+    }>;
+    getRegisteredServiceProviderEvents({ serviceType, owner, queryStartBlock }: GetEvent$1): Promise<{
+        blockNumber: number;
+        spID: number;
+        serviceType: string;
+        owner: any;
+        endpoint: any;
+        stakeAmount: BN__default;
+    }[]>;
+    getDeregisteredServiceProviderEvents({ serviceType, owner, queryStartBlock }: GetEvent$1): Promise<{
+        blockNumber: number;
+        spID: number;
+        serviceType: string;
+        owner: any;
+        endpoint: any;
+        stakeAmount: BN__default;
+    }[]>;
+    getIncreasedStakeEvents({ owner, queryStartBlock }: {
+        owner: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        owner: any;
+        increaseAmount: BN__default;
+        newStakeAmount: BN__default;
+    }[]>;
+    getDecreasedStakeEvaluatedEvents({ owner, queryStartBlock }: {
+        owner: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        owner: any;
+        decreaseAmount: BN__default;
+        newStakeAmount: BN__default;
+    }[]>;
+    getDecreasedStakeRequestedEvents({ owner, queryStartBlock }: {
+        owner: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        owner: any;
+        decreaseAmount: BN__default;
+        lockupExpiryBlock: number;
+    }[]>;
+    getDecreasedStakeCancelledEvents({ owner, queryStartBlock }: {
+        owner: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        owner: any;
+        decreaseAmount: BN__default;
+        lockupExpiryBlock: number;
+    }[]>;
+    getDeregisteredService({ serviceType, spID, queryStartBlock }: {
+        serviceType: string;
+        spID: string;
+        queryStartBlock: number;
+    }): Promise<{
+        endpoint: string;
+        delegateOwnerWallet: string;
+        owner?: string | undefined;
+    }>;
+    increaseStake(amount: BN__default): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+        tokenApproveReceipt: {
+            txReceipt: web3_core.TransactionReceipt;
+        };
+    }>;
+    /**
+     * Makes a request to decrease stake
+     * @param amount
+     * @returns decrease stake lockup expiry block
+     */
+    requestDecreaseStake(amount: BN__default): Promise<number>;
+    /**
+     * Gets the pending decrease stake request for a given account
+     * @param account wallet address to fetch for
+     */
+    getPendingDecreaseStakeRequest(account: string): Promise<{
+        amount: BN__default;
+        lockupExpiryBlock: number;
+    }>;
+    /**
+     * Gets the pending decrease stake lockup duration
+     */
+    getDecreaseStakeLockupDuration(): Promise<number>;
+    /**
+     * Gets the deployer cut lockup duration
+     */
+    getDeployerCutLockupDuration(): Promise<number>;
+    /**
+     * Cancels the pending decrease stake request
+     * @param account wallet address to cancel request for
+     */
+    cancelDecreaseStakeRequest(account: string): Promise<void>;
+    /**
+     * Fetches the pending decrease stake lockup expiry block for a user
+     * @param account wallet address to fetch for
+     */
+    getLockupExpiry(account: string): Promise<number>;
+    decreaseStake(): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+    }>;
+    /**
+     * Deregisters a service
+     * @param serviceType
+     * @param endpoint
+     */
+    deregister(serviceType: string, endpoint: string): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+        spID: number;
+        serviceType: string;
+        owner: any;
+        endpoint: any;
+    }>;
+    getTotalServiceTypeProviders(serviceType: string): Promise<number>;
+    getServiceProviderIdFromEndpoint(endpoint: string): Promise<number>;
+    getServiceProviderInfo(serviceType: string, serviceId: number): Promise<{
+        owner: any;
+        endpoint: any;
+        spID: number;
+        type: string;
+        blockNumber: number;
+        delegateOwnerWallet: any;
+    }>;
+    getServiceEndpointInfo(serviceType: string, serviceId: number): Promise<{
+        owner: any;
+        endpoint: any;
+        spID: number;
+        type: string;
+        blockNumber: number;
+        delegateOwnerWallet: any;
+    }>;
+    getServiceProviderInfoFromEndpoint(endpoint: string): Promise<{
+        owner: any;
+        endpoint: any;
+        spID: number;
+        type: string;
+        blockNumber: number;
+        delegateOwnerWallet: any;
+    }>;
+    getServiceProviderIdsFromAddress(ownerAddress: string, serviceType: string): Promise<number[]>;
+    getServiceProviderIdFromAddress(ownerAddress: string, serviceType: string): Promise<number>;
+    getServiceEndpointInfoFromAddress(ownerAddress: string, serviceType: string): Promise<{
+        owner: any;
+        endpoint: any;
+        spID: number;
+        type: string;
+        blockNumber: number;
+        delegateOwnerWallet: any;
+    }[]>;
+    /**
+     * Returns all service providers of requested `serviceType`
+     * Returns array of objects with schema { blockNumber, delegateOwnerWallet, endpoint, owner, spID, type }
+     */
+    getServiceProviderList(serviceType: string): Promise<{
+        owner: any;
+        endpoint: any;
+        spID: number;
+        type: string;
+        blockNumber: number;
+        delegateOwnerWallet: any;
+    }[]>;
+    updateDecreaseStakeLockupDuration(duration: string): Promise<web3_core.TransactionReceipt>;
+    getServiceProviderDetails(serviceProviderAddress: string): Promise<{
+        deployerCut: number;
+        deployerStake: BN__default;
+        maxAccountStake: BN__default;
+        minAccountStake: BN__default;
+        numberOfEndpoints: number;
+        validBounds: any;
+    }>;
+    updateDelegateOwnerWallet(serviceType: string, endpoint: string, updatedDelegateOwnerWallet: string): Promise<web3_core.TransactionReceipt>;
+    updateEndpoint(serviceType: string, oldEndpoint: string, newEndpoint: string): Promise<web3_core.TransactionReceipt>;
+    requestUpdateDeployerCut(ownerAddress: string, deployerCut: string): Promise<web3_core.TransactionReceipt>;
+    getPendingUpdateDeployerCutRequest(ownerAddress: string): Promise<{
+        lockupExpiryBlock: number;
+        newDeployerCut: number;
+    }>;
+    cancelUpdateDeployerCut(ownerAddress: string): Promise<web3_core.TransactionReceipt>;
+    updateDeployerCut(ownerAddress: string): Promise<web3_core.TransactionReceipt>;
+    updateServiceProviderStake(ownerAddress: string, newAmount: string): Promise<web3_core.TransactionReceipt>;
+}
+
+declare type GetEvent = {
+    delegator: string;
+    serviceProvider: string;
+    queryStartBlock: number;
+};
+declare class DelegateManagerClient extends GovernedContractClient {
+    audiusTokenClient: AudiusTokenClient;
+    stakingProxyClient: StakingProxyClient;
+    constructor(ethWeb3Manager: EthWeb3Manager, contractABI: ContractABI['abi'], contractRegistryKey: string, getRegistryAddress: GetRegistryAddress, audiusTokenClient: AudiusTokenClient, stakingProxyClient: StakingProxyClient, governanceClient: GovernanceClient, logger?: Logger);
+    delegateStake(targetSP: string, amount: BN__default): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+        tokenApproveReceipt: {
+            txReceipt: web3_core.TransactionReceipt;
+        };
+        delegator: any;
+        serviceProvider: any;
+        increaseAmount: BN__default;
+    }>;
+    getIncreaseDelegateStakeEvents({ delegator, serviceProvider, queryStartBlock }: GetEvent): Promise<{
+        blockNumber: number;
+        delegator: any;
+        increaseAmount: BN__default;
+        serviceProvider: any;
+    }[]>;
+    getDecreaseDelegateStakeEvents({ delegator, serviceProvider, queryStartBlock }: GetEvent): Promise<{
+        blockNumber: number;
+        delegator: any;
+        amount: BN__default;
+        serviceProvider: any;
+    }[]>;
+    getUndelegateStakeRequestedEvents({ delegator, serviceProvider, queryStartBlock }: GetEvent): Promise<{
+        blockNumber: number;
+        lockupExpiryBlock: number;
+        delegator: any;
+        amount: BN__default;
+        serviceProvider: any;
+    }[]>;
+    getUndelegateStakeCancelledEvents({ delegator, serviceProvider, queryStartBlock }: GetEvent): Promise<{
+        blockNumber: number;
+        delegator: any;
+        amount: BN__default;
+        serviceProvider: any;
+    }[]>;
+    getClaimEvents({ claimer, queryStartBlock }: {
+        claimer: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        claimer: any;
+        rewards: BN__default;
+        newTotal: BN__default;
+    }[]>;
+    getSlashEvents({ target, queryStartBlock }: {
+        target: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        target: any;
+        amount: BN__default;
+        newTotal: BN__default;
+    }[]>;
+    getDelegatorRemovedEvents({ target, queryStartBlock }: {
+        target: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        serviceProvider: any;
+        delegator: any;
+        unstakedAmount: BN__default;
+    }[]>;
+    requestUndelegateStake(targetSP: string, amount: BN__default): Promise<web3_core.TransactionReceipt>;
+    cancelUndelegateStakeRequest(): Promise<web3_core.TransactionReceipt>;
+    undelegateStake(): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+        delegator: any;
+        serviceProvider: any;
+        decreaseAmount: BN__default;
+    }>;
+    claimRewards(serviceProvider: string, txRetries?: number): Promise<web3_core.TransactionReceipt>;
+    requestRemoveDelegator(serviceProvider: string, delegator: string): Promise<web3_core.TransactionReceipt>;
+    cancelRemoveDelegatorRequest(serviceProvider: string, delegator: string): Promise<web3_core.TransactionReceipt>;
+    removeDelegator(serviceProvider: string, delegator: string): Promise<{
+        txReceipt: web3_core.TransactionReceipt;
+        delegator: any;
+        serviceProvider: any;
+        unstakedAmount: BN__default;
+    }>;
+    getDelegatorsList(serviceProvider: string): Promise<any>;
+    getTotalDelegatedToServiceProvider(serviceProvider: string): Promise<BN__default>;
+    getTotalDelegatorStake(delegator: string): Promise<BN__default>;
+    getTotalLockedDelegationForServiceProvider(serviceProvider: string): Promise<BN__default>;
+    getDelegatorStakeForServiceProvider(delegator: string, serviceProvider: string): Promise<BN__default>;
+    getPendingUndelegateRequest(delegator: string): Promise<{
+        amount: BN__default;
+        lockupExpiryBlock: number;
+        target: any;
+    }>;
+    getPendingRemoveDelegatorRequest(serviceProvider: string, delegator: string): Promise<{
+        lockupExpiryBlock: number;
+    }>;
+    getUndelegateLockupDuration(): Promise<number>;
+    getMaxDelegators(): Promise<number>;
+    getMinDelegationAmount(): Promise<BN__default>;
+    getRemoveDelegatorLockupDuration(): Promise<number>;
+    getRemoveDelegatorEvalDuration(): Promise<number>;
+    getGovernanceAddress(): Promise<any>;
+    getServiceProviderFactoryAddress(): Promise<any>;
+    getClaimsManagerAddress(): Promise<any>;
+    getStakingAddress(): Promise<any>;
+    getSPMinDelegationAmount({ serviceProvider }: {
+        serviceProvider: string;
+    }): Promise<BN__default>;
+    updateSPMinDelegationAmount({ serviceProvider, amount }: {
+        serviceProvider: string;
+        amount: BN__default;
+    }): Promise<web3_core.TransactionReceipt>;
+    updateRemoveDelegatorLockupDuration(duration: string): Promise<web3_core.TransactionReceipt>;
+    updateUndelegateLockupDuration(duration: string): Promise<web3_core.TransactionReceipt>;
+}
+
+declare class ClaimsManagerClient extends ContractClient {
+    web3Manager: EthWeb3Manager;
+    getFundingRoundBlockDiff(): Promise<number>;
+    getLastFundedBlock(): Promise<number>;
+    getFundsPerRound(): Promise<BN>;
+    getTotalClaimedInRound(): Promise<BN>;
+    getGovernanceAddress(): Promise<any>;
+    getServiceProviderFactoryAddress(): Promise<any>;
+    getDelegateManagerAddress(): Promise<any>;
+    getStakingAddress(): Promise<any>;
+    claimPending(address: string): Promise<any>;
+    initiateRound(txRetries?: number): Promise<web3_core.TransactionReceipt>;
+    getClaimProcessedEvents({ claimer, queryStartBlock }: {
+        claimer: string;
+        queryStartBlock: number;
+    }): Promise<{
+        blockNumber: number;
+        claimer: any;
+        rewards: BN;
+        oldTotal: BN;
+        newTotal: BN;
+    }[]>;
+}
+
+declare class ClaimDistributionClient extends ContractClient {
+    /**
+     * Calls the contract method to check if the claim index has been claimed
+     */
+    isClaimed(index: number): Promise<any>;
+    /**
+     * Proxies the calls the contract method to make a claim
+     * @param index
+     * @param account
+     * @param amount
+     * @param merkleProof
+     * @returns transaction
+     */
+    claim(index: number, account: string, amount: BN__default, merkleProof: string[]): Promise<Maybe<{
+        txHash: string;
+        txParams: {
+            /**
+             * Proxies the calls the contract method to make a claim
+             * @param index
+             * @param account
+             * @param amount
+             * @param merkleProof
+             * @returns transaction
+             */
+            data: string;
+            gasLimit: string;
+            gasPrice: number;
+            nonce: string;
+            to: string;
+            value: string;
+        };
+    }>>;
+}
+
+declare class WormholeClient {
+    ethWeb3Manager: EthWeb3Manager;
+    contractABI: ContractABI['abi'];
+    contractAddress: string;
+    web3: Web3__default;
+    audiusTokenClient: AudiusTokenClient;
+    WormholeContract: Contract;
+    constructor(ethWeb3Manager: EthWeb3Manager, contractABI: ContractABI['abi'], contractAddress: string, audiusTokenClient: AudiusTokenClient);
+    nonces(wallet: string): Promise<number>;
+    initialize(fromAcct: string, wormholeAddress: string, relayer: string): Promise<{
+        txReceipt: Maybe<{
+            txHash: string;
+            txParams: {
+                data: string;
+                gasLimit: string;
+                gasPrice: number;
+                nonce: string;
+                to: string;
+                value: string;
+            };
+        }>;
+    }>;
+    /**
+     * Transfers in eth from the user's wallet to the wormhole contract and
+     * specifies a solana wallet to realized the tokens in SOL
+     */
+    transferTokens(fromAcct: string, amount: BN__default, chainId: number, solanaAccount: string, arbiterFee: string, deadline: string, signedDigest: {
+        v: string;
+        r: string;
+        s: string;
+    }, relayer: string): Promise<Maybe<{
+        txHash: string;
+        txParams: {
+            data: string;
+            gasLimit: string;
+            gasPrice: number;
+            nonce: string;
+            to: string;
+            value: string;
+        };
+    }>>;
+}
+
+declare class EthRewardsManagerClient extends ContractClient {
+    token(): Promise<any>;
+    getGovernanceAddress(): Promise<any>;
+    getRecipientAddress(): Promise<any>;
+    getAntiAbuseOracleAddresses(): Promise<any>;
+}
+
+declare class TrustedNotifierManagerClient extends GovernedContractClient {
+    /**
+     * Register Trusted Notifier with specified fields (wallet, endpoint, email)
+     * @notice Only callable by Governance contract
+     * @notice All fields must be unique and non-falsey
+     * @notice New Trusted Notifier is assigned an auto-incremented integer ID
+     * @returns Newly assigned integer ID
+     */
+    registerNotifier(wallet: string, endpoint: string, email: string, privateKey?: string | null): Promise<web3_core.TransactionReceipt>;
+    /**
+     * Deregister Trusted Notifier associated with wallet
+     * @notice Only callable by Governance contract or wallet
+     * @returns ID of deregistered Trusted Notifier
+     */
+    deregisterNotifier(wallet: string, privateKey?: string | null): Promise<web3_core.TransactionReceipt>;
+    getLatestNotifierID(): Promise<number>;
+    /**
+     * Returns all TrustedNotifier info associated with ID
+     */
+    getNotifierForID(ID: string): Promise<{
+        wallet: any;
+        endpoint: any;
+        email: any;
+    }>;
+    /**
+     * Returns all TrustedNotifier info associated with wallet
+     */
+    getNotifierForWallet(wallet: string): Promise<{
+        ID: any;
+        endpoint: any;
+        email: any;
+    }>;
+    /**
+     * Returns all TrustedNotifier info associated with endpoint
+     */
+    getNotifierForEndpoint(endpoint: string): Promise<{
+        ID: any;
+        wallet: any;
+        email: any;
+    }>;
+    /**
+     * Returns all TrustedNotifier info associated with email
+     */
+    getNotifierForEmail(email: string): Promise<{
+        ID: any;
+        wallet: any;
+        endpoint: any;
+    }>;
+}
+
+declare type EthContractsConfig = {
+    ethWeb3Manager: EthWeb3Manager;
+    tokenContractAddress: string;
+    registryAddress: string;
+    claimDistributionContractAddress: string;
+    wormholeContractAddress: string;
+    isServer?: boolean;
+    logger?: Logger;
+    isDebug?: boolean;
+};
+declare class EthContracts {
+    ethWeb3Manager: EthWeb3Manager;
+    tokenContractAddress: string;
+    claimDistributionContractAddress: string;
+    wormholeContractAddress: string;
+    registryAddress: string;
+    isServer: boolean;
+    logger: Logger;
+    isDebug: boolean;
+    expectedServiceVersions: null | string[];
+    AudiusTokenClient: AudiusTokenClient;
+    RegistryClient: RegistryClient;
+    StakingProxyClient: StakingProxyClient;
+    GovernanceClient: GovernanceClient;
+    ClaimsManagerClient: ClaimsManagerClient;
+    EthRewardsManagerClient: EthRewardsManagerClient;
+    ServiceTypeManagerClient: ServiceTypeManagerClient;
+    ServiceProviderFactoryClient: ServiceProviderFactoryClient;
+    DelegateManagerClient: DelegateManagerClient;
+    ClaimDistributionClient: ClaimDistributionClient | undefined;
+    WormholeClient: WormholeClient;
+    TrustedNotifierManagerClient: TrustedNotifierManagerClient;
+    contractClients: ContractClient[];
+    _regressedMode: boolean;
+    contracts: Record<string, string> | undefined;
+    contractAddresses: Record<string, string> | undefined;
+    constructor({ ethWeb3Manager, tokenContractAddress, registryAddress, claimDistributionContractAddress, wormholeContractAddress, isServer, logger, isDebug }: EthContractsConfig);
+    init(): Promise<void>;
+    /**
+     * Estabilishes that connection to discovery providers has regressed
+     */
+    enterRegressedMode(): void;
+    isInRegressedMode(): boolean;
+    getRegistryAddressForContract(contractName: string): Promise<string>;
+    getCurrentVersion(serviceType: string): Promise<string>;
+    getExpectedServiceVersions(): Promise<Record<string, string | null | undefined>>;
+    /**
+     * Determine whether major and minor versions match for two version strings
+     * Version string 2 must have equivalent major/minor versions and a patch >= version1
+     * @param version1 string 1
+     * @param version2 string 2
+     */
+    isValidSPVersion(version1: string, version2: string): boolean;
+    /**
+     * Determines whether the major and minor versions are equal
+     * @param version1 string 1
+     * @param version2 string 2
+     */
+    hasSameMajorAndMinorVersion(version1: string, version2: string): boolean;
+    getServiceProviderList(spType: string): Promise<{
+        owner: any;
+        endpoint: any;
+        spID: number;
+        type: string;
+        blockNumber: number;
+        delegateOwnerWallet: any;
+    }[]>;
+    getNumberOfVersions(spType: string): Promise<number>;
+    getVersion(spType: string, queryIndex: number): Promise<string>;
+    getServiceTypeInfo(spType: string): Promise<{
+        isValid: any;
+        minStake: BN;
+        maxStake: BN;
+    }>;
+}
+
+declare type DiscoveryProviderSelectionConfig = Omit<ServiceSelectionConfig, 'getServices'> & {
+    reselectTimeout?: number;
+    selectionCallback?: (endpoint: string, decisionTree: Decision[]) => void;
+    monitoringCallbacks?: {
+        healthCheck: (config: Record<string, unknown>) => void;
+        request: (config: Record<string, unknown>) => void;
+    };
+    unhealthySlotDiffPlays?: number;
+    unhealthyBlockDiff?: number;
+};
+declare class DiscoveryProviderSelection extends ServiceSelection {
+    currentVersion: string;
+    ethContracts: EthContracts;
+    reselectTimeout: Maybe<number>;
+    selectionCallback: Maybe<DiscoveryProviderSelectionConfig['selectionCallback']>;
+    monitoringCallbacks: NonNullable<DiscoveryProviderSelectionConfig['monitoringCallbacks']> | {};
+    unhealthySlotDiffPlays: Nullable<number>;
+    unhealthyBlockDiff: number;
+    _regressedMode: boolean;
+    validVersions: Nullable<string[]>;
+    constructor(config: DiscoveryProviderSelectionConfig, ethContracts: EthContracts);
+    /** Retrieves a cached discovery provider from localstorage */
+    getCached(): any;
+    /** Clears any cached discovery provider from localstorage */
+    clearCached(): void;
+    /** Sets a cached discovery provider in localstorage */
+    setCached(endpoint: string): void;
+    /** Allows the selection take a shortcut if there's a cached provider */
+    shortcircuit(): any;
+    select(): Promise<any>;
+    /**
+     * Checks whether a given response is healthy:
+     * - Not behind in blocks
+     * - 200 response
+     * - Current version
+     *
+     * Other responses are collected in `this.backups` if
+     * - Behind by only a patch version
+     *
+     * @param response axios response
+     * @param urlMap health check urls mapped to their cannonical url
+     * e.g. https://discoveryprovider.audius.co/health_check => https://discoveryprovider.audius.co
+     */
+    isHealthy(response: AxiosResponse, urlMap: Record<string, string>): boolean;
+    /**
+     * Estabilishes that connection to discovery providers has regressed
+     */
+    enterRegressedMode(): void;
+    setUnhealthyBlockDiff(updatedDiff?: number): void;
+    setUnhealthySlotDiffPlays(updatedDiff: number): void;
+    isInRegressedMode(): boolean;
+    /**
+     * In the case of no "healthy" services, we resort to backups in the following order:
+     * 1. Pick the most recent (patch) version that's not behind
+     * 2. Pick the least behind provider that is a valid patch version and enter "regressed mode"
+     * 3. Pick `null`
+     */
+    selectFromBackups(): Promise<string>;
+}
+
+declare type CurrentUser = {
+    user_id: string;
+    wallet: string;
+    blocknumber: number;
+    track_blocknumber: number;
+    creator_node_endpoint: string;
+    is_creator: boolean;
+};
+/**
+ * Singleton class to store the current user if initialized.
+ * Some instances of AudiusLibs and services require a current user to
+ * return valid queries, e.g. requesting the a discprov to return a reposted track.
+ */
+declare class UserStateManager {
+    currentUser: CurrentUser | null;
+    constructor();
+    /**
+     * Sets this.currentUser with currentUser
+     * @param {Object} currentUser fields to override this.currentUser with
+     */
+    setCurrentUser(currentUser: CurrentUser): void;
+    getCurrentUser(): CurrentUser | null;
+    getCurrentUserId(): string | null;
+    clearUser(): void;
+}
+
+declare type RequestParams = {
+    queryParams: Record<string, string>;
+    endpoint: string;
+    timeout?: number;
+    method?: Method;
+    urlParams?: PathArg;
+    headers?: Record<string, string>;
+    data?: Record<string, unknown>;
+};
+declare type DiscoveryProviderConfig = {
+    whitelist?: Set<string>;
+    blacklist?: Set<string>;
+    userStateManager: UserStateManager;
+    ethContracts: EthContracts;
+    web3Manager?: Web3Manager;
+    reselectTimeout?: number;
+    selectionCallback?: DiscoveryProviderSelectionConfig['selectionCallback'];
+    monitoringCallbacks?: DiscoveryProviderSelectionConfig['monitoringCallbacks'];
+    selectionRequestTimeout?: number;
+    selectionRequestRetries?: number;
+    unhealthySlotDiffPlays?: number;
+    unhealthyBlockDiff?: number;
+};
+declare type UserProfile = {
+    userId: number;
+    email: string;
+    name: string;
+    handle: string;
+    verified: boolean;
+    imageURL?: string;
+    sub: number;
+    iat: string;
+};
+/**
+ * Constructs a service class for a discovery node
+ * @param whitelist whether or not to only include specified nodes in selection
+ * @param userStateManager singleton UserStateManager instance
+ * @param ethContracts singleton EthContracts instance
+ * @param web3Manager
+ * @param reselectTimeout timeout to clear locally cached discovery providers
+ * @param selectionCallback invoked when a discovery node is selected
+ * @param monitoringCallbacks callbacks to be invoked with metrics from requests sent to a service
+ *  @param monitoringCallbacks.request
+ *  @param monitoringCallbacks.healthCheck
+ * @param selectionRequestTimeout the amount of time (ms) an individual request should take before reselecting
+ * @param selectionRequestRetries the number of retries to a given discovery node we make before reselecting
+ * @param unhealthySlotDiffPlays the number of slots we would consider a discovery node unhealthy
+ * @param unhealthyBlockDiff the number of missed blocks after which we would consider a discovery node unhealthy
+ */
+declare class DiscoveryProvider {
+    whitelist: Set<string> | undefined;
+    blacklist: Set<string> | undefined;
+    userStateManager: UserStateManager;
+    ethContracts: EthContracts;
+    web3Manager: Web3Manager | undefined;
+    unhealthyBlockDiff: number;
+    serviceSelector: DiscoveryProviderSelection;
+    selectionRequestTimeout: number;
+    selectionRequestRetries: number;
+    unhealthySlotDiffPlays: number | undefined;
+    request404Count: number;
+    maxRequestsForTrue404: number;
+    monitoringCallbacks: DiscoveryProviderSelection['monitoringCallbacks'] | undefined;
+    discoveryProviderEndpoint: string | undefined;
+    constructor({ whitelist, blacklist, userStateManager, ethContracts, web3Manager, reselectTimeout, selectionCallback, monitoringCallbacks, selectionRequestTimeout, selectionRequestRetries, unhealthySlotDiffPlays, unhealthyBlockDiff }: DiscoveryProviderConfig);
+    init(): Promise<void>;
+    setEndpoint(endpoint: string): void;
+    setUnhealthyBlockDiff(updatedBlockDiff?: number): void;
+    setUnhealthySlotDiffPlays(updatedDiff: number): void;
+    /**
+     * Get users with all relevant user data
+     * can be filtered by providing an integer array of ids
+     * @param limit
+     * @param offset
+     * @param idsArray
+     * @param walletAddress
+     * @param handle
+     * @param isCreator null returns all users, true returns creators only, false returns users only
+     * @returns {Object} {Array of User metadata Objects}
+     * additional metadata fields on user objects:
+     *  {Integer} track_count - track count for given user
+     *  {Integer} playlist_count - playlist count for given user
+     *  {Integer} album_count - album count for given user
+     *  {Integer} follower_count - follower count for given user
+     *  {Integer} followee_count - followee count for given user
+     *  {Integer} repost_count - repost count for given user
+     *  {Integer} track_blocknumber - blocknumber of latest track for user
+     *  {Boolean} does_current_user_follow - does current user follow given user
+     *  {Array} followee_follows - followees of current user that follow given user
+     * @example
+     * await getUsers()
+     * await getUsers(100, 0, [3,2,6]) - Invalid user ids will not be accepted
+     */
+    getUsers(limit?: number, offset?: number, idsArray?: string[], walletAddress?: string, handle?: string, isCreator?: null, minBlockNumber?: number): Promise<unknown>;
+    /**
+     * get tracks with all relevant track data
+     * can be filtered by providing an integer array of ids
+     * @param limit
+     * @param offset
+     * @param idsArray
+     * @param targetUserId the owner of the tracks being queried
+     * @param sort a string of form eg. blocknumber:asc,timestamp:desc describing a sort path
+     * @param minBlockNumber The min block number
+     * @param filterDeleted If set to true, filters the deleted tracks
+     * @returns {Object} {Array of track metadata Objects}
+     * additional metadata fields on track objects:
+     *  {Integer} repost_count - repost count for given track
+     *  {Integer} save_count - save count for given track
+     *  {Array} followee_reposts - followees of current user that have reposted given track
+     *  {Boolean} has_current_user_reposted - has current user reposted given track
+     *  {Boolean} has_current_user_saved - has current user saved given track
+     * @example
+     * await getTracks()
+     * await getTracks(100, 0, [3,2,6]) - Invalid track ids will not be accepted
+     */
+    getTracks(limit?: number, offset?: number, idsArray?: string[], targetUserId?: string, sort?: boolean, minBlockNumber?: number, filterDeleted?: boolean, withUsers?: boolean): Promise<unknown>;
+    /**
+     * Gets a particular track by its creator's handle and the track's URL slug
+     * @param handle the handle of the owner of the track
+     * @param slug the URL slug of the track, generally the title urlized
+     * @returns {Object} the requested track's metadata
+     */
+    getTracksByHandleAndSlug(handle: string, slug: string): Promise<unknown>;
+    /**
+     * @typedef {Object} getTracksIdentifier
+     * @property {string} handle
+     * @property {number} id
+     * @property {string} url_title
+     */
+    /**
+     * gets all tracks matching identifiers, including unlisted.
+     *
+     * @param identifiers
+     * @returns {(Array)} track
+     */
+    getTracksIncludingUnlisted(identifiers: string[], withUsers?: boolean): Promise<unknown>;
+    /**
+     * Gets random tracks from trending tracks for a given genre.
+     * If genre not given, will return trending tracks across all genres.
+     * Excludes specified track ids.
+     *
+     * @param genre
+     * @param limit
+     * @param exclusionList
+     * @param time
+     * @returns {(Array)} track
+     */
+    getRandomTracks(genre: string, limit: number, exclusionList: number[], time: string): Promise<unknown>;
+    /**
+     * Gets all stems for a given trackId as an array of tracks.
+     * @param trackId
+     * @returns {(Array)} track
+     */
+    getStemsForTrack(trackId: number): Promise<unknown>;
+    /**
+     * Gets all the remixes of a given trackId as an array of tracks.
+     * @param trackId
+     * @param limit
+     * @param offset
+     * @returns {(Array)} track
+     */
+    getRemixesOfTrack(trackId: number, limit?: number, offset?: number): Promise<unknown>;
+    /**
+     * Gets the remix parents of a given trackId as an array of tracks.
+     * @param limit
+     * @param offset
+     * @returns {(Array)} track
+     */
+    getRemixTrackParents(trackId: number, limit?: number, offset?: number): Promise<unknown>;
+    /**
+     * Gets tracks trending on Audius.
+     * @param genre
+     * @param timeFrame one of day, week, month, or year
+     * @param idsArray track ids
+     * @param limit
+     * @param offset
+     */
+    getTrendingTracks(genre?: string, timeFrame?: string, idsArray?: number[], limit?: number, offset?: number, withUsers?: boolean): Promise<{
+        listenCounts: Array<{
+            trackId: number;
+            listens: number;
+        }>;
+    } | null | undefined>;
+    /**
+     * get full playlist objects, including tracks, for passed in array of playlistId
+     * @returns {Array} array of playlist objects
+     * additional metadata fields on playlist objects:
+     *  {Integer} repost_count - repost count for given playlist
+     *  {Integer} save_count - save count for given playlist
+     *  {Boolean} has_current_user_reposted - has current user reposted given playlist
+     *  {Array} followee_reposts - followees of current user that have reposted given playlist
+     *  {Boolean} has_current_user_reposted - has current user reposted given playlist
+     *  {Boolean} has_current_user_saved - has current user saved given playlist
+     */
+    getPlaylists(limit?: number, offset?: number, idsArray?: null, targetUserId?: null, withUsers?: boolean): Promise<unknown>;
+    /**
+     * Return social feed for current user
+     * @param filter - filter by "all", "original", or "repost"
+     * @param limit - max # of items to return
+     * @param offset - offset into list to return from (for pagination)
+     * @returns {Object} {Array of track and playlist metadata objects}
+     * additional metadata fields on track and playlist objects:
+     *  {String} activity_timestamp - timestamp of requested user's repost for given track or playlist,
+     *    used for sorting feed
+     *  {Integer} repost_count - repost count of given track/playlist
+     *  {Integer} save_count - save count of given track/playlist
+     *  {Boolean} has_current_user_reposted - has current user reposted given track/playlist
+     *  {Array} followee_reposts - followees of current user that have reposted given track/playlist
+     */
+    getSocialFeed(filter: string, limit?: number, offset?: number, withUsers?: boolean, tracksOnly?: boolean): Promise<unknown>;
+    /**
+     * Return repost feed for requested user
+     * @param userId - requested user id
+     * @param limit - max # of items to return (for pagination)
+     * @param offset - offset into list to return from (for pagination)
+     * @returns {Object} {Array of track and playlist metadata objects}
+     * additional metadata fields on track and playlist objects:
+     *  {String} activity_timestamp - timestamp of requested user's repost for given track or playlist,
+     *    used for sorting feed
+     *  {Integer} repost_count - repost count of given track/playlist
+     *  {Integer} save_count - save count of given track/playlist
+     *  {Boolean} has_current_user_reposted - has current user reposted given track/playlist
+     *  {Array} followee_reposts - followees of current user that have reposted given track/playlist
+     */
+    getUserRepostFeed(userId: number, limit?: number, offset?: number, withUsers?: boolean): Promise<unknown>;
+    /**
+     * get intersection of users that follow followeeUserId and users that are followed by followerUserId
+     * @param followeeUserId user that is followed
+     * @param followerUserId user that follows
+     * @example
+     * getFollowIntersectionUsers(100, 0, 1, 1) - IDs must be valid
+     */
+    getFollowIntersectionUsers(limit: number | undefined, offset: number | undefined, followeeUserId: number, followerUserId: number): Promise<unknown>;
+    /**
+     * get intersection of users that have reposted repostTrackId and users that are followed by followerUserId
+     * followee = user that is followed; follower = user that follows
+     * @param repostTrackId track that is reposted
+     * @param followerUserId user that reposted track
+     * @example
+     * getTrackRepostIntersectionUsers(100, 0, 1, 1) - IDs must be valid
+     */
+    getTrackRepostIntersectionUsers(limit: number | undefined, offset: number | undefined, repostTrackId: number, followerUserId: number): Promise<unknown>;
+    /**
+     * get intersection of users that have reposted repostPlaylistId and users that are followed by followerUserId
+     * followee = user that is followed; follower = user that follows
+     * @param repostPlaylistId playlist that is reposted
+     * @param followerUserId user that reposted track
+     * @example
+     * getPlaylistRepostIntersectionUsers(100, 0, 1, 1) - IDs must be valid
+     */
+    getPlaylistRepostIntersectionUsers(limit: number | undefined, offset: number | undefined, repostPlaylistId: number, followerUserId: number): Promise<unknown>;
+    /**
+     * get users that follow followeeUserId, sorted by follower count descending
+     * @param followeeUserId user that is followed
+     * @return {Array} array of user objects with standard user metadata
+     */
+    getFollowersForUser(limit: number | undefined, offset: number | undefined, followeeUserId: number): Promise<unknown>;
+    /**
+     * get users that are followed by followerUserId, sorted by follower count descending
+     * @param followerUserId user - i am the one who follows
+     * @return {Array} array of user objects with standard user metadata
+     */
+    getFolloweesForUser(limit: number | undefined, offset: number | undefined, followerUserId: number): Promise<unknown>;
+    /**
+     * get users that reposted repostTrackId, sorted by follower count descending
+     * @param repostTrackId
+     * @return {Array} array of user objects
+     * additional metadata fields on user objects:
+     *  {Integer} follower_count - follower count of given user
+     * @example
+     * getRepostersForTrack(100, 0, 1) - ID must be valid
+     */
+    getRepostersForTrack(limit: number | undefined, offset: number | undefined, repostTrackId: number): Promise<unknown>;
+    /**
+     * get users that reposted repostPlaylistId, sorted by follower count descending
+     * @param repostPlaylistId
+     * @return {Array} array of user objects
+     * additional metadata fields on user objects:
+     *  {Integer} follower_count - follower count of given user
+     * @example
+     * getRepostersForPlaylist(100, 0, 1) - ID must be valid
+     */
+    getRepostersForPlaylist(limit: number | undefined, offset: number | undefined, repostPlaylistId: number): Promise<unknown>;
+    /**
+     * get users that saved saveTrackId, sorted by follower count descending
+     * @param saveTrackId
+     * @return {Array} array of user objects
+     * additional metadata fields on user objects:
+     *  {Integer} follower_count - follower count of given user
+     * @example
+     * getSaversForTrack(100, 0, 1) - ID must be valid
+     */
+    getSaversForTrack(limit: number | undefined, offset: number | undefined, saveTrackId: number): Promise<unknown>;
+    /**
+     * get users that saved savePlaylistId, sorted by follower count descending
+     * @param savePlaylistId
+     * @return {Array} array of user objects
+     * additional metadata fields on user objects:
+     *  {Integer} follower_count - follower count of given user
+     * @example
+     * getSaversForPlaylist(100, 0, 1) - ID must be valid
+     */
+    getSaversForPlaylist(limit: number | undefined, offset: number | undefined, savePlaylistId: number): Promise<unknown>;
+    /**
+     * get whether a JWT given by Audius Oauth popup is valid
+     * @param token - JWT
+     * @return {UserProfile | false} profile info of user attached to JWT payload if the JWT is valid, else false
+     */
+    verifyToken(token: string): Promise<UserProfile | false>;
+    /**
+     * Perform a full-text search. Returns tracks, users, playlists, albums
+     *    with optional user-specific results for each
+     *  - user, track, and playlist objects have all same data as returned from standalone endpoints
+     * @param text search query
+     * @param kind 'tracks', 'users', 'playlists', 'albums', 'all'
+     * @param limit max # of items to return per list (for pagination)
+     * @param offset offset into list to return from (for pagination)
+     */
+    searchFull(text: string, kind: string, limit?: number, offset?: number): Promise<unknown>;
+    /**
+     * Perform a lighter-weight full-text search. Returns tracks, users, playlists, albums
+     *    with optional user-specific results for each
+     *  - user, track, and playlist objects have core data, and track & playlist objects
+     *    also return user object
+     * @param text search query
+     * @param limit max # of items to return per list (for pagination)
+     * @param offset offset into list to return from (for pagination)
+     */
+    searchAutocomplete(text: string, limit?: number, offset?: number): Promise<unknown>;
+    /**
+     * Perform a tags-only search. Returns tracks with required tag and users
+     * that have used a tag greater than a specified number of times
+     * @param text search query
+     * @param userTagCount min # of times a user must have used a tag to be returned
+     * @param kind 'tracks', 'users', 'playlists', 'albums', 'all'
+     * @param limit max # of items to return per list (for pagination)
+     * @param offset offset into list to return from (for pagination)
+     */
+    searchTags(text: string, userTagCount?: number, kind?: string, limit?: number, offset?: number): Promise<unknown>;
+    /**
+     * Return saved playlists for current user
+     * NOTE in returned JSON, SaveType string one of track, playlist, album
+     * @param limit - max # of items to return
+     * @param offset - offset into list to return from (for pagination)
+     */
+    getSavedPlaylists(limit?: number, offset?: number, withUsers?: boolean): Promise<unknown>;
+    /**
+     * Return saved albums for current user
+     * NOTE in returned JSON, SaveType string one of track, playlist, album
+     * @param limit - max # of items to return
+     * @param offset - offset into list to return from (for pagination)
+     */
+    getSavedAlbums(limit?: number, offset?: number, withUsers?: boolean): Promise<unknown>;
+    /**
+     * Return saved tracks for current user
+     * NOTE in returned JSON, SaveType string one of track, playlist, album
+     * @param limit - max # of items to return
+     * @param offset - offset into list to return from (for pagination)
+     */
+    getSavedTracks(limit?: number, offset?: number, withUsers?: boolean): Promise<unknown>;
+    /**
+     * Return user collections (saved & uploaded) along w/ users for those collections
+     */
+    getUserAccount(wallet: string): Promise<CurrentUser | null | undefined>;
+    getTopPlaylists(type: string, limit: number, mood: string, filter: string, withUsers?: boolean): Promise<unknown>;
+    getTopFolloweeWindowed(type: string, window: string, limit: string, withUsers?: boolean): Promise<unknown>;
+    getTopFolloweeSaves(type: string, limit: string, withUsers?: boolean): Promise<unknown>;
+    getLatest(type: string): Promise<unknown>;
+    getTopCreatorsByGenres(genres: string[], limit?: number, offset?: number, withUsers?: boolean): Promise<unknown>;
+    getURSMContentNodes(ownerWallet?: string | null): Promise<unknown>;
+    getNotifications(minBlockNumber: string, trackIds: string[], timeout: number): Promise<unknown>;
+    getSolanaNotifications(minSlotNumber: number, timeout: number): Promise<unknown>;
+    getTrackListenMilestones(timeout: number): Promise<unknown>;
+    getChallengeAttestation(challengeId: string, encodedUserId: string, specifier: string, oracleAddress: string, discoveryProviderEndpoint: string): Promise<any>;
+    getCreateSenderAttestation(senderEthAddress: string, discoveryProviderEndpoint: string): Promise<any>;
+    getUndisbursedChallenges(limit?: number | null, offset?: number | null, completedBlockNumber?: string | null, encodedUserId?: number | null): Promise<{
+        amount: number;
+    }[]>;
+    /**
+     * Performs a single request, defined in the request, via axios, calling any
+     * monitoring callbacks as needed.
+     *
+     * @param {{
+       endpoint: string,
+       urlParams: string,
+       queryParams: object,
+       method: string,
+       headers: object,
+     }} requestObj
+     * @param {string} discoveryProviderEndpoint
+     * @returns
+     * @memberof DiscoveryProvider
+     */
+    _performRequestWithMonitoring(requestObj: RequestParams, discoveryProviderEndpoint: string): Promise<any>;
+    /**
+     * Gets how many blocks behind a discovery node is.
+     * If this method throws (missing data in health check response),
+     * return an unhealthy number of blocks
+     * @param parsedResponse health check response object
+     * @returns a number of blocks if behind or null if not behind
+     */
+    _getBlocksBehind(parsedResponse: {
+        latest_indexed_block: number;
+        latest_chain_block: number;
+    }): Promise<number | null>;
+    /**
+     * Gets how many plays slots behind a discovery node is.
+     * If this method throws (missing data in health check response),
+     * return an unhealthy number of slots
+     * @param parsedResponse health check response object
+     * @returns a number of slots if behind or null if not behind
+     */
+    _getPlaysSlotsBehind(parsedResponse: {
+        latest_indexed_slot_plays: number;
+        latest_chain_slot_plays: number;
+    }): Promise<number | null>;
+    /**
+     * Makes a request to a discovery node, reselecting if necessary
+     * @param {{
+     *  endpoint: string
+     *  urlParams: object
+     *  queryParams: object
+     *  method: string
+     *  headers: object
+     * }} {
+     *  endpoint: the base route
+     *  urlParams: string of URL params to be concatenated after base route
+     *  queryParams: URL query (search) params
+     *  method: string HTTP method
+     * }
+     * @param retry whether to retry on failure
+     * @param attemptedRetries number of attempted retries (stops retrying at max)
+     */
+    _makeRequest<Response>(requestObj: Record<string, unknown>, retry?: boolean, attemptedRetries?: number): Promise<Response | undefined | null>;
+    /**
+     * Gets the healthy discovery provider endpoint used in creating the axios request later.
+     * If the number of retries is over the max count for retires, clear the cache and reselect
+     * another healthy discovery provider. Else, return the current discovery provider endpoint
+     * @param attemptedRetries the number of attempted requests made to the current disc prov endpoint
+     */
+    getHealthyDiscoveryProviderEndpoint(attemptedRetries: number): Promise<string>;
+    /**
+     * Creates the discovery provider axios request object with necessary configs
+     * @param requestObj
+     * @param discoveryProviderEndpoint
+     */
+    _createDiscProvRequest(requestObj: RequestParams, discoveryProviderEndpoint: string): AxiosRequestConfig;
+}
+
+declare type LoginSuccessCallback = (profile: UserProfile) => void;
+declare type LoginErrorCallback = (errorMessage: string) => void;
+declare type ButtonOptions = {
+    size: 'small' | 'medium' | 'large';
+    corners: 'default' | 'pill';
+    customText: string;
+    disableHoverGrow: boolean;
+    fullWidth: boolean;
+};
+declare type OauthConfig = {
+    appName?: string;
+    discoveryProvider: DiscoveryProvider;
+};
+declare class Oauth {
+    discoveryProvider: DiscoveryProvider;
+    appName: string | null;
+    activePopupWindow: null | Window;
+    popupCheckInterval: NodeJS.Timer | null;
+    loginSuccessCallback: LoginSuccessCallback | null;
+    loginErrorCallback: LoginErrorCallback | null;
+    constructor({ discoveryProvider, appName }: OauthConfig);
+    init(successCallback: LoginSuccessCallback, errorCallback?: LoginErrorCallback): void;
+    login(): void;
+    renderButton(element: HTMLElement, options?: ButtonOptions): void;
+    verifyToken(token: string): Promise<false | UserProfile>;
+    _surfaceError(errorMessage: string): void;
+    _clearPopupCheckInterval(): void;
+    _receiveMessage(event: MessageEvent): Promise<void>;
+}
+
+declare type Web3Config = {
+    providers: string[];
+};
+declare type SdkConfig = {
+    appName: string;
+    discoveryNodeConfig?: DiscoveryProviderConfig;
+    ethContractsConfig?: EthContractsConfig;
+    ethWeb3Config?: EthWeb3Config;
+    identityServiceConfig?: IdentityService;
+    web3Config?: Web3Config;
+};
+/**
+ * The Audius SDK
+ */
+declare const sdk: (config?: SdkConfig | undefined) => Promise<{
+    oauth: Oauth | undefined;
+    discoveryNode: DiscoveryProvider;
+}>;
+
+declare type SchemaConfig = {
+    schema: {
+        definitions: Record<string, {
+            required: string[];
+            properties: Record<string, {
+                default: unknown;
+            }>;
+        } | {}>;
+    };
+    baseDefinition: string;
+    validate?: (obj: Record<string, unknown>) => void;
+};
+declare type Schemas = {
+    TrackSchema: SchemaConfig;
+    UserSchema: SchemaConfig;
+};
+
+declare type Metadata = {
+    track_segments: unknown;
+    download?: {
+        is_downloadable: boolean;
+        cid: string;
+    };
+    cover_art_sizes: string;
+};
+declare type ProgressCB = (loaded: number, total: number) => void;
+declare type MonitoringCallbacks = {
+    request?: Function;
+    healthCheck?: Function;
+};
+declare type ClockValueRequestConfig = {
+    user: CurrentUser;
+    endpoint: string;
+    timeout?: number;
+};
+declare type FileUploadResponse = {
+    data: {
+        uuid: string;
+    };
+    error: Error;
+};
+declare class CreatorNode {
+    /**
+     * Pulls off the primary creator node from a creator node endpoint string.
+     * @param endpoints user.creator_node_endpoint
+     */
+    static getPrimary(endpoints: string): string | undefined;
+    /**
+     * Pulls off the secondary creator nodes from a creator node endpoint string.
+     * @param endpoints user.creator_node_endpoint
+     */
+    static getSecondaries(endpoints: string): string[];
+    /**
+     * Pulls the user's creator nodes out of the list
+     * @param endpoints user.creator_node_endpoint
+     */
+    static getEndpoints(endpoints: string): string[];
+    /**
+     * Builds the creator_node_endpoint value off of a primary and secondaries list
+     * @param primary the primary endpoint
+     * @param secondaries a list of secondary endpoints
+     */
+    static buildEndpoint(primary: string, secondaries: string[]): string;
+    /**
+     * Pulls off the user's clock value from a creator node endpoint and the user's wallet address.
+     * @param endpoint content node endpoint
+     * @param wallet user wallet address
+     * @param timeout max time alloted for clock request
+     * @param params optional query string params
+     */
+    static getClockValue(endpoint: string, wallet: string, timeout: number, params?: Record<string, string>): Promise<any>;
+    /**
+     * Checks if a download is available from provided creator node endpoints
+     * @param endpoints creator node endpoints
+     * @param trackId
+     */
+    static checkIfDownloadAvailable(endpoints: string, trackId: number): Promise<any>;
+    web3Manager: Web3Manager;
+    creatorNodeEndpoint: string;
+    isServer: boolean;
+    userStateManager: UserStateManager;
+    lazyConnect: boolean;
+    schemas: Schemas;
+    passList: Set<string> | null;
+    blockList: Set<string> | null;
+    monitoringCallbacks: MonitoringCallbacks;
+    connected: boolean;
+    connecting: boolean;
+    authToken: null;
+    maxBlockNumber: number;
+    /**
+     * Constructs a service class for a creator node
+     * @param web3Manager
+     * @param creatorNodeEndpoint fallback creator node endpoint (to be deprecated)
+     * @param isServer
+     * @param userStateManager  singleton UserStateManager instance
+     * @param lazyConnect whether or not to lazy connect (sign in) on load
+     * @param schemas
+     * @param passList whether or not to include only specified nodes (default null)
+     * @param blockList whether or not to exclude any nodes (default null)
+     * @param monitoringCallbacks callbacks to be invoked with metrics from requests sent to a service
+     */
+    constructor(web3Manager: Web3Manager, creatorNodeEndpoint: string, isServer: boolean, userStateManager: UserStateManager, lazyConnect: boolean, schemas: Schemas, passList?: Set<string> | null, blockList?: Set<string> | null, monitoringCallbacks?: MonitoringCallbacks);
+    init(): Promise<void>;
+    /** Establishes a connection to a content node endpoint */
+    connect(): Promise<void>;
+    /** Checks if connected, otherwise establishing a connection */
+    ensureConnected(): Promise<void>;
+    getEndpoint(): string;
+    /**
+     * Switch from one creatorNodeEndpoint to another including logging out from the old node, updating the endpoint and logging into new node */
+    setEndpoint(creatorNodeEndpoint: string): Promise<void>;
+    /** Clear all connection state in this class by deleting authToken and setting 'connected' = false */
+    clearConnection(): void;
+    /**
+     * Uploads creator content to a creator node
+     * @param metadata the creator metadata
+     */
+    uploadCreatorContent(metadata: Metadata, blockNumber?: null): Promise<any>;
+    /**
+     * Creates a creator on the creator node, associating user id with file content
+     * @param audiusUserId returned by user creation on-blockchain
+     * @param metadataFileUUID unique ID for metadata file
+     * @param blockNumber
+     */
+    associateCreator(audiusUserId: number, metadataFileUUID: string, blockNumber: number): Promise<void>;
+    /**
+     * Uploads a track (including audio and image content) to a creator node
+     * @param trackFile the audio content
+     * @param coverArtFile the image content
+     * @param metadata the metadata for the track
+     * @param onProgress an optional on progress callback
+     */
+    uploadTrackContent(trackFile: File, coverArtFile: File, metadata: Metadata, onProgress?: ProgressCB): Promise<any>;
+    /**
+     * Uploads track metadata to a creator node
+     * The metadata object must include a `track_id` field or a
+     * source file must be provided (returned from uploading track content).
+     * @param metadata
+     * @param sourceFile
+     */
+    uploadTrackMetadata(metadata: Metadata, sourceFile: string): Promise<any>;
+    /**
+     * Creates a track on the content node, associating track id with file content
+     * @param audiusTrackId returned by track creation on-blockchain
+     * @param metadataFileUUID unique ID for metadata file
+     * @param blockNumber
+     * @param transcodedTrackUUID the CID for the transcoded master if this is a first-time upload
+     */
+    associateTrack(audiusTrackId: number, metadataFileUUID: string, blockNumber: number, transcodedTrackUUID: string): Promise<void>;
+    /**
+     * Uploads an image to the connected content node
+     * @param file image to upload
+     * @param onProgress called with loaded bytes and total bytes
+     * @param timeoutMs timeout in ms axios request to upload file to CN will wait
+     * @return response body
+     */
+    uploadImage(file: File, square: boolean | undefined, onProgress: ProgressCB, timeoutMs?: number | null): Promise<{
+        uuid: string;
+    }>;
+    /**
+     * @param file track to upload
+     * @param onProgress called with loaded bytes and total bytes
+     * @return response body
+     */
+    uploadTrackAudio(file: File, onProgress: ProgressCB): Promise<any>;
+    handleAsyncTrackUpload(file: File, onProgress: ProgressCB): Promise<any>;
+    pollProcessingStatus(uuid: string): Promise<any>;
+    /**
+     * Gets the task progress given the task type and uuid associated with the task
+     * @param uuid the uuid of the track transcoding task
+     * @returns the status, and the success or failed response if the task is complete
+     */
+    getTrackContentProcessingStatus(uuid: string): Promise<any>;
+    /**
+     * Given a particular endpoint to a creator node, check whether
+     * this user has a sync in progress on that node.
+     * @param endpoint
+     * @param timeout ms
+     */
+    getSyncStatus(endpoint: string, timeout?: number | null): Promise<{
+        status: any;
+        userBlockNumber: number;
+        trackBlockNumber: number;
+        isBehind: boolean;
+        isConfigured: boolean;
+    }>;
+    /**
+     * Syncs a secondary creator node for a given user
+     * @param secondary
+     * @param primary specific primary to use
+     * @param immediate whether or not this is a blocking request and handled right away
+     * @param validate whether or not to validate the provided secondary is valid
+     */
+    syncSecondary(secondary: string, primary?: string, immediate?: boolean, validate?: boolean): Promise<axios.AxiosResponse<any> | undefined>;
+    /**
+     * Signs up a creator node user with a wallet address
+     * @param walletAddress
+     */
+    _signupNodeUser(walletAddress: string): Promise<void>;
+    /**
+     * Logs user into cnode, if not already logged in.
+     * Requests a challenge from cnode, sends signed challenge response to cn.
+     * If successful, receive and set authToken locally.
+     */
+    _loginNodeUser(): Promise<void>;
+    /** Calls logout on the content node. Needs an authToken for this since logout is an authenticated endpoint */
+    _logoutNodeUser(): Promise<void>;
+    /**
+     * Gets and returns the clock values across the replica set for the wallet in userStateManager.
+     * @returns Array of objects with the structure:
+     *
+     * {
+     *  type: 'primary' or 'secondary',
+     *  endpoint: <Content Node endpoint>,
+     *  clockValue: clock value (should be an integer) or null
+     * }
+     *
+     * 'clockValue' may be null if the request to fetch the clock value fails
+     */
+    getClockValuesFromReplicaSet(): Promise<{
+        type: string;
+        endpoint: string;
+        clockValue: any;
+    }[] | undefined>;
+    /**
+     * Wrapper around getClockValue() to return either a proper or null clock value
+     * @param {Object} param
+     * @param {Object} param.user user metadata object from userStateManager
+     * @param {string} param.endpoint the Content Node endpoint to check the clock value for
+     * @param {number?} [param.timeout=1000] the max time allotted for a clock request; defaulted to 1000ms
+     */
+    _clockValueRequest({ user, endpoint, timeout }: ClockValueRequestConfig): Promise<{
+        type: string;
+        endpoint: string;
+        clockValue: any;
+    }>;
+    /**
+     * Makes an axios request to the connected creator node.
+     * @param requiresConnection if set, the currently configured creator node
+     * is connected to before the request is made.
+     * @return response body
+     */
+    _makeRequest(axiosRequestObj: AxiosRequestConfig, requiresConnection?: boolean): Promise<any>;
+    /**
+     * Create headers and formData for file upload
+     * @param file the file to upload
+     * @returns headers and formData in an object
+     */
+    createFormDataAndUploadHeaders(file: File, extraFormDataOptions?: Record<string, unknown>): {
+        headers: Record<string, string | null>;
+        formData: FormData;
+    };
+    /**
+     * Uploads a file to the connected creator node.
+     * @param file
+     * @param route route to handle upload (image_upload, track_upload, etc.)
+     * @param onProgress called with loaded bytes and total bytes
+     * @param extraFormDataOptions extra FormData fields passed to the upload
+     * @param retries max number of attempts made for axios request to upload file to CN before erroring
+     * @param timeoutMs timeout in ms axios request to upload file to CN will wait
+     */
+    _uploadFile(file: File, route: string, onProgress?: ProgressCB, extraFormDataOptions?: Record<string, unknown>, retries?: number, timeoutMs?: number | null): Promise<FileUploadResponse>;
+    _handleErrorHelper(e: Error | AxiosError, requestUrl?: string, requestId?: string | null): Promise<void>;
+}
+
+type Options = { skipRollover: boolean }
+
+declare class SanityChecks {
+  libs: any
+  options: Options
+
+  constructor(libsInstance: any, options?: Options): void
+  async run(creatorNodeWhitelist: string[] | null): Promise<void>
+}
+
+declare const libs: any;
+
+export { CreatorNode, SanityChecks, Utils, libs, sdk };