BlockchainProviderConnector

Blockchain provider interface for order signing

Overview

The BlockchainProviderConnector interface defines the contract for blockchain providers that can sign cross-chain orders. Implement this interface to use custom signing solutions.

Interface Definition

interface BlockchainProviderConnector {
  signTypedData(
    walletAddress: string,
    typedData: EIP712TypedData
  ): Promise<string>
}

Methods

signTypedData

Signs EIP-712 typed data for order creation.

async signTypedData(
  walletAddress: string,
  typedData: EIP712TypedData
): Promise<string>

walletAddress · string · required

The wallet address that will sign the data

typedData · EIP712TypedData · required

EIP-712 typed data structure containing:

• domain - EIP-712 domain separator
• types - Type definitions
• primaryType - Primary type name
• message - Data to sign

Returns: Promise resolving to signature hex string

Built-in Implementations

The SDK provides one built-in implementation:

PrivateKeyProviderConnector

Signs using a private key with Web3.js or Ethers.js.

import { PrivateKeyProviderConnector } from '@1inch/cross-chain-sdk'
import Web3 from 'web3'

const connector = new PrivateKeyProviderConnector(
  '0x...', // private key
  new Web3('https://rpc.example.com')
)

See PrivateKeyProviderConnector for details.

Custom Implementation

You can implement custom signing logic by implementing the interface:

WalletConnect Example

import { BlockchainProviderConnector, EIP712TypedData } from '@1inch/cross-chain-sdk'
import { SignClient } from '@walletconnect/sign-client'

class WalletConnectProviderConnector implements BlockchainProviderConnector {
  constructor(private signClient: SignClient, private session: any) {}
  
  async signTypedData(
    walletAddress: string,
    typedData: EIP712TypedData
  ): Promise<string> {
    const signature = await this.signClient.request({
      topic: this.session.topic,
      chainId: `eip155:${typedData.domain.chainId}`,
      request: {
        method: 'eth_signTypedData_v4',
        params: [walletAddress, JSON.stringify(typedData)]
      }
    })
    
    return signature as string
  }
}

// Usage
const signClient = await SignClient.init({ /* ... */ })
const session = await signClient.connect({ /* ... */ })

const connector = new WalletConnectProviderConnector(signClient, session)

const sdk = new SDK({
  url: 'https://api.1inch.com/fusion-plus',
  authKey: 'your-auth-key',
  blockchainProvider: connector
})

Hardware Wallet Example

import { BlockchainProviderConnector, EIP712TypedData } from '@1inch/cross-chain-sdk'
import Ledger from '@ledgerhq/hw-app-eth'
import Transport from '@ledgerhq/hw-transport-webhid'

class LedgerProviderConnector implements BlockchainProviderConnector {
  constructor(private ledger: Ledger) {}
  
  async signTypedData(
    walletAddress: string,
    typedData: EIP712TypedData
  ): Promise<string> {
    const domainSeparatorHex = /* compute domain separator */
    const messageHashHex = /* compute message hash */
    
    const signature = await this.ledger.signEIP712HashedMessage(
      "44'/60'/0'/0/0", // derivation path
      domainSeparatorHex,
      messageHashHex
    )
    
    // Convert signature to hex string
    return '0x' + signature.r + signature.s + signature.v.toString(16)
  }
}

// Usage
const transport = await Transport.create()
const ledger = new Ledger(transport)
const connector = new LedgerProviderConnector(ledger)

const sdk = new SDK({
  url: 'https://api.1inch.com/fusion-plus',
  authKey: 'your-auth-key',
  blockchainProvider: connector
})

MetaMask Example

import { BlockchainProviderConnector, EIP712TypedData } from '@1inch/cross-chain-sdk'

class MetaMaskProviderConnector implements BlockchainProviderConnector {
  constructor(private ethereum: any) {
    if (!ethereum) {
      throw new Error('MetaMask not installed')
    }
  }
  
  async signTypedData(
    walletAddress: string,
    typedData: EIP712TypedData
  ): Promise<string> {
    const signature = await this.ethereum.request({
      method: 'eth_signTypedData_v4',
      params: [walletAddress, JSON.stringify(typedData)]
    })
    
    return signature
  }
}

// Usage (browser only)
const connector = new MetaMaskProviderConnector(window.ethereum)

const sdk = new SDK({
  url: 'https://api.1inch.com/fusion-plus',
  authKey: 'your-auth-key',
  blockchainProvider: connector
})

Safe (Gnosis Safe) Example

import { BlockchainProviderConnector, EIP712TypedData } from '@1inch/cross-chain-sdk'
import Safe, { EthersAdapter } from '@safe-global/protocol-kit'
import { ethers } from 'ethers'

class SafeProviderConnector implements BlockchainProviderConnector {
  constructor(private safe: Safe) {}
  
  async signTypedData(
    walletAddress: string,
    typedData: EIP712TypedData
  ): Promise<string> {
    const signature = await this.safe.signTypedData(typedData)
    return signature.data
  }
}

// Usage
const provider = new ethers.providers.JsonRpcProvider(rpc)
const signer = new ethers.Wallet(ownerKey, provider)
const ethAdapter = new EthersAdapter({ ethers, signerOrProvider: signer })

const safe = await Safe.create({
  ethAdapter,
  safeAddress: '0x...' // Safe address
})

const connector = new SafeProviderConnector(safe)

const sdk = new SDK({
  url: 'https://api.1inch.com/fusion-plus',
  authKey: 'your-auth-key',
  blockchainProvider: connector
})

EIP-712 TypedData Structure

The typedData parameter follows the EIP-712 standard:

interface EIP712TypedData {
  domain: {
    name: string
    version: string
    chainId: number
    verifyingContract: string
  }
  types: {
    [key: string]: Array<{
      name: string
      type: string
    }>
  }
  primaryType: string
  message: {
    [key: string]: any
  }
}

Testing Your Implementation

import { SDK } from '@1inch/cross-chain-sdk'

// Test your custom connector
async function testConnector(connector: BlockchainProviderConnector) {
  const sdk = new SDK({
    url: 'https://api.1inch.com/fusion-plus',
    authKey: 'your-auth-key',
    blockchainProvider: connector
  })
  
  try {
    // Try to create an order
    const quote = await sdk.getQuote({ /* params */ })
    const order = await sdk.createOrder(quote, { /* params */ })
    console.log('✓ Connector working correctly')
    console.log('Order hash:', order.hash)
  } catch (error) {
    console.error('✗ Connector test failed:', error)
  }
}

// Test your implementation
await testConnector(new YourCustomConnector())

Notes

The signTypedData method must return a valid EIP-712 signature as a hex string (with ‘0x’ prefix).

For production use, ensure your implementation handles errors gracefully and validates inputs.

Never expose private keys or signing capabilities to untrusted code. Always validate the data being signed.

Related

• PrivateKeyProviderConnector - Built-in private key connector
• SDK Config - SDK configuration
• createOrder - Order creation (requires signing)