@audius/sdk 0.0.0

package/tests/socialFeatureClientTest.js

@@ -0,0 +1,79 @@
+const assert = require('assert')
+let helpers = require('./helpers')
+let { Utils } = require('../src/utils')
+
+let audiusInstance = helpers.audiusInstance
+
+before(async function () {
+  await audiusInstance.init()
+})
+
+it('Should add + delete track repost', async function () {
+  // add creator
+  const handle = 'sid' + Math.floor(Math.random() * 10000000)
+  const creatorId = (await audiusInstance.contracts.UserFactoryClient.addUser(handle)).userId
+  assert.ok(creatorId && Number.isInteger(creatorId), 'invalid creatorId')
+
+  // add track
+  const cid = helpers.constants.trackMetadataCID
+  const trackMultihashDecoded = Utils.decodeMultihash(cid)
+  const { trackId } = await audiusInstance.contracts.TrackFactoryClient.addTrack(
+    creatorId,
+    trackMultihashDecoded.digest,
+    trackMultihashDecoded.hashFn,
+    trackMultihashDecoded.size
+  )
+  assert.ok(trackId && Number.isInteger(trackId), 'invalid trackId')
+  const track = await audiusInstance.contracts.TrackFactoryClient.getTrack(trackId)
+  assert.strictEqual(track.multihashDigest, trackMultihashDecoded.digest, 'Unexpected track multihash digest')
+
+  // add track repost
+  const addTrackRepostTx = await audiusInstance.contracts.SocialFeatureFactoryClient.addTrackRepost(creatorId, trackId)
+  assert.ok('TrackRepostAdded' in addTrackRepostTx.events, 'Did not find TrackRepostAdded event in transaction')
+
+  // delete track repost
+  const deleteTrackRepostTx = await audiusInstance.contracts.SocialFeatureFactoryClient.deleteTrackRepost(creatorId, trackId)
+  assert.ok('TrackRepostDeleted' in deleteTrackRepostTx.events, 'Did not find TrackRepostDeleted event in transaction')
+})
+
+it('Should add + delete playlist repost', async function () {
+  // add creator
+  const handle = 'sid' + Math.floor(Math.random() * 10000000)
+  const creatorId = (await audiusInstance.contracts.UserFactoryClient.addUser(handle)).userId
+  assert.ok(creatorId && Number.isInteger(creatorId), 'invalid creatorId')
+
+  // add playlist
+  const { playlistId } = await audiusInstance.contracts.PlaylistFactoryClient.createPlaylist(
+    creatorId,
+    'initialPlaylistName',
+    false,
+    false,
+    [])
+  assert.ok(playlistId && Number.isInteger(playlistId), 'invalid playlistId')
+
+  // add playlist repost
+  const addPlaylistRepostTx = await audiusInstance.contracts.SocialFeatureFactoryClient.addPlaylistRepost(creatorId, playlistId)
+  assert.ok('PlaylistRepostAdded' in addPlaylistRepostTx.events, 'Did not find PlaylistRepostAdded event in transaction')
+
+  // delete playlist repost
+  const deletePlaylistRepostTx = await audiusInstance.contracts.SocialFeatureFactoryClient.deletePlaylistRepost(creatorId, playlistId)
+  assert.ok('PlaylistRepostDeleted' in deletePlaylistRepostTx.events, 'Did not find PlaylistRepostDeleted event in transaction')
+})
+
+it('Should add + delete user follow', async function () {
+  // add 2 users
+  const handle1 = '2sid_' + Math.floor(Math.random() + 10000000)
+  const handle2 = '3sid_' + Math.floor(Math.random() + 10000000)
+  const userId1 = (await audiusInstance.contracts.UserFactoryClient.addUser(handle1)).userId
+  const userId2 = (await audiusInstance.contracts.UserFactoryClient.addUser(handle2)).userId
+  assert.ok(userId1 && Number.isInteger(userId1), 'invalid userId')
+  assert.ok(userId2 && Number.isInteger(userId2), 'invalid userId')
+
+  // add user follow
+  const addUserFollowTx = await audiusInstance.contracts.SocialFeatureFactoryClient.addUserFollow(userId1, userId2)
+  assert.ok('UserFollowAdded' in addUserFollowTx.events, 'Did not find UserFollowAdded event in transaction')
+
+  // delete user follow
+  const deleteUserFollowTx = await audiusInstance.contracts.SocialFeatureFactoryClient.deleteUserFollow(userId1, userId2)
+  assert.ok('UserFollowDeleted' in deleteUserFollowTx.events, 'Did not find UserFollowDeleted event in transaction')
+})

