@cityofzion/bs-ethereum 0.8.0 → 0.8.2

package/src/__tests__/BSEthereum.spec.ts

@@ -1,123 +1,123 @@
-import { ethers } from 'ethers'
-import { BSEthereum } from '../BSEthereum'
-import { Account } from '@cityofzion/blockchain-service'
-
-let bsEthereum: BSEthereum
-let wallet: ethers.Wallet
-let account: Account
-
-describe('BSEthereum', () => {
-  beforeAll(() => {
-    bsEthereum = new BSEthereum('neo3', { type: 'testnet' })
-    wallet = ethers.Wallet.createRandom()
-    account = {
-      key: wallet.privateKey,
-      type: 'privateKey',
-      address: wallet.address,
-    }
-  })
-
-  it('Should be able to validate an address', () => {
-    const validAddress = '0xD81a8F3c3f8b006Ef1ae4a2Fd28699AD7E3e21C5'
-    const invalidAddress = 'invalid address'
-
-    expect(bsEthereum.validateAddress(validAddress)).toBeTruthy()
-    expect(bsEthereum.validateAddress(invalidAddress)).toBeFalsy()
-  })
-
-  it('Should be able to validate an encrypted key', async () => {
-    const validEncryptedJson = await wallet.encrypt('password')
-    const invalidEncryptedJson = '{ invalid: json }'
-
-    expect(bsEthereum.validateEncrypted(validEncryptedJson)).toBeTruthy()
-    expect(bsEthereum.validateEncrypted(invalidEncryptedJson)).toBeFalsy()
-  })
-
-  it('Should be able to validate a private key', () => {
-    const validKey = wallet.privateKey
-    const invalidKey = 'invalid key'
-
-    expect(bsEthereum.validateKey(validKey)).toBeTruthy()
-    expect(bsEthereum.validateKey(invalidKey)).toBeFalsy()
-  })
-
-  it('Should be able to validate an domain', () => {
-    const validDomain = 'alice.eth'
-    const invalidDomain = 'invalid domain'
-
-    expect(bsEthereum.validateNameServiceDomainFormat(validDomain)).toBeTruthy()
-    expect(bsEthereum.validateNameServiceDomainFormat(invalidDomain)).toBeFalsy()
-  })
-
-  it('Should be able to generate a account from mnemonic', () => {
-    const account = bsEthereum.generateAccountFromMnemonic(wallet.mnemonic.phrase, 0)
-
-    expect(bsEthereum.validateAddress(account.address)).toBeTruthy()
-    expect(bsEthereum.validateKey(account.key)).toBeTruthy()
-  })
-
-  it('Should be able to generate a account from wif', () => {
-    const accountFromWif = bsEthereum.generateAccountFromKey(wallet.privateKey)
-    expect(accountFromWif).toEqual(account)
-  })
-
-  it('Should be able to decrypt a encrypted key', async () => {
-    const password = 'TestPassword'
-    const validEncryptedJson = await wallet.encrypt(password)
-    const decryptedAccount = await bsEthereum.decrypt(validEncryptedJson, password)
-    expect(decryptedAccount).toEqual(account)
-  })
-
-  it.skip('Should be able to calculate transfer fee', async () => {
-    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const fee = await bsEthereum.calculateTransferFee({
-      senderAccount: account,
-      intent: {
-        amount: '0.1',
-        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
-        tokenDecimals: 18,
-        tokenHash: '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc',
-      },
-    })
-
-    expect(fee).toEqual(expect.any(Number))
-  })
-
-  it.skip('Should be able to transfer a native token', async () => {
-    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
-        tokenDecimals: 18,
-        tokenHash: '-',
-      },
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 50000)
-
-  it.skip('Should be able to transfer a ERC20 token', async () => {
-    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
-        tokenDecimals: 18,
-        tokenHash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
-      },
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 50000)
-
-  it('Should be able to resolve a name service domain', async () => {
-    const address = await bsEthereum.resolveNameServiceDomain('alice.eth')
-    expect(address).toEqual('0xa974890156A3649A23a6C0f2ebd77D6F7A7333d4')
-  }, 10000)
-})
+import { ethers } from 'ethers'
+import { BSEthereum } from '../BSEthereum'
+import { Account } from '@cityofzion/blockchain-service'
+
+let bsEthereum: BSEthereum
+let wallet: ethers.Wallet
+let account: Account
+
+describe('BSEthereum', () => {
+  beforeAll(() => {
+    bsEthereum = new BSEthereum('neo3', { type: 'testnet' })
+    wallet = ethers.Wallet.createRandom()
+    account = {
+      key: wallet.privateKey,
+      type: 'privateKey',
+      address: wallet.address,
+    }
+  })
+
+  it('Should be able to validate an address', () => {
+    const validAddress = '0xD81a8F3c3f8b006Ef1ae4a2Fd28699AD7E3e21C5'
+    const invalidAddress = 'invalid address'
+
+    expect(bsEthereum.validateAddress(validAddress)).toBeTruthy()
+    expect(bsEthereum.validateAddress(invalidAddress)).toBeFalsy()
+  })
+
+  it('Should be able to validate an encrypted key', async () => {
+    const validEncryptedJson = await wallet.encrypt('password')
+    const invalidEncryptedJson = '{ invalid: json }'
+
+    expect(bsEthereum.validateEncrypted(validEncryptedJson)).toBeTruthy()
+    expect(bsEthereum.validateEncrypted(invalidEncryptedJson)).toBeFalsy()
+  })
+
+  it('Should be able to validate a private key', () => {
+    const validKey = wallet.privateKey
+    const invalidKey = 'invalid key'
+
+    expect(bsEthereum.validateKey(validKey)).toBeTruthy()
+    expect(bsEthereum.validateKey(invalidKey)).toBeFalsy()
+  })
+
+  it('Should be able to validate an domain', () => {
+    const validDomain = 'alice.eth'
+    const invalidDomain = 'invalid domain'
+
+    expect(bsEthereum.validateNameServiceDomainFormat(validDomain)).toBeTruthy()
+    expect(bsEthereum.validateNameServiceDomainFormat(invalidDomain)).toBeFalsy()
+  })
+
+  it('Should be able to generate a account from mnemonic', () => {
+    const account = bsEthereum.generateAccountFromMnemonic(wallet.mnemonic.phrase, 0)
+
+    expect(bsEthereum.validateAddress(account.address)).toBeTruthy()
+    expect(bsEthereum.validateKey(account.key)).toBeTruthy()
+  })
+
+  it('Should be able to generate a account from wif', () => {
+    const accountFromWif = bsEthereum.generateAccountFromKey(wallet.privateKey)
+    expect(accountFromWif).toEqual(account)
+  })
+
+  it('Should be able to decrypt a encrypted key', async () => {
+    const password = 'TestPassword'
+    const validEncryptedJson = await wallet.encrypt(password)
+    const decryptedAccount = await bsEthereum.decrypt(validEncryptedJson, password)
+    expect(decryptedAccount).toEqual(account)
+  })
+
+  it.skip('Should be able to calculate transfer fee', async () => {
+    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const fee = await bsEthereum.calculateTransferFee({
+      senderAccount: account,
+      intent: {
+        amount: '0.1',
+        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
+        tokenDecimals: 18,
+        tokenHash: '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc',
+      },
+    })
+
+    expect(fee).toEqual(expect.any(Number))
+  })
+
+  it.skip('Should be able to transfer a native token', async () => {
+    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const transactionHash = await bsEthereum.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
+        tokenDecimals: 18,
+        tokenHash: '-',
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  }, 50000)
+
+  it.skip('Should be able to transfer a ERC20 token', async () => {
+    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const transactionHash = await bsEthereum.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
+        tokenDecimals: 18,
+        tokenHash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  }, 50000)
+
+  it('Should be able to resolve a name service domain', async () => {
+    const address = await bsEthereum.resolveNameServiceDomain('alice.eth')
+    expect(address).toEqual('0xa974890156A3649A23a6C0f2ebd77D6F7A7333d4')
+  }, 10000)
+})

