@chorus-one/polygon 1.0.0

package/test/integration/testStaker.ts

@@ -0,0 +1,130 @@
+import { PolygonStaker, CHORUS_ONE_POLYGON_VALIDATORS } from '@chorus-one/polygon'
+import { LocalSigner } from '@chorus-one/signer-local'
+import { KeyType } from '@chorus-one/signer'
+import * as bip39 from 'bip39'
+import { HDKey } from '@scure/bip32'
+import type { Address, PublicClient } from 'viem'
+import { createPublicClient, http } from 'viem'
+import { hardhat } from 'viem/chains'
+
+export class PolygonTestStaker {
+  private mnemonic: string
+  public hdPath: string
+  public delegatorAddress: Address
+  public validatorShareAddress: Address
+  public staker: PolygonStaker
+  public localSigner: LocalSigner
+  public publicClient: PublicClient
+
+  constructor (params: { mnemonic: string; rpcUrl: string }) {
+    if (!params.mnemonic) {
+      throw new Error('Mnemonic is required')
+    }
+
+    this.mnemonic = params.mnemonic
+    this.hdPath = "m/44'/60'/0'/0/0"
+    this.validatorShareAddress = CHORUS_ONE_POLYGON_VALIDATORS.mainnet
+
+    this.staker = new PolygonStaker({
+      network: 'mainnet',
+      rpcUrl: params.rpcUrl
+    })
+
+    this.publicClient = createPublicClient({
+      chain: hardhat,
+      transport: http(params.rpcUrl)
+    })
+  }
+
+  async init (): Promise<void> {
+    const seed = bip39.mnemonicToSeedSync(this.mnemonic)
+    const hdKey = HDKey.fromMasterSeed(seed)
+    const derived = hdKey.derive(this.hdPath)
+    const publicKey = derived.publicKey
+
+    if (!publicKey) {
+      throw new Error('Failed to derive public key')
+    }
+
+    const addressDerivationFn = PolygonStaker.getAddressDerivationFn()
+    const addresses = await addressDerivationFn(publicKey)
+    this.delegatorAddress = `0x${addresses[0]}` as Address
+
+    this.localSigner = new LocalSigner({
+      mnemonic: this.mnemonic,
+      accounts: [{ hdPath: this.hdPath }],
+      keyType: KeyType.SECP256K1,
+      addressDerivationFn
+    })
+    await this.localSigner.init()
+  }
+
+  private async waitForTx (txHash: `0x${string}`): Promise<void> {
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash })
+    if (receipt.status !== 'success') {
+      throw new Error(`Transaction failed: ${txHash}`)
+    }
+  }
+
+  async approve (amount: string): Promise<string> {
+    const { tx } = await this.staker.buildApproveTx({ amount })
+    const { signedTx } = await this.staker.sign({
+      signer: this.localSigner,
+      signerAddress: this.delegatorAddress,
+      tx
+    })
+    const { txHash } = await this.staker.broadcast({ signedTx })
+    await this.waitForTx(txHash)
+    return txHash
+  }
+
+  async stake (amount: string, minSharesToMint: bigint): Promise<string> {
+    const { tx } = await this.staker.buildStakeTx({
+      delegatorAddress: this.delegatorAddress,
+      validatorShareAddress: this.validatorShareAddress,
+      amount,
+      minSharesToMint
+    })
+    const { signedTx } = await this.staker.sign({
+      signer: this.localSigner,
+      signerAddress: this.delegatorAddress,
+      tx
+    })
+    const { txHash } = await this.staker.broadcast({ signedTx })
+    await this.waitForTx(txHash)
+    return txHash
+  }
+
+  async unstake (amount: string, maximumSharesToBurn: bigint): Promise<string> {
+    const { tx } = await this.staker.buildUnstakeTx({
+      delegatorAddress: this.delegatorAddress,
+      validatorShareAddress: this.validatorShareAddress,
+      amount,
+      maximumSharesToBurn
+    })
+    const { signedTx } = await this.staker.sign({
+      signer: this.localSigner,
+      signerAddress: this.delegatorAddress,
+      tx
+    })
+    const { txHash } = await this.staker.broadcast({ signedTx })
+    await this.waitForTx(txHash)
+    return txHash
+  }
+
+  async withdraw (unbondNonce: bigint): Promise<string> {
+    const { tx } = await this.staker.buildWithdrawTx({
+      delegatorAddress: this.delegatorAddress,
+      validatorShareAddress: this.validatorShareAddress,
+      unbondNonce
+    })
+    const { signedTx } = await this.staker.sign({
+      signer: this.localSigner,
+      signerAddress: this.delegatorAddress,
+      tx
+    })
+    const { txHash } = await this.staker.broadcast({ signedTx })
+    await this.waitForTx(txHash)
+    return txHash
+  }
+}

