@chorus-one/polygon 1.0.0

package/src/types.ts

@@ -0,0 +1,45 @@
+import type { Hex, TransactionReceipt } from 'viem'
+import type { PolygonNetworks } from './constants'
+
+export interface PolygonNetworkConfig {
+  /** Network to use: 'mainnet' (Ethereum L1) or 'testnet' (Sepolia L1) */
+  network: PolygonNetworks
+  /** Optional RPC endpoint URL override. If not provided, uses viem's default for the network. */
+  rpcUrl?: string
+}
+
+export interface Transaction {
+  /** The recipient (contract) address in hexadecimal format */
+  to: Hex
+  /** The data to be included in the transaction in hexadecimal format (includes referrer tracking suffix) */
+  data: Hex
+  /** The amount of ETH (in wei) to be sent with the transaction */
+  value?: bigint
+}
+
+export interface PolygonTxStatus {
+  /** Status of the transaction */
+  status: 'success' | 'failure' | 'unknown'
+  /** Transaction receipt (null if unknown) */
+  receipt: TransactionReceipt | null
+}
+
+export interface StakeInfo {
+  /** Total staked amount formatted in POL */
+  balance: string
+  /** Total shares held by the delegator */
+  shares: bigint
+  /** Current exchange rate between shares and POL (with high precision) */
+  exchangeRate: bigint
+}
+
+export interface UnbondInfo {
+  /** Amount pending unbonding in POL */
+  amount: string
+  /** Whether the unbond can be withdrawn now */
+  isWithdrawable: boolean
+  /** Shares amount pending unbonding */
+  shares: bigint
+  /** Epoch number when the unbond becomes claimable */
+  withdrawEpoch: bigint
+}

package/test/fixtures/expected-data.ts

@@ -0,0 +1,17 @@
+import type { Address, Hex } from 'viem'
+import { NETWORK_CONTRACTS, CHORUS_ONE_POLYGON_VALIDATORS } from '../../src/constants'
+
+const { stakingTokenAddress } = NETWORK_CONTRACTS.mainnet
+
+export const TEST_ADDRESS: Address = '0x1234567890123456789012345678901234567890'
+export const TEST_VALIDATOR_SHARE: Address = CHORUS_ONE_POLYGON_VALIDATORS.mainnet
+
+export const EXPECTED_APPROVE_TX = {
+  amount: '100',
+  expected: {
+    to: stakingTokenAddress as Address,
+    // approve(address spender, uint256 amount) with spender = stakeManagerAddress (0x5e3e...), amount = 100e18
+    data: '0x095ea7b30000000000000000000000005e3ef299fddf15eaa0432e6e66473ace8c13d9080000000000000000000000000000000000000000000000056bc75e2d63100000' as Hex,
+    value: 0n
+  }
+}

package/test/integration/localSigner.spec.ts

