@audius/sdk 0.0.0

package/src/utils/network.ts

@@ -0,0 +1,308 @@
+import axios, {
+  AxiosRequestConfig,
+  AxiosResponse,
+  CancelTokenSource
+} from 'axios'
+import semver from 'semver'
+
+import { Utils } from './utils'
+import { promiseFight } from './promiseFight'
+
+export type ServiceName = string
+export interface ServiceWithEndpoint {
+  endpoint: string
+  spID?: string
+}
+export type Service = ServiceName | ServiceWithEndpoint
+
+interface Request {
+  id?: string
+  url: string
+}
+
+interface TimingConfig {
+  timeout?: number
+}
+
+export interface Timing {
+  request: Request
+  response: AxiosResponse | null
+  millis: number | null
+}
+
+/**
+ * Fetches a url and times how long it took the request to complete.
+ */
+async function timeRequest(
+  request: Request,
+  timeout?: number | null
+): Promise<Timing> {
+  // This is non-perfect because of the js event loop, but enough
+  // of a proximation. Don't use for mission-critical timing.
+  const startTime = new Date().getTime()
+  const config: TimingConfig = {}
+  if (timeout !== null && timeout !== undefined) {
+    config.timeout = timeout
+  }
+  let response
+  try {
+    response = await axios.get(request.url, config)
+  } catch (e) {
+    console.debug(`Error with request for ${request.url}: ${e}`)
+    return { request, response: null, millis: null }
+  }
+  const millis = new Date().getTime() - startTime
+  return { request, response, millis }
+}
+
+interface SortServiceTimingsConfig {
+  serviceTimings: Timing[]
+  sortByVersion: boolean
+  currentVersion?: string | null
+  /*
+   *  the number of milliseconds at which we consider services to be equally as fast
+   *  and pick randomly between them. Default of null implies that the faster service
+   *  (even if by 1ms) will be picked always.
+   */
+  equivalencyDelta?: number | null
+}
+
+/**
+ * Custom sort for `serviceTimings`, the response from `timeRequest()` function above
+ */
+function sortServiceTimings({
+  serviceTimings,
+  sortByVersion,
+  currentVersion = null, // only required if `sortByVersion` = false
+  equivalencyDelta = null
+}: SortServiceTimingsConfig) {
+  return serviceTimings.sort((a, b) => {
+    // If health check failed, send to back of timings
+    if (a.response == null) return 1
+    if (b.response == null) return -1
+
+    const aVersion = a.response.data.data.version
+    const bVersion = b.response.data.data.version
+
+    if (sortByVersion) {
+      // Always sort by version desc
+      if (semver.gt(aVersion, bVersion)) return -1
+      if (semver.lt(aVersion, bVersion)) return 1
+    } else if (!sortByVersion && currentVersion) {
+      // Only sort by version if behind current on-chain version
+      if (
+        semver.gt(currentVersion, aVersion) &&
+        semver.gt(currentVersion, bVersion)
+      ) {
+        if (semver.gt(aVersion, bVersion)) return -1
+        if (semver.lt(aVersion, bVersion)) return 1
+      } else if (semver.gt(currentVersion, aVersion)) {
+        return 1
+      } else if (semver.gt(currentVersion, bVersion)) {
+        return -1
+      }
+    }
+
+    // If same version and transcode queue load, do a tie breaker on the response time
+    // If the requests are near eachother (delta < equivalencyDelta), pick randomly
+
+    const delta = (a.millis ?? 0) - (b.millis ?? 0)
+    if (equivalencyDelta !== null && delta < equivalencyDelta) {
+      return 1 - 2 * Math.random() // [-1, 1]
+    }
+    return delta
+  })
+}
+
+interface TimeRequestsConfig {
+  requests: Request[]
+  sortByVersion?: boolean
+  filterNonResponsive?: boolean
+  // current on-chain service version - only required if `sortByVersion` = false
+  currentVersion?: string | null
+  // ms applied to each individual request
+  timeout?: number | null
+  /*
+   *  the number of milliseconds at which we consider services to be equally as fast
+   *  and pick randomly between them. Default of null implies that the faster service
+   *  (even if by 1ms) will be picked always.
+   */
+  equivalencyDelta?: number | null
+}
+
+/**
+ * Fetches multiple urls and times each request and returns the results sorted
+ * first by version and then by lowest-latency.
+ */
+async function timeRequests({
+  requests,
+  sortByVersion = false,
+  currentVersion = null, // only required if `sortByVersion` = false
+  filterNonResponsive = false,
+  timeout = null,
+  equivalencyDelta = null
+}: TimeRequestsConfig) {
+  let serviceTimings = await Promise.all(
+    requests.map(async (request) => await timeRequest(request, timeout))
+  )
+
+  if (filterNonResponsive) {
+    serviceTimings = serviceTimings.filter((timing) => timing.response !== null)
+  }
+
+  return sortServiceTimings({
+    serviceTimings,
+    currentVersion,
+    sortByVersion,
+    equivalencyDelta
+  })
+}
+
+type RequestResponses =
+  | { blob: AxiosResponse; url: string }
+  | AxiosResponse
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- this is a return type
+  | void
+
+/**
+ * Races multiple requests
+ * @param urls
+ * @param callback invoked with the first successful url
+ * @param axiosConfig extra axios config for each request
+ * @param timeout timeout for any requests to be considered bad
+ * @param timeBetweenRequests time between requests being dispatched to free up client network interface
+ */
+async function raceRequests(
+  urls: string[],
+  callback: (url: string) => void,
+  axiosConfig: AxiosRequestConfig,
+  timeout = 3000,
+  timeBetweenRequests = 100,
+  validationCheck = (_: AxiosResponse) => true
+) {
+  const CancelToken = axios.CancelToken
+
+  const sources: CancelTokenSource[] = []
+  let hasFinished = false
+  const requests = urls.map(async (url, i) => {
+    const source = CancelToken.source()
+    sources.push(source)
+
+    // Slightly offset requests by their order, so:
+    // 1. We try creator node gateways first
+    // 2. We give requests the opportunity to get canceled if other's are very fast
+    await Utils.wait(timeBetweenRequests * i)
+    if (hasFinished) return
+    return await new Promise<RequestResponses>((resolve, reject) => {
+      axios({
+        method: 'get',
+        url,
+        cancelToken: source.token,
+        ...axiosConfig
+      })
+        .then((response) => {
+          const isValid = validationCheck(response)
+          if (isValid) {
+            hasFinished = true
+            resolve({
+              blob: response,
+              url
+            })
+          } else {
+            // Invalid because of validity check
+            reject(response)
+          }
+        })
+        .catch((thrown) => {
+          reject(thrown)
+          // no-op.
+          // If debugging `axios.isCancel(thrown)`
+          // can be used to check if the throw was from a cancel.
+        })
+    })
+  })
+  if (timeout !== null) {
+    requests.push(Utils.wait(timeout))
+  }
+  let response
+  let errored: AxiosResponse[]
+  try {
+    const { val, errored: e } = await promiseFight<
+      RequestResponses,
+      AxiosResponse
+    >(requests, true)
+    response = val
+    errored = e
+  } catch (e: any) {
+    response = null
+    errored = e
+  }
+  sources.forEach((source) => {
+    source.cancel('Fetch already succeeded')
+  })
+
+  if (response && 'url' in response && 'blob' in response) {
+    callback(response.url)
+    return { response: response.blob, errored }
+  }
+
+  return { response: null, errored }
+}
+
+interface AllRequestsConfig {
+  /*
+   * map of actual URL to hit (e.g. https://resource/endpoint)
+   * and identifying value (e.g. https://resource)
+   */
+  urlMap: Record<string, Service>
+  /*
+   * timeout for any request to be considered bad
+   */
+  timeout: number
+  /* a check invoked for each response.
+   *  If invalid, the response is filtered out.
+   *  (response: any) => boolean
+   */
+  validationCheck: (_: AxiosResponse) => boolean
+}
+
+/**
+ * Gets the response for many requests with a timeout to each
+ */
+async function allRequests({
+  urlMap,
+  timeout,
+  validationCheck
+}: AllRequestsConfig) {
+  const urls = Object.keys(urlMap)
+  const requests = urls.map(async (url) => {
+    return await new Promise<Service | null>((resolve) => {
+      axios({
+        method: 'get',
+        timeout,
+        url
+      })
+        .then((response) => {
+          const isValid = validationCheck(response)
+          if (isValid) {
+            resolve(urlMap[url] as Service)
+          } else {
+            resolve(null)
+          }
+        })
+        .catch(() => {
+          resolve(null)
+        })
+    })
+  })
+  const responses = (await Promise.all(requests)).filter(Boolean)
+  return responses
+}
+
+export {
+  timeRequest,
+  timeRequests,
+  raceRequests,
+  allRequests,
+  sortServiceTimings
+}

