@webacy-xyz/sdk-threat 1.0.1

package/dist/esm/resources/usage.js

@@ -0,0 +1,120 @@
+/**
+ * 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 class UsageResource {
+    httpClient;
+    constructor(httpClient) {
+        this.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`);
+     *   }
+     * }
+     * ```
+     */
+    async getUsage(options) {
+        const queryParams = new URLSearchParams();
+        if (options?.start_date) {
+            queryParams.append('start_date', options.start_date);
+        }
+        if (options?.end_date) {
+            queryParams.append('end_date', options.end_date);
+        }
+        const queryString = queryParams.toString();
+        const path = queryString ? `/usage?${queryString}` : '/usage';
+        const response = await this.httpClient.get(path, {
+            timeout: options?.timeout,
+            signal: options?.signal,
+        });
+        return response.data;
+    }
+    /**
+     * 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!');
+     * }
+     * ```
+     */
+    async getCurrent(options) {
+        const response = await this.httpClient.get('/usage/current', {
+            timeout: options?.timeout,
+            signal: options?.signal,
+        });
+        return response.data;
+    }
+    /**
+     * 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(', ')}`);
+     * }
+     * ```
+     */
+    async getPlans(options) {
+        const response = await this.httpClient.get('/usage/usagePlans', {
+            timeout: options?.timeout,
+            signal: options?.signal,
+        });
+        return response.data;
+    }
+}
+//# sourceMappingURL=usage.js.map

package/dist/esm/resources/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.js","sourceRoot":"","sources":["../../../src/resources/usage.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,aAAa;IACK;IAA7B,YAA6B,UAAsB;QAAtB,eAAU,GAAV,UAAU,CAAY;IAAG,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,KAAK,CAAC,QAAQ,CAAC,OAAsB;QACnC,MAAM,WAAW,GAAG,IAAI,eAAe,EAAE,CAAC;QAE1C,IAAI,OAAO,EAAE,UAAU,EAAE,CAAC;YACxB,WAAW,CAAC,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;QACvD,CAAC;QACD,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;YACtB,WAAW,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,WAAW,GAAG,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,UAAU,WAAW,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;QAE9D,MAAM,QAAQ,GAA4B,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE;YACxE,OAAO,EAAE,OAAO,EAAE,OAAO;YACzB,MAAM,EAAE,OAAO,EAAE,MAAM;SACxB,CAAC,CAAC;QAEH,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,UAAU,CAAC,OAGhB;QACC,MAAM,QAAQ,GAAuC,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAC5E,gBAAgB,EAChB;YACE,OAAO,EAAE,OAAO,EAAE,OAAO;YACzB,MAAM,EAAE,OAAO,EAAE,MAAM;SACxB,CACF,CAAC;QAEF,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,QAAQ,CAAC,OAGd;QACC,MAAM,QAAQ,GAAqC,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAC1E,mBAAmB,EACnB;YACE,OAAO,EAAE,OAAO,EAAE,OAAO;YACzB,MAAM,EAAE,OAAO,EAAE,MAAM;SACxB,CACF,CAAC;QAEF,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;CACF"}

package/dist/esm/resources/wallets.js

@@ -0,0 +1,118 @@
+import { BaseResource } from '@webacy-xyz/sdk-core';
+/**
+ * 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 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!');
+     *   }
+     * }
+     * ```
+     */
+    async getTransactions(address, options = {}) {
+        const chain = this.resolveChain(options);
+        this.validateAddress(address, chain);
+        const queryParams = new URLSearchParams();
+        queryParams.append('chain', chain);
+        if (options.limit !== undefined) {
+            queryParams.append('limit', String(options.limit));
+        }
+        if (options.offset !== undefined) {
+            queryParams.append('offset', String(options.offset));
+        }
+        const response = await this.httpClient.get(`/wallets/${encodeURIComponent(address)}/transactions?${queryParams.toString()}`, {
+            timeout: options.timeout,
+            signal: options.signal,
+        });
+        return response.data;
+    }
+    /**
+     * 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}`);
+     *   }
+     * }
+     * ```
+     */
+    async getApprovals(address, options = {}) {
+        const chain = this.resolveChain(options);
+        this.validateAddress(address, chain);
+        const queryParams = new URLSearchParams();
+        queryParams.append('chain', chain);
+        const response = await this.httpClient.get(`/wallets/${encodeURIComponent(address)}/approvals?${queryParams.toString()}`, {
+            timeout: options.timeout,
+            signal: options.signal,
+        });
+        return response.data;
+    }
+}
+//# sourceMappingURL=wallets.js.map

