perps-sdk-ts 1.0.1

package/dist/rpc/trading_operations.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingOperationsRPC = void 0;
+const types_1 = require("../types");
+/**
+ * Trading Operations RPC
+ * Handles all trading contract interactions including opening/closing trades,
+ * updating margins, and managing limit orders.
+ */
+class TradingOperationsRPC {
+    constructor(tradingContract, tradingStorageContract, signer) {
+        this.tradingContract = tradingContract;
+        this.tradingStorageContract = tradingStorageContract;
+        this.signer = signer;
+    }
+    /**
+     * Get execution fee required for trading operations
+     * @returns Execution fee in ETH
+     */
+    async getExecutionFee() {
+        const fee = await this.tradingContract.getExecutionFee();
+        return (0, types_1.fromBlockchain18)(fee);
+    }
+    /**
+     * Open a new trade position
+     * @param trade - Trade parameters
+     * @param orderType - Order type (MARKET, LIMIT, etc.)
+     * @param slippageP - Slippage percentage (e.g., 1 for 1%)
+     * @param executionFeeEth - Execution fee in ETH (optional, will fetch if not provided)
+     * @returns Transaction receipt
+     */
+    async openTrade(trade, orderType, slippageP, executionFeeEth) {
+        if (!this.signer) {
+            throw new Error('Signer required for trading operations');
+        }
+        // Get execution fee if not provided
+        if (!executionFeeEth) {
+            executionFeeEth = await this.getExecutionFee();
+        }
+        // Convert order type to number
+        const orderTypeMap = {
+            [types_1.TradeInputOrderType.MARKET]: 0,
+            [types_1.TradeInputOrderType.STOP_LIMIT]: 1,
+            [types_1.TradeInputOrderType.LIMIT]: 2,
+            [types_1.TradeInputOrderType.MARKET_ZERO_FEE]: 3,
+        };
+        // Prepare trade struct with blockchain values
+        const tradeStruct = {
+            trader: trade.trader,
+            pairIndex: trade.pairIndex,
+            index: trade.index,
+            initialPosToken: (0, types_1.toBlockchain6)(trade.initialPosToken),
+            positionSizeUSDC: (0, types_1.toBlockchain6)(trade.positionSizeUSDC),
+            openPrice: (0, types_1.toBlockchain10)(trade.openPrice),
+            buy: trade.buy,
+            leverage: (0, types_1.toBlockchain10)(trade.leverage),
+            tp: (0, types_1.toBlockchain10)(trade.tp),
+            sl: (0, types_1.toBlockchain10)(trade.sl),
+            timestamp: Math.floor(Date.now() / 1000),
+        };
+        const slippageBlockchain = (0, types_1.toBlockchain10)(slippageP);
+        const executionFeeWei = (0, types_1.toBlockchain18)(executionFeeEth);
+        // Create transaction
+        const tx = {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('openTrade', [
+                tradeStruct,
+                orderTypeMap[orderType],
+                slippageBlockchain,
+            ]),
+            value: executionFeeWei,
+        };
+        return await this.signAndSend(tx);
+    }
+    /**
+     * Close a trade position at market price
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @param closeAmount - Amount of collateral to close (USDC)
+     * @param executionFeeEth - Execution fee in ETH (optional)
+     * @returns Transaction receipt
+     */
+    async closeTradeMarket(pairIndex, index, closeAmount, executionFeeEth) {
+        if (!this.signer) {
+            throw new Error('Signer required for trading operations');
+        }
+        if (!executionFeeEth) {
+            executionFeeEth = await this.getExecutionFee();
+        }
+        const closeAmountBlockchain = (0, types_1.toBlockchain6)(closeAmount);
+        const executionFeeWei = (0, types_1.toBlockchain18)(executionFeeEth);
+        const tx = {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('closeTradeMarket', [
+                pairIndex,
+                index,
+                closeAmountBlockchain,
+            ]),
+            value: executionFeeWei,
+        };
+        return await this.signAndSend(tx);
+    }
+    /**
+     * Update margin for an existing trade
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @param updateType - DEPOSIT or WITHDRAW
+     * @param amount - Amount to add/remove (USDC)
+     * @param priceUpdateData - Price oracle update data
+     * @returns Transaction receipt
+     */
+    async updateMargin(pairIndex, index, updateType, amount, priceUpdateData = []) {
+        if (!this.signer) {
+            throw new Error('Signer required for trading operations');
+        }
+        const amountBlockchain = (0, types_1.toBlockchain6)(amount);
+        const tx = {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('updateMargin', [
+                pairIndex,
+                index,
+                updateType,
+                amountBlockchain,
+                priceUpdateData,
+            ]),
+            value: 1n, // 1 wei for price update
+        };
+        return await this.signAndSend(tx);
+    }
+    /**
+     * Update take profit and stop loss for a trade
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @param newSl - New stop loss price
+     * @param newTp - New take profit price
+     * @param priceUpdateData - Price oracle update data
+     * @returns Transaction receipt
+     */
+    async updateTpAndSl(pairIndex, index, newSl, newTp, priceUpdateData = []) {
+        if (!this.signer) {
+            throw new Error('Signer required for trading operations');
+        }
+        const slBlockchain = (0, types_1.toBlockchain10)(newSl);
+        const tpBlockchain = (0, types_1.toBlockchain10)(newTp);
+        const tx = {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('updateTpAndSl', [
+                pairIndex,
+                index,
+                slBlockchain,
+                tpBlockchain,
+                priceUpdateData,
+            ]),
+            value: 1n, // 1 wei for price update
+        };
+        return await this.signAndSend(tx);
+    }
+    /**
+     * Cancel a pending limit order
+     * @param pairIndex - Trading pair index
+     * @param index - Order index
+     * @returns Transaction receipt
+     */
+    async cancelOpenLimitOrder(pairIndex, index) {
+        if (!this.signer) {
+            throw new Error('Signer required for trading operations');
+        }
+        const tx = {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('cancelOpenLimitOrder', [
+                pairIndex,
+                index,
+            ]),
+        };
+        return await this.signAndSend(tx);
+    }
+    /**
+     * Get open trade information
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @returns Trade information
+     */
+    async getOpenTrade(trader, pairIndex, index) {
+        const result = await this.tradingStorageContract.openTrades(trader, pairIndex, index);
+        return {
+            trader: result.trader,
+            pairIndex: Number(result.pairIndex),
+            index: Number(result.index),
+            initialPosToken: (0, types_1.fromBlockchain6)(result.initialPosToken),
+            positionSizeUSDC: (0, types_1.fromBlockchain6)(result.positionSizeUSDC),
+            openPrice: (0, types_1.fromBlockchain10)(result.openPrice),
+            buy: result.buy,
+            leverage: (0, types_1.fromBlockchain10)(result.leverage),
+            tp: (0, types_1.fromBlockchain10)(result.tp),
+            sl: (0, types_1.fromBlockchain10)(result.sl),
+            timestamp: Number(result.timestamp),
+        };
+    }
+    /**
+     * Get additional trade information
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @returns Trade info
+     */
+    async getOpenTradeInfo(trader, pairIndex, index) {
+        const result = await this.tradingStorageContract.openTradesInfo(trader, pairIndex, index);
+        return {
+            openInterestUSDC: (0, types_1.fromBlockchain6)(result.openInterestUSDC),
+            tpLastUpdated: Number(result.tpLastUpdated),
+            slLastUpdated: Number(result.slLastUpdated),
+            beingMarketClosed: result.beingMarketClosed,
+            lossProtection: Number(result.lossProtection),
+        };
+    }
+    /**
+     * Get number of open trades for a trader on a pair
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @returns Number of open trades
+     */
+    async getOpenTradesCount(trader, pairIndex) {
+        const count = await this.tradingStorageContract.openTradesCount(trader, pairIndex);
+        return Number(count);
+    }
+    /**
+     * Get limit order information
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @param index - Order index
+     * @returns Limit order information
+     */
+    async getOpenLimitOrder(trader, pairIndex, index) {
+        const result = await this.tradingStorageContract.getOpenLimitOrder(trader, pairIndex, index);
+        return {
+            trader: result.trader,
+            pairIndex: Number(result.pairIndex),
+            index: Number(result.index),
+            positionSize: (0, types_1.fromBlockchain6)(result.positionSize),
+            buy: result.buy,
+            leverage: (0, types_1.fromBlockchain10)(result.leverage),
+            tp: (0, types_1.fromBlockchain10)(result.tp),
+            sl: (0, types_1.fromBlockchain10)(result.sl),
+            price: (0, types_1.fromBlockchain10)(result.price),
+            slippageP: (0, types_1.fromBlockchain10)(result.slippageP),
+            block: Number(result.block),
+            executionFee: (0, types_1.fromBlockchain18)(result.executionFee),
+        };
+    }
+    /**
+     * Helper method to sign and send transactions
+     */
+    async signAndSend(tx) {
+        if (!this.signer) {
+            throw new Error('Signer not set');
+        }
+        const address = await this.signer.getAddress();
+        tx.from = address;
+        const provider = this.tradingContract.runner?.provider;
+        if (!provider) {
+            throw new Error('Provider not available');
+        }
+        if (!tx.chainId) {
+            const network = await provider.getNetwork();
+            tx.chainId = network.chainId;
+        }
+        if (tx.nonce === undefined) {
+            tx.nonce = await provider.getTransactionCount(address);
+        }
+        if (!tx.gasLimit) {
+            tx.gasLimit = await provider.estimateGas(tx);
+        }
+        if (!tx.maxFeePerGas && !tx.gasPrice) {
+            const feeData = await provider.getFeeData();
+            if (feeData.maxFeePerGas) {
+                tx.maxFeePerGas = feeData.maxFeePerGas;
+                tx.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas || feeData.maxFeePerGas;
+            }
+            else {
+                tx.gasPrice = feeData.gasPrice || undefined;
+            }
+        }
+        const signedTx = await this.signer.signTransaction(tx);
+        const txResponse = await provider.broadcastTransaction(signedTx);
+        return await txResponse.wait();
+    }
+    /**
+     * Set signer for transactions
+     */
+    setSigner(signer) {
+        this.signer = signer;
+    }
+}
+exports.TradingOperationsRPC = TradingOperationsRPC;