package/src/utils/promiseFight.test.ts

@@ -0,0 +1,87 @@
+import { promiseFight } from './promiseFight'
+import assert from 'assert'
+
+/**
+ * A promise that either resolves or rejects. If it resolves,
+ * resolves with the provided id.
+ * @param id identifier for this promise
+ * @param resolveTimeout resolves after this timeout
+ * @param rejectTimeout rejects after this timeout
+ */
+const p = async (
+  id: string,
+  resolveTimeout: null | number,
+  rejectTimeout?: number
+) =>
+  await new Promise((resolve, reject) => {
+    if (resolveTimeout) {
+      setTimeout(() => resolve(id), resolveTimeout)
+    }
+    if (rejectTimeout) {
+      setTimeout(() => reject(id), rejectTimeout)
+    }
+  })
+
+describe('promiseFight', () => {
+  it('should pick the first', async () => {
+    const res = await promiseFight([p('first', 1), p('second', 100)])
+    assert.strictEqual(res, 'first')
+  })
+
+  it('should pick the first of many', async () => {
+    const res = await promiseFight([
+      p('first', 1),
+      p('second', 100),
+      p('third', 101),
+      p('fourth', 102),
+      p('fifth', 103)
+    ])
+    assert.strictEqual(res, 'first')
+  })
+
+  it('should pick the first that succeeds', async () => {
+    const res = await promiseFight([
+      p('first', 100),
+      p('second', null, 10),
+      p('third', null, 20)
+    ])
+    assert.strictEqual(res, 'first')
+  })
+
+  it('should pick the first that succeeds and capture the failed', async () => {
+    const res = await promiseFight(
+      [p('first', 100), p('second', null, 10), p('third', null, 20)],
+      true
+    )
+    assert.deepStrictEqual(res, { val: 'first', errored: ['second', 'third'] })
+  })
+
+  it('should pick the first that succeeds and capture the failed that finished', async () => {
+    const res = await promiseFight(
+      [
+        p('first', 100),
+        p('second', null, 10),
+        p('third', null, 20),
+        p('fourth', null, 200)
+      ],
+      true
+    )
+    assert.deepStrictEqual(res, { val: 'first', errored: ['second', 'third'] })
+  })
+
+  it('should fail if all of the promises fail', async () => {
+    try {
+      await promiseFight(
+        [
+          p('first', null, 100),
+          p('second', null, 10),
+          p('third', null, 20),
+          p('fourth', null, 200)
+        ],
+        true
+      )
+    } catch (e) {
+      assert.deepStrictEqual(e, ['first', 'second', 'third', 'fourth'])
+    }
+  })
+})

