@sip-protocol/sdk 0.3.2 → 0.5.0

package/src/wallet/sui/mock.ts

@@ -0,0 +1,439 @@
+/**
+ * Mock Sui Wallet Adapter
+ *
+ * Testing implementation of Sui wallet adapter.
+ * Provides full mock functionality without requiring browser environment.
+ */
+
+import type {
+  HexString,
+  Asset,
+  Signature,
+  UnsignedTransaction,
+  SignedTransaction,
+  TransactionReceipt,
+} from '@sip-protocol/types'
+import { WalletErrorCode } from '@sip-protocol/types'
+import { BaseWalletAdapter } from '../base-adapter'
+import { WalletError } from '../errors'
+import type {
+  SuiWalletProvider,
+  SuiAccountInfo,
+  SuiTransactionBlock,
+  SuiSignMessageInput,
+  SuiSignMessageResponse,
+  SignedSuiTransaction,
+} from './types'
+import { suiPublicKeyToHex, getDefaultSuiRpcEndpoint } from './types'
+
+/**
+ * Configuration for mock Sui adapter
+ */
+export interface MockSuiAdapterConfig {
+  /** Mock address (0x-prefixed hex) */
+  address?: string
+  /** Mock public key (0x-prefixed hex) */
+  publicKey?: string
+  /** Mock balance in MIST */
+  balance?: bigint
+  /** Token balances by coin type */
+  tokenBalances?: Record<string, bigint>
+  /** Whether to simulate connection failure */
+  shouldFailConnect?: boolean
+  /** Whether to simulate signing failure */
+  shouldFailSign?: boolean
+  /** Whether to simulate transaction failure */
+  shouldFailTransaction?: boolean
+  /** Simulated network */
+  network?: string
+  /** Simulated latency in ms */
+  latency?: number
+}
+
+/**
+ * Mock Sui wallet adapter for testing
+ *
+ * Provides full Sui wallet functionality with mock data.
+ * No browser environment or actual wallet required.
+ *
+ * @example
+ * ```typescript
+ * const wallet = new MockSuiAdapter({
+ *   address: '0x1234...abcd',
+ *   balance: 1_000_000_000n, // 1 SUI
+ * })
+ *
+ * await wallet.connect()
+ * const balance = await wallet.getBalance() // 1_000_000_000n
+ *
+ * // Simulate failures
+ * const failingWallet = new MockSuiAdapter({
+ *   shouldFailSign: true,
+ * })
+ * ```
+ */
+export class MockSuiAdapter extends BaseWalletAdapter {
+  readonly chain = 'sui' as const
+  readonly name = 'mock-sui'
+
+  private mockAddress: HexString
+  private mockPublicKey: HexString
+  private mockBalance: bigint
+  private mockTokenBalances: Map<string, bigint>
+  private shouldFailConnect: boolean
+  private shouldFailSign: boolean
+  private shouldFailTransaction: boolean
+  private network: string
+  private latency: number
+  private accounts: SuiAccountInfo[]
+
+  // Track signed transactions for verification
+  private signedTransactions: SuiTransactionBlock[] = []
+  private sentTransactions: string[] = []
+
+  constructor(config: MockSuiAdapterConfig = {}) {
+    super()
+    this.mockAddress = (config.address ?? '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef') as HexString
+    this.mockPublicKey = (config.publicKey ?? '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd') as HexString
+    this.mockBalance = config.balance ?? 1_000_000_000n // 1 SUI default
+    this.mockTokenBalances = new Map(Object.entries(config.tokenBalances ?? {}))
+    this.shouldFailConnect = config.shouldFailConnect ?? false
+    this.shouldFailSign = config.shouldFailSign ?? false
+    this.shouldFailTransaction = config.shouldFailTransaction ?? false
+    this.network = config.network ?? 'mainnet'
+    this.latency = config.latency ?? 10
+
+    this.accounts = [
+      {
+        address: this.mockAddress,
+        publicKey: this.mockPublicKey,
+      },
+    ]
+  }
+
+  /**
+   * Get the current Sui network
+   */
+  getNetwork(): string {
+    return this.network
+  }
+
+  /**
+   * Get RPC endpoint
+   */
+  getRpcEndpoint(): string {
+    return getDefaultSuiRpcEndpoint(this.network)
+  }
+
+  /**
+   * Get all connected accounts
+   */
+  getAccounts(): SuiAccountInfo[] {
+    return [...this.accounts]
+  }
+
+  /**
+   * Connect to the mock wallet
+   */
+  async connect(): Promise<void> {
+    this._connectionState = 'connecting'
+
+    // Simulate network latency
+    await this.simulateLatency()
+
+    if (this.shouldFailConnect) {
+      this.setError(WalletErrorCode.CONNECTION_FAILED, 'Mock connection failure')
+      throw new WalletError('Mock connection failure', WalletErrorCode.CONNECTION_FAILED)
+    }
+
+    this.setConnected(this.mockAddress, this.mockPublicKey)
+  }
+
+  /**
+   * Disconnect from the mock wallet
+   */
+  async disconnect(): Promise<void> {
+    await this.simulateLatency()
+    this.setDisconnected('User disconnected')
+  }
+
+  /**
+   * Sign a message
+   */
+  async signMessage(message: Uint8Array): Promise<Signature> {
+    this.requireConnected()
+    await this.simulateLatency()
+
+    if (this.shouldFailSign) {
+      throw new WalletError('Mock signing failure', WalletErrorCode.SIGNING_REJECTED)
+    }
+
+    // Create deterministic mock signature (64 bytes)
+    const mockSig = new Uint8Array(64)
+    for (let i = 0; i < 64; i++) {
+      mockSig[i] = (message[i % message.length] ?? 0) ^ (i * 7) ^ this.mockAddress.charCodeAt(i % this.mockAddress.length)
+    }
+
+    return {
+      signature: ('0x' + Buffer.from(mockSig).toString('hex')) as HexString,
+      publicKey: this._publicKey as HexString,
+    }
+  }
+
+  /**
+   * Sign a transaction
+   */
+  async signTransaction(tx: UnsignedTransaction): Promise<SignedTransaction> {
+    this.requireConnected()
+    await this.simulateLatency()
+
+    if (this.shouldFailSign) {
+      throw new WalletError('Mock signing failure', WalletErrorCode.SIGNING_REJECTED)
+    }
+
+    const suiTx = tx.data as SuiTransactionBlock
+    this.signedTransactions.push(suiTx)
+
+    // Create mock signed bytes
+    const txDataStr = JSON.stringify(tx.data)
+    const signature = await this.signMessage(new TextEncoder().encode(txDataStr))
+
+    return {
+      unsigned: tx,
+      signatures: [signature],
+      serialized: signature.signature,
+    }
+  }
+
+  /**
+   * Sign and send a transaction
+   */
+  async signAndSendTransaction(tx: UnsignedTransaction): Promise<TransactionReceipt> {
+    this.requireConnected()
+    await this.simulateLatency()
+
+    if (this.shouldFailSign) {
+      throw new WalletError('Mock signing failure', WalletErrorCode.SIGNING_REJECTED)
+    }
+
+    if (this.shouldFailTransaction) {
+      throw new WalletError('Mock transaction failure', WalletErrorCode.TRANSACTION_FAILED)
+    }
+
+    // Generate mock transaction hash (digest)
+    const txHash = `0x${Date.now().toString(16)}${Math.random().toString(16).slice(2)}`
+    this.sentTransactions.push(txHash)
+
+    return {
+      txHash: txHash as HexString,
+      status: 'confirmed',
+      blockNumber: BigInt(Math.floor(Math.random() * 1000000)),
+      timestamp: Date.now(),
+    }
+  }
+
+  /**
+   * Get native SUI balance
+   */
+  async getBalance(): Promise<bigint> {
+    this.requireConnected()
+    await this.simulateLatency()
+    return this.mockBalance
+  }
+
+  /**
+   * Get token balance
+   */
+  async getTokenBalance(asset: Asset): Promise<bigint> {
+    this.requireConnected()
+    await this.simulateLatency()
+
+    if (asset.chain !== 'sui') {
+      throw new WalletError(
+        `Asset chain ${asset.chain} not supported by Sui adapter`,
+        WalletErrorCode.UNSUPPORTED_CHAIN
+      )
+    }
+
+    // Native SUI
+    if (!asset.address || asset.address === '0x2::sui::SUI') {
+      return this.mockBalance
+    }
+
+    const coinType = asset.address
+    return this.mockTokenBalances.get(coinType) ?? 0n
+  }
+
+  // ── Mock Control Methods ──────────────────────────────────────────────────
+
+  /**
+   * Set mock balance
+   */
+  setMockBalance(balance: bigint): void {
+    this.mockBalance = balance
+  }
+
+  /**
+   * Set mock token balance
+   */
+  setMockTokenBalance(coinType: string, balance: bigint): void {
+    this.mockTokenBalances.set(coinType, balance)
+  }
+
+  /**
+   * Get all signed transactions (for verification)
+   */
+  getSignedTransactions(): SuiTransactionBlock[] {
+    return [...this.signedTransactions]
+  }
+
+  /**
+   * Get all sent transaction hashes (for verification)
+   */
+  getSentTransactions(): string[] {
+    return [...this.sentTransactions]
+  }
+
+  /**
+   * Clear transaction history
+   */
+  clearTransactionHistory(): void {
+    this.signedTransactions = []
+    this.sentTransactions = []
+  }
+
+  /**
+   * Simulate an account change event
+   */
+  simulateAccountChange(newAddress: HexString, newPublicKey?: HexString): void {
+    const previousAddress = this._address
+    this.mockAddress = newAddress
+    this._address = newAddress as string
+
+    if (newPublicKey) {
+      this.mockPublicKey = newPublicKey
+      this._publicKey = newPublicKey
+    }
+
+    this.accounts = [
+      {
+        address: newAddress,
+        publicKey: this.mockPublicKey,
+      },
+    ]
+
+    this.emitAccountChanged(previousAddress, newAddress)
+  }
+
+  /**
+   * Simulate a disconnect event
+   */
+  simulateDisconnect(): void {
+    this.setDisconnected('Simulated disconnect')
+  }
+
+  private async simulateLatency(): Promise<void> {
+    if (this.latency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.latency))
+    }
+  }
+}
+
+/**
+ * Create a mock Sui wallet provider for testing real adapter
+ */
+export function createMockSuiProvider(
+  config: MockSuiAdapterConfig = {}
+): SuiWalletProvider {
+  const address = config.address ?? '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+  const publicKey = config.publicKey ?? '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd'
+
+  const account: SuiAccountInfo = {
+    address,
+    publicKey,
+  }
+
+  return {
+    async hasPermissions(): Promise<boolean> {
+      return !config.shouldFailConnect
+    },
+
+    async requestPermissions(): Promise<boolean> {
+      if (config.shouldFailConnect) {
+        throw new Error('User rejected the request')
+      }
+      return true
+    },
+
+    async getAccounts(): Promise<SuiAccountInfo[]> {
+      if (config.shouldFailConnect) {
+        throw new Error('User rejected the request')
+      }
+      return [account]
+    },
+
+    async signTransactionBlock(input: {
+      transactionBlock: SuiTransactionBlock | any
+      account?: SuiAccountInfo
+      chain?: string
+    }): Promise<SignedSuiTransaction> {
+      if (config.shouldFailSign) {
+        throw new Error('User rejected the request')
+      }
+
+      // Return mock signed transaction
+      const mockSig = new Uint8Array(64)
+      for (let i = 0; i < 64; i++) {
+        mockSig[i] = i
+      }
+
+      return {
+        signature: Buffer.from(mockSig).toString('base64'),
+        transactionBlockBytes: Buffer.from(new Uint8Array(128).fill(1)).toString('base64'),
+      }
+    },
+
+    async signAndExecuteTransactionBlock(input: {
+      transactionBlock: SuiTransactionBlock | any
+      account?: SuiAccountInfo
+      chain?: string
+      options?: any
+    }): Promise<{ digest: string }> {
+      if (config.shouldFailSign) {
+        throw new Error('User rejected the request')
+      }
+
+      if (config.shouldFailTransaction) {
+        throw new Error('Transaction failed')
+      }
+
+      const digest = `${Date.now().toString(16)}${Math.random().toString(16).slice(2)}`
+      return { digest }
+    },
+
+    async signMessage(input: SuiSignMessageInput): Promise<SuiSignMessageResponse> {
+      if (config.shouldFailSign) {
+        throw new Error('User rejected the request')
+      }
+
+      const mockSig = new Uint8Array(64)
+      for (let i = 0; i < 64; i++) {
+        mockSig[i] = (input.message[i % input.message.length] ?? 0) ^ i
+      }
+
+      return {
+        signature: Buffer.from(mockSig).toString('base64'),
+        messageBytes: Buffer.from(input.message).toString('base64'),
+      }
+    },
+  }
+}
+
+/**
+ * Create a mock Sui adapter
+ */
+export function createMockSuiAdapter(
+  config: MockSuiAdapterConfig = {}
+): MockSuiAdapter {
+  return new MockSuiAdapter(config)
+}

