TypeScript SDK Utilities

type Call = {
  target: string      // Contract address to call
  data: string        // Encoded calldata
  value: number | bigint  // Native token value to send
}

type TokenAmount = {
  token: string       // Token contract address
  amount: number | bigint  // Token amount
}

type Route = {
  salt: string        // Unique salt for CREATE2 deployment
  deadline: number | bigint  // Execution deadline timestamp
  portal: string      // Portal contract address
  nativeAmount: number | bigint  // Native tokens to transfer
  tokens: TokenAmount[]  // ERC20 tokens to transfer
  calls: Call[]       // Contract calls to execute
}

type Reward = {
  creator: string     // Intent creator address
  prover: string      // Prover/filler address
  deadline: number | bigint  // Reward claim deadline
  nativeAmount: bigint  // Native token reward
  tokens: TokenAmount[]  // ERC20 token rewards
}

type Intent = {
  destination: number  // Destination chain ID
  route: Route        // Execution route
  reward: Reward      // Fulfillment reward
}

function encodeRoute(route: Route): string

import { encodeRoute } from './utils/intent'

const route = {
  salt: '0x1234...',
  deadline: 1700000000,
  portal: '0xPortalAddress...',
  nativeAmount: 1000000000000000000n,
  tokens: [
    { token: '0xTokenAddress...', amount: 1000000n }
  ],
  calls: [
    { 
      target: '0xTarget...', 
      data: '0xCalldata...', 
      value: 0 
    }
  ]
}

const encoded = encodeRoute(route)

function encodeReward(reward: Reward): string

import { encodeReward } from './utils/intent'

const reward = {
  deadline: 1700000000,
  creator: '0xCreator...',
  prover: '0xProver...',
  nativeAmount: 500000000000000000n,
  tokens: [
    { token: '0xRewardToken...', amount: 50000n }
  ]
}

const encoded = encodeReward(reward)

function encodeIntent(intent: Intent): string

import { encodeIntent } from './utils/intent'

const intent = {
  destination: 1,
  route: { /* route object */ },
  reward: { /* reward object */ }
}

const encoded = encodeIntent(intent)

function hashIntent(intent: Intent): {
  routeHash: string
  rewardHash: string
  intentHash: string
}

import { hashIntent } from './utils/intent'

const { routeHash, rewardHash, intentHash } = hashIntent(intent)
console.log('Intent hash:', intentHash)

async function intentVaultAddress(
  intentSourceAddress: string,
  intent: Intent
): Promise<string>

import { intentVaultAddress } from './utils/intent'

const vaultAddress = await intentVaultAddress(
  '0xIntentSource...',
  intent
)
console.log('Vault will be deployed at:', vaultAddress)

async function encodeTransfer(
  to: string,
  value: number
): Promise<string>

import { encodeTransfer } from './utils/encode'

const calldata = await encodeTransfer(
  '0xRecipient...',
  1000000
)

async function encodeTransferNative(
  to: string,
  value: number
): Promise<string>

async function encodeTransferPayable(
  to: string,
  value: number
): Promise<string>

async function encodeIdentifier(
  counter: number,
  chainid: NumberLike
): Promise<string>

import { encodeIdentifier } from './utils/encode'

const identifier = await encodeIdentifier(1, 1) // Ethereum mainnet

static addressToBytes32(address: string): string

import { TypeCasts } from './utils/typeCasts'

const bytes32 = TypeCasts.addressToBytes32('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb')
// Returns: '0x000000000000000000000000742d35cc6634c0532925a3b844bc9e7595f0beb'

static bytes32ToAddress(bytes32: string): string

import { TypeCasts } from './utils/typeCasts'

const address = TypeCasts.bytes32ToAddress(
  '0x000000000000000000000000742d35cc6634c0532925a3b844bc9e7595f0beb'
)
// Returns: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'

static addressesToBytes32Array(addresses: string[]): string[]

static bytes32ArrayToAddresses(bytes32Array: string[]): string[]

import {
  addressToBytes32,
  bytes32ToAddress,
  addressesToBytes32Array,
  bytes32ArrayToAddresses
} from './utils/typeCasts'

// Use directly without class prefix
const bytes = addressToBytes32('0x...')
const addr = bytes32ToAddress('0x...')

type Output = {
  token: string       // Token address as bytes32
  amount: bigint      // Token amount
  recipient: string   // Recipient address as bytes32
  chainId: number     // Destination chain ID
}

type OnchainCrosschainOrderData = {
  destination: number
  route: Route
  creator: string
  prover: string
  nativeAmount: bigint
  rewardTokens: TokenAmount[]
  routePortal: string      // bytes32
  routeDeadline: number
  maxSpent: Output[]
}

type GaslessCrosschainOrderData = {
  destination: number
  portal: string
  routeTokens: TokenAmount[]
  calls: Call[]
  prover: string
  nativeAmount: bigint
  rewardTokens: TokenAmount[]
  routePortal: string      // bytes32
  routeDeadline: number
  maxSpent: Output[]
}

async function encodeOnchainCrosschainOrderData(
  onchainCrosschainOrderData: OnchainCrosschainOrderData
): Promise<string>

async function encodeGaslessCrosschainOrderData(
  gaslessCrosschainOrderData: GaslessCrosschainOrderData
): Promise<string>

async function encodeOnchainCrosschainOrder(
  onchainCrosschainOrder: OnchainCrosschainOrder
): Promise<string>

import { encodeOnchainCrosschainOrderData } from './utils/EcoERC7683'

const orderData = {
  destination: 1,
  route: { /* route */ },
  creator: '0xCreator...',
  prover: '0xProver...',
  nativeAmount: 1000000000000000000n,
  rewardTokens: [],
  routePortal: '0x...',
  routeDeadline: 1700000000,
  maxSpent: [
    {
      token: '0x...',
      amount: 1000000n,
      recipient: '0x...',
      chainId: 1
    }
  ]
}

const encoded = await encodeOnchainCrosschainOrderData(orderData)