package/dist/esm/resources/wallets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallets.js","sourceRoot":"","sources":["../../../src/resources/wallets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAQlE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,eAAgB,SAAQ,YAAY;IAC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,KAAK,CAAC,eAAe,CACnB,OAAe,EACf,UAAqC,EAAE;QAEvC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAErC,MAAM,WAAW,GAAG,IAAI,eAAe,EAAE,CAAC;QAC1C,WAAW,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEnC,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAChC,WAAW,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QACrD,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACjC,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QACvD,CAAC;QAED,MAAM,QAAQ,GAA6C,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAClF,YAAY,kBAAkB,CAAC,OAAO,CAAC,iBAAiB,WAAW,CAAC,QAAQ,EAAE,EAAE,EAChF;YACE,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,MAAM,EAAE,OAAO,CAAC,MAAM;SACvB,CACF,CAAC;QAEF,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,KAAK,CAAC,YAAY,CAChB,OAAe,EACf,UAAkC,EAAE;QAEpC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAErC,MAAM,WAAW,GAAG,IAAI,eAAe,EAAE,CAAC;QAC1C,WAAW,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEnC,MAAM,QAAQ,GAA0C,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAC/E,YAAY,kBAAkB,CAAC,OAAO,CAAC,cAAc,WAAW,CAAC,QAAQ,EAAE,EAAE,EAC7E;YACE,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,MAAM,EAAE,OAAO,CAAC,MAAM;SACvB,CACF,CAAC;QAEF,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;CACF"}

package/dist/esm/types/account-trace.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=account-trace.js.map

package/dist/esm/types/account-trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-trace.js","sourceRoot":"","sources":["../../../src/types/account-trace.ts"],"names":[],"mappings":""}

package/dist/esm/types/address.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=address.js.map

package/dist/esm/types/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../../../src/types/address.ts"],"names":[],"mappings":""}

package/dist/esm/types/contract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contract.js.map

package/dist/esm/types/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../../src/types/contract.ts"],"names":[],"mappings":""}

package/dist/esm/types/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/esm/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":""}

package/dist/esm/types/ledger.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ledger.js.map

package/dist/esm/types/ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.js","sourceRoot":"","sources":["../../../src/types/ledger.ts"],"names":[],"mappings":""}

package/dist/esm/types/url.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=url.js.map

package/dist/esm/types/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","sourceRoot":"","sources":["../../../src/types/url.ts"],"names":[],"mappings":""}

package/dist/esm/types/usage.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=usage.js.map

package/dist/esm/types/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.js","sourceRoot":"","sources":["../../../src/types/usage.ts"],"names":[],"mappings":""}

package/dist/esm/types/wallet.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wallet.js.map

package/dist/esm/types/wallet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.js","sourceRoot":"","sources":["../../../src/types/wallet.ts"],"names":[],"mappings":""}

package/dist/types/client.d.ts