package/src/wallet/sui/types.ts

@@ -0,0 +1,245 @@
+/**
+ * Sui Wallet Types
+ *
+ * Type definitions for Sui wallet adapters.
+ * Supports Sui Wallet, Ethos, Suiet, and other Sui wallets.
+ */
+
+import type { HexString } from '@sip-protocol/types'
+
+/**
+ * Supported Sui wallet names
+ */
+export type SuiWalletName = 'sui-wallet' | 'ethos' | 'suiet' | 'generic'
+
+/**
+ * Sui account information
+ */
+export interface SuiAccountInfo {
+  /** Account address (0x-prefixed hex, 64 characters) */
+  address: string
+  /** Public key (0x-prefixed hex) */
+  publicKey: string
+}
+
+/**
+ * Sui transaction block
+ */
+export interface SuiTransactionBlock {
+  /** Transaction kind */
+  kind: 'moveCall' | 'transferObjects' | 'splitCoins' | 'mergeCoins' | 'publish'
+  /** Transaction data */
+  data: any
+  /** Sender address */
+  sender?: string
+  /** Gas budget */
+  gasBudget?: string
+  /** Gas price */
+  gasPrice?: string
+}
+
+/**
+ * Signed Sui transaction
+ */
+export interface SignedSuiTransaction {
+  /** Transaction signature */
+  signature: string
+  /** Signed transaction bytes */
+  transactionBlockBytes: string
+}
+
+/**
+ * Sui sign message input
+ */
+export interface SuiSignMessageInput {
+  /** Message bytes to sign */
+  message: Uint8Array
+  /** Account to sign with */
+  account?: SuiAccountInfo
+}
+
+/**
+ * Sui sign message response
+ */
+export interface SuiSignMessageResponse {
+  /** Signature (base64 or hex) */
+  signature: string
+  /** Message bytes (base64) */
+  messageBytes: string
+}
+
+/**
+ * Sui Wallet API interface
+ *
+ * @see https://docs.sui.io/standards/wallet-standard
+ */
+export interface SuiWalletAPI {
+  /**
+   * Check if wallet has permissions
+   */
+  hasPermissions(permissions?: string[]): Promise<boolean>
+
+  /**
+   * Request wallet permissions
+   */
+  requestPermissions(permissions?: string[]): Promise<boolean>
+
+  /**
+   * Get connected accounts
+   */
+  getAccounts(): Promise<SuiAccountInfo[]>
+
+  /**
+   * Sign a transaction block
+   */
+  signTransactionBlock(input: {
+    transactionBlock: SuiTransactionBlock | any
+    account?: SuiAccountInfo
+    chain?: string
+  }): Promise<SignedSuiTransaction>
+
+  /**
+   * Sign and execute a transaction block
+   */
+  signAndExecuteTransactionBlock(input: {
+    transactionBlock: SuiTransactionBlock | any
+    account?: SuiAccountInfo
+    chain?: string
+    options?: {
+      showEffects?: boolean
+      showEvents?: boolean
+      showObjectChanges?: boolean
+      showBalanceChanges?: boolean
+    }
+  }): Promise<{
+    digest: string
+    effects?: any
+    events?: any[]
+    objectChanges?: any[]
+    balanceChanges?: any[]
+  }>
+
+  /**
+   * Sign a message
+   */
+  signMessage(input: SuiSignMessageInput): Promise<SuiSignMessageResponse>
+
+  /**
+   * Event listeners
+   */
+  on?: (event: string, handler: (...args: any[]) => void) => void
+  off?: (event: string, handler: (...args: any[]) => void) => void
+}
+
+/**
+ * Ethos wallet API interface
+ */
+export interface EthosAPI extends SuiWalletAPI {
+  // Ethos-specific methods can be added here
+}
+
+/**
+ * Generic Sui wallet provider interface
+ */
+export interface SuiWalletProvider {
+  hasPermissions(permissions?: string[]): Promise<boolean>
+  requestPermissions(permissions?: string[]): Promise<boolean>
+  getAccounts(): Promise<SuiAccountInfo[]>
+  signTransactionBlock(input: {
+    transactionBlock: SuiTransactionBlock | any
+    account?: SuiAccountInfo
+    chain?: string
+  }): Promise<SignedSuiTransaction>
+  signAndExecuteTransactionBlock(input: {
+    transactionBlock: SuiTransactionBlock | any
+    account?: SuiAccountInfo
+    chain?: string
+    options?: any
+  }): Promise<{ digest: string; [key: string]: any }>
+  signMessage(input: SuiSignMessageInput): Promise<SuiSignMessageResponse>
+
+  // Event handling
+  on?: (event: string, handler: (...args: any[]) => void) => void
+  off?: (event: string, handler: (...args: any[]) => void) => void
+}
+
+/**
+ * Window interface for Sui wallets
+ */
+declare global {
+  interface Window {
+    suiWallet?: SuiWalletAPI
+    ethos?: EthosAPI
+    suiet?: SuiWalletProvider
+    sui?: SuiWalletProvider
+  }
+}
+
+/**
+ * Sui wallet adapter configuration
+ */
+export interface SuiAdapterConfig {
+  /** Wallet name (default: 'sui-wallet') */
+  wallet?: SuiWalletName
+  /** Custom provider (for testing) */
+  provider?: SuiWalletProvider
+  /** Network name (default: 'mainnet') */
+  network?: string
+  /** RPC endpoint (optional) */
+  rpcEndpoint?: string
+}
+
+/**
+ * Get Sui wallet provider from window
+ */
+export function getSuiProvider(walletName: SuiWalletName): SuiWalletProvider | undefined {
+  if (typeof window === 'undefined') return undefined
+
+  switch (walletName) {
+    case 'sui-wallet':
+      return window.suiWallet as SuiWalletProvider | undefined
+    case 'ethos':
+      return window.ethos as SuiWalletProvider | undefined
+    case 'suiet':
+      return window.suiet
+    case 'generic':
+      return window.sui
+    default:
+      return undefined
+  }
+}
+
+/**
+ * Convert Sui public key to hex format
+ *
+ * Ensures proper 0x prefix and formatting
+ */
+export function suiPublicKeyToHex(publicKey: string | Uint8Array): HexString {
+  if (typeof publicKey === 'string') {
+    // Already a string, ensure 0x prefix
+    return (publicKey.startsWith('0x') ? publicKey : `0x${publicKey}`) as HexString
+  }
+
+  // Convert Uint8Array to hex
+  const hex = Array.from(publicKey)
+    .map(b => b.toString(16).padStart(2, '0'))
+    .join('')
+  return `0x${hex}` as HexString
+}
+
+/**
+ * Default RPC endpoints for Sui networks
+ */
+export const DEFAULT_SUI_RPC_ENDPOINTS: Record<string, string> = {
+  mainnet: 'https://fullnode.mainnet.sui.io:443',
+  testnet: 'https://fullnode.testnet.sui.io:443',
+  devnet: 'https://fullnode.devnet.sui.io:443',
+  localnet: 'http://localhost:9000',
+}
+
+/**
+ * Get default RPC endpoint for network
+ */
+export function getDefaultSuiRpcEndpoint(network: string): string {
+  return DEFAULT_SUI_RPC_ENDPOINTS[network.toLowerCase()] ?? DEFAULT_SUI_RPC_ENDPOINTS.mainnet
+}