@audius/sdk 15.1.0 → 15.3.0

package/src/sdk/oauth/OAuth.ts

@@ -294,11 +294,34 @@ export class OAuth {
   }
 
   /**
-   * Returns true if the user is currently authenticated (i.e. an access
-   * token is present in the token store).
+   * Returns true if the user has a valid session. Checks the access token
+   * expiry when available — if the token has expired but a refresh token
+   * exists, a silent refresh is attempted. Returns false only when no
+   * usable session remains.
    */
   async isAuthenticated(): Promise<boolean> {
-    return !!(await this.config.tokenStore.getAccessToken())
+    const store = this.config.tokenStore
+
+    // If the refresh token is known-expired, the session is dead
+    const refreshExpiry = await store.getRefreshTokenExpiry()
+    if (refreshExpiry != null && Date.now() >= refreshExpiry) {
+      return false
+    }
+
+    const accessToken = await store.getAccessToken()
+    if (!accessToken) {
+      // No access token but we may still have a valid refresh token
+      return !!(await store.getRefreshToken())
+    }
+
+    const accessExpiry = await store.getAccessTokenExpiry()
+    if (accessExpiry != null && Date.now() >= accessExpiry) {
+      // Access token expired — try a silent refresh
+      const refreshed = await this.refreshAccessToken()
+      return refreshed != null
+    }
+
+    return true
   }
 
   /**
@@ -315,30 +338,42 @@ export class OAuth {
    * current server-side state (useful for detecting revoked sessions or
    * refreshing stale profile data on page load).
    *
+   * If the access token has expired, a single token refresh is attempted
+   * before failing.
+   *
    * Throws `ResponseError` if the server returns a non-2xx response (e.g. 401
    * if no token is stored or the token has expired), or `FetchError` if the
    * request fails at the network level.
    */
   async getUser(): Promise<User> {
+    let res = await this._fetchMe()
+    if (res.status === 401) {
+      const newToken = await this.refreshAccessToken()
+      if (newToken) {
+        res = await this._fetchMe()
+      }
+    }
+    if (!res.ok) {
+      throw new ResponseError(res, 'Failed to fetch user profile.')
+    }
+    const json = await res.json()
+    return UserFromJSON(json.data)
+  }
+
+  private async _fetchMe(): Promise<Response> {
     const accessToken = await this.config.tokenStore.getAccessToken()
     const headers: Record<string, string> = {}
     if (accessToken) {
       headers.Authorization = `Bearer ${accessToken}`
     }
-    let res: Response
     try {
-      res = await fetch(`${this.config.basePath}/me`, { headers })
+      return await fetch(`${this.config.basePath}/me`, { headers })
     } catch (e) {
       throw new FetchError(
         e instanceof Error ? e : new Error(String(e)),
         'Failed to fetch user profile.'
       )
     }
-    if (!res.ok) {
-      throw new ResponseError(res, 'Failed to fetch user profile.')
-    }
-    const json = await res.json()
-    return UserFromJSON(json.data)
   }
 
   /**
@@ -369,7 +404,9 @@ export class OAuth {
       if (tokens.access_token && tokens.refresh_token) {
         await this.config.tokenStore.setTokens(
           tokens.access_token,
-          tokens.refresh_token
+          tokens.refresh_token,
+          tokens.expires_in,
+          tokens.refresh_expires_in
         )
         return tokens.access_token
       }
@@ -433,7 +470,9 @@ export class OAuth {
     const tokens = await tokenRes.json()
     await this.config.tokenStore.setTokens(
       tokens.access_token,
-      tokens.refresh_token
+      tokens.refresh_token,
+      tokens.expires_in,
+      tokens.refresh_expires_in
     )
   }
 

package/src/sdk/oauth/TokenStoreAsyncStorage.ts

@@ -4,6 +4,8 @@ import type { OAuthTokenStore } from './tokenStore'
 
 const AS_ACCESS_TOKEN_KEY = 'audius_access_token'
 const AS_REFRESH_TOKEN_KEY = 'audius_refresh_token'
+const AS_ACCESS_TOKEN_EXPIRY_KEY = 'audius_access_token_expiry'
+const AS_REFRESH_TOKEN_EXPIRY_KEY = 'audius_refresh_token_expiry'
 
 export class TokenStoreAsyncStorage implements OAuthTokenStore {
   getAccessToken(): Promise<string | null> {
@@ -14,17 +16,59 @@ export class TokenStoreAsyncStorage implements OAuthTokenStore {
     return AsyncStorage.getItem(AS_REFRESH_TOKEN_KEY)
   }
 
-  async setTokens(access: string, refresh: string): Promise<void> {
-    await Promise.all([
+  async getAccessTokenExpiry(): Promise<number | null> {
+    const raw = await AsyncStorage.getItem(AS_ACCESS_TOKEN_EXPIRY_KEY)
+    if (raw == null) return null
+    const n = Number(raw)
+    return Number.isFinite(n) ? n : null
+  }
+
+  async getRefreshTokenExpiry(): Promise<number | null> {
+    const raw = await AsyncStorage.getItem(AS_REFRESH_TOKEN_EXPIRY_KEY)
+    if (raw == null) return null
+    const n = Number(raw)
+    return Number.isFinite(n) ? n : null
+  }
+
+  async setTokens(
+    access: string,
+    refresh: string,
+    expiresIn?: number,
+    refreshExpiresIn?: number
+  ): Promise<void> {
+    const ops: Array<Promise<void>> = [
       AsyncStorage.setItem(AS_ACCESS_TOKEN_KEY, access),
       AsyncStorage.setItem(AS_REFRESH_TOKEN_KEY, refresh)
-    ])
+    ]
+    if (expiresIn != null) {
+      ops.push(
+        AsyncStorage.setItem(
+          AS_ACCESS_TOKEN_EXPIRY_KEY,
+          String(Date.now() + expiresIn * 1000)
+        )
+      )
+    } else {
+      ops.push(AsyncStorage.removeItem(AS_ACCESS_TOKEN_EXPIRY_KEY))
+    }
+    if (refreshExpiresIn != null) {
+      ops.push(
+        AsyncStorage.setItem(
+          AS_REFRESH_TOKEN_EXPIRY_KEY,
+          String(Date.now() + refreshExpiresIn * 1000)
+        )
+      )
+    } else {
+      ops.push(AsyncStorage.removeItem(AS_REFRESH_TOKEN_EXPIRY_KEY))
+    }
+    await Promise.all(ops)
   }
 
   async clear(): Promise<void> {
     await Promise.all([
       AsyncStorage.removeItem(AS_ACCESS_TOKEN_KEY),
-      AsyncStorage.removeItem(AS_REFRESH_TOKEN_KEY)
+      AsyncStorage.removeItem(AS_REFRESH_TOKEN_KEY),
+      AsyncStorage.removeItem(AS_ACCESS_TOKEN_EXPIRY_KEY),
+      AsyncStorage.removeItem(AS_REFRESH_TOKEN_EXPIRY_KEY)
     ])
   }
 }

package/src/sdk/oauth/TokenStoreLocalStorage.ts

@@ -2,6 +2,8 @@ import type { OAuthTokenStore } from './tokenStore'
 
 const LS_ACCESS_TOKEN_KEY = 'audius_access_token'
 const LS_REFRESH_TOKEN_KEY = 'audius_refresh_token'
+const LS_ACCESS_TOKEN_EXPIRY_KEY = 'audius_access_token_expiry'
+const LS_REFRESH_TOKEN_EXPIRY_KEY = 'audius_refresh_token_expiry'
 
 /**
  * Default token store implementation that persists tokens to `localStorage`
@@ -24,13 +26,58 @@ export class TokenStoreLocalStorage implements OAuthTokenStore {
     }
   }
 
-  async setTokens(access: string, refresh: string): Promise<void> {
+  async getAccessTokenExpiry(): Promise<number | null> {
+    try {
+      const raw = window.localStorage.getItem(LS_ACCESS_TOKEN_EXPIRY_KEY)
+      if (raw == null) return null
+      const n = Number(raw)
+      return Number.isFinite(n) ? n : null
+    } catch {
+      return null
+    }
+  }
+
+  async getRefreshTokenExpiry(): Promise<number | null> {
+    try {
+      const raw = window.localStorage.getItem(LS_REFRESH_TOKEN_EXPIRY_KEY)
+      if (raw == null) return null
+      const n = Number(raw)
+      return Number.isFinite(n) ? n : null
+    } catch {
+      return null
+    }
+  }
+
+  async setTokens(
+    access: string,
+    refresh: string,
+    expiresIn?: number,
+    refreshExpiresIn?: number
+  ): Promise<void> {
     window.localStorage.setItem(LS_ACCESS_TOKEN_KEY, access)
     window.localStorage.setItem(LS_REFRESH_TOKEN_KEY, refresh)
+    if (expiresIn != null) {
+      window.localStorage.setItem(
+        LS_ACCESS_TOKEN_EXPIRY_KEY,
+        String(Date.now() + expiresIn * 1000)
+      )
+    } else {
+      window.localStorage.removeItem(LS_ACCESS_TOKEN_EXPIRY_KEY)
+    }
+    if (refreshExpiresIn != null) {
+      window.localStorage.setItem(
+        LS_REFRESH_TOKEN_EXPIRY_KEY,
+        String(Date.now() + refreshExpiresIn * 1000)
+      )
+    } else {
+      window.localStorage.removeItem(LS_REFRESH_TOKEN_EXPIRY_KEY)
+    }
   }
 
   async clear(): Promise<void> {
     window.localStorage.removeItem(LS_ACCESS_TOKEN_KEY)
     window.localStorage.removeItem(LS_REFRESH_TOKEN_KEY)
+    window.localStorage.removeItem(LS_ACCESS_TOKEN_EXPIRY_KEY)
+    window.localStorage.removeItem(LS_REFRESH_TOKEN_EXPIRY_KEY)
   }
 }

package/src/sdk/oauth/TokenStoreMemory.ts

@@ -12,6 +12,8 @@ import type { OAuthTokenStore } from './tokenStore'
 export class TokenStoreMemory implements OAuthTokenStore {
   private _accessToken: string | null = null
   private _refreshToken: string | null = null
+  private _accessTokenExpiry: number | null = null
+  private _refreshTokenExpiry: number | null = null
 
   async getAccessToken(): Promise<string | null> {
     return this._accessToken
@@ -21,13 +23,32 @@ export class TokenStoreMemory implements OAuthTokenStore {
     return this._refreshToken
   }
 
-  async setTokens(access: string, refresh: string): Promise<void> {
+  async getAccessTokenExpiry(): Promise<number | null> {
+    return this._accessTokenExpiry
+  }
+
+  async getRefreshTokenExpiry(): Promise<number | null> {
+    return this._refreshTokenExpiry
+  }
+
+  async setTokens(
+    access: string,
+    refresh: string,
+    expiresIn?: number,
+    refreshExpiresIn?: number
+  ): Promise<void> {
     this._accessToken = access
     this._refreshToken = refresh
+    this._accessTokenExpiry =
+      expiresIn != null ? Date.now() + expiresIn * 1000 : null
+    this._refreshTokenExpiry =
+      refreshExpiresIn != null ? Date.now() + refreshExpiresIn * 1000 : null
   }
 
   async clear(): Promise<void> {
     this._accessToken = null
     this._refreshToken = null
+    this._accessTokenExpiry = null
+    this._refreshTokenExpiry = null
   }
 }

package/src/sdk/oauth/tokenStore.test.ts

@@ -3,10 +3,12 @@ import { describe, it, expect } from 'vitest'
 import { TokenStoreMemory } from './TokenStoreMemory'
 
 describe('TokenStoreMemory', () => {
-  it('starts with null tokens', async () => {
+  it('starts with null tokens and expiries', async () => {
     const store = new TokenStoreMemory()
     expect(await store.getAccessToken()).toBeNull()
     expect(await store.getRefreshToken()).toBeNull()
+    expect(await store.getAccessTokenExpiry()).toBeNull()
+    expect(await store.getRefreshTokenExpiry()).toBeNull()
   })
 
   it('setTokens stores both tokens', async () => {
@@ -16,11 +18,38 @@ describe('TokenStoreMemory', () => {
     expect(await store.getRefreshToken()).toBe('refresh-456')
   })
 
-  it('clear resets both tokens to null', async () => {
+  it('setTokens stores expiry when expiresIn is provided', async () => {
     const store = new TokenStoreMemory()
-    await store.setTokens('a', 'r')
+    const before = Date.now()
+    await store.setTokens('at', 'rt', 3600)
+    const expiry = await store.getAccessTokenExpiry()
+    expect(expiry).toBeGreaterThanOrEqual(before + 3600 * 1000)
+    expect(expiry).toBeLessThanOrEqual(Date.now() + 3600 * 1000)
+  })
+
+  it('setTokens stores refresh expiry when refreshExpiresIn is provided', async () => {
+    const store = new TokenStoreMemory()
+    const before = Date.now()
+    await store.setTokens('at', 'rt', 3600, 2592000)
+    const expiry = await store.getRefreshTokenExpiry()
+    expect(expiry).toBeGreaterThanOrEqual(before + 2592000 * 1000)
+    expect(expiry).toBeLessThanOrEqual(Date.now() + 2592000 * 1000)
+  })
+
+  it('setTokens leaves expiry null when not provided', async () => {
+    const store = new TokenStoreMemory()
+    await store.setTokens('at', 'rt')
+    expect(await store.getAccessTokenExpiry()).toBeNull()
+    expect(await store.getRefreshTokenExpiry()).toBeNull()
+  })
+
+  it('clear resets all values to null', async () => {
+    const store = new TokenStoreMemory()
+    await store.setTokens('a', 'r', 3600, 2592000)
     await store.clear()
     expect(await store.getAccessToken()).toBeNull()
     expect(await store.getRefreshToken()).toBeNull()
+    expect(await store.getAccessTokenExpiry()).toBeNull()
+    expect(await store.getRefreshTokenExpiry()).toBeNull()
   })
 })

package/src/sdk/oauth/tokenStore.ts

@@ -6,6 +6,15 @@
 export interface OAuthTokenStore {
   getAccessToken(): Promise<string | null>
   getRefreshToken(): Promise<string | null>
-  setTokens(access: string, refresh: string): Promise<void>
+  /** Returns the epoch (ms) at which the access token expires, or null if unknown. */
+  getAccessTokenExpiry(): Promise<number | null>
+  /** Returns the epoch (ms) at which the refresh token expires, or null if unknown. */
+  getRefreshTokenExpiry(): Promise<number | null>
+  setTokens(
+    access: string,
+    refresh: string,
+    expiresIn?: number,
+    refreshExpiresIn?: number
+  ): Promise<void>
   clear(): Promise<void>
 }