package/tests/stakingTest.js

@@ -0,0 +1,302 @@
+const assert = require('assert')
+const nock = require('nock')
+const helpers = require('./helpers')
+const { time } = require('@openzeppelin/test-helpers')
+
+// const audiusConfig = helpers.audiusLibsConfig
+const { getRandomLocalhost, audiusInstance: audius0 } = helpers
+const initializeLibConfig = helpers.initializeLibConfig
+const ethContractsConfig = require('../eth-contracts/config.json')
+const AudiusLibs = require('../src/index');
+const { convertAudsToWeiBN } = require('../initScripts/helpers/utils');
+const { initial } = require('lodash')
+const { deregisterSPEndpoint } = require('./helpers')
+
+let token
+let ownerWallet
+let accounts
+let audius1
+let audius2
+let sp1
+let sp2
+
+const assertThrows = async (blockOrPromise, expectedErrorCode, expectedReason) => {
+  try {
+    (typeof blockOrPromise === 'function') ? await blockOrPromise() : await blockOrPromise
+  } catch (error) {
+    assert(error.message.search(expectedErrorCode) > -1, `Expected error code "${expectedErrorCode}" but failed with "${error}" instead.`)
+    return error
+  }
+  // assert.fail() for some reason does not have its error string printed 🤷
+  assert(false, `Expected "${expectedErrorCode}"${expectedReason ? ` (with reason: "${expectedReason}")` : ''} but it did not fail`)
+}
+
+const assertRevert = async (blockOrPromise, expectedReason) => {
+  const error = await assertThrows(blockOrPromise, 'revert', expectedReason)
+  if (!expectedReason) {
+    return
+  }
+  const expectedMsgFound = error.message.indexOf(expectedReason) >= 0
+  assert.equal(expectedMsgFound, true, 'Expected revert reason not found')
+}
+
+describe('Staking tests', () => {
+  let testServiceType = 'discovery-provider'
+
+  before(async function () {
+    await audius0.init()
+    token = audius0.ethContracts.AudiusTokenClient
+    accounts = await audius0.ethWeb3Manager.getWeb3().eth.getAccounts()
+
+    // Set lockup durations to a small number so we can reach it
+    // in a reasonable test time
+    await audius0.ethContracts.GovernanceClient.setVotingPeriod(1)
+    await audius0.ethContracts.GovernanceClient.setExecutionDelay(0)
+    await audius0.ethContracts.ServiceProviderFactoryClient.updateDecreaseStakeLockupDuration(10)
+    await audius0.ethContracts.DelegateManagerClient.updateUndelegateLockupDuration(10)
+
+    ownerWallet = accounts[0]
+    sp1 = accounts[1]
+    sp2 = accounts[2]
+
+    // Initialize more lib instances
+    let libsConfig1 = await initializeLibConfig(sp1)
+    assert(
+      ethContractsConfig.ownerWallet !== libsConfig1.ownerWallet,
+      'New wallet addr')
+    audius1 = new AudiusLibs(libsConfig1)
+    await audius1.init()
+
+    let libsConfig2 = await initializeLibConfig(accounts[2])
+    assert(
+      ethContractsConfig.ownerWallet !== libsConfig2.ownerWallet,
+      'New wallet addr')
+    audius2 = new AudiusLibs(libsConfig2)
+    await audius2.init()
+
+    // Refund test accounts
+    await token.transfer(sp1, convertAudsToWeiBN(audius1.ethWeb3Manager.getWeb3(), 2000000))
+    await token.transfer(sp2, convertAudsToWeiBN(audius1.ethWeb3Manager.getWeb3(), 2000000))
+
+  })
+
+  it('initial staking contract state', async function () {
+    let tokenAddr = await audius0.ethContracts.StakingProxyClient.token()
+    assert(token.contractAddress, tokenAddr, 'Expect correct token address from staking proxy')
+    let supportsHistory = await audius0.ethContracts.StakingProxyClient.supportsHistory()
+    assert.equal(supportsHistory, true, 'History support required')
+    assert.equal(await audius0.ethContracts.StakingProxyClient.totalStaked(), 0, 'Expect no stake on init')
+  })
+
+  describe('Registration', () => {
+    let initialSPBalance
+    let testEndpt
+    let testEndpt2
+    let initialStake
+    let defaultStake
+
+    beforeEach(async () => {
+
+      // Clear any accounts registered w/the audius1 account
+      initialSPBalance = await token.balanceOf(sp1)
+      testEndpt = getRandomLocalhost()
+
+      let path = '/version'
+      let response = {
+        service: testServiceType,
+        version : '0.0.1'
+      }
+
+      if (testServiceType === 'discovery-provider') {
+        path = '/health_check'
+        response = {data: {...response}}
+      }
+
+      nock(testEndpt)
+        .get(path)
+        .reply(200, response)
+
+      // Cache stake amount prior to register
+      initialStake = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      defaultStake = convertAudsToWeiBN(audius1.ethWeb3Manager.getWeb3(), 210000)
+
+      // Register
+      let tx = await audius1.ethContracts.ServiceProviderFactoryClient.register(
+        testServiceType,
+        testEndpt,
+        defaultStake
+      )
+    })
+
+    afterEach(async () => {
+      await deregisterSPEndpoint(audius1, sp1, testServiceType)
+    })
+
+    it('register service provider + stake', async function () {
+      const newBalance = await token.balanceOf(sp1)
+      const expectedNewBalance = initialSPBalance.sub(defaultStake)
+      assert(
+        newBalance.eq(expectedNewBalance),
+        'Expect decrease in bal'
+      )
+
+      const staked = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      const expectedStaked = initialStake.add(defaultStake)
+      assert(
+        staked.eq(expectedStaked),
+        'Expect increase in stake'
+      )
+    })
+
+    it('increases service provider stake', async function () {
+      let preIncreaseBalance = await token.balanceOf(sp1)
+      let preIncreaseStake = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      let tx = await audius1.ethContracts.ServiceProviderFactoryClient.increaseStake(defaultStake)
+
+      const newBalance = await token.balanceOf(sp1)
+      const expectedBalance = preIncreaseBalance.sub(defaultStake)
+      assert(
+        newBalance.eq(expectedBalance),
+        'Expect decrease in balance'
+      )
+      const totalStaked = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      const expectedStaked = preIncreaseStake.add(defaultStake)
+      assert(
+        totalStaked.eq(expectedStaked),
+        'Expect increase in stake'
+      )
+
+      // Confirm revert occurred for incorrect owner
+      assertRevert(
+        audius2.ethContracts.ServiceProviderFactoryClient.increaseStake(
+          defaultStake
+        ),
+        'incorrect owner'
+      )
+    })
+
+    it('decreases service provider stake', async () => {
+      const preDecreaseBal = await token.balanceOf(sp1)
+      const preDecreaseStake = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+
+      const decreaseAmount = audius1.ethWeb3Manager.getWeb3().utils.toBN(10000)
+
+      const lockupExpiryBlock = await audius1.ethContracts.ServiceProviderFactoryClient.requestDecreaseStake(
+        decreaseAmount
+      )
+      await time.advanceBlockTo(lockupExpiryBlock)
+
+      await audius1.ethContracts.ServiceProviderFactoryClient.decreaseStake(
+        lockupExpiryBlock
+      )
+
+      const newBalance = await token.balanceOf(sp1)
+      const expectedBalance = preDecreaseBal.add(decreaseAmount)
+      assert(
+        newBalance.eq(expectedBalance),
+        'Expect increase in balance'
+      )
+
+      const totalStaked = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      const expectedStaked = preDecreaseStake.sub(decreaseAmount)
+      assert(
+        totalStaked.eq(expectedStaked),
+        'Expect decrease in stake'
+      )
+
+      assertRevert(
+        audius2.ethContracts.ServiceProviderFactoryClient.decreaseStake(
+          decreaseAmount
+        ),
+        'incorrect owner'
+      )
+
+      const currentStake = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      // Configure amount greater than current stake to try and decrease
+      const increaseAmt = audius1.ethWeb3Manager.getWeb3().utils.toBN(10)
+      const invalidDecreaseAmount = currentStake.add(increaseAmt)
+      assertRevert(
+        audius1.ethContracts.ServiceProviderFactoryClient.decreaseStake(
+          invalidDecreaseAmount
+        ),
+        'subtraction overflow'
+      )
+    })
+  })
+
+  describe('Deregistration', () => {
+    beforeEach(async () => {
+
+      // Clear any accounts registered w/the audius1 account
+      initialSPBalance = await token.balanceOf(sp1)
+      testEndpt = getRandomLocalhost()
+
+      let path = '/version'
+      let response = {
+        service: testServiceType,
+        version : '0.0.1'
+      }
+
+      if (testServiceType === 'discovery-provider') {
+        path = '/health_check'
+        response = {data: {...response}}
+      }
+
+      nock(testEndpt)
+        .get(path)
+        .reply(200, response)
+
+      // Cache stake amount prior to register
+      initialStake = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      defaultStake = convertAudsToWeiBN(audius1.ethWeb3Manager.getWeb3(), 210000)
+
+      // Register
+      let tx = await audius1.ethContracts.ServiceProviderFactoryClient.register(
+        testServiceType,
+        testEndpt,
+        defaultStake
+      )
+    })
+
+    it('deregisters service provider + recover stake', async function () {
+      const initialBalance = await token.balanceOf(sp1)
+      const preDeregisterStake = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+
+      nock(testEndpt)
+        .get('/version')
+        .reply(200, {
+          service: testServiceType,
+          version: '0.0.1'
+      })
+
+      const tx = await audius1.ethContracts.ServiceProviderFactoryClient.deregister(
+        testServiceType,
+        testEndpt
+      )
+
+      const lockupExpiryBlock = await audius1.ethContracts.ServiceProviderFactoryClient.getLockupExpiry(
+        audius1.ethWeb3Manager.getWalletAddress()
+      )
+
+      await time.advanceBlockTo(lockupExpiryBlock)
+
+      await audius1.ethContracts.ServiceProviderFactoryClient.decreaseStake(
+        lockupExpiryBlock
+      )
+
+      const newBalance = await token.balanceOf(sp1)
+      const expectedBalance = initialBalance.add(preDeregisterStake)
+      assert(
+        newBalance.eq(expectedBalance),
+        'Expect stake returned after deregistration'
+      )
+
+      const totalStaked = await audius1.ethContracts.StakingProxyClient.totalStakedFor(sp1)
+      const expectedStaked = preDeregisterStake.sub(defaultStake)
+      assert(
+        totalStaked.isZero(),
+        'Expect decrease in stake after deregistration'
+      )
+    })
+  })
+})