package/src/__tests__/BitqueryEDSEthereum.spec.ts

@@ -1,49 +1,49 @@
-import { BitqueryEDSEthereum } from '../BitqueryEDSEthereum'
-
-let bitqueryEDSEthereum: BitqueryEDSEthereum
-
-describe('FlamingoEDSNeo3', () => {
-  beforeAll(() => {
-    bitqueryEDSEthereum = new BitqueryEDSEthereum('mainnet')
-  })
-
-  it('Should return a list with prices of tokens using USD', async () => {
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('USD')
-
-    tokenPriceList.forEach(tokenPrice => {
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-        hash: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return a list with prices of tokens using BRL', async () => {
-    const tokenPriceListInUSD = await bitqueryEDSEthereum.getTokenPrices('USD')
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('BRL')
-
-    tokenPriceList.forEach((tokenPrice, index) => {
-      expect(tokenPrice.price).toBeGreaterThan(tokenPriceListInUSD[index].price)
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-        hash: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return a list with prices of tokens using EUR', async () => {
-    const tokenPriceListInUSD = await bitqueryEDSEthereum.getTokenPrices('USD')
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('EUR')
-
-    tokenPriceList.forEach((tokenPrice, index) => {
-      expect(tokenPrice.price).toBeLessThan(tokenPriceListInUSD[index].price)
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-        hash: expect.any(String),
-      })
-    })
-  })
-})
+import { BitqueryEDSEthereum } from '../BitqueryEDSEthereum'
+
+let bitqueryEDSEthereum: BitqueryEDSEthereum
+
+describe('FlamingoEDSNeo3', () => {
+  beforeAll(() => {
+    bitqueryEDSEthereum = new BitqueryEDSEthereum('mainnet')
+  })
+
+  it('Should return a list with prices of tokens using USD', async () => {
+    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('USD')
+
+    tokenPriceList.forEach(tokenPrice => {
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+        hash: expect.any(String),
+      })
+    })
+  })
+
+  it('Should return a list with prices of tokens using BRL', async () => {
+    const tokenPriceListInUSD = await bitqueryEDSEthereum.getTokenPrices('USD')
+    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('BRL')
+
+    tokenPriceList.forEach((tokenPrice, index) => {
+      expect(tokenPrice.price).toBeGreaterThan(tokenPriceListInUSD[index].price)
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+        hash: expect.any(String),
+      })
+    })
+  })
+
+  it('Should return a list with prices of tokens using EUR', async () => {
+    const tokenPriceListInUSD = await bitqueryEDSEthereum.getTokenPrices('USD')
+    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('EUR')
+
+    tokenPriceList.forEach((tokenPrice, index) => {
+      expect(tokenPrice.price).toBeLessThan(tokenPriceListInUSD[index].price)
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+        hash: expect.any(String),
+      })
+    })
+  })
+})