package/test/integration/utils.ts

@@ -0,0 +1,263 @@
+import { PolygonStaker, CHORUS_ONE_POLYGON_VALIDATORS, NETWORK_CONTRACTS, type Transaction } from '@chorus-one/polygon'
+import {
+  createWalletClient,
+  createPublicClient,
+  http,
+  erc20Abi,
+  encodeFunctionData,
+  parseEther,
+  toHex,
+  type PublicClient,
+  type WalletClient,
+  type Hex,
+  type Address
+} from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { hardhat } from 'viem/chains'
+import { assert } from 'chai'
+import networkConfig from '../lib/networks.json'
+
+export interface TestSetup {
+  validatorShareAddress: Address
+  walletClient: WalletClient
+  publicClient: PublicClient
+  staker: PolygonStaker
+  delegatorAddress: Address
+}
+
+export interface StakingParams {
+  delegatorAddress: Address
+  validatorShareAddress: Address
+  amount: string
+  maximumSharesToBurn?: bigint
+  staker: PolygonStaker
+  walletClient: WalletClient
+  publicClient: PublicClient
+}
+
+export const prepareTests = async (): Promise<TestSetup> => {
+  const privateKey = networkConfig.accounts[0].privateKey as Hex
+  const account = privateKeyToAccount(privateKey)
+
+  const walletClient = createWalletClient({
+    account,
+    chain: hardhat,
+    transport: http()
+  })
+
+  const publicClient = createPublicClient({
+    chain: hardhat,
+    transport: http()
+  })
+
+  const staker = new PolygonStaker({
+    network: 'mainnet',
+    rpcUrl: hardhat.rpcUrls.default.http[0]
+  })
+
+  return {
+    validatorShareAddress: CHORUS_ONE_POLYGON_VALIDATORS.mainnet,
+    walletClient,
+    publicClient,
+    staker,
+    delegatorAddress: account.address
+  }
+}
+
+export const fundWithStakingToken = async ({
+  publicClient,
+  recipientAddress,
+  amount
+}: {
+  publicClient: PublicClient
+  recipientAddress: Address
+  amount: bigint
+}): Promise<void> => {
+  await impersonate({ publicClient, address: NETWORK_CONTRACTS.mainnet.stakeManagerAddress })
+
+  const impersonatedClient = createWalletClient({
+    account: NETWORK_CONTRACTS.mainnet.stakeManagerAddress,
+    chain: hardhat,
+    transport: http()
+  })
+
+  await sendTx({
+    tx: {
+      to: NETWORK_CONTRACTS.mainnet.stakingTokenAddress,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'transfer',
+        args: [recipientAddress, amount]
+      }),
+      value: 0n
+    },
+    walletClient: impersonatedClient,
+    publicClient,
+    senderAddress: NETWORK_CONTRACTS.mainnet.stakeManagerAddress
+  })
+}
+
+export const approve = async ({
+  delegatorAddress,
+  amount,
+  staker,
+  walletClient,
+  publicClient
+}: Omit<StakingParams, 'validatorShareAddress'>): Promise<void> => {
+  const { tx } = await staker.buildApproveTx({ amount })
+  await sendTx({ tx, walletClient, publicClient, senderAddress: delegatorAddress })
+}
+
+export const stake = async ({
+  delegatorAddress,
+  validatorShareAddress,
+  amount,
+  staker,
+  walletClient,
+  publicClient
+}: StakingParams): Promise<void> => {
+  const { tx } = await staker.buildStakeTx({ delegatorAddress, validatorShareAddress, amount, minSharesToMint: 0n })
+  await sendTx({ tx, walletClient, publicClient, senderAddress: delegatorAddress })
+}
+
+export const approveAndStake = async (params: StakingParams): Promise<void> => {
+  await approve(params)
+  await stake(params)
+}
+
+export const sendTx = async ({
+  tx,
+  walletClient,
+  publicClient,
+  senderAddress
+}: {
+  tx: Transaction
+  walletClient: WalletClient
+  publicClient: PublicClient
+  senderAddress: Address
+}): Promise<void> => {
+  const request = await walletClient.prepareTransactionRequest({
+    ...tx,
+    chain: undefined
+  })
+
+  const hash = await walletClient.sendTransaction({
+    ...request,
+    account: senderAddress
+  })
+
+  const receipt = await publicClient.getTransactionReceipt({ hash })
+  assert.equal(receipt.status, 'success')
+}
+
+export const unstake = async ({
+  delegatorAddress,
+  validatorShareAddress,
+  amount,
+  maximumSharesToBurn,
+  staker,
+  walletClient,
+  publicClient
+}: Required<StakingParams>): Promise<void> => {
+  const { tx } = await staker.buildUnstakeTx({ delegatorAddress, validatorShareAddress, amount, maximumSharesToBurn })
+  await sendTx({ tx, walletClient, publicClient, senderAddress: delegatorAddress })
+}
+
+export const getStakingTokenBalance = async ({
+  publicClient,
+  address
+}: {
+  publicClient: PublicClient
+  address: Address
+}): Promise<bigint> => {
+  return publicClient.readContract({
+    address: NETWORK_CONTRACTS.mainnet.stakingTokenAddress,
+    abi: erc20Abi,
+    functionName: 'balanceOf',
+    args: [address]
+  })
+}
+
+export const getWithdrawalDelay = async ({ publicClient }: { publicClient: PublicClient }): Promise<bigint> => {
+  return publicClient.readContract({
+    address: NETWORK_CONTRACTS.mainnet.stakeManagerAddress,
+    abi: [
+      {
+        type: 'function',
+        name: 'withdrawalDelay',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view'
+      }
+    ] as const,
+    functionName: 'withdrawalDelay'
+  })
+}
+
+export const impersonate = async ({
+  publicClient,
+  address
+}: {
+  publicClient: PublicClient
+  address: Address
+}): Promise<void> => {
+  await publicClient.request({
+    method: 'hardhat_impersonateAccount',
+    params: [address]
+  } as any)
+
+  await publicClient.request({
+    method: 'hardhat_setBalance',
+    params: [address, toHex(parseEther('10'))]
+  } as any)
+}
+
+// Reference: https://etherscan.io/address/0x6e7a5820baD6cebA8Ef5ea69c0C92EbbDAc9CE48
+const GOVERNANCE_ADDRESS = '0x6e7a5820baD6cebA8Ef5ea69c0C92EbbDAc9CE48' as Address
+
+// Reference: https://github.com/0xPolygon/pos-contracts/blob/main/contracts/staking/stakeManager/StakeManager.sol
+const SET_CURRENT_EPOCH_ABI = [
+  {
+    type: 'function',
+    name: 'setCurrentEpoch',
+    inputs: [{ name: '_currentEpoch', type: 'uint256' }],
+    outputs: [],
+    stateMutability: 'nonpayable'
+  }
+] as const
+
+export const advanceEpoch = async ({
+  publicClient,
+  staker,
+  targetEpoch
+}: {
+  publicClient: PublicClient
+  staker: PolygonStaker
+  targetEpoch: bigint
+}): Promise<void> => {
+  const currentEpoch = await staker.getEpoch()
+  if (currentEpoch >= targetEpoch) return
+
+  await impersonate({ publicClient, address: GOVERNANCE_ADDRESS })
+
+  const governanceWallet = createWalletClient({
+    account: GOVERNANCE_ADDRESS,
+    chain: hardhat,
+    transport: http()
+  })
+
+  await sendTx({
+    tx: {
+      to: NETWORK_CONTRACTS.mainnet.stakeManagerAddress,
+      data: encodeFunctionData({
+        abi: SET_CURRENT_EPOCH_ABI,
+        functionName: 'setCurrentEpoch',
+        args: [targetEpoch]
+      }),
+      value: 0n
+    },
+    walletClient: governanceWallet,
+    publicClient,
+    senderAddress: GOVERNANCE_ADDRESS
+  })
+}

