@exodus/solana-api 3.25.4 → 3.26.1

package/src/api.js

@@ -20,22 +20,14 @@ import lodash from 'lodash'
 import ms from 'ms'
 import urljoin from 'url-join'
 
-import { Connection } from './connection.js'
 import { getStakeActivation } from './get-stake-activation/index.js'
-import {
-  isSolTransferInstruction,
-  isSplMintInstruction,
-  isSplTransferInstruction,
-} from './txs-utils.js'
+import { parseTransaction } from './tx-parser.js'
 
 const createApi = createApiCJS.default || createApiCJS
 
 // Doc: https://docs.solana.com/apps/jsonrpc-api
 
 const RPC_URL = 'https://solana.a.exodus.io' // https://vip-api.mainnet-beta.solana.com/, https://api.mainnet-beta.solana.com
-const WS_ENDPOINT = 'wss://solana.a.exodus.io/ws' // not standard across all node providers (we're compatible only with Quicknode)
-const FORCE_HTTP = true // use https over ws
-const ZERO = BigInt(0)
 
 const errorMessagesToRetry = [
   'Blockhash not found',
@@ -44,14 +36,11 @@ const errorMessagesToRetry = [
 
 // Tokens + SOL api support
 export class Api {
-  constructor({ rpcUrl, wsUrl, assets, txsLimit, tokenAssetType = 'SOLANA_TOKEN' }) {
-    this.tokenAssetType = tokenAssetType
+  constructor({ rpcUrl, wsUrl, assets, txsLimit }) {
     this.setServer(rpcUrl)
-    this.setWsEndpoint(wsUrl)
     this.setTokens(assets)
     this.tokensToSkip = {}
     this.txsLimit = txsLimit
-    this.connections = {}
     this.getSupply = memoize(async (mintAddress) => {
       // cached getSupply
       const result = await this.rpcCall('getTokenSupply', [mintAddress])
@@ -76,12 +65,8 @@ export class Api {
     this.api = createApi(this.rpcUrl)
   }
 
-  setWsEndpoint(wsUrl) {
-    this.wsUrl = wsUrl || WS_ENDPOINT
-  }
-
   setTokens(assets = {}) {
-    const solTokens = pickBy(assets, (asset) => asset.assetType === this.tokenAssetType)
+    const solTokens = pickBy(assets, (asset) => asset.name !== asset.baseAsset.name)
     this.tokens = new Map(Object.values(solTokens).map((v) => [v.mintAddress, v]))
   }
 
@@ -91,51 +76,7 @@ export class Api {
     })
   }
 
-  async watchAddress({
-    address,
-    tokensAddresses = [],
-    onMessage,
-    handleAccounts,
-    handleTransfers,
-    handleReconnect,
-    reconnectDelay,
-  }) {
-    if (this.connections[address]) return // already subscribed
-    const conn = new Connection({
-      endpoint: this.wsUrl,
-      address,
-      tokensAddresses,
-      onMsg: (json) => onMessage(json),
-      callback: (updates) =>
-        this.handleUpdates({ updates, address, handleAccounts, handleTransfers }),
-      reconnectCallback: handleReconnect,
-      reconnectDelay,
-    })
-
-    this.connections[address] = conn
-    return conn.start()
-  }
-
-  async unwatchAddress({ address }) {
-    if (this.connections[address]) {
-      await this.connections[address].stop()
-      delete this.connections[address]
-    }
-  }
-
-  async handleUpdates({ updates, address, handleAccounts, handleTransfers }) {
-    // console.log(`got ws updates from ${address}:`, updates)
-    if (handleTransfers) return handleTransfers(updates)
-  }
-
-  async rpcCall(method, params = [], { address = '', forceHttp = FORCE_HTTP } = {}) {
-    // ws request
-    const connection = this.connections[address] || lodash.sample(Object.values(this.connections)) // pick random connection
-    if (lodash.get(connection, 'isOpen') && !lodash.get(connection, 'shutdown') && !forceHttp) {
-      return connection.sendMessage(method, params)
-    }
-
-    // http fallback
+  async rpcCall(method, params = []) {
     return this.api.post({ method, params })
   }
 
@@ -172,11 +113,9 @@ export class Api {
   }
 
   async getRecentBlockHash(commitment) {
-    const result = await this.rpcCall(
-      'getLatestBlockhash',
-      [{ commitment: commitment || 'confirmed', encoding: 'jsonParsed' }],
-      { forceHttp: true }
-    )
+    const result = await this.rpcCall('getLatestBlockhash', [
+      { commitment: commitment || 'confirmed', encoding: 'jsonParsed' },
+    ])
     return lodash.get(result, 'value.blockhash')
   }
 
@@ -188,18 +127,8 @@ export class Api {
     ])
   }
 
-  async getPriorityFee(transaction) {
-    // https://docs.helius.dev/solana-rpc-nodes/alpha-priority-fee-api
-    const result = await this.rpcCall('getPriorityFeeEstimate', [
-      { transaction, options: { recommended: true } },
-    ])
-    return result.priorityFeeEstimate
-  }
-
   async getBalance(address) {
-    const result = await this.rpcCall('getBalance', [address, { encoding: 'jsonParsed' }], {
-      address,
-    })
+    const result = await this.rpcCall('getBalance', [address, { encoding: 'jsonParsed' }])
     return lodash.get(result, 'value', 0)
   }
 
@@ -240,13 +169,7 @@ export class Api {
     const fetchRetry = retry(
       async () => {
         try {
-          return await this.rpcCall(
-            'getSignaturesForAddress',
-            [address, { until, before, limit }],
-            {
-              address,
-            }
-          )
+          return await this.rpcCall('getSignaturesForAddress', [address, { until, before, limit }])
         } catch (error) {
           if (
             error.message &&
@@ -353,535 +276,8 @@ export class Api {
     return { transactions, newCursor }
   }
 
-  parseTransaction(
-    ownerAddress,
-    txDetails,
-    tokenAccountsByOwner,
-    { includeUnparsed = false } = {}
-  ) {
-    let { fee, preBalances, postBalances, preTokenBalances, postTokenBalances, innerInstructions } =
-      txDetails.meta
-    preBalances = preBalances || []
-    postBalances = postBalances || []
-    preTokenBalances = preTokenBalances || []
-    postTokenBalances = postTokenBalances || []
-    innerInstructions = innerInstructions || []
-
-    let { instructions, accountKeys = [] } = txDetails.transaction.message
-    const feePayerPubkey = accountKeys[0].pubkey
-    const ownerIsFeePayer = feePayerPubkey === ownerAddress
-    const txId = txDetails.transaction.signatures[0]
-
-    const getUnparsedTx = () => {
-      const ownerIndex = accountKeys.findIndex((accountKey) => accountKey.pubkey === ownerAddress)
-      const feePaid = ownerIndex === 0 ? fee : 0
-
-      return {
-        unparsed: true,
-        amount:
-          ownerIndex === -1 ? 0 : postBalances[ownerIndex] - preBalances[ownerIndex] + feePaid,
-        fee: feePaid,
-        data: {
-          meta: txDetails.meta,
-        },
-      }
-    }
-
-    const getInnerTxsFromBalanceChanges = () => {
-      const ownPreTokenBalances = preTokenBalances.filter(
-        (balance) => balance.owner === ownerAddress
-      )
-      const ownPostTokenBalances = postTokenBalances.filter(
-        (balance) => balance.owner === ownerAddress
-      )
-
-      return ownPostTokenBalances
-        .map((postBalance) => {
-          const tokenAccount = tokenAccountsByOwner.find(
-            (tokenAccount) => tokenAccount.mintAddress === postBalance.mint
-          )
-
-          const preBalance = ownPreTokenBalances.find(
-            (balance) => balance.accountIndex === postBalance.accountIndex
-          )
-
-          const preAmount = BigInt(preBalance?.uiTokenAmount?.amount ?? '0')
-          const postAmount = BigInt(postBalance?.uiTokenAmount?.amount ?? '0')
-
-          const amount = postAmount - preAmount
-
-          if (!tokenAccount || amount === ZERO) return null
-
-          // This is not perfect as there could be multiple same-token transfers in single
-          // transaction, but our wallet only supports one transaction with single txId
-          // so we are picking first that matches (correct token + type - send or receive)
-          const match = innerInstructions.find((inner) => {
-            const targetOwner = amount < ZERO ? ownerAddress : null
-            return (
-              inner.token.mintAddress === tokenAccount.mintAddress && targetOwner === inner.owner
-            )
-          })
-
-          // It's possible we won't find a match, because our innerInstructions only contain
-          // spl-token transfers, but balances of SPL tokens can change in different ways too.
-          // for now, we are ignoring this to simplify as those cases are not that common, but
-          // they should be handled eventually. It was already a scretch to add unparsed txs logic
-          // to existing parser, expanding it further is not going to end well.
-          // this probably should be refactored from ground to handle all those transactions
-          // as a core part of it in the future
-          if (!match) return null
-
-          const { from, to, owner } = match
-
-          return {
-            id: txId,
-            slot: txDetails.slot,
-            owner,
-            from,
-            to,
-            amount: (amount < ZERO ? -amount : amount).toString(), // inconsistent with the rest, but it can and did overflow
-            fee: 0,
-            token: tokenAccount,
-            data: {
-              inner: true,
-            },
-          }
-        })
-        .filter((ix) => !!ix)
-    }
-
-    instructions = instructions
-      .filter((ix) => ix.parsed) // only known instructions
-      .map((ix) => ({
-        program: ix.program, // system or spl-token
-        type: ix.parsed.type, // transfer, createAccount, initializeAccount
-        ...ix.parsed.info,
-      }))
-
-    let solanaTransferTx = lodash.find(instructions, (ix) => {
-      if (![ix.source, ix.destination].includes(ownerAddress)) return false
-      return ix.program === 'system' && ix.type === 'transfer'
-    }) // get SOL transfer
-
-    // check if there is a temp account created & closed within the instructions when there is no direct solana transfer
-    const accountToRedeemToOwner = solanaTransferTx
-      ? undefined
-      : instructions.find(
-          ({ type, owner, destination }) =>
-            type === 'closeAccount' && owner === ownerAddress && destination === ownerAddress
-        )?.account
-
-    innerInstructions = innerInstructions
-      .reduce((acc, val) => {
-        return [...acc, ...val.instructions]
-      }, [])
-      .filter(
-        (ix) =>
-          ix.parsed &&
-          (isSplTransferInstruction({ program: ix.program, type: ix.parsed.type }) ||
-            isSplMintInstruction({ program: ix.program, type: ix.parsed.type }) ||
-            (!includeUnparsed &&
-              isSolTransferInstruction({ program: ix.program, type: ix.parsed.type })))
-      )
-      .map((ix) => {
-        let source = lodash.get(ix, 'parsed.info.source')
-        const destination = isSplMintInstruction({ program: ix.program, type: ix.parsed.type })
-          ? lodash.get(ix, 'parsed.info.account') // only for minting
-          : lodash.get(ix, 'parsed.info.destination')
-        const amount = Number(
-          lodash.get(ix, 'parsed.info.amount', 0) ||
-            lodash.get(ix, 'parsed.info.tokenAmount.amount', 0)
-        )
-        const authority = lodash.get(ix, 'parsed.info.authority')
-
-        if (accountToRedeemToOwner && destination === accountToRedeemToOwner) {
-          solanaTransferTx = {
-            from: authority || source,
-            to: ownerAddress,
-            amount,
-            fee,
-          }
-          return
-        }
-
-        if (
-          source === ownerAddress &&
-          isSolTransferInstruction({ program: ix.program, type: ix.parsed.type })
-        ) {
-          const lamports = Number(lodash.get(ix, 'parsed.info.lamports', 0))
-          if (solanaTransferTx) {
-            solanaTransferTx.lamports += lamports
-            solanaTransferTx.amount = solanaTransferTx.lamports
-            if (!Array.isArray(solanaTransferTx.to)) {
-              solanaTransferTx.data = {
-                sent: [
-                  {
-                    address: solanaTransferTx.to,
-                    amount: lamports,
-                  },
-                ],
-              }
-              solanaTransferTx.to = [solanaTransferTx.to]
-            }
-
-            solanaTransferTx.to.push(destination)
-            solanaTransferTx.data.sent.push({ address: destination, amount: lamports })
-          } else {
-            solanaTransferTx = {
-              source,
-              owner: source,
-              from: source,
-              to: [destination],
-              lamports,
-              amount: lamports,
-              data: {
-                sent: [
-                  {
-                    address: destination,
-                    amount: lamports,
-                  },
-                ],
-              },
-              fee,
-            }
-          }
-
-          return
-        }
-
-        const tokenAccount = tokenAccountsByOwner.find(({ tokenAccountAddress }) => {
-          return [source, destination].includes(tokenAccountAddress)
-        })
-        if (!tokenAccount) return
-
-        if (isSplMintInstruction({ program: ix.program, type: ix.parsed.type })) {
-          source = lodash.get(ix, 'parsed.info.mintAuthority')
-        }
-
-        const isSending = tokenAccountsByOwner.some(({ tokenAccountAddress }) => {
-          return [source].includes(tokenAccountAddress)
-        })
-
-        // owner if it's a send tx
-        return {
-          id: txId,
-          program: ix.program,
-          type: ix.parsed.type,
-          slot: txDetails.slot,
-          owner: isSending ? ownerAddress : null,
-          from: isSending ? ownerAddress : source,
-          to: isSending ? destination : ownerAddress,
-          amount,
-          token: tokenAccount,
-          // Attribute fee only when owner is the actual fee payer
-          fee: isSending && ownerIsFeePayer ? fee : 0,
-        }
-      })
-      .filter((ix) => !!ix)
-
-    // Collect inner instructions into batch sends
-    for (let i = 0; i < innerInstructions.length - 1; i++) {
-      const tx = innerInstructions[i]
-
-      for (let j = i + 1; j < innerInstructions.length; j++) {
-        const next = innerInstructions[j]
-        if (
-          tx.id === next.id &&
-          tx.token === next.token &&
-          tx.owner === ownerAddress &&
-          tx.from === next.from
-        ) {
-          if (!tx.data) {
-            tx.data = { sent: [{ address: tx.to, amount: tx.amount }] }
-            tx.to = [tx.to]
-            tx.fee = 0
-          }
-
-          tx.data.sent.push({
-            address: next.to,
-            amount: next.amount,
-          })
-          tx.to.push(next.to)
-
-          tx.amount += next.amount
-
-          innerInstructions.splice(j, 1)
-          j--
-        }
-      }
-    }
-
-    // program:type tells us if it's a SOL or Token transfer
-
-    const stakeTx = lodash.find(instructions, { program: 'system', type: 'createAccountWithSeed' })
-    const stakeWithdraw = lodash.find(instructions, { program: 'stake', type: 'withdraw' })
-    const stakeUndelegate = lodash.find(instructions, { program: 'stake', type: 'deactivate' })
-
-    let tx = {}
-    if (stakeTx) {
-      // start staking
-      tx = {
-        owner: stakeTx.base,
-        from: stakeTx.base,
-        to: stakeTx.base,
-        amount: stakeTx.lamports,
-        fee,
-        staking: {
-          method: 'createAccountWithSeed',
-          seed: stakeTx.seed,
-          stakeAddresses: [stakeTx.newAccount],
-          stake: stakeTx.lamports,
-        },
-      }
-    } else if (stakeWithdraw) {
-      const stakeAccounts = lodash.map(
-        lodash.filter(instructions, { program: 'stake', type: 'withdraw' }),
-        'stakeAccount'
-      )
-      tx = {
-        owner: stakeWithdraw.withdrawAuthority,
-        from: stakeWithdraw.stakeAccount,
-        to: stakeWithdraw.destination,
-        amount: stakeWithdraw.lamports,
-        fee,
-        staking: {
-          method: 'withdraw',
-          stakeAddresses: stakeAccounts,
-          stake: stakeWithdraw.lamports,
-        },
-      }
-    } else if (stakeUndelegate) {
-      const stakeAccounts = lodash.map(
-        lodash.filter(instructions, { program: 'stake', type: 'deactivate' }),
-        'stakeAccount'
-      )
-      tx = {
-        owner: stakeUndelegate.stakeAuthority,
-        from: stakeUndelegate.stakeAuthority,
-        to: stakeUndelegate.stakeAccount, // obsolete
-        amount: 0,
-        fee,
-        staking: {
-          method: 'undelegate',
-          stakeAddresses: stakeAccounts,
-        },
-      }
-    } else {
-      if (solanaTransferTx) {
-        const isSending = ownerAddress === solanaTransferTx.source
-        tx = {
-          owner: solanaTransferTx.source,
-          from: solanaTransferTx.source,
-          to: solanaTransferTx.destination,
-          amount: solanaTransferTx.lamports, // number
-          fee: isSending && ownerIsFeePayer ? fee : 0,
-          data: solanaTransferTx.data,
-        }
-      }
-
-      const accountIndexes = accountKeys.reduce((acc, key, i) => {
-        const hasKnownOwner = tokenAccountsByOwner.some(
-          (tokenAccount) => tokenAccount.tokenAccountAddress === key.pubkey
-        )
-
-        acc[i] = {
-          ...key,
-          owner: hasKnownOwner ? ownerAddress : null, // not know (like in an outgoing tx)
-        }
-
-        return acc
-      }, Object.create(null)) // { 0: { pubkey, owner }, 1: { ... }, ... }
-
-      // Parse Token txs
-      const tokenTxs = this._parseTokenTransfers({
-        instructions,
-        innerInstructions,
-        tokenAccountsByOwner,
-        ownerAddress,
-        fee: ownerIsFeePayer ? fee : 0,
-        accountIndexes,
-        preTokenBalances,
-        postTokenBalances,
-      })
-
-      if (tokenTxs.length > 0) {
-        // found spl-token simple transfer/transferChecked instruction
-        tx.tokenTxs = tokenTxs.map((tx) => ({
-          id: txId,
-          slot: txDetails.slot,
-          ...tx,
-        }))
-      } else if (preTokenBalances && postTokenBalances) {
-        // probably a DEX program is involved (multiple instructions), compute balance changes
-        // group by owner and supported token
-        const preBalances = preTokenBalances.filter((t) => {
-          return (
-            accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint)
-          )
-        })
-        const postBalances = postTokenBalances.filter((t) => {
-          return (
-            accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint)
-          )
-        })
-
-        if (preBalances.length > 0 || postBalances.length > 0 || solanaTransferTx) {
-          tx = {}
-
-          if (includeUnparsed && innerInstructions.length > 0) {
-            // when using includeUnparsed for DEX tx we want to keep SOL tx as "unparsed"
-            // 1. we want to treat all SOL dex transactions as "Contract transaction", not "Sent SOL"
-            // 2. default behavior is not perfect. For example it doesn't see SOL-side tx in
-            //    SOL->SPL swaps on Raydium and Orca.
-            tx = getUnparsedTx()
-            tx.dexTxs = getInnerTxsFromBalanceChanges()
-          } else {
-            if (solanaTransferTx) {
-              // the base tx will be the one that moved solana.
-              tx =
-                solanaTransferTx.from && solanaTransferTx.to
-                  ? solanaTransferTx
-                  : {
-                      owner: solanaTransferTx.source,
-                      from: solanaTransferTx.source,
-                      to: solanaTransferTx.destination,
-                      amount: solanaTransferTx.lamports, // number
-                      fee: ownerAddress === solanaTransferTx.source ? fee : 0,
-                    }
-            }
-
-            // If it has inner instructions then it's a DEX tx that moved SPL -> SPL
-            if (innerInstructions.length > 0) {
-              tx.dexTxs = innerInstructions
-              // if tx involves only SPL swaps. Expand DEX ix (first element as tx base and the other kept there)
-              if (!tx.from && !solanaTransferTx) {
-                tx = tx.dexTxs[0]
-                tx.dexTxs = innerInstructions.slice(1)
-              }
-            }
-          }
-        }
-      }
-    }
-
-    const unparsed = Object.keys(tx).length === 0
-
-    if (unparsed && includeUnparsed) {
-      tx = getUnparsedTx()
-    }
-
-    // How tokens tx are parsed:
-    // 0. compute incoming or outgoing tx: it's outgoing if spl-token:transfer has source/destination included in tokenAccountsByOwner
-    // 1. if it's a sent tx: sum all instructions amount (spl-token:transfer)
-    // 2. if it's an incoming tx: sum all the amounts with destination included in tokenAccountsByOwner (aggregating by ticker)
-    // QUESTION: How do I know what are my tokens addresses deterministically? It's not possible, gotta use tokenAccountsByOwner
-
-    return {
-      id: txId,
-      slot: txDetails.slot,
-      error: !(txDetails.meta.err === null),
-      ...tx,
-    }
-  }
-
-  _parseTokenTransfers({
-    instructions,
-    innerInstructions = [],
-    tokenAccountsByOwner,
-    ownerAddress,
-    fee,
-    accountIndexes = {},
-    preTokenBalances,
-    postTokenBalances,
-  }) {
-    if (
-      preTokenBalances.length === 0 &&
-      postTokenBalances.length === 0 &&
-      !Array.isArray(tokenAccountsByOwner)
-    ) {
-      return []
-    }
-
-    const tokenTxs = []
-
-    instructions.forEach((instruction) => {
-      const { type, program, source, destination, amount, tokenAmount } = instruction
-
-      if (isSplTransferInstruction({ program, type })) {
-        let tokenAccount = lodash.find(tokenAccountsByOwner, { tokenAccountAddress: source })
-        const isSending = !!tokenAccount
-        if (!isSending) {
-          // receiving
-          tokenAccount = lodash.find(tokenAccountsByOwner, {
-            tokenAccountAddress: destination,
-          })
-        }
-
-        if (!tokenAccount) return // no transfers with our addresses involved
-
-        const owner = isSending ? ownerAddress : null
-
-        delete tokenAccount.balance
-        delete tokenAccount.owner
-
-        // If it's a sending tx we want to have the destination's owner as "to" address
-        let to = ownerAddress
-        let from = ownerAddress
-        if (isSending) {
-          to = destination // token account address (trying to get the owner below, we don't always have postTokenBalances...)
-          postTokenBalances.forEach((t) => {
-            if (accountIndexes[t.accountIndex].pubkey === destination) to = t.owner
-          })
-        } else {
-          // is receiving tx
-          from = source // token account address
-          preTokenBalances.forEach((t) => {
-            if (accountIndexes[t.accountIndex].pubkey === source) from = t.owner
-          })
-        }
-
-        tokenTxs.push({
-          owner,
-          token: tokenAccount,
-          from,
-          to,
-          amount: Number(amount || tokenAmount?.amount || 0), // supporting types: transfer, transferChecked, transferCheckedWithFee
-          fee: isSending ? fee : 0, // in lamports
-        })
-      }
-    })
-
-    innerInstructions.forEach((parsedIx) => {
-      const { type, program, amount, from, to } = parsedIx
-
-      // Handle token minting (mintTo, mintToChecked)
-      if (isSplMintInstruction({ program, type })) {
-        const {
-          token: { tokenAccountAddress },
-        } = parsedIx
-
-        // Check if the destination token account belongs to our owner
-        const tokenAccount = lodash.find(tokenAccountsByOwner, {
-          tokenAccountAddress,
-        })
-
-        if (!tokenAccount) return // not our token account
-
-        delete tokenAccount.balance
-        delete tokenAccount.owner
-
-        tokenTxs.push({
-          owner: null, // no owner for minting (it's created from thin air)
-          token: tokenAccount,
-          from, // mint address as the source
-          to, // our address as recipient
-          amount: Number(amount || 0),
-          fee: 0, // no fee for receiving minted tokens
-        })
-      }
-    })
-
-    return tokenTxs
+  parseTransaction(...args) {
+    return parseTransaction(...args)
   }
 
   async getWalletTokensList({ tokenAccounts }) {
@@ -911,16 +307,16 @@ export class Api {
 
   async getTokenAccountsByOwner(address, tokenTicker) {
     const [{ value: standardTokenAccounts }, { value: token2022Accounts }] = await Promise.all([
-      this.rpcCall(
-        'getTokenAccountsByOwner',
-        [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
-        { address }
-      ),
-      this.rpcCall(
-        'getTokenAccountsByOwner',
-        [address, { programId: TOKEN_2022_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
-        { address }
-      ),
+      this.rpcCall('getTokenAccountsByOwner', [
+        address,
+        { programId: TOKEN_PROGRAM_ID.toBase58() },
+        { encoding: 'jsonParsed' },
+      ]),
+      this.rpcCall('getTokenAccountsByOwner', [
+        address,
+        { programId: TOKEN_2022_PROGRAM_ID.toBase58() },
+        { encoding: 'jsonParsed' },
+      ]),
     ])
 
     // merge regular token and token2022 program tokens
@@ -1033,11 +429,10 @@ export class Api {
   }
 
   async getAccountInfo(address, encoding = 'jsonParsed') {
-    const { value } = await this.rpcCall(
-      'getAccountInfo',
-      [address, { encoding, commitment: 'confirmed' }],
-      { address }
-    )
+    const { value } = await this.rpcCall('getAccountInfo', [
+      address,
+      { encoding, commitment: 'confirmed' },
+    ])
     return value
   }
 
@@ -1130,7 +525,7 @@ export class Api {
         encoding: 'jsonParsed',
       },
     ]
-    const res = await this.rpcCall('getProgramAccounts', params, { address })
+    const res = await this.rpcCall('getProgramAccounts', params)
 
     const accounts = {}
     let totalStake = 0
@@ -1206,7 +601,7 @@ export class Api {
     const broadcastTxWithRetry = retry(
       async () => {
         try {
-          const result = await this.rpcCall('sendTransaction', params, { forceHttp: true })
+          const result = await this.rpcCall('sendTransaction', params)
           console.log(`tx ${JSON.stringify(result)} sent!`)
 
           return result || null