@webacy-xyz/sdk-threat 1.0.1

package/dist/types/resources/contracts.d.ts

@@ -0,0 +1,148 @@
+import { BaseResource } from '@webacy-xyz/sdk-core';
+import { ContractRiskResponse, ContractSourceCodeResponse, TokenTaxResponse, SolidityAnalysisRequest, SolidityAnalysisResponse, ContractAnalysisOptions, SourceCodeOptions, TaxOptions } from '../types';
+/**
+ * Resource for smart contract security analysis
+ *
+ * Provides comprehensive contract analysis including:
+ * - Static and dynamic code analysis
+ * - Vulnerability detection
+ * - Source code verification
+ * - Tax/fee detection
+ * - Deployer risk analysis
+ *
+ * @example
+ * ```typescript
+ * // Analyze a contract
+ * const risk = await client.contracts.analyze('0x...', { chain: Chain.ETH });
+ *
+ * // Get source code
+ * const source = await client.contracts.getSourceCode('0x...', { chain: Chain.ETH });
+ *
+ * // With default chain configured, chain can be omitted
+ * const client = new ThreatClient({ apiKey: '...', defaultChain: Chain.ETH });
+ * const risk = await client.contracts.analyze('0x...'); // Uses ETH
+ * ```
+ */
+export declare class ContractsResource extends BaseResource {
+    /**
+     * Analyze a smart contract for security risks
+     *
+     * Returns comprehensive analysis including:
+     * - Risk score and categorization
+     * - Vulnerability detection
+     * - Source code analysis (if verified)
+     * - Similar contracts
+     * - Deployer risk (optional)
+     *
+     * @param address - Contract address
+     * @param options - Analysis options (chain is optional if defaultChain is set)
+     * @returns Contract risk analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.contracts.analyze('0xContract...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain, options can be omitted
+     * const result = await client.contracts.analyze('0xContract...');
+     *
+     * console.log(`Risk score: ${result.score}`);
+     * console.log(`Tags: ${result.tags.map(t => t.name).join(', ')}`);
+     *
+     * // Check for vulnerabilities
+     * if (result.source_code_analysis && 'vulnerabilities' in result.source_code_analysis) {
+     *   for (const vuln of result.source_code_analysis.vulnerabilities) {
+     *     console.warn(`${vuln.severity}: ${vuln.title}`);
+     *   }
+     * }
+     * ```
+     */
+    analyze(address: string, options?: ContractAnalysisOptions): Promise<ContractRiskResponse>;
+    /**
+     * Get contract source code
+     *
+     * Returns source code and metadata for verified contracts.
+     *
+     * @param address - Contract address
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Contract source code and metadata
+     *
+     * @example
+     * ```typescript
+     * const source = await client.contracts.getSourceCode('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const source = await client.contracts.getSourceCode('0x...');
+     *
+     * if (source.is_verified) {
+     *   console.log(`Contract: ${source.contract_name}`);
+     *   console.log(`Compiler: ${source.compiler_version}`);
+     * } else {
+     *   console.log('Contract source not verified');
+     * }
+     * ```
+     */
+    getSourceCode(address: string, options?: SourceCodeOptions): Promise<ContractSourceCodeResponse>;
+    /**
+     * Get token buy/sell taxes
+     *
+     * Analyzes token contracts for buy and sell taxes.
+     *
+     * @param address - Token contract address
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Tax information
+     *
+     * @example
+     * ```typescript
+     * const taxes = await client.contracts.getTaxes('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const taxes = await client.contracts.getTaxes('0x...');
+     *
+     * if (taxes.buyTaxPercentage !== null || taxes.sellTaxPercentage !== null) {
+     *   console.log(`Buy tax: ${taxes.buyTaxPercentage}%`);
+     *   console.log(`Sell tax: ${taxes.sellTaxPercentage}%`);
+     * }
+     * ```
+     */
+    getTaxes(address: string, options?: TaxOptions): Promise<TokenTaxResponse>;
+    /**
+     * Analyze Solidity source code
+     *
+     * Analyzes raw Solidity source code for vulnerabilities
+     * without requiring deployment.
+     *
+     * @param request - Analysis request with source code
+     * @returns Analysis results
+     *
+     * @example
+     * ```typescript
+     * const result = await client.contracts.analyzeSolidity({
+     *   source_code: `
+     *     pragma solidity ^0.8.0;
+     *     contract MyToken {
+     *       // ...
+     *     }
+     *   `,
+     *   compiler_version: '0.8.19',
+     * });
+     *
+     * if (result.success && result.results) {
+     *   console.log(`Security score: ${result.results.security_score}`);
+     *   for (const vuln of result.results.vulnerabilities) {
+     *     console.warn(`${vuln.severity}: ${vuln.title}`);
+     *   }
+     * }
+     * ```
+     */
+    analyzeSolidity(request: SolidityAnalysisRequest, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<SolidityAnalysisResponse>;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/types/resources/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/resources/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,gBAAgB,EAChB,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACX,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,OAAO,CACX,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,oBAAoB,CAAC;IAsBhC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,0BAA0B,CAAC;IAkBtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAkBpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,eAAe,CACnB,OAAO,EAAE,uBAAuB,EAChC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACnD,OAAO,CAAC,wBAAwB,CAAC;CAYrC"}

package/dist/types/resources/index.d.ts

@@ -0,0 +1,8 @@
+export { AddressesResource } from './addresses';
+export { ContractsResource } from './contracts';
+export { UrlResource } from './url';
+export { WalletsResource } from './wallets';
+export { LedgerResource } from './ledger';
+export { AccountTraceResource } from './account-trace';
+export { UsageResource } from './usage';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/resources/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/types/resources/ledger.d.ts

@@ -0,0 +1,107 @@
+import { HttpClient } from '@webacy-xyz/sdk-core';
+import { LedgerFamily, LedgerScanRequest, LedgerEIP712Request, LedgerScanResponse, LedgerScanOptions } from '../types';
+/**
+ * Resource for hardware wallet transaction scanning
+ *
+ * Provides security analysis for transactions before signing on
+ * hardware wallets (Ledger devices).
+ *
+ * @example
+ * ```typescript
+ * // Scan a transaction before signing
+ * const result = await client.ledger.scanTransaction('ethereum', {
+ *   tx: { from: '0x...', raw: '0x...' },
+ *   chain: 1,
+ * });
+ *
+ * if (!result.is_safe) {
+ *   console.error('Transaction may be risky!');
+ * }
+ * ```
+ */
+export declare class LedgerResource {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Scan a transaction before signing
+     *
+     * Analyzes a transaction for security risks before signing
+     * on a hardware wallet.
+     *
+     * @param family - Ledger device family (ethereum, solana, bitcoin)
+     * @param request - Transaction scan request
+     * @param options - Request options
+     * @returns Security analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ledger.scanTransaction('ethereum', {
+     *   tx: {
+     *     from: '0xYourWallet...',
+     *     raw: '0xEncodedTransaction...',
+     *   },
+     *   chain: 1, // Ethereum mainnet
+     * });
+     *
+     * if (!result.is_safe) {
+     *   console.error(`Risk level: ${result.risk_level}`);
+     *   for (const risk of result.risks) {
+     *     console.warn(`${risk.level}: ${risk.description}`);
+     *   }
+     * }
+     *
+     * // Check decoded data
+     * if (result.decoded?.function_name) {
+     *   console.log(`Function: ${result.decoded.function_name}`);
+     * }
+     * ```
+     */
+    scanTransaction(family: LedgerFamily, request: LedgerScanRequest, options?: LedgerScanOptions): Promise<LedgerScanResponse>;
+    /**
+     * Scan EIP-712 typed data before signing
+     *
+     * Analyzes EIP-712 structured data for security risks
+     * before signing on a hardware wallet.
+     *
+     * @param family - Ledger device family
+     * @param request - EIP-712 scan request
+     * @param options - Request options
+     * @returns Security analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ledger.scanEip712('ethereum', {
+     *   signer: '0xYourWallet...',
+     *   typedData: {
+     *     domain: {
+     *       name: 'MyDApp',
+     *       version: '1',
+     *       chainId: 1,
+     *       verifyingContract: '0x...',
+     *     },
+     *     message: {
+     *       // Message content
+     *     },
+     *     primaryType: 'Order',
+     *     types: {
+     *       EIP712Domain: [
+     *         { name: 'name', type: 'string' },
+     *         // ...
+     *       ],
+     *       Order: [
+     *         { name: 'maker', type: 'address' },
+     *         // ...
+     *       ],
+     *     },
+     *   },
+     *   chain: 1,
+     * });
+     *
+     * if (!result.is_safe) {
+     *   console.error('EIP-712 data may be risky!');
+     * }
+     * ```
+     */
+    scanEip712(family: LedgerFamily, request: LedgerEIP712Request, options?: LedgerScanOptions): Promise<LedgerScanResponse>;
+}
+//# sourceMappingURL=ledger.d.ts.map

package/dist/types/resources/ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../../src/resources/ledger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgB,MAAM,sBAAsB,CAAC;AAChE,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,eAAe,CACnB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;IAa9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACG,UAAU,CACd,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;CAY/B"}

package/dist/types/resources/url.d.ts

@@ -0,0 +1,69 @@
+import { HttpClient } from '@webacy-xyz/sdk-core';
+import { UrlRiskResponse, UrlAddResponse, UrlCheckOptions } from '../types';
+/**
+ * Resource for URL safety analysis
+ *
+ * Provides URL risk assessment to identify phishing sites,
+ * malicious domains, and other web-based threats.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.url.check('https://suspicious-site.com');
+ * if (result.prediction === 'malicious') {
+ *   console.warn('URL is malicious!');
+ * }
+ * ```
+ */
+export declare class UrlResource {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Check if a URL is safe
+     *
+     * Analyzes a URL for phishing, malware, and other threats.
+     *
+     * @param url - URL to check
+     * @param options - Request options
+     * @returns URL safety analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.url.check('https://example.com');
+     *
+     * if (result.prediction === 'malicious') {
+     *   console.error('URL is potentially dangerous!');
+     *   console.log('Details:', result.details);
+     * } else if (result.prediction === 'benign') {
+     *   console.log('URL appears safe');
+     * }
+     *
+     * // Check blacklist/whitelist status
+     * if (result.blacklist === 'true') {
+     *   console.error('URL is blacklisted');
+     * }
+     * if (result.whitelist === 'true') {
+     *   console.log('URL is whitelisted');
+     * }
+     * ```
+     */
+    check(url: string, options?: UrlCheckOptions): Promise<UrlRiskResponse>;
+    /**
+     * Add a URL to the database
+     *
+     * Report a URL to be analyzed and added to the threat database.
+     *
+     * @param url - URL to add
+     * @param options - Request options
+     * @returns Addition result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.url.add('https://phishing-site.com');
+     * if (result.success) {
+     *   console.log('URL reported successfully');
+     * }
+     * ```
+     */
+    add(url: string, options?: UrlCheckOptions): Promise<UrlAddResponse>;
+}
+//# sourceMappingURL=url.d.ts.map

package/dist/types/resources/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/resources/url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA6C,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE5E;;;;;;;;;;;;;GAaG;AACH,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAiB7E;;;;;;;;;;;;;;;;OAgBG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;CAgB3E"}

package/dist/types/resources/usage.d.ts

@@ -0,0 +1,99 @@
+import { HttpClient } from '@webacy-xyz/sdk-core';
+import { UsageData, CurrentUsageResponse, UsagePlansResponse, UsageOptions } from '../types';
+/**
+ * Resource for API usage and quota management
+ *
+ * Provides access to API usage statistics, current quota,
+ * and available plans.
+ *
+ * @example
+ * ```typescript
+ * const current = await client.usage.getCurrent();
+ * console.log(`Used: ${current.calls_used}/${current.calls_limit}`);
+ * ```
+ */
+export declare class UsageResource {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Get historical usage data
+     *
+     * Returns API usage statistics for a time period.
+     *
+     * @param options - Request options with date range
+     * @returns Historical usage data
+     *
+     * @example
+     * ```typescript
+     * const usage = await client.usage.getUsage({
+     *   start_date: '2024-01-01',
+     *   end_date: '2024-01-31',
+     * });
+     *
+     * console.log(`Total calls: ${usage.total_calls}`);
+     * console.log(`Period calls: ${usage.period_calls}`);
+     *
+     * // Usage by endpoint
+     * if (usage.by_endpoint) {
+     *   for (const [endpoint, count] of Object.entries(usage.by_endpoint)) {
+     *     console.log(`${endpoint}: ${count} calls`);
+     *   }
+     * }
+     * ```
+     */
+    getUsage(options?: UsageOptions): Promise<UsageData>;
+    /**
+     * Get current usage status
+     *
+     * Returns current period usage and remaining quota.
+     *
+     * @param options - Request options
+     * @returns Current usage status
+     *
+     * @example
+     * ```typescript
+     * const current = await client.usage.getCurrent();
+     *
+     * console.log(`Plan: ${current.plan}`);
+     * console.log(`Used: ${current.calls_used}/${current.calls_limit}`);
+     * console.log(`Remaining: ${current.calls_remaining}`);
+     * console.log(`Usage: ${current.usage_percentage}%`);
+     * console.log(`Resets: ${current.reset_date}`);
+     *
+     * if (current.usage_percentage > 80) {
+     *   console.warn('Approaching usage limit!');
+     * }
+     * ```
+     */
+    getCurrent(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<CurrentUsageResponse>;
+    /**
+     * Get available usage plans
+     *
+     * Returns list of available plans and their features.
+     *
+     * @param options - Request options
+     * @returns Available plans
+     *
+     * @example
+     * ```typescript
+     * const plans = await client.usage.getPlans();
+     *
+     * console.log(`Current plan: ${plans.current_plan}`);
+     *
+     * for (const plan of plans.plans) {
+     *   console.log(`${plan.name}:`);
+     *   console.log(`  Monthly limit: ${plan.monthly_limit}`);
+     *   console.log(`  Rate limit: ${plan.rate_limit}/sec`);
+     *   console.log(`  Features: ${plan.features.join(', ')}`);
+     * }
+     * ```
+     */
+    getPlans(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<UsagePlansResponse>;
+}
+//# sourceMappingURL=usage.d.ts.map

package/dist/types/resources/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../src/resources/usage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgB,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7F;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC;IAqB1D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE;QACzB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAYjC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE;QACvB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAWhC"}

package/dist/types/resources/wallets.d.ts

@@ -0,0 +1,93 @@
+import { BaseResource } from '@webacy-xyz/sdk-core';
+import { WalletTransactionsResponse, WalletApprovalsResponse, WalletTransactionsOptions, WalletApprovalsOptions } from '../types';
+/**
+ * Resource for wallet transaction and approval analysis
+ *
+ * Provides security analysis for wallet activity including:
+ * - Transaction risk analysis
+ * - Token approval monitoring
+ * - Counterparty risk assessment
+ *
+ * @example
+ * ```typescript
+ * // Get transaction risks
+ * const txs = await client.wallets.getTransactions('0x...', { chain: Chain.ETH });
+ *
+ * // Get token approvals
+ * const approvals = await client.wallets.getApprovals('0x...', { chain: Chain.ETH });
+ *
+ * // With default chain configured, chain can be omitted
+ * const client = new ThreatClient({ apiKey: '...', defaultChain: Chain.ETH });
+ * const txs = await client.wallets.getTransactions('0x...'); // Uses ETH
+ * ```
+ */
+export declare class WalletsResource extends BaseResource {
+    /**
+     * Get wallet transaction risk analysis
+     *
+     * Analyzes recent transactions for security risks including:
+     * - Interactions with risky addresses
+     * - Sanctioned counterparties
+     * - Suspicious patterns
+     *
+     * @param address - Wallet address
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Transaction risk analysis
+     *
+     * @example
+     * ```typescript
+     * const result = await client.wallets.getTransactions('0x...', {
+     *   chain: Chain.ETH,
+     *   limit: 50,
+     * });
+     *
+     * // With default chain configured
+     * const result = await client.wallets.getTransactions('0x...');
+     *
+     * console.log(`Total issues: ${result.count}`);
+     * console.log(`High risk: ${result.high}`);
+     * console.log(`Overall risk: ${result.overallRisk}`);
+     *
+     * for (const issue of result.issues) {
+     *   if (issue.transaction.sanctioned_address) {
+     *     console.error('Transaction with sanctioned address!');
+     *   }
+     * }
+     * ```
+     */
+    getTransactions(address: string, options?: WalletTransactionsOptions): Promise<WalletTransactionsResponse>;
+    /**
+     * Get wallet token approvals
+     *
+     * Lists all active token approvals for a wallet,
+     * with risk assessment for each spender.
+     *
+     * @param address - Wallet address
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Token approvals with risk data
+     *
+     * @example
+     * ```typescript
+     * const result = await client.wallets.getApprovals('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const result = await client.wallets.getApprovals('0x...');
+     *
+     * console.log(`Total approvals: ${result.count}`);
+     * console.log(`High risk approvals: ${result.high_risk_count}`);
+     *
+     * for (const approval of result.approvals) {
+     *   if (approval.is_unlimited) {
+     *     console.warn(`Unlimited approval to ${approval.spender}`);
+     *   }
+     *   if (approval.spender_risk && approval.spender_risk > 50) {
+     *     console.error(`High risk spender: ${approval.spender}`);
+     *   }
+     * }
+     * ```
+     */
+    getApprovals(address: string, options?: WalletApprovalsOptions): Promise<WalletApprovalsResponse>;
+}
+//# sourceMappingURL=wallets.d.ts.map

package/dist/types/resources/wallets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallets.d.ts","sourceRoot":"","sources":["../../../src/resources/wallets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACvB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAgB,SAAQ,YAAY;IAC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,eAAe,CACnB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,0BAA0B,CAAC;IAyBtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,YAAY,CAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,uBAAuB,CAAC;CAiBpC"}

package/dist/types/types/account-trace.d.ts

@@ -0,0 +1,68 @@
+import { Chain } from '@webacy-xyz/sdk-core';
+/**
+ * Account trace response
+ */
+export interface AccountTraceResponse {
+    /** Source address */
+    address: string;
+    /** Traced connections */
+    connections: TraceConnection[];
+    /** Summary statistics */
+    summary: TraceSummary;
+}
+/**
+ * Traced connection to another address
+ */
+export interface TraceConnection {
+    /** Connected address */
+    address: string;
+    /** Relationship type */
+    relationship: 'sent_to' | 'received_from' | 'interacted_with';
+    /** Total value transferred */
+    total_value?: string;
+    /** Transaction count */
+    tx_count: number;
+    /** First interaction */
+    first_seen?: string;
+    /** Last interaction */
+    last_seen?: string;
+    /** Address labels */
+    labels?: string[];
+    /** Risk indicators */
+    risk_flags?: string[];
+}
+/**
+ * Trace summary statistics
+ */
+export interface TraceSummary {
+    /** Total unique connections */
+    total_connections: number;
+    /** High risk connections */
+    high_risk_connections: number;
+    /** Total value sent */
+    total_sent?: string;
+    /** Total value received */
+    total_received?: string;
+    /** Sanctioned connections */
+    sanctioned_connections: number;
+    /** Mixer connections */
+    mixer_connections: number;
+}
+/**
+ * Options for account trace requests
+ */
+export interface AccountTraceOptions {
+    /**
+     * Target blockchain
+     *
+     * Optional if `defaultChain` was set in the client configuration.
+     */
+    chain?: Chain;
+    /** Trace depth (number of hops) */
+    depth?: number;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Abort signal */
+    signal?: AbortSignal;
+}
+//# sourceMappingURL=account-trace.d.ts.map

package/dist/types/types/account-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-trace.d.ts","sourceRoot":"","sources":["../../../src/types/account-trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,qBAAqB;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,yBAAyB;IACzB,OAAO,EAAE,YAAY,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,wBAAwB;IACxB,YAAY,EAAE,SAAS,GAAG,eAAe,GAAG,iBAAiB,CAAC;IAC9D,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wBAAwB;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,wBAAwB;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uBAAuB;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qBAAqB;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,sBAAsB;IACtB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,+BAA+B;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4BAA4B;IAC5B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6BAA6B;IAC7B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,wBAAwB;IACxB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mBAAmB;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB"}