@@ -0,0 +1,145 @@
+import { BaseClient, WebacyClientConfig, RequestInterceptor, ResponseInterceptor, ErrorInterceptor } from '@webacy-xyz/sdk-core';
+import { AddressesResource } from './resources/addresses';
+import { ContractsResource } from './resources/contracts';
+import { UrlResource } from './resources/url';
+import { WalletsResource } from './resources/wallets';
+import { LedgerResource } from './resources/ledger';
+import { AccountTraceResource } from './resources/account-trace';
+import { UsageResource } from './resources/usage';
+/**
+ * Webacy Threat SDK Client
+ *
+ * Provides access to threat and risk analysis including address risk,
+ * sanctions screening, contract security, URL safety, and more.
+ *
+ * @example
+ * ```typescript
+ * import { ThreatClient, Chain, RiskModule } from '@webacy-xyz/sdk-threat';
+ *
+ * const client = new ThreatClient({
+ *   apiKey: process.env.WEBACY_API_KEY!,
+ * });
+ *
+ * // Address risk analysis
+ * const risk = await client.addresses.analyze('0x...', { chain: 'eth' });
+ *
+ * // Sanctions screening
+ * const sanctioned = await client.addresses.checkSanctioned('0x...', { chain: 'eth' });
+ *
+ * // URL safety check
+ * const urlRisk = await client.url.check('https://suspicious-site.com');
+ * ```
+ */
+export declare class ThreatClient extends BaseClient {
+    /**
+     * Addresses resource
+     *
+     * Comprehensive security analysis for blockchain addresses including
+     * risk scoring, sanctions screening, and address poisoning detection.
+     */
+    readonly addresses: AddressesResource;
+    /**
+     * Contracts resource
+     *
+     * Smart contract security analysis including vulnerability detection,
+     * source code analysis, and tax detection.
+     */
+    readonly contracts: ContractsResource;
+    /**
+     * URL resource
+     *
+     * URL safety analysis to identify phishing sites and malicious domains.
+     */
+    readonly url: UrlResource;
+    /**
+     * Wallets resource
+     *
+     * Wallet activity analysis including transaction risks and token approvals.
+     */
+    readonly wallets: WalletsResource;
+    /**
+     * Ledger resource
+     *
+     * Hardware wallet transaction scanning for secure signing.
+     */
+    readonly ledger: LedgerResource;
+    /**
+     * Account trace resource
+     *
+     * Fund flow tracing to identify connections to risky entities.
+     */
+    readonly accountTrace: AccountTraceResource;
+    /**
+     * Usage resource
+     *
+     * API usage statistics and quota management.
+     */
+    readonly usage: UsageResource;
+    /**
+     * Create a new ThreatClient instance
+     *
+     * @param config - Client configuration
+     * @throws AuthenticationError if API key is not provided
+     *
+     * @example
+     * ```typescript
+     * // Basic setup
+     * const client = new ThreatClient({
+     *   apiKey: 'your-api-key',
+     * });
+     *
+     * // With default chain (omit chain in API calls)
+     * const client = new ThreatClient({
+     *   apiKey: 'your-api-key',
+     *   defaultChain: Chain.ETH,
+     * });
+     *
+     * // With custom configuration
+     * const client = new ThreatClient({
+     *   apiKey: 'your-api-key',
+     *   timeout: 60000,
+     *   retry: {
+     *     maxRetries: 5,
+     *   },
+     * });
+     * ```
+     */
+    constructor(config: WebacyClientConfig);
+    /**
+     * Add a request interceptor
+     *
+     * @example
+     * ```typescript
+     * client.addRequestInterceptor((url, config) => {
+     *   console.log(`Making request to ${url}`);
+     *   return config;
+     * });
+     * ```
+     */
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
+    /**
+     * Add a response interceptor
+     *
+     * @example
+     * ```typescript
+     * client.addResponseInterceptor((response) => {
+     *   console.log(`Received ${response.status} response`);
+     *   return response;
+     * });
+     * ```
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    /**
+     * Add an error interceptor
+     *
+     * @example
+     * ```typescript
+     * client.addErrorInterceptor((error) => {
+     *   console.error(`Request failed: ${error.message}`);
+     *   return error;
+     * });
+     * ```
+     */
+    addErrorInterceptor(interceptor: ErrorInterceptor): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/types/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,YAAa,SAAQ,UAAU;IAC1C;;;;;OAKG;IACH,SAAgB,SAAS,EAAE,iBAAiB,CAAC;IAE7C;;;;;OAKG;IACH,SAAgB,SAAS,EAAE,iBAAiB,CAAC;IAE7C;;;;OAIG;IACH,SAAgB,GAAG,EAAE,WAAW,CAAC;IAEjC;;;;OAIG;IACH,SAAgB,OAAO,EAAE,eAAe,CAAC;IAEzC;;;;OAIG;IACH,SAAgB,MAAM,EAAE,cAAc,CAAC;IAEvC;;;;OAIG;IACH,SAAgB,YAAY,EAAE,oBAAoB,CAAC;IAEnD;;;;OAIG;IACH,SAAgB,KAAK,EAAE,aAAa,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;gBACS,MAAM,EAAE,kBAAkB;IAatC;;;;;;;;;;OAUG;IACM,qBAAqB,CAAC,WAAW,EAAE,kBAAkB,GAAG,IAAI;IAIrE;;;;;;;;;;OAUG;IACM,sBAAsB,CAAC,WAAW,EAAE,mBAAmB,GAAG,IAAI;IAIvE;;;;;;;;;;OAUG;IACM,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,GAAG,IAAI;CAGlE"}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { ThreatClient } from './client';
+export { AddressesResource, ContractsResource, UrlResource, WalletsResource, LedgerResource, AccountTraceResource, UsageResource, } from './resources';
+export type { RiskIssue, FundFlowRisk, FundFlowData, AddressInfo, TokenRiskInfo, TaxInfo, AccessControlInfo, AddressDetails, DeployerRisk, AddressRiskResponse, SanctionedResponse, PoisoningResponse, AddressAnalysisOptions, SanctionsOptions, PoisoningOptions, ContractRiskResponse, SourceCodeAnalysis, Vulnerability, ContractSourceCodeResponse, TokenTaxResponse, SolidityAnalysisRequest, SolidityAnalysisResponse, ContractAnalysisOptions, SourceCodeOptions, TaxOptions, UrlRiskResponse, UrlAddResponse, UrlCheckOptions, TransactionIssue, TransactionDetails, WalletTransactionsResponse, TokenApproval, WalletApprovalsResponse, WalletTransactionsOptions, WalletApprovalsOptions, LedgerFamily, LedgerTransactionData, LedgerScanRequest, EIP712TypedData, LedgerEIP712Request, LedgerRisk, LedgerScanResponse, LedgerScanOptions, AccountTraceResponse, TraceConnection, TraceSummary, AccountTraceOptions, UsageData, CurrentUsageResponse, UsagePlan, UsagePlansResponse, UsageOptions, } from './types';
+export { Chain, ChainCompatibility, isEvmChain, CHAIN_NAMES, RiskModule, RiskScore, RiskLevel, TypeOfAddress, TokenStandard, WebacyError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, NetworkError, type WebacyClientConfig, type RiskTag, type InformationalTag, type RiskCategory, type TokenMetadata, } from '@webacy-xyz/sdk-core';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGxC,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,aAAa,GACd,MAAM,aAAa,CAAC;AAGrB,YAAY,EAEV,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,EACb,OAAO,EACP,iBAAiB,EACjB,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EAEhB,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC1B,gBAAgB,EAChB,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EAEV,eAAe,EACf,cAAc,EACd,eAAe,EAEf,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,aAAa,EACb,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EAEtB,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,kBAAkB,EAClB,iBAAiB,EAEjB,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,mBAAmB,EAEnB,SAAS,EACT,oBAAoB,EACpB,SAAS,EACT,kBAAkB,EAClB,YAAY,GACb,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,KAAK,EACL,kBAAkB,EAClB,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,SAAS,EACT,aAAa,EACb,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,aAAa,EACb,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,OAAO,EACZ,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,sBAAsB,CAAC"}

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

@@ -0,0 +1,59 @@
+import { BaseResource } from '@webacy-xyz/sdk-core';
+import { AccountTraceResponse, AccountTraceOptions } from '../types';
+/**
+ * Resource for account fund flow tracing
+ *
+ * Traces fund flows to and from addresses to identify
+ * connections to risky entities.
+ *
+ * @example
+ * ```typescript
+ * const trace = await client.accountTrace.trace('0x...', { chain: Chain.ETH });
+ * console.log(`Sanctioned connections: ${trace.summary.sanctioned_connections}`);
+ *
+ * // With default chain configured, chain can be omitted
+ * const client = new ThreatClient({ apiKey: '...', defaultChain: Chain.ETH });
+ * const trace = await client.accountTrace.trace('0x...'); // Uses ETH
+ * ```
+ */
+export declare class AccountTraceResource extends BaseResource {
+    /**
+     * Trace account fund flows
+     *
+     * Analyzes connections to identify:
+     * - Direct counterparties
+     * - Sanctioned address connections
+     * - Mixer usage
+     * - High-risk entities
+     *
+     * @param address - Address to trace
+     * @param options - Trace options (chain is optional if defaultChain is set)
+     * @returns Fund flow trace result
+     *
+     * @example
+     * ```typescript
+     * const trace = await client.accountTrace.trace('0x...', {
+     *   chain: Chain.ETH,
+     *   depth: 2, // Trace 2 hops
+     * });
+     *
+     * // With default chain configured
+     * const trace = await client.accountTrace.trace('0x...');
+     *
+     * console.log(`Total connections: ${trace.summary.total_connections}`);
+     * console.log(`High risk: ${trace.summary.high_risk_connections}`);
+     * console.log(`Sanctioned: ${trace.summary.sanctioned_connections}`);
+     * console.log(`Mixers: ${trace.summary.mixer_connections}`);
+     *
+     * // Check individual connections
+     * for (const conn of trace.connections) {
+     *   if (conn.risk_flags?.length) {
+     *     console.warn(`Risky connection: ${conn.address}`);
+     *     console.warn(`Flags: ${conn.risk_flags.join(', ')}`);
+     *   }
+     * }
+     * ```
+     */
+    trace(address: string, options?: AccountTraceOptions): Promise<AccountTraceResponse>;
+}
+//# sourceMappingURL=account-trace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"account-trace.d.ts","sourceRoot":"","sources":["../../../src/resources/account-trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAErE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;IACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACG,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAqB/F"}

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

@@ -0,0 +1,118 @@
+import { BaseResource } from '@webacy-xyz/sdk-core';
+import { AddressRiskResponse, SanctionedResponse, PoisoningResponse, AddressAnalysisOptions, SanctionsOptions, PoisoningOptions } from '../types';
+/**
+ * Resource for address risk analysis
+ *
+ * Provides comprehensive security analysis for blockchain addresses including:
+ * - Overall risk scoring
+ * - Risk categorization and tagging
+ * - Sanctions screening
+ * - Address poisoning detection
+ * - Fund flow analysis
+ *
+ * @example
+ * ```typescript
+ * // Analyze an address
+ * const risk = await client.addresses.analyze('0x...', { chain: Chain.ETH });
+ *
+ * // Check sanctions
+ * const sanctioned = await client.addresses.checkSanctioned('0x...', { chain: Chain.ETH });
+ *
+ * // With default chain configured, chain can be omitted
+ * const client = new ThreatClient({ apiKey: '...', defaultChain: Chain.ETH });
+ * const risk = await client.addresses.analyze('0x...'); // Uses ETH
+ * ```
+ */
+export declare class AddressesResource extends BaseResource {
+    /**
+     * Analyze an address for security risks
+     *
+     * Returns comprehensive risk analysis including:
+     * - Overall risk score (0-100)
+     * - Risk tags and categories
+     * - Detailed analysis data (optional)
+     * - Deployer risk for contracts (optional)
+     *
+     * @param address - Address to analyze
+     * @param options - Analysis options (chain is optional if defaultChain is set)
+     * @returns Address risk analysis result
+     *
+     * @example
+     * ```typescript
+     * // Basic analysis
+     * const risk = await client.addresses.analyze('0x742d35Cc...', {
+     *   chain: Chain.ETH,
+     * });
+     * console.log(`Risk score: ${risk.overallRisk}`);
+     *
+     * // With default chain, options can be omitted
+     * const risk = await client.addresses.analyze('0x742d35Cc...');
+     *
+     * // With specific modules
+     * const risk = await client.addresses.analyze('0x...', {
+     *   chain: Chain.ETH,
+     *   modules: [RiskModule.SANCTIONS_COMPLIANCE, RiskModule.FUND_FLOW_SCREENING],
+     * });
+     *
+     * // With detailed response and deployer risk
+     * const risk = await client.addresses.analyze('0x...', {
+     *   chain: Chain.ETH,
+     *   detailed: true,
+     *   deployerRisk: true,
+     * });
+     * ```
+     */
+    analyze(address: string, options?: AddressAnalysisOptions): Promise<AddressRiskResponse>;
+    /**
+     * Check if an address is sanctioned
+     *
+     * Screens the address against known sanctions lists including OFAC.
+     *
+     * @param address - Address to check
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Sanctions check result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.addresses.checkSanctioned('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const result = await client.addresses.checkSanctioned('0x...');
+     *
+     * if (result.is_sanctioned) {
+     *   console.error('Address is sanctioned!');
+     *   console.log('Details:', result.sanction_details);
+     * }
+     * ```
+     */
+    checkSanctioned(address: string, options?: SanctionsOptions): Promise<SanctionedResponse>;
+    /**
+     * Check for address poisoning attacks
+     *
+     * Detects if an address has been targeted by address poisoning
+     * (dust attack) attempts.
+     *
+     * @param address - Address to check
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Poisoning detection result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.addresses.checkPoisoning('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const result = await client.addresses.checkPoisoning('0x...');
+     *
+     * if (result.is_poisoned) {
+     *   console.warn('Address poisoning detected!');
+     *   console.log('Similar addresses:', result.poisoning_details?.similar_addresses);
+     * }
+     * ```
+     */
+    checkPoisoning(address: string, options?: PoisoningOptions): Promise<PoisoningResponse>;
+}
+//# sourceMappingURL=addresses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../src/resources/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,OAAO,CACX,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,mBAAmB,CAAC;IAgC/B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,eAAe,CACnB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IAkB9B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,iBAAiB,CAAC;CAiB9B"}