@audius/sdk 0.0.0 → 0.0.1

package/dist/index.d.ts

@@ -1,17 +1,22 @@
-import { UserImporterOptions, ImportCandidate } from 'ipfs-unixfs-importer';
-import * as ipfs_unixfs_importer_types_src_types from 'ipfs-unixfs-importer/types/src/types';
+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 * as BN from 'bn.js';
 import { AbiItem } from 'web3-utils';
-import * as axios from 'axios';
-import { AxiosResponse, AxiosRequestConfig, AxiosError } from 'axios';
-import FormData from 'form-data';
+import * as web3_core from 'web3-core';
+import { Log, TransactionReceipt, HttpProvider, EventLog } from 'web3-core';
 import Wallet from 'ethereumjs-wallet';
-import { HttpProvider, AbstractProvider, Log, TransactionReceipt } from 'web3-core';
 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 {
@@ -144,43 +149,218 @@ interface ContractMethod {
     };
     encodeABI: () => string;
     send: <Tx>(config: {
-        from: Wallet | undefined;
+        from: Wallet | string | undefined;
         gas: number;
         gasPrice?: number;
     }) => Tx;
 }
 
-declare type Providers = [
-    HttpProvider,
-    ...Array<HttpProvider | AbstractProvider>
-];
+declare type ServiceName = string;
+interface ServiceWithEndpoint {
+    endpoint: string;
+    spID?: string;
+}
+declare type Service = ServiceName | ServiceWithEndpoint;
 
-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 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 Web3Config = {
-    ownerWallet: Wallet;
-    providers: Providers;
+declare type TimeFrame = 'day' | 'week' | 'month' | 'year' | 'millennium';
+
+declare type Web3Config$1 = {
     useExternalWeb3: boolean;
     internalWeb3Config: {
         web3ProviderEndpoints: string[];
-        privateKey: string;
+        privateKey?: string;
     };
-    externalWeb3Config: {
+    externalWeb3Config?: {
         web3: Web3__default;
         ownerWallet: Wallet;
     };
@@ -191,7 +371,47 @@ declare class AudiusABIDecoder {
     static decodeLogs(_: string, logs: Log[]): abiDecoder.DecodedLog;
 }
 
-declare type TimeFrame = 'day' | 'week' | 'month' | 'year' | 'millennium';
+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 = {
@@ -236,11 +456,15 @@ declare type AttestationResult = {
     phase?: string;
     reason?: string;
 };
+declare type IdentityServiceConfig = {
+    identityServiceEndpoint: string;
+    captcha?: Captcha;
+};
 declare class IdentityService {
     identityServiceEndpoint: string;
-    captcha: Captcha;
+    captcha: Captcha | undefined;
     web3Manager: Web3Manager | null;
-    constructor(identityServiceEndpoint: string, captcha: Captcha);
+    constructor({ identityServiceEndpoint, captcha }: IdentityServiceConfig);
     setWeb3Manager(web3Manager: Web3Manager): void;
     getFn(params: {
         lookupKey: string;
@@ -365,40 +589,1039 @@ declare class IdentityService {
     }>;
 }
 
-/** singleton class to be instantiated and persisted with every AudiusLibs */
-declare class Web3Manager {
-    web3Config: Web3Config;
-    isServer: boolean;
+declare type EthWeb3Config = {
+    ownerWallet: Wallet | string;
+    providers: string[];
+};
+declare type EthWeb3ManagerConfig = {
+    web3Config: EthWeb3Config;
     identityService: IdentityService;
-    hedgehog: Hedgehog;
-    AudiusABIDecoder: typeof AudiusABIDecoder;
-    web3: Web3__default | undefined;
-    useExternalWeb3: boolean | undefined;
-    ownerWallet: Wallet;
-    constructor(web3Config: Web3Config, identityService: IdentityService, hedgehog: Hedgehog, isServer: boolean);
-    init(): Promise<void>;
+    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;
-    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>;
+    sign(data: string): Promise<string>;
+    sendTransaction(contractMethod: ContractMethod, contractAddress?: string | null, privateKey?: string | null, txRetries?: number, txGasLimit?: number | null): Promise<TransactionReceipt>;
     /**
-     * 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
+     * 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
      */
-    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;
+    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: ContractClient): 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 = {
@@ -427,6 +1650,521 @@ declare class UserStateManager {
     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?: {
@@ -686,4 +2424,6 @@ declare class SanityChecks {
   async run(creatorNodeWhitelist: string[] | null): Promise<void>
 }
 
-export { CreatorNode, SanityChecks, Utils };
+declare const libs: any;
+
+export { CreatorNode, SanityChecks, Utils, libs, sdk };