package/test/lib/networks.json

@@ -0,0 +1,14 @@
+{
+  "networks": {
+    "ethereum": {
+      "name": "ethereum",
+      "url": "https://ethereum-rpc.publicnode.com"
+    }
+  },
+  "accounts": [
+    {
+      "privateKey": "0x689af8efa8c651a91ad287602527f3af2fe9f6501a7ac4b061667b5a93e037fd",
+      "balance": "10000000000000000000000"
+    }
+  ]
+}

package/test/staker.spec.ts

@@ -0,0 +1,154 @@
+import { PolygonStaker } from '../src/staker'
+import { NETWORK_CONTRACTS } from '../src/constants'
+import { describe, it, beforeEach } from 'mocha'
+import { use, expect, assert } from 'chai'
+import chaiAsPromised from 'chai-as-promised'
+import { type Address, maxUint256, encodeFunctionData, erc20Abi } from 'viem'
+import { EXPECTED_APPROVE_TX, TEST_ADDRESS, TEST_VALIDATOR_SHARE } from './fixtures/expected-data'
+
+use(chaiAsPromised)
+
+describe('PolygonStaker', () => {
+  let staker: PolygonStaker
+
+  beforeEach(() => {
+    staker = new PolygonStaker({
+      network: 'mainnet',
+      rpcUrl: 'https://ethereum-rpc.publicnode.com'
+    })
+  })
+
+  describe('buildApproveTx', () => {
+    it('should generate correct unsigned approve tx', async () => {
+      const { tx } = await staker.buildApproveTx({
+        amount: EXPECTED_APPROVE_TX.amount
+      })
+
+      assert.equal(tx.to, EXPECTED_APPROVE_TX.expected.to)
+      assert.equal(tx.data, EXPECTED_APPROVE_TX.expected.data)
+      assert.equal(tx.value, EXPECTED_APPROVE_TX.expected.value)
+    })
+
+    it('should generate correct unsigned approve tx for max (unlimited) amount', async () => {
+      const { tx } = await staker.buildApproveTx({ amount: 'max' })
+
+      const expectedData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'approve',
+        args: [NETWORK_CONTRACTS.mainnet.stakeManagerAddress, maxUint256]
+      })
+
+      assert.equal(tx.to, EXPECTED_APPROVE_TX.expected.to)
+      assert.equal(tx.data, expectedData)
+      assert.equal(tx.value, EXPECTED_APPROVE_TX.expected.value)
+    })
+
+    it('should reject invalid amounts', async () => {
+      await expect(staker.buildApproveTx({ amount: '0' })).to.be.rejectedWith('Amount must be greater than 0')
+      await expect(staker.buildApproveTx({ amount: '' })).to.be.rejectedWith('Amount cannot be empty')
+      await expect(staker.buildApproveTx({ amount: 'invalid' })).to.be.rejectedWith('Amount must be a valid number')
+    })
+  })
+
+  describe('address validation', () => {
+    it('should reject invalid delegator address in buildStakeTx', async () => {
+      await expect(
+        staker.buildStakeTx({
+          delegatorAddress: 'invalid' as Address,
+          validatorShareAddress: TEST_VALIDATOR_SHARE,
+          amount: '100',
+          minSharesToMint: 0n
+        })
+      ).to.be.rejectedWith('Invalid delegator address')
+    })
+
+    it('should reject invalid validator share address in buildStakeTx', async () => {
+      await expect(
+        staker.buildStakeTx({
+          delegatorAddress: TEST_ADDRESS,
+          validatorShareAddress: 'invalid' as Address,
+          amount: '100',
+          minSharesToMint: 0n
+        })
+      ).to.be.rejectedWith('Invalid validator share address')
+    })
+
+    it('should reject invalid delegator address in buildUnstakeTx', async () => {
+      await expect(
+        staker.buildUnstakeTx({
+          delegatorAddress: 'invalid' as Address,
+          validatorShareAddress: TEST_VALIDATOR_SHARE,
+          amount: '100',
+          maximumSharesToBurn: 0n
+        })
+      ).to.be.rejectedWith('Invalid delegator address')
+    })
+
+    it('should reject invalid validator share address in buildUnstakeTx', async () => {
+      await expect(
+        staker.buildUnstakeTx({
+          delegatorAddress: TEST_ADDRESS,
+          validatorShareAddress: 'invalid' as Address,
+          amount: '100',
+          maximumSharesToBurn: 0n
+        })
+      ).to.be.rejectedWith('Invalid validator share address')
+    })
+  })
+
+  describe('buildStakeTx slippage validation', () => {
+    it('should reject when both slippageBps and minSharesToMint are provided', async () => {
+      await expect(
+        staker.buildStakeTx({
+          delegatorAddress: TEST_ADDRESS,
+          validatorShareAddress: TEST_VALIDATOR_SHARE,
+          amount: '100',
+          slippageBps: 50,
+          minSharesToMint: 100n
+        })
+      ).to.be.rejectedWith('Cannot specify both slippageBps and minSharesToMint. Use one or the other.')
+    })
+  })
+
+  describe('buildUnstakeTx slippage validation', () => {
+    it('should reject when both slippageBps and maximumSharesToBurn are provided', async () => {
+      await expect(
+        staker.buildUnstakeTx({
+          delegatorAddress: TEST_ADDRESS,
+          validatorShareAddress: TEST_VALIDATOR_SHARE,
+          amount: '100',
+          slippageBps: 50,
+          maximumSharesToBurn: 100n
+        })
+      ).to.be.rejectedWith('Cannot specify both slippageBps and maximumSharesToBurn. Use one or the other.')
+    })
+  })
+
+  describe('getUnbonds', () => {
+    it('should return empty array for empty nonces input', async () => {
+      const result = await staker.getUnbonds({
+        delegatorAddress: TEST_ADDRESS,
+        validatorShareAddress: TEST_VALIDATOR_SHARE,
+        unbondNonces: []
+      })
+
+      assert.isArray(result)
+      assert.lengthOf(result, 0)
+    })
+  })
+
+  describe('getAddressDerivationFn', () => {
+    it('should derive correct ethereum address from a compressed public key', async () => {
+      const fn = PolygonStaker.getAddressDerivationFn()
+
+      // Known secp256k1 compressed public key (generator point)
+      const compressedPubKey = Uint8Array.from(
+        Buffer.from('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', 'hex')
+      )
+
+      const [address] = await fn(compressedPubKey)
+      assert.isString(address)
+      assert.equal(address.length, 40)
+    })
+  })
+})

package/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.cjs.json",
+  "compilerOptions": {
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../signer" }]
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "baseUrl": ".",
+    "paths": {
+      "@chorus-one/signer": ["../signer/src"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../signer" }]
+}

package/tsconfig.mjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.mjs.json",
+  "compilerOptions": {
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../signer" }]
+}