package/dist/rpc/trading_parameters.d.ts

@@ -0,0 +1,49 @@
+import { Contract, Provider } from 'ethers';
+import { TradeInput, LossProtectionInfo } from '../types';
+import { PairsCache } from './pairs_cache';
+/**
+ * RPC module for trading-related parameters
+ */
+export declare class TradingParametersRPC {
+    private provider;
+    private pairInfosContract;
+    private pairsCache;
+    constructor(provider: Provider, pairInfosContract: Contract, pairsCache: PairsCache);
+    /**
+     * Get loss protection tier for a trade
+     * @param tradeInput - Trade input parameters
+     * @returns Loss protection tier
+     */
+    getLossProtectionTier(tradeInput: TradeInput): Promise<number>;
+    /**
+     * Get loss protection percentage for a tier
+     * @param tier - Loss protection tier
+     * @param pairIndex - Pair index
+     * @returns Loss protection percentage
+     */
+    getLossProtectionPercentage(tier: number, pairIndex: number): Promise<number>;
+    /**
+     * Calculate loss protection amount
+     * @param tier - Loss protection tier
+     * @param pairIndex - Pair index
+     * @param collateral - Collateral amount
+     * @param openingFee - Opening fee amount
+     * @returns Loss protection amount
+     */
+    getLossProtectionAmount(tier: number, pairIndex: number, collateral: number, openingFee: number): Promise<number>;
+    /**
+     * Get complete loss protection info for a trade
+     * @param tradeInput - Trade input parameters
+     * @param openingFee - Opening fee amount
+     * @returns Loss protection info
+     */
+    getLossProtectionInfo(tradeInput: TradeInput, openingFee: number): Promise<LossProtectionInfo>;
+    /**
+     * Get referral rebate for a trader
+     * @param trader - Trader address
+     * @param referrer - Referrer address
+     * @param openingFee - Opening fee amount
+     * @returns Rebate amount
+     */
+    getTradeReferralRebate(trader: string, referrer: string, openingFee: number): Promise<number>;
+}