package/src/__tests__/GhostMarketNDSEthereum.spec.ts

@@ -1,45 +1,45 @@
-import { GhostMarketNDSEthereum } from '../GhostMarketNDSEthereum'
-
-let ghostMarketNDSEthereum: GhostMarketNDSEthereum
-
-describe('GhostMarketNDSEthereum', () => {
-  beforeAll(() => {
-    ghostMarketNDSEthereum = new GhostMarketNDSEthereum('mainnet')
-  })
-
-  it('Get NFT', async () => {
-    const nft = await ghostMarketNDSEthereum.getNft({
-      contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
-      tokenId: '379',
-    })
-
-    expect(nft).toEqual(
-      expect.objectContaining({
-        id: '379',
-        contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
-        symbol: 'MOAR',
-        collectionImage: expect.any(String),
-        collectionName: '"MOAR" by Joan Cornella',
-        image: expect.any(String),
-        isSVG: expect.any(Boolean),
-        name: 'MOAR #379',
-      })
-    )
-  })
-
-  it('Get NFTS by address', async () => {
-    const nfts = await ghostMarketNDSEthereum.getNftsByAddress({
-      address: '0xd773c81a4a855556ce2f2372b12272710b95b26c',
-    })
-    expect(nfts.items.length).toBeGreaterThan(0)
-    nfts.items.forEach(nft => {
-      expect(nft).toEqual(
-        expect.objectContaining({
-          symbol: expect.any(String),
-          id: expect.any(String),
-          contractHash: expect.any(String),
-        })
-      )
-    })
-  })
-})
+import { GhostMarketNDSEthereum } from '../GhostMarketNDSEthereum'
+
+let ghostMarketNDSEthereum: GhostMarketNDSEthereum
+
+describe('GhostMarketNDSEthereum', () => {
+  beforeAll(() => {
+    ghostMarketNDSEthereum = new GhostMarketNDSEthereum('mainnet')
+  })
+
+  it('Get NFT', async () => {
+    const nft = await ghostMarketNDSEthereum.getNft({
+      contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
+      tokenId: '379',
+    })
+
+    expect(nft).toEqual(
+      expect.objectContaining({
+        id: '379',
+        contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
+        symbol: 'MOAR',
+        collectionImage: expect.any(String),
+        collectionName: '"MOAR" by Joan Cornella',
+        image: expect.any(String),
+        isSVG: expect.any(Boolean),
+        name: 'MOAR #379',
+      })
+    )
+  })
+
+  it('Get NFTS by address', async () => {
+    const nfts = await ghostMarketNDSEthereum.getNftsByAddress({
+      address: '0xd773c81a4a855556ce2f2372b12272710b95b26c',
+    })
+    expect(nfts.items.length).toBeGreaterThan(0)
+    nfts.items.forEach(nft => {
+      expect(nft).toEqual(
+        expect.objectContaining({
+          symbol: expect.any(String),
+          id: expect.any(String),
+          contractHash: expect.any(String),
+        })
+      )
+    })
+  })
+})