package/tests/trackClientTest.js

@@ -0,0 +1,86 @@
+const assert = require('assert')
+let helpers = require('./helpers')
+let { Utils } = require('../src/utils')
+
+let audiusInstance = helpers.audiusInstance
+
+let trackMultihashDecoded = Utils.decodeMultihash(helpers.constants.trackMetadataCID)
+let trackMultihashDecoded2 = Utils.decodeMultihash(helpers.constants.trackMetadataCID2)
+
+let creatorId1
+let creatorId2
+let trackId1
+let trackId2
+
+before(async function () {
+  await audiusInstance.init()
+})
+
+it('should call getTrack on invalid value and return empty', async function () {
+  let track = await audiusInstance.contracts.TrackFactoryClient.getTrack(0)
+  assert.strictEqual(track.multihashDigest, helpers.constants['0x0'])
+})
+
+it('should call addTrack', async function () {
+  // Add creator so we have creatorId
+  let handle = 'dheeraj' + Math.floor(Math.random() * 10000000)
+
+  creatorId1 = (await audiusInstance.contracts.UserFactoryClient.addUser(handle)).userId
+
+  if (creatorId1 && Number.isInteger(creatorId1)) {
+    trackId1 = (await audiusInstance.contracts.TrackFactoryClient.addTrack(
+      creatorId1,
+      trackMultihashDecoded.digest,
+      trackMultihashDecoded.hashFn,
+      trackMultihashDecoded.size
+    )).trackId
+    let track = await audiusInstance.contracts.TrackFactoryClient.getTrack(trackId1)
+    assert.strictEqual(track.multihashDigest, trackMultihashDecoded.digest)
+  } else throw new Error('creatorId is not a valid integer')
+})
+
+it('should call updateTrack', async function () {
+  // Add creator so we have creatorId
+  const handle = 'skippy' + Math.floor(Math.random() * 10000000)
+
+  creatorId2 = (await audiusInstance.contracts.UserFactoryClient.addUser(handle)).userId
+
+  if (creatorId2 && Number.isInteger(creatorId2)) {
+    // add track
+    trackId1 = (await audiusInstance.contracts.TrackFactoryClient.addTrack(
+      creatorId2,
+      trackMultihashDecoded.digest,
+      trackMultihashDecoded.hashFn,
+      trackMultihashDecoded.size
+    )).trackId
+    let track = await audiusInstance.contracts.TrackFactoryClient.getTrack(trackId1)
+    assert.strictEqual(track.multihashDigest, trackMultihashDecoded.digest)
+
+    // update track
+    await audiusInstance.contracts.TrackFactoryClient.updateTrack(
+      trackId1,
+      creatorId2,
+      trackMultihashDecoded2.digest,
+      trackMultihashDecoded2.hashFn,
+      trackMultihashDecoded2.size
+    )
+    track = await audiusInstance.contracts.TrackFactoryClient.getTrack(trackId1)
+    assert.strictEqual(track.multihashDigest, trackMultihashDecoded2.digest)
+  } else throw new Error('creatorId is not a valid integer')
+})
+
+it('should call deleteTrack', async function () {
+  // add track
+  trackId2 = (await audiusInstance.contracts.TrackFactoryClient.addTrack(
+    creatorId2,
+    trackMultihashDecoded.digest,
+    trackMultihashDecoded.hashFn,
+    trackMultihashDecoded.size
+  )).trackId
+  let track = await audiusInstance.contracts.TrackFactoryClient.getTrack(trackId2)
+  assert.strictEqual(track.multihashDigest, trackMultihashDecoded.digest)
+
+  // delete track
+  let { trackId } = await audiusInstance.contracts.TrackFactoryClient.deleteTrack(trackId2)
+  assert.strictEqual(trackId, trackId2)
+})