package/dist/rpc/trading_parameters.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingParametersRPC = void 0;
+const types_1 = require("../types");
+/**
+ * RPC module for trading-related parameters
+ */
+class TradingParametersRPC {
+    constructor(provider, pairInfosContract, pairsCache) {
+        this.provider = provider;
+        this.pairInfosContract = pairInfosContract;
+        this.pairsCache = pairsCache;
+    }
+    /**
+     * Get loss protection tier for a trade
+     * @param tradeInput - Trade input parameters
+     * @returns Loss protection tier
+     */
+    async getLossProtectionTier(tradeInput) {
+        const pairIndex = await this.pairsCache.getPairIndex(tradeInput.pair);
+        if (pairIndex === undefined) {
+            throw new Error(`Pair ${tradeInput.pair} not found`);
+        }
+        try {
+            const tier = await this.pairInfosContract.getLossProtectionTier(pairIndex, (0, types_1.toBlockchain6)(tradeInput.collateralInTrade));
+            return Number(tier);
+        }
+        catch (error) {
+            console.error('Error getting loss protection tier:', error);
+            return 0;
+        }
+    }
+    /**
+     * Get loss protection percentage for a tier
+     * @param tier - Loss protection tier
+     * @param pairIndex - Pair index
+     * @returns Loss protection percentage
+     */
+    async getLossProtectionPercentage(tier, pairIndex) {
+        try {
+            const percentage = await this.pairInfosContract.getLossProtectionP(tier, pairIndex);
+            return (0, types_1.fromBlockchain10)(percentage);
+        }
+        catch (error) {
+            console.error('Error getting loss protection percentage:', error);
+            return 0;
+        }
+    }
+    /**
+     * Calculate loss protection amount
+     * @param tier - Loss protection tier
+     * @param pairIndex - Pair index
+     * @param collateral - Collateral amount
+     * @param openingFee - Opening fee amount
+     * @returns Loss protection amount
+     */
+    async getLossProtectionAmount(tier, pairIndex, collateral, openingFee) {
+        const percentage = await this.getLossProtectionPercentage(tier, pairIndex);
+        return openingFee * (percentage / 100);
+    }
+    /**
+     * Get complete loss protection info for a trade
+     * @param tradeInput - Trade input parameters
+     * @param openingFee - Opening fee amount
+     * @returns Loss protection info
+     */
+    async getLossProtectionInfo(tradeInput, openingFee) {
+        const pairIndex = await this.pairsCache.getPairIndex(tradeInput.pair);
+        if (pairIndex === undefined) {
+            throw new Error(`Pair ${tradeInput.pair} not found`);
+        }
+        const tier = await this.getLossProtectionTier(tradeInput);
+        const percentage = await this.getLossProtectionPercentage(tier, pairIndex);
+        const amount = await this.getLossProtectionAmount(tier, pairIndex, tradeInput.collateralInTrade, openingFee);
+        return {
+            tier,
+            percentage,
+            amount,
+        };
+    }
+    /**
+     * Get referral rebate for a trader
+     * @param trader - Trader address
+     * @param referrer - Referrer address
+     * @param openingFee - Opening fee amount
+     * @returns Rebate amount
+     */
+    async getTradeReferralRebate(trader, referrer, openingFee) {
+        // This would typically call the referral contract
+        // For now, return 0 as a placeholder
+        return 0;
+    }
+}
+exports.TradingParametersRPC = TradingParametersRPC;