package/src/utils/promiseFight.ts

@@ -0,0 +1,36 @@
+/**
+ * Given an array of promises, it returns the first resolved promise as soon as it finishes
+ * @param promises
+ * @param captureErrored optional capture errored promises
+ * @return A promise that resolves with the first promise that resolves
+ */
+export async function promiseFight<T1, T2>(
+  promises: Array<Promise<T1>>
+): Promise<T1 | T2>
+export async function promiseFight<T1, T2>(
+  promises: Array<Promise<T1>>,
+  captureErrored: boolean
+): Promise<{ val: T1; errored: T2[] }>
+export async function promiseFight<T1, T2>(
+  promises: Array<Promise<T1>>,
+  captureErrored?: boolean
+) {
+  const errored: T2[] = []
+  return await Promise.all<Array<Promise<T1 | T2>>>(
+    promises.map(async (p) => {
+      return await p.then<T1, T2>(
+        async (val) => await Promise.reject(val),
+        async (err) => {
+          if (captureErrored) errored.push(err)
+          return await Promise.resolve(err)
+        }
+      )
+    })
+  ).then(
+    async (errors) => await Promise.reject(errors),
+    async (val) => {
+      if (captureErrored) return await Promise.resolve({ val, errored })
+      else return await Promise.resolve(val)
+    }
+  )
+}

package/src/utils/signatures.ts

