@shapeshiftoss/swap-widget 0.0.2 → 0.1.0

package/src/machines/__tests__/swapMachine.test.ts

@@ -1,544 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { createActor } from 'xstate'
-
-import type { Asset, QuoteResponse, TradeRate } from '../../types'
-import { createInitialContext, swapMachine } from '../swapMachine'
-
-const TEST_ETH: Asset = {
-  assetId: 'eip155:1/slip44:60',
-  chainId: 'eip155:1',
-  symbol: 'ETH',
-  name: 'Ethereum',
-  precision: 18,
-}
-
-const TEST_BTC: Asset = {
-  assetId: 'bip122:000000000019d6689c085ae165831e93/slip44:0',
-  chainId: 'bip122:000000000019d6689c085ae165831e93',
-  symbol: 'BTC',
-  name: 'Bitcoin',
-  precision: 8,
-}
-
-const TEST_USDC: Asset = {
-  assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-  chainId: 'eip155:1',
-  symbol: 'USDC',
-  name: 'USD Coin',
-  precision: 6,
-}
-
-const TEST_RATE: TradeRate = {
-  swapperName: 'THORChain' as TradeRate['swapperName'],
-  rate: '1500',
-  buyAmountCryptoBaseUnit: '1500000000',
-  sellAmountCryptoBaseUnit: '1000000000000000000',
-  steps: 1,
-  affiliateBps: '0',
-}
-
-const TEST_QUOTE_NO_APPROVAL = {
-  transactionData: { to: '0xRouter', data: '0xSwapData', value: '1000000000000000000' },
-} as QuoteResponse
-
-const TEST_QUOTE_WITH_APPROVAL = {
-  transactionData: { to: '0xRouter', data: '0xSwapData', value: '1000000000000000000' },
-  approval: { isRequired: true, spender: '0xSpender' },
-} as QuoteResponse
-
-describe('swapMachine', () => {
-  describe('initial state', () => {
-    it('starts in idle and auto-transitions to input', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      const snapshot = actor.getSnapshot()
-      expect(snapshot.value).toBe('input')
-      actor.stop()
-    })
-
-    it('has correct initial context', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      const ctx = actor.getSnapshot().context
-      expect(ctx.sellAsset.symbol).toBe('ETH')
-      expect(ctx.buyAsset.symbol).toBe('USDC')
-      expect(ctx.sellAmount).toBe('')
-      expect(ctx.sellAmountBaseUnit).toBeUndefined()
-      expect(ctx.selectedRate).toBeNull()
-      expect(ctx.quote).toBeNull()
-      expect(ctx.txHash).toBeNull()
-      expect(ctx.approvalTxHash).toBeNull()
-      expect(ctx.error).toBeNull()
-      expect(ctx.retryCount).toBe(0)
-      expect(ctx.chainType).toBe('evm')
-      expect(ctx.slippage).toBe('0.5')
-      expect(ctx.isSellAssetEvm).toBe(true)
-      expect(ctx.isSellAssetUtxo).toBe(false)
-      expect(ctx.isSellAssetSolana).toBe(false)
-      expect(ctx.isBuyAssetEvm).toBe(true)
-      actor.stop()
-    })
-  })
-
-  describe('input state — context update events', () => {
-    it('SET_SELL_ASSET updates sellAsset and chain flags', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_BTC })
-      const ctx = actor.getSnapshot().context
-      expect(ctx.sellAsset.symbol).toBe('BTC')
-      expect(ctx.chainType).toBe('utxo')
-      expect(ctx.isSellAssetEvm).toBe(false)
-      expect(ctx.isSellAssetUtxo).toBe(true)
-      expect(ctx.isSellAssetSolana).toBe(false)
-      expect(actor.getSnapshot().value).toBe('input')
-      actor.stop()
-    })
-
-    it('SET_SELL_ASSET recalculates sellAmountBaseUnit with new precision', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '0.001', amountBaseUnit: '1000000000000000' })
-      expect(actor.getSnapshot().context.sellAmountBaseUnit).toBe('1000000000000000')
-
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_BTC })
-      expect(actor.getSnapshot().context.sellAmountBaseUnit).toBe('100000')
-      actor.stop()
-    })
-
-    it('SET_SELL_ASSET keeps sellAmountBaseUnit undefined when no sell amount', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      expect(actor.getSnapshot().context.sellAmountBaseUnit).toBeUndefined()
-
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_BTC })
-      expect(actor.getSnapshot().context.sellAmountBaseUnit).toBeUndefined()
-      actor.stop()
-    })
-
-    it('SET_BUY_ASSET updates buyAsset and isBuyAssetEvm', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_BUY_ASSET', asset: TEST_BTC })
-      const ctx = actor.getSnapshot().context
-      expect(ctx.buyAsset.symbol).toBe('BTC')
-      expect(ctx.isBuyAssetEvm).toBe(false)
-      expect(actor.getSnapshot().value).toBe('input')
-      actor.stop()
-    })
-
-    it('SET_SELL_AMOUNT updates sellAmount and sellAmountBaseUnit', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '2.5', amountBaseUnit: '2500000000000000000' })
-      const ctx = actor.getSnapshot().context
-      expect(ctx.sellAmount).toBe('2.5')
-      expect(ctx.sellAmountBaseUnit).toBe('2500000000000000000')
-      actor.stop()
-    })
-
-    it('SET_SLIPPAGE updates slippage', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SLIPPAGE', slippage: '1.0' })
-      expect(actor.getSnapshot().context.slippage).toBe('1.0')
-      actor.stop()
-    })
-
-    it('SELECT_RATE updates selectedRate', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SELECT_RATE', rate: TEST_RATE })
-      expect(actor.getSnapshot().context.selectedRate).toEqual(TEST_RATE)
-      actor.stop()
-    })
-
-    it('SET_WALLET_ADDRESS updates walletAddress', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_WALLET_ADDRESS', address: '0xWallet' })
-      expect(actor.getSnapshot().context.walletAddress).toBe('0xWallet')
-      actor.stop()
-    })
-
-    it('SET_RECEIVE_ADDRESS updates effectiveReceiveAddress', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_RECEIVE_ADDRESS', address: '0xReceiver' })
-      expect(actor.getSnapshot().context.effectiveReceiveAddress).toBe('0xReceiver')
-      actor.stop()
-    })
-
-    it('UPDATE_CHAIN_INFO updates all chain flags', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({
-        type: 'UPDATE_CHAIN_INFO',
-        chainType: 'utxo',
-        isSellAssetEvm: false,
-        isSellAssetUtxo: true,
-        isSellAssetSolana: false,
-        isBuyAssetEvm: false,
-      })
-      const ctx = actor.getSnapshot().context
-      expect(ctx.chainType).toBe('utxo')
-      expect(ctx.isSellAssetEvm).toBe(false)
-      expect(ctx.isSellAssetUtxo).toBe(true)
-      expect(ctx.isBuyAssetEvm).toBe(false)
-      actor.stop()
-    })
-  })
-
-  describe('input → quoting transition', () => {
-    it('FETCH_QUOTE transitions to quoting when hasValidInput', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      expect(actor.getSnapshot().value).toBe('quoting')
-      actor.stop()
-    })
-
-    it('FETCH_QUOTE stays in input when no valid input', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'FETCH_QUOTE' })
-      expect(actor.getSnapshot().value).toBe('input')
-      actor.stop()
-    })
-
-    it('FETCH_QUOTE stays in input when sellAmountBaseUnit is "0"', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '0', amountBaseUnit: '0' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      expect(actor.getSnapshot().value).toBe('input')
-      actor.stop()
-    })
-  })
-
-  describe('quoting state', () => {
-    it('QUOTE_SUCCESS transitions to executing when no approval required', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      expect(actor.getSnapshot().value).toBe('executing')
-      expect(actor.getSnapshot().context.quote).toEqual(TEST_QUOTE_NO_APPROVAL)
-      actor.stop()
-    })
-
-    it('QUOTE_SUCCESS transitions to approval_needed when approval required on evm with ERC20', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_USDC })
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      expect(actor.getSnapshot().value).toBe('approval_needed')
-      expect(actor.getSnapshot().context.quote).toEqual(TEST_QUOTE_WITH_APPROVAL)
-      actor.stop()
-    })
-
-    it('QUOTE_SUCCESS skips approval for native assets even when API says required', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      expect(actor.getSnapshot().value).toBe('executing')
-      actor.stop()
-    })
-
-    it('QUOTE_SUCCESS transitions to executing when approval required but non-evm chain', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_BTC })
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '100000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      expect(actor.getSnapshot().value).toBe('executing')
-      actor.stop()
-    })
-
-    it('QUOTE_ERROR transitions to error with error message', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_ERROR', error: 'No quotes available' })
-      expect(actor.getSnapshot().value).toBe('error')
-      expect(actor.getSnapshot().context.error).toBe('No quotes available')
-      actor.stop()
-    })
-  })
-
-  describe('approval_needed → approving', () => {
-    it('APPROVE transitions to approving', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_USDC })
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      expect(actor.getSnapshot().value).toBe('approval_needed')
-      actor.send({ type: 'APPROVE' })
-      expect(actor.getSnapshot().value).toBe('approving')
-      actor.stop()
-    })
-
-    it('RESET from approval_needed goes to input', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_USDC })
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      actor.send({ type: 'RESET' })
-      expect(actor.getSnapshot().value).toBe('input')
-      actor.stop()
-    })
-  })
-
-  describe('approving state', () => {
-    it('APPROVAL_SUCCESS transitions to executing with approvalTxHash', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_USDC })
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      actor.send({ type: 'APPROVE' })
-      actor.send({ type: 'APPROVAL_SUCCESS', txHash: '0xApprovalHash' })
-      expect(actor.getSnapshot().value).toBe('executing')
-      expect(actor.getSnapshot().context.approvalTxHash).toBe('0xApprovalHash')
-      actor.stop()
-    })
-
-    it('APPROVAL_ERROR transitions to error', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_USDC })
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      actor.send({ type: 'APPROVE' })
-      actor.send({ type: 'APPROVAL_ERROR', error: 'User rejected' })
-      expect(actor.getSnapshot().value).toBe('error')
-      expect(actor.getSnapshot().context.error).toBe('User rejected')
-      actor.stop()
-    })
-  })
-
-  describe('executing state', () => {
-    it('EXECUTE_SUCCESS transitions to polling_status with txHash', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      actor.send({ type: 'EXECUTE_SUCCESS', txHash: '0xTxHash' })
-      expect(actor.getSnapshot().value).toBe('polling_status')
-      expect(actor.getSnapshot().context.txHash).toBe('0xTxHash')
-      actor.stop()
-    })
-
-    it('EXECUTE_ERROR transitions to error', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      actor.send({ type: 'EXECUTE_ERROR', error: 'Transaction failed' })
-      expect(actor.getSnapshot().value).toBe('error')
-      expect(actor.getSnapshot().context.error).toBe('Transaction failed')
-      actor.stop()
-    })
-  })
-
-  describe('polling_status state', () => {
-    it('STATUS_CONFIRMED transitions to complete', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      actor.send({ type: 'EXECUTE_SUCCESS', txHash: '0xTxHash' })
-      actor.send({ type: 'STATUS_CONFIRMED' })
-      expect(actor.getSnapshot().value).toBe('complete')
-      actor.stop()
-    })
-
-    it('STATUS_FAILED transitions to error', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      actor.send({ type: 'EXECUTE_SUCCESS', txHash: '0xTxHash' })
-      actor.send({ type: 'STATUS_FAILED', error: 'Transaction reverted' })
-      expect(actor.getSnapshot().value).toBe('error')
-      expect(actor.getSnapshot().context.error).toBe('Transaction reverted')
-      actor.stop()
-    })
-  })
-
-  describe('error state', () => {
-    it('RETRY transitions to executing and increments retryCount', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      actor.send({ type: 'EXECUTE_ERROR', error: 'Gas too low' })
-      expect(actor.getSnapshot().context.retryCount).toBe(0)
-      actor.send({ type: 'RETRY' })
-      expect(actor.getSnapshot().value).toBe('executing')
-      expect(actor.getSnapshot().context.retryCount).toBe(1)
-      expect(actor.getSnapshot().context.error).toBeNull()
-      actor.stop()
-    })
-
-    it('RETRY works up to 3 times then stays in error', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-
-      actor.send({ type: 'EXECUTE_ERROR', error: 'fail 1' })
-      actor.send({ type: 'RETRY' })
-      expect(actor.getSnapshot().value).toBe('executing')
-      expect(actor.getSnapshot().context.retryCount).toBe(1)
-
-      actor.send({ type: 'EXECUTE_ERROR', error: 'fail 2' })
-      actor.send({ type: 'RETRY' })
-      expect(actor.getSnapshot().value).toBe('executing')
-      expect(actor.getSnapshot().context.retryCount).toBe(2)
-
-      actor.send({ type: 'EXECUTE_ERROR', error: 'fail 3' })
-      actor.send({ type: 'RETRY' })
-      expect(actor.getSnapshot().value).toBe('executing')
-      expect(actor.getSnapshot().context.retryCount).toBe(3)
-
-      actor.send({ type: 'EXECUTE_ERROR', error: 'fail 4' })
-      actor.send({ type: 'RETRY' })
-      expect(actor.getSnapshot().value).toBe('error')
-      expect(actor.getSnapshot().context.retryCount).toBe(3)
-      actor.stop()
-    })
-
-    it('RESET from error transitions to input and resets context', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_ERROR', error: 'Some error' })
-      actor.send({ type: 'RESET' })
-      const ctx = actor.getSnapshot().context
-      expect(actor.getSnapshot().value).toBe('input')
-      expect(ctx.error).toBeNull()
-      expect(ctx.quote).toBeNull()
-      expect(ctx.txHash).toBeNull()
-      expect(ctx.retryCount).toBe(0)
-      actor.stop()
-    })
-  })
-
-  describe('complete state', () => {
-    it('RESET from complete transitions to input and resets context', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      actor.send({ type: 'EXECUTE_SUCCESS', txHash: '0xTxHash' })
-      actor.send({ type: 'STATUS_CONFIRMED' })
-      expect(actor.getSnapshot().value).toBe('complete')
-      actor.send({ type: 'RESET' })
-      const ctx = actor.getSnapshot().context
-      expect(actor.getSnapshot().value).toBe('input')
-      expect(ctx.txHash).toBeNull()
-      expect(ctx.quote).toBeNull()
-      expect(ctx.retryCount).toBe(0)
-      actor.stop()
-    })
-  })
-
-  describe('createInitialContext', () => {
-    it('returns default context without input', () => {
-      const ctx = createInitialContext()
-      expect(ctx.sellAsset.symbol).toBe('ETH')
-      expect(ctx.buyAsset.symbol).toBe('USDC')
-      expect(ctx.slippage).toBe('0.5')
-      expect(ctx.chainType).toBe('evm')
-    })
-
-    it('accepts custom sell/buy assets', () => {
-      const ctx = createInitialContext({ sellAsset: TEST_BTC, buyAsset: TEST_ETH })
-      expect(ctx.sellAsset.symbol).toBe('BTC')
-      expect(ctx.buyAsset.symbol).toBe('ETH')
-      expect(ctx.chainType).toBe('utxo')
-    })
-
-    it('accepts custom slippage', () => {
-      const ctx = createInitialContext({ slippage: '2.0' })
-      expect(ctx.slippage).toBe('2.0')
-    })
-  })
-
-  describe('full happy path — no approval', () => {
-    it('idle → input → quoting → executing → polling_status → complete → input', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      expect(actor.getSnapshot().value).toBe('input')
-
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000000000000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      expect(actor.getSnapshot().value).toBe('quoting')
-
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_NO_APPROVAL })
-      expect(actor.getSnapshot().value).toBe('executing')
-
-      actor.send({ type: 'EXECUTE_SUCCESS', txHash: '0xHash' })
-      expect(actor.getSnapshot().value).toBe('polling_status')
-
-      actor.send({ type: 'STATUS_CONFIRMED' })
-      expect(actor.getSnapshot().value).toBe('complete')
-
-      actor.send({ type: 'RESET' })
-      expect(actor.getSnapshot().value).toBe('input')
-      actor.stop()
-    })
-  })
-
-  describe('full happy path — with approval', () => {
-    it('idle → input → quoting → approval_needed → approving → executing → polling_status → complete', () => {
-      const actor = createActor(swapMachine)
-      actor.start()
-      expect(actor.getSnapshot().value).toBe('input')
-
-      actor.send({ type: 'SET_SELL_ASSET', asset: TEST_USDC })
-      actor.send({ type: 'SET_SELL_AMOUNT', amount: '1', amountBaseUnit: '1000000' })
-      actor.send({ type: 'FETCH_QUOTE' })
-      expect(actor.getSnapshot().value).toBe('quoting')
-
-      actor.send({ type: 'QUOTE_SUCCESS', quote: TEST_QUOTE_WITH_APPROVAL })
-      expect(actor.getSnapshot().value).toBe('approval_needed')
-
-      actor.send({ type: 'APPROVE' })
-      expect(actor.getSnapshot().value).toBe('approving')
-
-      actor.send({ type: 'APPROVAL_SUCCESS', txHash: '0xApproval' })
-      expect(actor.getSnapshot().value).toBe('executing')
-
-      actor.send({ type: 'EXECUTE_SUCCESS', txHash: '0xSwap' })
-      expect(actor.getSnapshot().value).toBe('polling_status')
-
-      actor.send({ type: 'STATUS_CONFIRMED' })
-      expect(actor.getSnapshot().value).toBe('complete')
-      actor.stop()
-    })
-  })
-})