package/src/sdk/oauth/tokenStoreAsyncStorage.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+const mockAsyncStorage = {
+  getItem: vi.fn(),
+  setItem: vi.fn(),
+  removeItem: vi.fn()
+}
+
+vi.mock('@react-native-async-storage/async-storage', () => ({
+  default: mockAsyncStorage
+}))
+
+// Import after mock is registered
+const { TokenStoreAsyncStorage } = await import('./TokenStoreAsyncStorage')
+
+describe('TokenStoreAsyncStorage — AsyncStorage persistence', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('reads persisted tokens from AsyncStorage', async () => {
+    mockAsyncStorage.getItem.mockImplementation(async (key: string) => {
+      if (key === 'audius_access_token') return 'persisted-access'
+      if (key === 'audius_refresh_token') return 'persisted-refresh'
+      return null
+    })
+    const store = new TokenStoreAsyncStorage()
+    expect(await store.getAccessToken()).toBe('persisted-access')
+    expect(await store.getRefreshToken()).toBe('persisted-refresh')
+  })
+
+  it('returns null when AsyncStorage is empty', async () => {
+    mockAsyncStorage.getItem.mockResolvedValue(null)
+    const store = new TokenStoreAsyncStorage()
+    expect(await store.getAccessToken()).toBeNull()
+    expect(await store.getRefreshToken()).toBeNull()
+    expect(await store.getAccessTokenExpiry()).toBeNull()
+    expect(await store.getRefreshTokenExpiry()).toBeNull()
+  })
+
+  it('setTokens writes tokens to AsyncStorage', async () => {
+    mockAsyncStorage.setItem.mockResolvedValue(undefined)
+    mockAsyncStorage.removeItem.mockResolvedValue(undefined)
+    const store = new TokenStoreAsyncStorage()
+    await store.setTokens('at', 'rt')
+    expect(mockAsyncStorage.setItem).toHaveBeenCalledWith(
+      'audius_access_token',
+      'at'
+    )
+    expect(mockAsyncStorage.setItem).toHaveBeenCalledWith(
+      'audius_refresh_token',
+      'rt'
+    )
+  })
+
+  it('setTokens writes expiry keys when provided', async () => {
+    mockAsyncStorage.setItem.mockResolvedValue(undefined)
+    mockAsyncStorage.removeItem.mockResolvedValue(undefined)
+    const store = new TokenStoreAsyncStorage()
+    await store.setTokens('at', 'rt', 3600, 2592000)
+    expect(mockAsyncStorage.setItem).toHaveBeenCalledWith(
+      'audius_access_token_expiry',
+      expect.any(String)
+    )
+    expect(mockAsyncStorage.setItem).toHaveBeenCalledWith(
+      'audius_refresh_token_expiry',
+      expect.any(String)
+    )
+  })
+
+  it('setTokens removes expiry keys when not provided', async () => {
+    mockAsyncStorage.setItem.mockResolvedValue(undefined)
+    mockAsyncStorage.removeItem.mockResolvedValue(undefined)
+    const store = new TokenStoreAsyncStorage()
+    await store.setTokens('at', 'rt')
+    expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith(
+      'audius_access_token_expiry'
+    )
+    expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith(
+      'audius_refresh_token_expiry'
+    )
+  })
+
+  it('reads persisted expiry from AsyncStorage', async () => {
+    const futureMs = String(Date.now() + 3600000)
+    mockAsyncStorage.getItem.mockImplementation(async (key: string) => {
+      if (key === 'audius_access_token_expiry') return futureMs
+      if (key === 'audius_refresh_token_expiry') return futureMs
+      return null
+    })
+    const store = new TokenStoreAsyncStorage()
+    expect(await store.getAccessTokenExpiry()).toBe(Number(futureMs))
+    expect(await store.getRefreshTokenExpiry()).toBe(Number(futureMs))
+  })
+
+  it('returns null for non-numeric expiry values (NaN safety)', async () => {
+    mockAsyncStorage.getItem.mockImplementation(async (key: string) => {
+      if (key === 'audius_access_token_expiry') return 'corrupted-value'
+      if (key === 'audius_refresh_token_expiry') return 'not-a-number'
+      return null
+    })
+    const store = new TokenStoreAsyncStorage()
+    expect(await store.getAccessTokenExpiry()).toBeNull()
+    expect(await store.getRefreshTokenExpiry()).toBeNull()
+  })
+
+  it('clear removes all keys from AsyncStorage', async () => {
+    mockAsyncStorage.setItem.mockResolvedValue(undefined)
+    mockAsyncStorage.removeItem.mockResolvedValue(undefined)
+    const store = new TokenStoreAsyncStorage()
+    await store.setTokens('at', 'rt')
+    await store.clear()
+    expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith(
+      'audius_access_token'
+    )
+    expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith(
+      'audius_refresh_token'
+    )
+    expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith(
+      'audius_access_token_expiry'
+    )
+    expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith(
+      'audius_refresh_token_expiry'
+    )
+  })
+})