package/dist/signers/base.d.ts

@@ -0,0 +1,24 @@
+import { TransactionRequest } from 'ethers';
+/**
+ * Abstract base class for transaction signers
+ * Implementations can use local private keys, AWS KMS, or other signing methods
+ */
+export declare abstract class BaseSigner {
+    /**
+     * Sign a transaction
+     * @param transaction - Transaction to sign
+     * @returns Signed transaction
+     */
+    abstract signTransaction(transaction: TransactionRequest): Promise<string>;
+    /**
+     * Get the Ethereum address associated with this signer
+     * @returns Ethereum address
+     */
+    abstract getAddress(): Promise<string>;
+    /**
+     * Sign a message
+     * @param message - Message to sign
+     * @returns Signature
+     */
+    abstract signMessage(message: string | Uint8Array): Promise<string>;
+}

package/dist/signers/base.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSigner = void 0;
+/**
+ * Abstract base class for transaction signers
+ * Implementations can use local private keys, AWS KMS, or other signing methods
+ */
+class BaseSigner {
+}
+exports.BaseSigner = BaseSigner;

package/dist/signers/kms.d.ts

@@ -0,0 +1,47 @@
+import { Provider, TransactionRequest } from 'ethers';
+import { BaseSigner } from './base';
+/**
+ * AWS KMS signer for secure transaction signing without exposing private keys
+ * Private key never leaves AWS KMS hardware security modules
+ */
+export declare class KMSSigner extends BaseSigner {
+    private kmsClient;
+    private kmsKeyId;
+    private provider;
+    private addressCache?;
+    /**
+     * Create a KMS signer
+     * @param kmsKeyId - AWS KMS key ID
+     * @param provider - Ethereum provider
+     * @param region - AWS region (default: us-east-1)
+     */
+    constructor(kmsKeyId: string, provider: Provider, region?: string);
+    /**
+     * Get the public key from KMS
+     * @returns DER-encoded public key
+     */
+    private getPublicKey;
+    /**
+     * Get the Ethereum address derived from the KMS key
+     * @returns Ethereum address
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Sign a message hash using KMS
+     * @param msgHash - Message hash to sign
+     * @returns DER-encoded signature
+     */
+    private signMsgHash;
+    /**
+     * Sign a transaction using KMS
+     * @param transaction - Transaction to sign
+     * @returns Signed transaction as hex string
+     */
+    signTransaction(transaction: TransactionRequest): Promise<string>;
+    /**
+     * Sign a message using KMS
+     * @param message - Message to sign
+     * @returns Signature as hex string
+     */
+    signMessage(message: string | Uint8Array): Promise<string>;
+}

