@eth-optimism/actions-sdk 0.2.0 → 0.4.0

package/src/utils/approve.ts

@@ -0,0 +1,197 @@
+import type { Address, PublicClient } from 'viem'
+import { encodeFunctionData, erc20Abi, maxUint256 } from 'viem'
+
+import type { TransactionData } from '@/types/transaction.js'
+
+/** Default Permit2 approval expiry: 30 days in seconds */
+export const DEFAULT_PERMIT2_EXPIRY_SECONDS = 30 * 24 * 60 * 60
+
+/**
+ * Permit2 ABI (subset for approvals)
+ */
+const PERMIT2_ABI = [
+  {
+    name: 'allowance',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'owner', type: 'address' },
+      { name: 'token', type: 'address' },
+      { name: 'spender', type: 'address' },
+    ],
+    outputs: [
+      { name: 'amount', type: 'uint160' },
+      { name: 'expiration', type: 'uint48' },
+      { name: 'nonce', type: 'uint48' },
+    ],
+  },
+  {
+    name: 'approve',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint160' },
+      { name: 'expiration', type: 'uint48' },
+    ],
+    outputs: [],
+  },
+] as const
+
+/**
+ * Permit2 allowance info
+ */
+export interface Permit2Allowance {
+  amount: bigint
+  expiration: number
+  nonce: number
+}
+
+/**
+ * Check Permit2 allowance for a token/spender pair
+ */
+export async function checkPermit2Allowance(params: {
+  publicClient: PublicClient
+  permit2Address: Address
+  owner: Address
+  token: Address
+  spender: Address
+}): Promise<Permit2Allowance> {
+  const { publicClient, permit2Address, owner, token, spender } = params
+
+  const result = await publicClient.readContract({
+    address: permit2Address,
+    abi: PERMIT2_ABI,
+    functionName: 'allowance',
+    args: [owner, token, spender],
+  })
+
+  return {
+    amount: BigInt(result[0]),
+    expiration: Number(result[1]),
+    nonce: Number(result[2]),
+  }
+}
+
+/**
+ * Build ERC20 token approval transaction to Permit2.
+ * Uses maxUint256 — the Uniswap-canonical pattern.
+ * Permit2 is immutable with no owner; spending is scoped by its own allowance system.
+ */
+export function buildTokenApprovalTx(
+  token: Address,
+  permit2Address: Address,
+): TransactionData {
+  return buildErc20ApprovalTx(token, permit2Address, maxUint256)
+}
+
+/**
+ * Build Permit2 approval transaction for a spender
+ */
+export function buildPermit2ApprovalTx(params: {
+  permit2Address: Address
+  token: Address
+  spender: Address
+  amount: bigint
+  expirySeconds?: number
+}): TransactionData {
+  const { permit2Address, token, spender, amount } = params
+  const expiration =
+    Math.floor(Date.now() / 1000) +
+    (params.expirySeconds ?? DEFAULT_PERMIT2_EXPIRY_SECONDS)
+
+  const data = encodeFunctionData({
+    abi: PERMIT2_ABI,
+    functionName: 'approve',
+    args: [token, spender, amount, expiration],
+  })
+
+  return {
+    to: permit2Address,
+    data,
+    value: 0n,
+  }
+}
+
+/**
+ * Check ERC20 token allowance
+ */
+export async function checkTokenAllowance(params: {
+  publicClient: PublicClient
+  token: Address
+  owner: Address
+  spender: Address
+}): Promise<bigint> {
+  const { publicClient, token, owner, spender } = params
+
+  return publicClient.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: 'allowance',
+    args: [owner, spender],
+  })
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Generic ERC20 approval utilities
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Build an ERC20 approve transaction.
+ * @param token - ERC20 token address
+ * @param spender - Address to approve
+ * @param amount - Amount to approve
+ * @returns Transaction data for the approval
+ */
+export function buildErc20ApprovalTx(
+  token: Address,
+  spender: Address,
+  amount: bigint,
+): TransactionData {
+  return {
+    to: token,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: 'approve',
+      args: [spender, amount],
+    }),
+    value: 0n,
+  }
+}
+
+/**
+ * Compute how much additional ERC20 approval is needed.
+ * Returns 0n if current allowance is sufficient.
+ * @param params - Token, owner, spender, required amount, and public client
+ * @returns The deficit (required - current), or 0n if already sufficient
+ */
+export async function getApprovalDeficit(params: {
+  publicClient: PublicClient
+  token: Address
+  owner: Address
+  spender: Address
+  amount: bigint
+}): Promise<bigint> {
+  const current = await checkTokenAllowance(params)
+  return current >= params.amount ? 0n : params.amount - current
+}
+
+/**
+ * Build an ERC20 approval transaction only if needed, approving only the deficit.
+ * Checks the current on-chain allowance, returns undefined if already sufficient.
+ * @param params - Token, owner, spender, required amount, and public client
+ * @returns Approval transaction for the deficit amount, or undefined if allowance is sufficient
+ */
+export async function buildApprovalTxIfNeeded(params: {
+  publicClient: PublicClient
+  token: Address
+  owner: Address
+  spender: Address
+  amount: bigint
+}): Promise<TransactionData | undefined> {
+  const deficit = await getApprovalDeficit(params)
+  return deficit > 0n
+    ? buildErc20ApprovalTx(params.token, params.spender, deficit)
+    : undefined
+}