package/src/sdk/oauth/tokenStoreLocalStorage.test.ts

@@ -34,6 +34,8 @@ describe('TokenStoreLocalStorage — localStorage persistence', () => {
     const store = new TokenStoreLocalStorage()
     expect(await store.getAccessToken()).toBeNull()
     expect(await store.getRefreshToken()).toBeNull()
+    expect(await store.getAccessTokenExpiry()).toBeNull()
+    expect(await store.getRefreshTokenExpiry()).toBeNull()
   })
 
   it('setTokens writes to localStorage', async () => {
@@ -49,7 +51,43 @@ describe('TokenStoreLocalStorage — localStorage persistence', () => {
     )
   })
 
-  it('clear removes tokens from localStorage', async () => {
+  it('setTokens writes expiry keys when provided', async () => {
+    const store = new TokenStoreLocalStorage()
+    await store.setTokens('at', 'rt', 3600, 2592000)
+    expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
+      'audius_access_token_expiry',
+      expect.any(String)
+    )
+    expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
+      'audius_refresh_token_expiry',
+      expect.any(String)
+    )
+  })
+
+  it('setTokens removes expiry keys when not provided', async () => {
+    const store = new TokenStoreLocalStorage()
+    await store.setTokens('at', 'rt')
+    expect(mockLocalStorage.removeItem).toHaveBeenCalledWith(
+      'audius_access_token_expiry'
+    )
+    expect(mockLocalStorage.removeItem).toHaveBeenCalledWith(
+      'audius_refresh_token_expiry'
+    )
+  })
+
+  it('reads persisted expiry from localStorage', async () => {
+    const futureMs = String(Date.now() + 3600000)
+    mockLocalStorage.getItem.mockImplementation((key: string) => {
+      if (key === 'audius_access_token_expiry') return futureMs
+      if (key === 'audius_refresh_token_expiry') return futureMs
+      return null
+    })
+    const store = new TokenStoreLocalStorage()
+    expect(await store.getAccessTokenExpiry()).toBe(Number(futureMs))
+    expect(await store.getRefreshTokenExpiry()).toBe(Number(futureMs))
+  })
+
+  it('clear removes all keys from localStorage', async () => {
     const store = new TokenStoreLocalStorage()
     await store.setTokens('at', 'rt')
     await store.clear()
@@ -59,5 +97,11 @@ describe('TokenStoreLocalStorage — localStorage persistence', () => {
     expect(mockLocalStorage.removeItem).toHaveBeenCalledWith(
       'audius_refresh_token'
     )
+    expect(mockLocalStorage.removeItem).toHaveBeenCalledWith(
+      'audius_access_token_expiry'
+    )
+    expect(mockLocalStorage.removeItem).toHaveBeenCalledWith(
+      'audius_refresh_token_expiry'
+    )
   })
 })

package/src/sdk/scripts/generateServicesConfig.ts

@@ -9,7 +9,6 @@ import {
   ServiceProviderFactory,
   ServiceTypeManager
 } from '@audius/eth'
-import range from 'lodash/range.js'
 import { createPublicClient, hexToString, http } from 'viem'
 import { mainnet } from 'viem/chains'
 
@@ -148,7 +147,7 @@ const generateServicesConfig = async (
       args: [serviceType]
     })
     const list = await Promise.all(
-      range(1, Number(count) + 1).map((i) =>
+      Array.from({ length: Number(count) }, (_, i) => i + 1).map((i) =>
         ethPublicClient.readContract({
           address: spfAddress,
           abi: ServiceProviderFactory.abi,

package/src/sdk/services/EntityManager/EntityManagerClient.ts

@@ -40,6 +40,10 @@ export class EntityManagerClient implements EntityManagerService {
   private readonly chainId: number
   private readonly contractAddress: string
   private readonly endpoint: string
+  private readonly apiKey?: string
+  private readonly apiSecret?: string
+  private readonly bearerToken?: string
+  private readonly appName?: string
 
   constructor(config_: EntityManagerConfig) {
     const config = mergeConfigWithDefaults(
@@ -51,6 +55,10 @@ export class EntityManagerClient implements EntityManagerService {
     this.contractAddress = config.contractAddress
     this.logger = config.logger.createPrefixedLogger('[entity-manager]')
     this.endpoint = config.endpoint
+    this.apiKey = config.apiKey
+    this.apiSecret = config.apiSecret
+    this.bearerToken = config.bearerToken
+    this.appName = config.appName
   }
 
   /**
@@ -87,13 +95,28 @@ export class EntityManagerClient implements EntityManagerService {
     const [senderAddress] = await this.audiusWalletClient.getAddresses()
     const signature = await this.audiusWalletClient.signTypedData(typedData)
 
-    const url = `${this.endpoint}/relay`
+    const params = new URLSearchParams()
+    if (this.apiKey) params.set('api_key', this.apiKey)
+    if (this.appName) params.set('app_name', this.appName)
+    const qs = params.toString()
+    const url = `${this.endpoint}/relay${qs ? `?${qs}` : ''}`
     this.logger.info(`Making relay request to ${url}`)
+
+    const headers = new Headers({
+      'Content-Type': 'application/json'
+    })
+
+    // Add auth header for API identification and rate limiting
+    if (this.bearerToken) {
+      headers.set('Authorization', `Bearer ${this.bearerToken}`)
+    } else if (this.apiKey && this.apiSecret) {
+      const credentials = btoa(`${this.apiKey}:${this.apiSecret}`)
+      headers.set('Authorization', `Basic ${credentials}`)
+    }
+
     const response = await fetch(url, {
       method: 'POST',
-      headers: new Headers({
-        'Content-Type': 'application/json'
-      }),
+      headers,
       body: JSON.stringify({
         contractAddress: this.contractAddress,
         contractRegistryKey: 'EntityManager',

package/src/sdk/services/EntityManager/types.ts

@@ -26,6 +26,14 @@ export type EntityManagerConfigInternal = {
    * The endpoint to use for relays
    */
   endpoint: string
+  /** API key for relay calls */
+  apiKey?: string
+  /** API secret for relay calls */
+  apiSecret?: string
+  /** Bearer token for relay calls */
+  bearerToken?: string
+  /** App name for relay calls */
+  appName?: string
 }
 export type EntityManagerConfig = Partial<EntityManagerConfigInternal> & {
   audiusWalletClient: AudiusWalletClient