package/dist/signers/kms.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KMSSigner = void 0;
+const client_kms_1 = require("@aws-sdk/client-kms");
+const ethers_1 = require("ethers");
+const base_1 = require("./base");
+const spki_1 = require("../crypto/spki");
+/**
+ * AWS KMS signer for secure transaction signing without exposing private keys
+ * Private key never leaves AWS KMS hardware security modules
+ */
+class KMSSigner extends base_1.BaseSigner {
+    /**
+     * Create a KMS signer
+     * @param kmsKeyId - AWS KMS key ID
+     * @param provider - Ethereum provider
+     * @param region - AWS region (default: us-east-1)
+     */
+    constructor(kmsKeyId, provider, region = 'us-east-1') {
+        super();
+        this.kmsKeyId = kmsKeyId;
+        this.provider = provider;
+        this.kmsClient = new client_kms_1.KMSClient({ region });
+    }
+    /**
+     * Get the public key from KMS
+     * @returns DER-encoded public key
+     */
+    async getPublicKey() {
+        const command = new client_kms_1.GetPublicKeyCommand({
+            KeyId: this.kmsKeyId,
+        });
+        const response = await this.kmsClient.send(command);
+        if (!response.PublicKey) {
+            throw new Error('Failed to get public key from KMS');
+        }
+        return response.PublicKey;
+    }
+    /**
+     * Get the Ethereum address derived from the KMS key
+     * @returns Ethereum address
+     */
+    async getAddress() {
+        if (this.addressCache) {
+            return this.addressCache;
+        }
+        const publicKey = await this.getPublicKey();
+        this.addressCache = (0, spki_1.derEncodedPublicKeyToEthAddress)(publicKey);
+        return this.addressCache;
+    }
+    /**
+     * Sign a message hash using KMS
+     * @param msgHash - Message hash to sign
+     * @returns DER-encoded signature
+     */
+    async signMsgHash(msgHash) {
+        const command = new client_kms_1.SignCommand({
+            KeyId: this.kmsKeyId,
+            Message: msgHash,
+            MessageType: 'DIGEST',
+            SigningAlgorithm: 'ECDSA_SHA_256',
+        });
+        const response = await this.kmsClient.send(command);
+        if (!response.Signature) {
+            throw new Error('Failed to sign message with KMS');
+        }
+        return response.Signature;
+    }
+    /**
+     * Sign a transaction using KMS
+     * @param transaction - Transaction to sign
+     * @returns Signed transaction as hex string
+     */
+    async signTransaction(transaction) {
+        // Get the address to fill in the 'from' field if not set
+        const address = await this.getAddress();
+        // Fill in missing fields
+        const tx = {
+            ...transaction,
+            from: address,
+        };
+        // Get chain ID if not provided
+        if (!tx.chainId) {
+            const network = await this.provider.getNetwork();
+            tx.chainId = network.chainId;
+        }
+        // Get nonce if not provided
+        if (tx.nonce === undefined) {
+            tx.nonce = await this.provider.getTransactionCount(address);
+        }
+        // Estimate gas if not provided
+        if (!tx.gasLimit) {
+            tx.gasLimit = await this.provider.estimateGas(tx);
+        }
+        // Get gas price if not provided (for legacy transactions)
+        if (!tx.maxFeePerGas && !tx.gasPrice) {
+            const feeData = await this.provider.getFeeData();
+            if (feeData.maxFeePerGas) {
+                tx.maxFeePerGas = feeData.maxFeePerGas;
+                tx.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas || feeData.maxFeePerGas;
+            }
+            else {
+                tx.gasPrice = feeData.gasPrice || undefined;
+            }
+        }
+        // Resolve address fields to strings
+        const resolvedTo = tx.to ? await (0, ethers_1.resolveAddress)(tx.to, this.provider) : null;
+        const resolvedFrom = tx.from ? await (0, ethers_1.resolveAddress)(tx.from, this.provider) : address;
+        // Create a transaction object with resolved fields
+        const resolvedTx = {
+            type: tx.type,
+            to: resolvedTo,
+            from: resolvedFrom,
+            nonce: tx.nonce,
+            gasLimit: tx.gasLimit,
+            gasPrice: tx.gasPrice,
+            maxFeePerGas: tx.maxFeePerGas,
+            maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+            data: tx.data,
+            value: tx.value,
+            chainId: tx.chainId,
+            accessList: tx.accessList,
+        };
+        // Create unsigned transaction
+        const unsignedTx = ethers_1.Transaction.from(resolvedTx);
+        const unsignedSerialized = unsignedTx.unsignedSerialized;
+        // Hash the unsigned transaction
+        const msgHash = (0, ethers_1.keccak256)(unsignedSerialized);
+        const msgHashBytes = (0, ethers_1.getBytes)(msgHash);
+        // Sign with KMS
+        const kmsSignature = await this.signMsgHash(msgHashBytes);
+        // Parse signature and recover v
+        const { r, s, v } = (0, spki_1.getSigRSV)(kmsSignature, msgHash, address);
+        // Create signed transaction
+        unsignedTx.signature = { r, s, v };
+        return unsignedTx.serialized;
+    }
+    /**
+     * Sign a message using KMS
+     * @param message - Message to sign
+     * @returns Signature as hex string
+     */
+    async signMessage(message) {
+        const address = await this.getAddress();
+        // Convert message to bytes
+        const messageBytes = typeof message === 'string' ? Buffer.from(message, 'utf8') : message;
+        // Create Ethereum signed message hash
+        const messageHash = (0, ethers_1.keccak256)(concat([
+            Buffer.from('\x19Ethereum Signed Message:\n', 'utf8'),
+            Buffer.from(String(messageBytes.length), 'utf8'),
+            messageBytes,
+        ]));
+        const msgHashBytes = (0, ethers_1.getBytes)(messageHash);
+        // Sign with KMS
+        const kmsSignature = await this.signMsgHash(msgHashBytes);
+        // Parse signature and recover v
+        const { r, s, v } = (0, spki_1.getSigRSV)(kmsSignature, messageHash, address);
+        return (0, spki_1.signatureToHex)(r, s, v);
+    }
+}
+exports.KMSSigner = KMSSigner;
+// Helper function for concat
+function concat(arrays) {
+    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}