package/tests/userClientTest.js

@@ -0,0 +1,121 @@
+const assert = require('assert')
+let helpers = require('./helpers')
+let { Utils } = require('../src/utils')
+
+let audiusInstance = helpers.audiusInstance
+let handle = 'handle' + Math.floor(Math.random() * 1000000)
+
+before(async function () {
+  await audiusInstance.init()
+})
+
+it('should call getUser on invalid value and verify blockchain is empty', async function () {
+  let creator = await audiusInstance.contracts.UserFactoryClient.getUser(0)
+  assert.strictEqual(creator.wallet, '0x0000000000000000000000000000000000000000')
+})
+
+it('should verify handle is valid', async function () {
+  let handleIsValid = await audiusInstance.contracts.UserFactoryClient.handleIsValid(handle)
+  assert.strictEqual(handleIsValid, true, 'Handle is valid')
+})
+
+it('should call addUser and verify new creator', async function () {
+  let metadata = {
+    'wallet': helpers.constants.wallet,
+    'is_creator': true,
+    'name': 'Creator Name' + Math.floor(Math.random() * 1000000),
+    'handle': handle,
+    'profile_picture': helpers.constants.trackMetadataCID,
+    'cover_photo': helpers.constants.trackMetadataCID,
+    'bio': 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.',
+    'location': 'San Francisco',
+    'creator_node_endpoint': helpers.constants.creatorNodeURL1,
+    'is_verified': false
+  }
+
+  const addUserResp = await audiusInstance.contracts.UserFactoryClient.addUser(metadata.handle)
+  const userId = addUserResp.userId
+  const creator = await audiusInstance.contracts.UserFactoryClient.getUser(userId)
+  const creatorMetadataMultihashDecoded = Utils.decodeMultihash(helpers.constants.creatorMetadataCID)
+  const profilePictureMultihashDecoded = Utils.decodeMultihash(metadata.profile_picture)
+  const coverPhotoMultihashDecoded = Utils.decodeMultihash(metadata.cover_photo)
+
+  assert.strictEqual(metadata.handle, Utils.hexToUtf8(creator.handle))
+
+  const updateMultihashResp = await audiusInstance.contracts.UserFactoryClient.updateMultihash(
+    userId, creatorMetadataMultihashDecoded.digest
+  )
+  assert.strictEqual(
+    updateMultihashResp.multihashDigest,
+    creatorMetadataMultihashDecoded.digest,
+    `Transaction failed - ${creatorMetadataMultihashDecoded.digest}`
+  )
+
+  const updateNameResp = await audiusInstance.contracts.UserFactoryClient.updateName(
+    userId, metadata.name
+  )
+  assert.deepStrictEqual(
+    updateNameResp.name,
+    metadata.name,
+    `Transaction failed - ${metadata.name}`
+  )
+
+  const updateLocationResp = await audiusInstance.contracts.UserFactoryClient.updateLocation(
+    userId, metadata.location
+  )
+  assert.deepStrictEqual(
+    updateLocationResp.location,
+    metadata.location,
+    `Transaction failed - ${metadata.location}`
+  )
+
+  const updateBioResp = await audiusInstance.contracts.UserFactoryClient.updateBio(
+    userId, metadata.bio
+  )
+  assert.deepStrictEqual(
+    updateBioResp.bio,
+    metadata.bio,
+    `Transaction failed - ${metadata.bio}`
+  )
+
+  const updateProfilePhotoResp = await audiusInstance.contracts.UserFactoryClient.updateProfilePhoto(
+    userId, profilePictureMultihashDecoded.digest
+  )
+  assert.deepStrictEqual(
+    updateProfilePhotoResp.profilePhotoMultihashDigest,
+    profilePictureMultihashDecoded.digest,
+    `Transaction failed - ${profilePictureMultihashDecoded.digest}`
+  )
+
+  const updateCoverPhotoResp = await audiusInstance.contracts.UserFactoryClient.updateCoverPhoto(
+    userId, coverPhotoMultihashDecoded.digest
+  )
+  assert.deepStrictEqual(
+    updateCoverPhotoResp.coverPhotoMultihashDigest,
+    coverPhotoMultihashDecoded.digest,
+    `Transaction failed - ${coverPhotoMultihashDecoded.digest}`
+  )
+
+  const updateIsCreatorResp = await audiusInstance.contracts.UserFactoryClient.updateIsCreator(
+    userId, metadata.is_creator
+  )
+  assert.deepStrictEqual(
+    updateIsCreatorResp.isCreator,
+    metadata.is_creator,
+    `Transaction failed - ${metadata.is_creator}`
+  )
+
+  const updateCreatorNodeEndpointResp = await audiusInstance.contracts.UserFactoryClient.updateCreatorNodeEndpoint(
+    userId, metadata.creator_node_endpoint
+  )
+  assert.deepStrictEqual(
+    updateCreatorNodeEndpointResp.creatorNodeEndpoint,
+    metadata.creator_node_endpoint,
+    `Transaction failed - ${metadata.creator_node_endpoint}`
+  )
+})
+
+it('should verify handle is not valid', async function () {
+  let handleIsValid = await audiusInstance.contracts.UserFactoryClient.handleIsValid(handle)
+  assert.strictEqual(handleIsValid, false, 'Handle is not valid')
+})

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@tsconfig/node16-strictest/tsconfig.json",
+  "compilerOptions": {
+    "lib": ["es2021", "dom"],
+    "checkJs": false,
+    "resolveJsonModule": true,
+    "typeRoots": ["./types", "./node_modules/@types"],
+    "exactOptionalPropertyTypes": false
+  }
+}