package/src/machines/__tests__/types.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { QuoteResponse, SwapperName } from '../../types'
-import type { SwapMachineContext, SwapMachineEvent } from '../types'
-
-describe('SwapMachine Types', () => {
-  it('SwapMachineContext type is structurally valid', () => {
-    const context: SwapMachineContext = {
-      sellAsset: {
-        assetId: 'eip155:1/slip44:60',
-        chainId: 'eip155:1',
-        symbol: 'ETH',
-        name: 'Ethereum',
-        precision: 18,
-      },
-      buyAsset: {
-        assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-        chainId: 'eip155:1',
-        symbol: 'USDC',
-        name: 'USD Coin',
-        precision: 6,
-      },
-      sellAmount: '1.0',
-      sellAmountBaseUnit: '1000000000000000000',
-      selectedRate: null,
-      quote: null,
-      txHash: null,
-      approvalTxHash: null,
-      error: null,
-      errorSource: null,
-      retryCount: 0,
-      chainType: 'evm',
-      slippage: '0.5',
-      walletAddress: undefined,
-      effectiveReceiveAddress: '0x1234567890abcdef1234567890abcdef12345678',
-      isSellAssetEvm: true,
-      isSellAssetUtxo: false,
-      isSellAssetSolana: false,
-      isBuyAssetEvm: true,
-    }
-
-    expect(context.sellAsset.symbol).toBe('ETH')
-    expect(context.buyAsset.symbol).toBe('USDC')
-    expect(context.chainType).toBe('evm')
-    expect(context.retryCount).toBe(0)
-  })
-
-  it('SwapMachineEvent discriminated union covers all event types', () => {
-    const events: SwapMachineEvent[] = [
-      {
-        type: 'SET_SELL_ASSET',
-        asset: {
-          assetId: 'eip155:1/slip44:60',
-          chainId: 'eip155:1',
-          symbol: 'ETH',
-          name: 'Ethereum',
-          precision: 18,
-        },
-      },
-      {
-        type: 'SET_BUY_ASSET',
-        asset: {
-          assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-          chainId: 'eip155:1',
-          symbol: 'USDC',
-          name: 'USD Coin',
-          precision: 6,
-        },
-      },
-      { type: 'SET_SELL_AMOUNT', amount: '1.0', amountBaseUnit: '1000000000000000000' },
-      { type: 'SET_SLIPPAGE', slippage: '1.0' },
-      {
-        type: 'SELECT_RATE',
-        rate: {
-          swapperName: 'THORChain' as SwapperName,
-          rate: '1500',
-          buyAmountCryptoBaseUnit: '1500000000',
-          sellAmountCryptoBaseUnit: '1000000000000000000',
-          steps: 1,
-          affiliateBps: '0',
-        },
-      },
-      { type: 'FETCH_QUOTE' },
-      { type: 'QUOTE_SUCCESS', quote: {} as QuoteResponse },
-      { type: 'QUOTE_ERROR', error: 'No quotes available' },
-      { type: 'APPROVE' },
-      { type: 'APPROVAL_SUCCESS', txHash: '0xabc' },
-      { type: 'APPROVAL_ERROR', error: 'Approval failed' },
-      { type: 'EXECUTE_SUCCESS', txHash: '0xdef' },
-      { type: 'EXECUTE_ERROR', error: 'Execution failed' },
-      { type: 'STATUS_CONFIRMED' },
-      { type: 'STATUS_FAILED', error: 'Transaction reverted' },
-      { type: 'RETRY' },
-      { type: 'RESET' },
-      { type: 'SET_WALLET_ADDRESS', address: '0x1234' },
-      { type: 'SET_RECEIVE_ADDRESS', address: '0x5678' },
-      {
-        type: 'UPDATE_CHAIN_INFO',
-        chainType: 'evm',
-        isSellAssetEvm: true,
-        isSellAssetUtxo: false,
-        isSellAssetSolana: false,
-        isBuyAssetEvm: true,
-      },
-    ]
-
-    expect(events).toHaveLength(20)
-    const eventTypes = events.map(e => e.type)
-    expect(eventTypes).toContain('SET_SELL_ASSET')
-    expect(eventTypes).toContain('RESET')
-    expect(eventTypes).toContain('UPDATE_CHAIN_INFO')
-  })
-
-  it('chainType supports all chain types', () => {
-    const chainTypes: SwapMachineContext['chainType'][] = [
-      'evm',
-      'utxo',
-      'solana',
-      'cosmos',
-      'other',
-    ]
-    expect(chainTypes).toHaveLength(5)
-  })
-})