@@ -0,0 +1,139 @@
+import { Utils } from './utils'
+import { ecsign, toBuffer } from 'ethereumjs-util'
+import { pack } from '@ethersproject/solidity'
+import type Web3 from 'web3'
+
+export const sign = (digest: any, privateKey: Buffer) => {
+  const buffer = toBuffer(digest)
+  const signature = ecsign(buffer, privateKey)
+  return signature
+}
+
+// lazyload permitTypehash to avoid a web3 race
+let _permitTypehash: null | string = null
+const getPermitTypehash = () => {
+  if (!_permitTypehash) {
+    _permitTypehash = Utils.keccak256(
+      'Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)'
+    )
+  }
+  return _permitTypehash
+}
+
+let _transferTokensTypehash: null | string = null
+const getTransferTokensTypeHash = () => {
+  if (!_transferTokensTypehash) {
+    _transferTokensTypehash = Utils.keccak256(
+      'TransferTokens(address from,uint256 amount,uint16 recipientChain,bytes32 recipient,uint256 artbiterFee,uint32 nonce,uint256 deadline)'
+    )
+  }
+  return _transferTokensTypehash
+}
+
+export interface ApproveTokens {
+  owner: string
+  spender: string
+  value: string
+}
+
+// Returns the EIP712 hash which should be signed by the user
+// in order to make a call to `permit`
+export function getPermitDigest(
+  web3: Web3,
+  name: string,
+  address: string,
+  chainId: string,
+  approve: ApproveTokens,
+  nonce: boolean,
+  deadline: string
+) {
+  const DOMAIN_SEPARATOR = getDomainSeparator(web3, name, address, chainId)
+
+  const innerEncoded = web3.eth.abi.encodeParameters(
+    ['bytes32', 'address', 'address', 'uint256', 'uint256', 'uint256'],
+    [
+      getPermitTypehash(),
+      approve.owner,
+      approve.spender,
+      approve.value,
+      nonce,
+      deadline
+    ]
+  )
+  const encoded = pack(
+    ['bytes1', 'bytes1', 'bytes32', 'bytes32'],
+    ['0x19', '0x01', DOMAIN_SEPARATOR, Utils.keccak256(innerEncoded)]
+  )
+  return Utils.keccak256(encoded)
+}
+
+export interface TransferTokens {
+  from: string
+  amount: string
+  recipientChain: string
+  recipient: string
+  arbiterFee: string
+}
+
+// Returns the EIP712 hash which should be signed by the user
+// in order to make a call to `transferTokens`
+export function getTransferTokensDigest(
+  web3: Web3,
+  name: string,
+  address: string,
+  chainId: string,
+  transferTokens: TransferTokens,
+  nonce: boolean,
+  deadline: string
+) {
+  const DOMAIN_SEPARATOR = getDomainSeparator(web3, name, address, chainId)
+  const innerEncoded = web3.eth.abi.encodeParameters(
+    [
+      'bytes32',
+      'address',
+      'uint256',
+      'uint16',
+      'bytes32',
+      'uint256',
+      'uint32',
+      'uint256'
+    ],
+    [
+      getTransferTokensTypeHash(),
+      transferTokens.from,
+      transferTokens.amount,
+      transferTokens.recipientChain,
+      transferTokens.recipient,
+      transferTokens.arbiterFee,
+      nonce,
+      deadline
+    ]
+  )
+  const encoded = pack(
+    ['bytes1', 'bytes1', 'bytes32', 'bytes32'],
+    ['0x19', '0x01', DOMAIN_SEPARATOR, Utils.keccak256(innerEncoded)]
+  )
+  return Utils.keccak256(encoded)
+}
+
+// Gets the EIP712 domain separator
+function getDomainSeparator(
+  web3: Web3,
+  name: string,
+  contractAddress: string,
+  chainId: string
+) {
+  const encoded = web3.eth.abi.encodeParameters(
+    ['bytes32', 'bytes32', 'bytes32', 'uint256', 'address'],
+    [
+      Utils.keccak256(
+        'EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'
+      ),
+      Utils.keccak256(name),
+      Utils.keccak256('1'),
+      chainId,
+      contractAddress
+    ]
+  )
+  return Utils.keccak256(encoded)
+}

package/src/utils/types.ts

@@ -0,0 +1,34 @@
+export type Maybe<T> = T | undefined
+export type Nullable<T> = T | null
+
+export 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
+}

package/src/utils/utils.test.ts

@@ -0,0 +1,36 @@
+import assert from 'assert'
+import { Utils } from './utils'
+
+describe('utils', () => {
+  it('should decodeMethod correctly', async () => {
+    const decoded = Utils.decodeMultihash(
+      'QmWAoBkJzA1Ffur3aiVPr8h5YSV5aBxRFNeZDPmB7vnBQP'
+    )
+    assert.strictEqual(
+      decoded.digest,
+      '0x74574595073a25aaac18f1089239a26f8bceaf76cc29973d2be13352d2abca4c'
+    )
+    assert.strictEqual(decoded.hashFn, 18) // constant
+    assert.strictEqual(decoded.size, 32) // constant
+  })
+
+  it('should encodeMethod correctly with 0x prefix', async () => {
+    const encoded = Utils.encodeMultihash(
+      '0x74574595073a25aaac18f1089239a26f8bceaf76cc29973d2be13352d2abca4c'
+    )
+    assert.strictEqual(
+      encoded,
+      'QmWAoBkJzA1Ffur3aiVPr8h5YSV5aBxRFNeZDPmB7vnBQP'
+    )
+  })
+
+  it('should encodeMethod correctly without 0x prefix', async () => {
+    const encoded = Utils.encodeMultihash(
+      '74574595073a25aaac18f1089239a26f8bceaf76cc29973d2be13352d2abca4c'
+    )
+    assert.strictEqual(
+      encoded,
+      'QmWAoBkJzA1Ffur3aiVPr8h5YSV5aBxRFNeZDPmB7vnBQP'
+    )
+  })
+})