@audius/sdk 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -1,22 +1,17 @@
-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 { UserImporterOptions, ImportCandidate } from 'ipfs-unixfs-importer';
+import * as ipfs_unixfs_importer_types_src_types from 'ipfs-unixfs-importer/types/src/types';
 import * as Web3 from 'web3';
 import Web3__default from 'web3';
+import * as BN from 'bn.js';
 import { AbiItem } from 'web3-utils';
-import * as web3_core from 'web3-core';
-import { Log, TransactionReceipt, HttpProvider, EventLog } from 'web3-core';
+import * as axios from 'axios';
+import { AxiosResponse, AxiosRequestConfig, AxiosError } from 'axios';
+import FormData from 'form-data';
 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 {
@@ -149,218 +144,43 @@ interface ContractMethod {
     };
     encodeABI: () => string;
     send: <Tx>(config: {
-        from: Wallet | string | undefined;
+        from: Wallet | 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 Providers = [
+    HttpProvider,
+    ...Array<HttpProvider | AbstractProvider>
+];
 
-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;
+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;
 };
-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 = {
+declare type Web3Config = {
+    ownerWallet: Wallet;
+    providers: Providers;
     useExternalWeb3: boolean;
     internalWeb3Config: {
         web3ProviderEndpoints: string[];
-        privateKey?: string;
+        privateKey: string;
     };
-    externalWeb3Config?: {
+    externalWeb3Config: {
         web3: Web3__default;
         ownerWallet: Wallet;
     };
@@ -371,47 +191,7 @@ declare class AudiusABIDecoder {
     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 TimeFrame = 'day' | 'week' | 'month' | 'year' | 'millennium';
 
 declare type Data = Record<string, unknown>;
 declare type RelayTransaction = {
@@ -456,15 +236,11 @@ declare type AttestationResult = {
     phase?: string;
     reason?: string;
 };
-declare type IdentityServiceConfig = {
-    identityServiceEndpoint: string;
-    captcha?: Captcha;
-};
 declare class IdentityService {
     identityServiceEndpoint: string;
-    captcha: Captcha | undefined;
+    captcha: Captcha;
     web3Manager: Web3Manager | null;
-    constructor({ identityServiceEndpoint, captcha }: IdentityServiceConfig);
+    constructor(identityServiceEndpoint: string, captcha: Captcha);
     setWeb3Manager(web3Manager: Web3Manager): void;
     getFn(params: {
         lookupKey: string;
@@ -589,1041 +365,40 @@ declare class IdentityService {
     }>;
 }
 
-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;
+/** singleton class to be instantiated and persisted with every AudiusLibs */
+declare class Web3Manager {
+    web3Config: Web3Config;
+    isServer: boolean;
     identityService: IdentityService;
-    hedgehog?: Hedgehog;
-    ownerWallet: Maybe<Wallet | string>;
-    constructor({ web3Config, identityService, hedgehog }: EthWeb3ManagerConfig);
+    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>;
     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>;
-    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;
+    sign(data: string): Promise<string | undefined>;
     /**
-     * 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`
+     * 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
      */
-    selectFromBackups(): Promise<string>;
+    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 CurrentUser = {
@@ -1652,521 +427,6 @@ 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?: {
@@ -2426,6 +686,4 @@ declare class SanityChecks {
   async run(creatorNodeWhitelist: string[] | null): Promise<void>
 }
 
-declare const libs: any;
-
-export { CreatorNode, SanityChecks, Utils, libs, sdk };
+export { CreatorNode, SanityChecks, Utils };