@@ -0,0 +1,128 @@
+import { type PublicClient, parseEther } from 'viem'
+import { hardhat } from 'viem/chains'
+import { assert } from 'chai'
+import { fundWithStakingToken, impersonate, getStakingTokenBalance, getWithdrawalDelay, advanceEpoch } from './utils'
+import { restoreToInitialState } from './setup'
+import { PolygonTestStaker } from './testStaker'
+
+const TEST_MNEMONIC = 'test test test test test test test test test test test junk'
+const AMOUNT = '100'
+
+describe('PolygonStaker with LocalSigner', () => {
+  let testStaker: PolygonTestStaker
+  let publicClient: PublicClient
+
+  afterEach(async () => {
+    await restoreToInitialState()
+  })
+
+  beforeEach(async () => {
+    testStaker = new PolygonTestStaker({
+      mnemonic: TEST_MNEMONIC,
+      rpcUrl: hardhat.rpcUrls.default.http[0]
+    })
+    await testStaker.init()
+
+    publicClient = testStaker.publicClient
+
+    await fundWithStakingToken({
+      publicClient,
+      recipientAddress: testStaker.delegatorAddress,
+      amount: parseEther('10000')
+    })
+
+    await impersonate({ publicClient, address: testStaker.delegatorAddress })
+  })
+
+  it('approves and stakes using LocalSigner', async () => {
+    await testStaker.approve(AMOUNT)
+
+    const allowance = await testStaker.staker.getAllowance(testStaker.delegatorAddress)
+    assert.equal(allowance, AMOUNT)
+
+    await testStaker.stake(AMOUNT, 0n)
+
+    const stakeInfo = await testStaker.staker.getStake({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress
+    })
+    assert.equal(stakeInfo.balance, AMOUNT)
+  })
+
+  it('unstakes using LocalSigner', async () => {
+    await testStaker.approve(AMOUNT)
+    await testStaker.stake(AMOUNT, 0n)
+
+    const nonceBefore = await testStaker.staker.getUnbondNonce({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress
+    })
+
+    const stakeBefore = await testStaker.staker.getStake({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress
+    })
+    await testStaker.unstake(AMOUNT, stakeBefore.shares)
+
+    const nonceAfter = await testStaker.staker.getUnbondNonce({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress
+    })
+    assert.equal(nonceAfter, nonceBefore + 1n)
+
+    const stakeAfter = await testStaker.staker.getStake({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress
+    })
+    assert.equal(stakeAfter.balance, '0')
+  })
+
+  it('withdraws using LocalSigner after unbonding period', async () => {
+    await testStaker.approve(AMOUNT)
+    await testStaker.stake(AMOUNT, 0n)
+
+    const stakeBefore = await testStaker.staker.getStake({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress
+    })
+    await testStaker.unstake(AMOUNT, stakeBefore.shares)
+
+    const nonce = await testStaker.staker.getUnbondNonce({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress
+    })
+
+    const unbond = await testStaker.staker.getUnbond({
+      delegatorAddress: testStaker.delegatorAddress,
+      validatorShareAddress: testStaker.validatorShareAddress,
+      unbondNonce: nonce
+    })
+
+    const withdrawalDelay = await getWithdrawalDelay({ publicClient })
+    await advanceEpoch({
+      publicClient,
+      staker: testStaker.staker,
+      targetEpoch: unbond.withdrawEpoch + withdrawalDelay
+    })
+
+    const balanceBefore = await getStakingTokenBalance({
+      publicClient,
+      address: testStaker.delegatorAddress
+    })
+
+    await testStaker.withdraw(nonce)
+
+    const balanceAfter = await getStakingTokenBalance({
+      publicClient,
+      address: testStaker.delegatorAddress
+    })
+    assert.equal(balanceAfter - balanceBefore, parseEther(AMOUNT))
+  })
+
+  it('reports transaction status correctly', async () => {
+    const txHash = await testStaker.approve(AMOUNT)
+
+    const { status } = await testStaker.staker.getTxStatus({ txHash: txHash as `0x${string}` })
+    assert.equal(status, 'success')
+  })
+})

package/test/integration/setup.ts

@@ -0,0 +1,41 @@
+import { createPublicClient, http } from 'viem'
+import { hardhat } from 'viem/chains'
+
+let currentSnapshotId: string | null = null
+
+const publicClient = createPublicClient({
+  chain: hardhat,
+  transport: http(hardhat.rpcUrls.default.http[0])
+})
+
+before(async () => {
+  currentSnapshotId = (await publicClient.request({
+    method: 'evm_snapshot',
+    params: []
+  } as any)) as string
+})
+
+export const restoreToInitialState = async () => {
+  if (!currentSnapshotId) {
+    throw new Error('No snapshot available to restore to')
+  }
+
+  const success = await publicClient.request({
+    method: 'evm_revert',
+    params: [currentSnapshotId]
+  } as any)
+
+  if (!success) {
+    throw new Error('Failed to restore snapshot')
+  }
+
+  const newSnapshotId = (await publicClient.request({
+    method: 'evm_snapshot',
+    params: []
+  } as any)) as string
+
+  if (!newSnapshotId) {
+    throw new Error('Failed to take new snapshot after restore')
+  }
+  currentSnapshotId = newSnapshotId
+}