package/src/utils/assets.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 
 import { MockUSDCAsset, MockWETHAsset } from '@/__mocks__/MockAssets.js'
-import { isAssetSupportedOnChain } from '@/utils/assets.js'
+import { isAssetSupportedOnChain, parseAssetAmount } from '@/utils/assets.js'
 
 describe('Asset Utilities', () => {
   describe('isAssetSupportedOnChain', () => {
@@ -25,4 +25,19 @@ describe('Asset Utilities', () => {
       expect(MockWETHAsset.type).toBe('erc20')
     })
   })
+
+  describe('parseAssetAmount', () => {
+    it('converts human-readable amount to wei using asset decimals', () => {
+      expect(parseAssetAmount(MockUSDCAsset, 100)).toBe(100000000n)
+      expect(parseAssetAmount(MockWETHAsset, 1)).toBe(1000000000000000000n)
+    })
+
+    it('returns undefined when amount is undefined', () => {
+      expect(parseAssetAmount(MockUSDCAsset, undefined)).toBeUndefined()
+    })
+
+    it('handles fractional amounts', () => {
+      expect(parseAssetAmount(MockUSDCAsset, 0.5)).toBe(500000n)
+    })
+  })
 })

package/src/utils/assets.ts

@@ -5,17 +5,20 @@ import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { Asset } from '@/types/asset.js'
 
 /**
- * Parse human-readable amount to wei/smallest unit
- * @param amount - Human-readable amount (e.g. 1.5)
- * @param decimals - Token decimals
- * @returns Amount in smallest unit (wei equivalent)
+ * Parse human-readable amount to wei using an asset's decimals.
+ * Returns undefined when amount is undefined.
  */
-export function parseAssetAmount(amount: number, decimals: number): bigint {
-  // Convert number to string with proper precision
-  const amountStr = amount.toString()
-
-  // Use viem's parseUnits for proper decimal handling
-  return parseUnits(amountStr, decimals)
+export function parseAssetAmount(asset: Asset, amount: number): bigint
+export function parseAssetAmount(
+  asset: Asset,
+  amount: number | undefined,
+): bigint | undefined
+export function parseAssetAmount(
+  asset: Asset,
+  amount: number | undefined,
+): bigint | undefined {
+  if (amount === undefined) return undefined
+  return parseUnits(amount.toString(), asset.metadata.decimals)
 }
 
 /**
@@ -83,3 +86,17 @@ export function getAssetAddress(
   }
   return address
 }
+
+/**
+ * Get all non-native contract addresses for an asset across all chains, lowercased.
+ * @param asset - Asset to extract addresses from
+ * @returns Array of lowercased contract addresses
+ */
+export function getAllAssetAddresses(asset: Asset): string[] {
+  return Object.values(asset.address)
+    .filter(
+      (addr): addr is Exclude<typeof addr, undefined | 'native'> =>
+        addr !== undefined && addr !== 'native',
+    )
+    .map((addr) => addr.toLowerCase())
+}