package/types/@audius-hedgehog/index.d.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-extraneous-class */
+declare module '@audius/hedgehog' {
+  import type { IdentityService } from '../../src/services/identity'
+  import type Wallet from 'ethereumjs-wallet'
+
+  type RecoveryInfo = {
+    login: string
+    host: string
+  }
+
+  export class Hedgehog {
+    wallet: Wallet
+    getFn: IdentityService['getFn']
+    setAuthFn: IdentityService['setAuthFn']
+    setUserFn: IdentityService['setUserFn']
+    identityService: IdentityService
+    constructor(
+      getFn: IdentityService['getFn'],
+      setAuthFn: IdentityService['setAuthFn'],
+      setUserFn: IdentityService['setUserFn'],
+      useLocalStorage: boolean
+    ): void
+    async login(email: string, password: string): Promise<Wallet>
+    async generateRecoveryInfo(): Promise<RecoveryInfo>
+    getWallet(): Wallet
+    async createWalletObj(passwordEntropy: string): Promise<Wallet>
+  }
+
+  export class WalletManager {
+    static async createAuthLookupKey(email: string, password: string)
+    static async decryptCipherTextAndRetrieveWallet(
+      password: string,
+      iv: string,
+      cipherText: string
+    ): Promise<{ walletObj: Wallet; entropy: string }>
+    static async getEntropyFromLocalStorage(): Promise<string>
+    static setEntropyInLocalStorage(entropy: string): void
+  }
+}

package/types/abi-decoder/index.d.ts

@@ -0,0 +1,41 @@
+declare module 'abi-decoder' {
+  import { Log } from 'web3-core'
+  import { AbiItem } from 'web3-utils'
+
+  export interface Input {
+    [index: string]: any
+    name: string
+    type: string
+    indexed?: boolean
+  }
+
+  export interface Output {
+    [index: string]: any
+    name: string
+    type: string
+  }
+
+  export interface Param {
+    name: string
+    type: string
+    value: string
+  }
+
+  export interface DecodedLog {
+    address: string
+    name: string
+    events: Param[]
+  }
+
+  export interface DecodedMethod {
+    name: string
+    params: Param[]
+  }
+
+  export function getABIs(): AbiItem[]
+  export function addABI(abi: AbiItem[]): void
+  export function getMethodIDs(): { [index: string]: AbiItem }
+  export function decodeMethod(input: string): DecodedMethod
+  export function decodeLogs(input: Log[]): DecodedLog
+  export function removeABI(abi: AbiItem[]): void
+}