Transaction Signing

/**
 * Sign a transaction with optional resolution for clear signing
 * @param path - BIP32 derivation path for signing key
 * @param rawTxHex - Raw transaction data as hex string
 * @param resolution - Optional transaction resolution for enhanced display
 * @returns Transaction signature components
 */
signTransaction(
  path: string,
  rawTxHex: string,
  resolution?: LedgerEthTransactionResolution | null
): Promise<{
  s: string;
  v: string;
  r: string;
}>;

// Basic transaction signing
const signature = await eth.signTransaction(
  "44'/60'/0'/0/0",
  "f86b808504a817c800825208943535353535353535353535353535353535353535880de0b6b3a7640000801ca0..."
);

console.log(signature.r); // "0x..."
console.log(signature.s); // "0x..."
console.log(signature.v); // "0x1c"

// Signing with pre-computed resolution
const resolution = {
  erc20Tokens: ["0xa0b86a33e6776a9feddac4f0c0bfb3f4a9d7d3e..."],
  nfts: [],
  externalPlugin: [],
  plugin: [],
  domains: []
};

const signature = await eth.signTransaction(
  "44'/60'/0'/0/0", 
  rawTxHex, 
  resolution
);

/**
 * Sign transaction with automatic metadata resolution for clear signing
 * @param path - BIP32 derivation path for signing key
 * @param rawTxHex - Raw transaction data as hex string
 * @param resolutionConfig - Configuration for metadata resolution
 * @param throwOnError - Whether to throw on resolution errors (default: true)
 * @returns Transaction signature components
 */
clearSignTransaction(
  path: string,
  rawTxHex: string,
  resolutionConfig: ResolutionConfig,
  throwOnError?: boolean
): Promise<{
  r: string;
  s: string;
  v: string;
}>;

// Clear signing with automatic ERC20 and NFT resolution
const signature = await eth.clearSignTransaction(
  "44'/60'/0'/0/0",
  rawTxHex,
  {
    erc20: true,
    nft: true,
    externalPlugins: true,
    uniswapV3: true
  }
);

// Clear signing with domain resolution
const signature = await eth.clearSignTransaction(
  "44'/60'/0'/0/0",
  rawTxHex,
  {
    erc20: true,
    domains: [
      {
        registry: "ens",
        domain: "example.eth",
        address: "0x..."
      }
    ]
  }
);

// Clear signing with error handling
try {
  const signature = await eth.clearSignTransaction(
    "44'/60'/0'/0/0",
    rawTxHex,
    { erc20: true, nft: true },
    true // Throw on resolution errors
  );
} catch (error) {
  if (error instanceof EthAppPleaseEnableContractData) {
    console.log("Please enable Contract Data in Ethereum app settings");
  }
}

/**
 * Provide ERC20 token information to the device
 * @param data - ERC20 token metadata as hex string
 * @returns Success status
 */
provideERC20TokenInformation(data: string): Promise<boolean>;

/**
 * Set external plugin data for contract interaction
 * @param payload - Plugin data payload
 * @param signature - Optional plugin signature for verification
 * @returns Success status
 */
setExternalPlugin(payload: string, signature?: string): Promise<boolean>;

/**
 * Set plugin data for contract interaction
 * @param data - Plugin data as hex string
 * @returns Success status
 */
setPlugin(data: string): Promise<boolean>;

/**
 * Provide NFT collection information to the device
 * @param data - NFT metadata as hex string
 * @returns Success status
 */
provideNFTInformation(data: string): Promise<boolean>;

/**
 * Provide domain name information for resolution
 * @param data - Domain data as hex string
 * @returns Success status
 */
provideDomainName(data: string): Promise<boolean>;

// Provide ERC20 token information
const tokenData = "0x1234..."; // Token metadata hex
await eth.provideERC20TokenInformation(tokenData);

// Set external plugin with signature
const pluginPayload = "0xabcd...";
const pluginSignature = "0x5678...";
await eth.setExternalPlugin(pluginPayload, pluginSignature);

// Provide NFT information
const nftData = "0xef01...";
await eth.provideNFTInformation(nftData);

// Provide domain name
const domainData = "0x2345...";
await eth.provideDomainName(domainData);

interface LedgerEthTransactionResolution {
  /** Array of ERC20 token addresses requiring resolution */
  erc20Tokens: Array<string>;
  /** Array of NFT contract addresses requiring resolution */
  nfts: Array<string>;
  /** Array of external plugin configurations */
  externalPlugin: Array<{
    payload: string;
    signature: string;
  }>;
  /** Array of plugin data */
  plugin: Array<string>;
  /** Array of domain descriptors for resolution */
  domains: DomainDescriptor[];
}

interface ResolutionConfig {
  /** Enable NFT metadata resolution */
  nft?: boolean;
  /** Enable external plugin resolution */  
  externalPlugins?: boolean;
  /** Enable ERC20 token resolution */
  erc20?: boolean;
  /** Domain descriptors for domain resolution */
  domains?: DomainDescriptor[];
  /** Enable Uniswap V3 transaction resolution */
  uniswapV3?: boolean;
}

interface DomainDescriptor {
  /** Domain registry type (e.g., "ens") */
  registry: string;
  /** Domain name (e.g., "example.eth") */
  domain: string;
  /** Resolved address */
  address: string;
}

class EthAppPleaseEnableContractData extends Error {
  /** Error thrown when contract data needs to be enabled in app settings */
  constructor(message: string);
}

class EthAppNftNotSupported extends Error {
  /** Error thrown when NFT operations are not supported by the app version */
  constructor(message: string);
}

try {
  const signature = await eth.signTransaction(path, rawTxHex);
} catch (error) {
  if (error instanceof EthAppPleaseEnableContractData) {
    // User needs to enable "Contract data" or "Blind signing" in Ethereum app
    console.log("Please enable Contract Data in the Ethereum app settings");
  } else if (error instanceof EthAppNftNotSupported) {
    // NFT operations not supported by current app version
    console.log("NFT operations not supported. Please update your Ethereum app");
  } else {
    // Other signing errors (insufficient funds, invalid transaction, etc.)
    console.log("Transaction signing failed:", error.message);
  }
}