package/src/assets/tokens/common.json

@@ -1,8 +1,8 @@
-[
-  {
-    "symbol": "ETH",
-    "name": "Ethereum",
-    "hash": "-",
-    "decimals": 16
-  }
+[
+  {
+    "symbol": "ETH",
+    "name": "Ethereum",
+    "hash": "-",
+    "decimals": 16
+  }
 ]

package/src/constants.ts

@@ -1,37 +1,37 @@
-import { NetworkType, Token } from '@cityofzion/blockchain-service'
-import commom from './assets/tokens/common.json'
-
-export type BitqueryNetwork = 'ethereum' | 'goerli'
-
-export const TOKENS: Record<NetworkType, Token[]> = {
-  mainnet: [...commom],
-  testnet: commom,
-  custom: commom,
-}
-
-export const NATIVE_ASSETS = commom
-
-export const DEFAULT_URL_BY_NETWORK_TYPE: Record<NetworkType, string> = {
-  mainnet: 'https://ethereum-mainnet-rpc.allthatnode.com',
-  testnet: 'https://ethereum-goerli-rpc.allthatnode.com',
-  custom: 'http://127.0.0.1:8545',
-}
-
-export const BITQUERY_API_KEY = 'BQYMp76Ny15C8ORbI2BOstFUhoMCahLI'
-export const BITQUERY_URL = 'https://graphql.bitquery.io'
-export const BITQUERY_NETWORK_BY_NETWORK_TYPE: Record<Exclude<NetworkType, 'custom'>, BitqueryNetwork> = {
-  mainnet: 'ethereum',
-  testnet: 'goerli',
-}
-
-export const GHOSTMARKET_URL_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
-  mainnet: 'https://api.ghostmarket.io/api/v2',
-  testnet: 'https://api-testnet.ghostmarket.io/api/v2',
-}
-
-export const GHOSTMARKET_CHAIN_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
-  mainnet: 'eth',
-  testnet: 'etht',
-}
-
-export const DERIVATION_PATH = "m/44'/60'/0'/0/?"
+import { NetworkType, Token } from '@cityofzion/blockchain-service'
+import commom from './assets/tokens/common.json'
+
+export type BitqueryNetwork = 'ethereum' | 'goerli'
+
+export const TOKENS: Record<NetworkType, Token[]> = {
+  mainnet: [...commom],
+  testnet: commom,
+  custom: commom,
+}
+
+export const NATIVE_ASSETS = commom
+
+export const DEFAULT_URL_BY_NETWORK_TYPE: Record<NetworkType, string> = {
+  mainnet: 'https://ethereum-mainnet-rpc.allthatnode.com',
+  testnet: 'https://ethereum-goerli-rpc.allthatnode.com',
+  custom: 'http://127.0.0.1:8545',
+}
+
+export const BITQUERY_API_KEY = 'BQYMp76Ny15C8ORbI2BOstFUhoMCahLI'
+export const BITQUERY_URL = 'https://graphql.bitquery.io'
+export const BITQUERY_NETWORK_BY_NETWORK_TYPE: Record<Exclude<NetworkType, 'custom'>, BitqueryNetwork> = {
+  mainnet: 'ethereum',
+  testnet: 'goerli',
+}
+
+export const GHOSTMARKET_URL_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
+  mainnet: 'https://api.ghostmarket.io/api/v2',
+  testnet: 'https://api-testnet.ghostmarket.io/api/v2',
+}
+
+export const GHOSTMARKET_CHAIN_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
+  mainnet: 'eth',
+  testnet: 'etht',
+}
+
+export const DERIVATION_PATH = "m/44'/60'/0'/0/?"