fakenet-signer/dist/index.d.ts

Multi-chain signature orchestrator for Solana - listens for signature requests, executes transactions on target chains (Ethereum, etc.), and returns results

import * as anchor from "@coral-xyz/anchor";
import { Connection, PublicKey } from "@solana/web3.js";
import { z } from "zod";

//#region types/index.d.ts
interface ServerConfig {
  solanaRpcUrl: string;
  solanaPrivateKey: string;
  mpcRootKey: string;
  infuraApiKey: string;
  programId: string;
  isDevnet: boolean;
  signatureDeposit?: string;
  chainId?: string;
  verbose?: boolean;
}
declare const serverConfigSchema: z.ZodObject<{
  solanaRpcUrl: z.ZodString;
  solanaPrivateKey: z.ZodString;
  mpcRootKey: z.ZodString;
  infuraApiKey: z.ZodString;
  programId: z.ZodString;
  isDevnet: z.ZodBoolean;
  signatureDeposit: z.ZodOptional<z.ZodString>;
  chainId: z.ZodOptional<z.ZodString>;
  verbose: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
interface SignBidirectionalEvent {
  sender: PublicKey;
  serializedTransaction: Buffer;
  caip2Id: string;
  keyVersion: number;
  deposit: bigint;
  path: string;
  algo: string;
  dest: string;
  params: string;
  outputDeserializationSchema: Buffer;
  respondSerializationSchema: Buffer;
}
interface SignatureRequestedEvent {
  sender: PublicKey;
  payload: number[];
  keyVersion: number;
  deposit: bigint;
  chainId: string;
  path: string;
  algo: string;
  dest: string;
  params: string;
  feePayer: PublicKey | null;
}
interface PendingTransaction {
  txHash: string;
  requestId: string;
  caip2Id: string;
  explorerDeserializationSchema: Buffer | number[];
  callbackSerializationSchema: Buffer | number[];
  sender: string;
  path: string;
  fromAddress: string;
  nonce: number;
  checkCount: number;
}
interface TransactionOutput {
  success: boolean;
  output: Record<string, unknown>;
}
type TransactionStatus = {
  status: 'pending';
} | {
  status: 'success';
  success: boolean;
  output: Record<string, unknown>;
} | {
  status: 'error';
  reason: string;
} | {
  status: 'fatal_error';
  reason: string;
};
interface SignatureResponse {
  bigR: {
    x: number[];
    y: number[];
  };
  s: number[];
  recoveryId: number;
}
interface ProcessedTransaction {
  unsignedTxHash: string;
  signedTxHash: string;
  signature: SignatureResponse;
  signedTransaction: string;
  fromAddress: string;
  nonce: number;
}
//#endregion
//#region sig-server.d.ts
declare class ChainSignatureServer {
  private connection;
  private wallet;
  private provider;
  private program;
  private pollCounter;
  private cpiSubscriptionId;
  private config;
  private logger;
  private monitorIntervalId;
  constructor(config: ServerConfig);
  start(): Promise<void>;
  private ensureInitialized;
  private startTransactionMonitor;
  private handleCompletedTransaction;
  private handleFailedTransaction;
  private setupEventListeners;
  private handleSignBidirectional;
  private handleSignatureRequest;
  shutdown(): Promise<void>;
}
//#endregion
//#region crypto-utils.d.ts
declare class CryptoUtils {
  static deriveEpsilon(requester: string, path: string): bigint;
  static deriveSigningKey(path: string, predecessor: string, basePrivateKey: string): Promise<string>;
  static signMessage(msgHash: number[] | string, privateKeyHex: string): Promise<SignatureResponse>;
  static signBidirectionalResponse(requestId: Uint8Array, serializedOutput: Uint8Array, privateKeyHex: string): Promise<SignatureResponse>;
}
//#endregion
//#region transaction-processor.d.ts
declare class TransactionProcessor {
  private static fundingProvider;
  private static fundingProviderError;
  static processTransactionForSigning(rlpEncodedTx: Uint8Array, privateKey: string, caip2Id: string, config: ServerConfig): Promise<ProcessedTransaction>;
  private static toSolanaSignature;
}
//#endregion
//#region ethereum-monitor.d.ts
declare class EthereumMonitor {
  private static providerCache;
  static waitForTransactionAndGetOutput(txHash: string, caip2Id: string, explorerDeserializationSchema: Buffer | number[], fromAddress: string, nonce: number, config: ServerConfig): Promise<TransactionStatus>;
  private static getProvider;
  private static extractTransactionOutput;
}
//#endregion
//#region cpi-event-parser.d.ts
declare const EMIT_CPI_INSTRUCTION_DISCRIMINATOR: Buffer<ArrayBuffer>;
interface ParsedCpiEvent {
  name: string;
  data: unknown;
}
declare class CpiEventParser {
  /**
   * Parse CPI events from a transaction
   * @param connection Solana connection
   * @param signature Transaction signature
   * @param targetProgramId Program ID to filter events for
   * @param program Anchor program instance
   * @returns Array of parsed events
   */
  static parseCpiEvents(connection: Connection, signature: string, targetProgramId: string, program: anchor.Program): Promise<ParsedCpiEvent[]>;
  /**
   * Parse a single instruction for CPI event data
   * @param instructionData Base58 encoded instruction data
   * @param program Anchor program instance
   * @returns Parsed event or null if not a CPI event
   */
  private static parseInstruction;
  /**
   * Subscribe to CPI events for a program
   * @param connection Solana connection
   * @param program Anchor program instance
   * @param eventHandlers Map of event names to handler functions
   * @returns Subscription ID for cleanup
   */
  static subscribeToCpiEvents(connection: Connection, program: anchor.Program, eventHandlers: Map<string, (event: unknown, slot: number) => Promise<void>>): number;
}
//#endregion
//#region request-id-generator.d.ts
declare class RequestIdGenerator {
  static generateSignRespondRequestId(sender: string, transactionData: number[], caip2Id: string, keyVersion: number, path: string, algo: string, dest: string, params: string): string;
  static generateRequestId(addr: string, payload: number[], path: string, keyVersion: number, chainId: number | string, algo: string, dest: string, params: string): string;
}
//#endregion
//#region output-serializer.d.ts
declare class OutputSerializer {
  static serialize(output: Record<string, unknown>, format: number, schema: Buffer | number[]): Promise<Uint8Array>;
  private static serializeBorsh;
  private static serializeAbi;
  private static getSchemaString;
  private static createBorshData;
  private static createAbiData;
}
//#endregion
//#region chain-utils.d.ts
/**
 * Utilities for chain-specific operations
 */
declare enum SerializationFormat {
  Borsh = 0,
  ABI = 1,
}
/**
 * Extract namespace from CAIP-2 chain ID
 *
 * @param caip2Id - CAIP-2 chain identifier (e.g., "eip155:1", "solana:mainnet")
 * @returns namespace - The chain namespace (e.g., "eip155", "solana")
 *
 * @example
 * getNamespaceFromCaip2("eip155:1") // "eip155"
 * getNamespaceFromCaip2("solana:mainnet") // "solana"
 */
declare function getNamespaceFromCaip2(caip2Id: string): string;
/**
 * Get serialization format from CAIP-2 chain ID
 * Multiple chains can share the same serialization format
 *
 * @param caip2Id - CAIP-2 chain identifier (e.g., "eip155:1", "solana:mainnet")
 * @returns SerializationFormat - Borsh for Solana, ABI for EVM chains
 *
 * @example
 * getSerializationFormat("eip155:1") // SerializationFormat.ABI
 * getSerializationFormat("eip155:11155111") // SerializationFormat.ABI
 * getSerializationFormat("solana:mainnet") // SerializationFormat.Borsh
 */
declare function getSerializationFormat(caip2Id: string): SerializationFormat;
//#endregion
//#region config.d.ts
declare const CONFIG: {
  readonly EPSILON_DERIVATION_PREFIX: "sig.network v1.0.0 epsilon derivation";
  readonly SOLANA_CHAIN_ID: "0x800001f5";
  readonly SECP256K1_P: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F";
  readonly SECP256K1_N: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141";
  readonly POLL_INTERVAL_MS: 5000;
  readonly TX_TIMEOUT_MS: 120000;
};
//#endregion
//#region envConfig.d.ts
declare const envConfig: {
  SOLANA_RPC_URL: string;
  SOLANA_PRIVATE_KEY: string;
  MPC_ROOT_KEY: string;
  INFURA_API_KEY: string;
  PROGRAM_ID: string;
  VERBOSE: boolean;
};
//#endregion
export { CONFIG, ChainSignatureServer, CpiEventParser, CryptoUtils, EMIT_CPI_INSTRUCTION_DISCRIMINATOR, EthereumMonitor, OutputSerializer, PendingTransaction, ProcessedTransaction, RequestIdGenerator, SerializationFormat, ServerConfig, SignBidirectionalEvent, SignatureRequestedEvent, SignatureResponse, TransactionOutput, TransactionProcessor, TransactionStatus, envConfig, getNamespaceFromCaip2, getSerializationFormat, serverConfigSchema };
//# sourceMappingURL=index.d.ts.map