@rlajous/sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Webacy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# @rlajous/sdk
+
+The official TypeScript/JavaScript SDK for the Webacy Risk Score API. This is the full SDK that includes both trading and threat analysis capabilities.
+
+## Installation
+
+```bash
+npm install @rlajous/sdk
+```
+
+Or install only what you need:
+
+```bash
+npm install @rlajous/sdk-trading   # Trading analysis only
+npm install @rlajous/sdk-threat    # Threat analysis only
+```
+
+## Quick Start
+
+```typescript
+import { WebacyClient, Chain, RiskModule } from '@rlajous/sdk';
+
+const client = new WebacyClient({
+  apiKey: process.env.WEBACY_API_KEY!,
+});
+
+// Trading: Analyze token holder distribution
+const holders = await client.trading.holderAnalysis.get('token_address', {
+  chain: 'sol',
+});
+console.log(`Sniper count: ${holders.sniper_analysis?.sniper_count}`);
+
+// Threat: Analyze address risk
+const risk = await client.threat.addresses.analyze('0x742d35Cc...', {
+  chain: 'eth',
+  modules: [RiskModule.FUND_FLOW_SCREENING],
+});
+console.log(`Risk score: ${risk.overallRisk}/100`);
+```
+
+## Features
+
+### Trading Analysis
+
+- **Holder Analysis** - Token holder distribution with sniper/bundler detection
+- **Trading Lite** - Simplified Solana token analysis
+- **Token Pools** - Liquidity pool data
+- **Trending Tokens** - Discover trending tokens
+
+```typescript
+// Holder analysis
+const holders = await client.trading.holderAnalysis.get('token', { chain: 'sol' });
+
+// Trading lite (Solana)
+const trading = await client.trading.tradingLite.analyze('pump_token');
+
+// Trending tokens
+const trending = await client.trading.tokens.getTrending({ chain: 'sol' });
+```
+
+### Threat Analysis
+
+- **Address Risk** - Comprehensive address security scoring
+- **Sanctions Screening** - OFAC compliance checking
+- **Address Poisoning** - Dust attack detection
+- **Contract Analysis** - Smart contract vulnerability detection
+- **URL Safety** - Phishing and malware detection
+- **Wallet Analysis** - Transaction and approval risk
+
+```typescript
+// Address risk
+const risk = await client.threat.addresses.analyze('0x...', { chain: 'eth' });
+
+// Sanctions check
+const sanctioned = await client.threat.addresses.checkSanctioned('0x...', { chain: 'eth' });
+
+// URL safety
+const urlRisk = await client.threat.url.check('https://suspicious-site.com');
+
+// Contract analysis
+const contract = await client.threat.contracts.analyze('0x...', { chain: 'eth' });
+```
+
+## Configuration
+
+```typescript
+const client = new WebacyClient({
+  // Required
+  apiKey: 'your-api-key',
+
+  // Optional
+  baseUrl: 'https://api.webacy.com',  // Custom API URL
+  apiVersion: 'v2',                    // API version
+  timeout: 30000,                      // Request timeout in ms
+
+  // Retry configuration
+  retry: {
+    maxRetries: 3,
+    initialDelay: 1000,
+    maxDelay: 30000,
+  },
+});
+```
+
+## Error Handling
+
+```typescript
+import {
+  WebacyClient,
+  WebacyError,
+  AuthenticationError,
+  RateLimitError,
+  ValidationError,
+  NotFoundError,
+} from '@rlajous/sdk';
+
+try {
+  const risk = await client.threat.addresses.analyze('0x...', { chain: 'eth' });
+} catch (error) {
+  if (error instanceof AuthenticationError) {
+    console.error('Invalid API key');
+  } else if (error instanceof RateLimitError) {
+    console.error(`Rate limited. Retry after ${error.retryAfter}s`);
+  } else if (error instanceof ValidationError) {
+    console.error('Invalid request:', error.errors);
+  } else if (error instanceof NotFoundError) {
+    console.error('Address not found');
+  }
+}
+```
+
+## Interceptors
+
+```typescript
+// Log all requests
+client.addRequestInterceptor((url, config) => {
+  console.log(`Request: ${url}`);
+  return config;
+});
+
+// Log all responses
+client.addResponseInterceptor((response) => {
+  console.log(`Response: ${response.status}`);
+  return response;
+});
+
+// Handle errors globally
+client.addErrorInterceptor((error) => {
+  if (error instanceof RateLimitError) {
+    console.warn('Rate limited, will retry...');
+  }
+  return error;
+});
+```
+
+## TypeScript Support
+
+Full TypeScript support with comprehensive type definitions:
+
+```typescript
+import type {
+  // Trading types
+  HolderAnalysisResult,
+  TradingLiteAnalysis,
+  SniperAnalysis,
+  FirstBuyersAnalysis,
+
+  // Threat types
+  AddressRiskResponse,
+  SanctionedResponse,
+  ContractRiskResponse,
+  UrlRiskResponse,
+
+  // Common types
+  Chain,
+  RiskModule,
+  RiskTag,
+} from '@rlajous/sdk';
+```
+
+## Supported Chains
+
+| Chain | Code | Trading | Threat |
+|-------|------|---------|--------|
+| Ethereum | `eth` | Yes | Yes |
+| Solana | `sol` | Yes | Yes |
+| Base | `base` | Yes | Yes |
+| BSC | `bsc` | Yes | Yes |
+| Polygon | `pol` | Yes | Yes |
+| Arbitrum | `arb` | Yes | Yes |
+| Optimism | `opt` | Yes | Yes |
+| TON | `ton` | - | Yes |
+| Sui | `sui` | - | Yes |
+| Stellar | `stellar` | - | Yes |
+| Bitcoin | `btc` | - | Yes |
+
+## Requirements
+
+- Node.js 18+ (uses native `fetch`)
+- Modern browsers (Chrome, Firefox, Safari, Edge)
+
+## License
+
+MIT

package/dist/cjs/client.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebacyClient = void 0;
+const sdk_core_1 = require("@rlajous/sdk-core");
+const sdk_trading_1 = require("@rlajous/sdk-trading");
+const sdk_threat_1 = require("@rlajous/sdk-threat");
+/**
+ * Unified Webacy SDK Client
+ *
+ * Provides access to all Webacy features including:
+ * - **Trading**: Token holder analysis, sniper/bundler detection, trending tokens
+ * - **Threat**: Address risk, sanctions, contracts, URL safety, wallet security
+ *
+ * This is the recommended package for most users as it provides access to
+ * all Webacy features in a single client.
+ *
+ * @example
+ * ```typescript
+ * import { WebacyClient, Chain, RiskModule } from '@rlajous/sdk';
+ *
+ * const client = new WebacyClient({
+ *   apiKey: process.env.WEBACY_API_KEY!,
+ * });
+ *
+ * // Trading: Holder analysis with sniper/bundler detection
+ * const holders = await client.trading.holderAnalysis.get('token_address', {
+ *   chain: 'sol',
+ * });
+ *
+ * // Threat: Address risk analysis
+ * const risk = await client.threat.addresses.analyze('0x...', {
+ *   chain: 'eth',
+ *   modules: [RiskModule.FUND_FLOW_SCREENING],
+ * });
+ *
+ * // Analyze a token from both perspectives
+ * const [holderData, riskData] = await Promise.all([
+ *   client.trading.holderAnalysis.get('0x...', { chain: 'eth' }),
+ *   client.threat.addresses.analyze('0x...', { chain: 'eth' }),
+ * ]);
+ * ```
+ */
+class WebacyClient extends sdk_core_1.BaseClient {
+    /**
+     * Trading namespace
+     *
+     * Contains all trading-related resources:
+     * - `holderAnalysis` - Token holder distribution and sniper detection
+     * - `tradingLite` - Simplified trading analysis (Solana)
+     * - `tokens` - Token pools and trending data
+     */
+    trading;
+    /**
+     * Threat namespace
+     *
+     * Contains all threat-related resources:
+     * - `addresses` - Address risk and sanctions screening
+     * - `contracts` - Smart contract security analysis
+     * - `url` - URL safety checking
+     * - `wallets` - Wallet transaction and approval analysis
+     * - `ledger` - Hardware wallet transaction scanning
+     * - `accountTrace` - Fund flow tracing
+     * - `usage` - API usage management
+     */
+    threat;
+    /**
+     * Create a new WebacyClient instance
+     *
+     * @param config - Client configuration
+     * @throws AuthenticationError if API key is not provided
+     *
+     * @example
+     * ```typescript
+     * // Basic setup
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     * });
+     *
+     * // With custom configuration
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     *   timeout: 60000,
+     *   retry: {
+     *     maxRetries: 5,
+     *     initialDelay: 2000,
+     *   },
+     * });
+     *
+     * // With custom headers
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     *   headers: {
+     *     'X-Custom-Header': 'value',
+     *   },
+     * });
+     * ```
+     */
+    constructor(config) {
+        super(config);
+        // Initialize trading namespace
+        this.trading = {
+            holderAnalysis: new sdk_trading_1.HolderAnalysisResource(this.httpClient, this.defaultChain),
+            tradingLite: new sdk_trading_1.TradingLiteResource(this.httpClient, this.defaultChain),
+            tokens: new sdk_trading_1.TokensResource(this.httpClient, this.defaultChain),
+        };
+        // Initialize threat namespace
+        this.threat = {
+            addresses: new sdk_threat_1.AddressesResource(this.httpClient, this.defaultChain),
+            contracts: new sdk_threat_1.ContractsResource(this.httpClient, this.defaultChain),
+            url: new sdk_threat_1.UrlResource(this.httpClient), // Chain-agnostic
+            wallets: new sdk_threat_1.WalletsResource(this.httpClient, this.defaultChain),
+            ledger: new sdk_threat_1.LedgerResource(this.httpClient), // Chain-agnostic
+            accountTrace: new sdk_threat_1.AccountTraceResource(this.httpClient, this.defaultChain),
+            usage: new sdk_threat_1.UsageResource(this.httpClient), // Chain-agnostic
+        };
+    }
+    /**
+     * Add a request interceptor
+     *
+     * Request interceptors are called before each request is sent.
+     * Use them to modify requests, add headers, or log requests.
+     *
+     * @example
+     * ```typescript
+     * client.addRequestInterceptor((url, config) => {
+     *   console.log(`Making request to ${url}`);
+     *   return config;
+     * });
+     * ```
+     */
+    addRequestInterceptor(interceptor) {
+        super.addRequestInterceptor(interceptor);
+    }
+    /**
+     * Add a response interceptor
+     *
+     * Response interceptors are called after each successful response.
+     * Use them to transform responses or log data.
+     *
+     * @example
+     * ```typescript
+     * client.addResponseInterceptor((response) => {
+     *   console.log(`Received ${response.status} response`);
+     *   return response;
+     * });
+     * ```
+     */
+    addResponseInterceptor(interceptor) {
+        super.addResponseInterceptor(interceptor);
+    }
+    /**
+     * Add an error interceptor
+     *
+     * Error interceptors are called when a request fails.
+     * Use them to handle errors globally or transform error types.
+     *
+     * @example
+     * ```typescript
+     * client.addErrorInterceptor((error) => {
+     *   if (error instanceof RateLimitError) {
+     *     console.warn('Rate limited, will retry...');
+     *   }
+     *   return error;
+     * });
+     * ```
+     */
+    addErrorInterceptor(interceptor) {
+        super.addErrorInterceptor(interceptor);
+    }
+}
+exports.WebacyClient = WebacyClient;
+//# sourceMappingURL=client.js.map

package/dist/cjs/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":";;;AAAA,gDAM2B;AAC3B,sDAAmG;AACnG,oDAQ6B;AAkC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAa,YAAa,SAAQ,qBAAU;IAC1C;;;;;;;OAOG;IACa,OAAO,CAAmB;IAE1C;;;;;;;;;;;OAWG;IACa,MAAM,CAAkB;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,YAAY,MAA0B;QACpC,KAAK,CAAC,MAAM,CAAC,CAAC;QAEd,+BAA+B;QAC/B,IAAI,CAAC,OAAO,GAAG;YACb,cAAc,EAAE,IAAI,oCAAsB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YAC9E,WAAW,EAAE,IAAI,iCAAmB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YACxE,MAAM,EAAE,IAAI,4BAAc,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;SAC/D,CAAC;QAEF,8BAA8B;QAC9B,IAAI,CAAC,MAAM,GAAG;YACZ,SAAS,EAAE,IAAI,8BAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YACpE,SAAS,EAAE,IAAI,8BAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YACpE,GAAG,EAAE,IAAI,wBAAW,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,iBAAiB;YACxD,OAAO,EAAE,IAAI,4BAAe,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YAChE,MAAM,EAAE,IAAI,2BAAc,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,iBAAiB;YAC9D,YAAY,EAAE,IAAI,iCAAoB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YAC1E,KAAK,EAAE,IAAI,0BAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,iBAAiB;SAC7D,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;OAaG;IACM,qBAAqB,CAAC,WAA+B;QAC5D,KAAK,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACM,sBAAsB,CAAC,WAAgC;QAC9D,KAAK,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACM,mBAAmB,CAAC,WAA6B;QACxD,KAAK,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACzC,CAAC;CACF;AAtID,oCAsIC"}

package/dist/cjs/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreatClient = exports.TradingClient = exports.normalizeEvmAddress = exports.normalizeAddress = exports.isValidStellarAddress = exports.isValidSuiAddress = exports.isValidTonAddress = exports.isValidBitcoinAddress = exports.isValidSolanaAddress = exports.isValidEvmAddress = exports.isValidAddress = exports.DEFAULT_RETRY_CONFIG = exports.NetworkError = exports.NotFoundError = exports.ValidationError = exports.RateLimitError = exports.AuthenticationError = exports.WebacyError = exports.TokenStandard = exports.TypeOfAddress = exports.RiskLevel = exports.RiskScore = exports.RiskModule = exports.CHAIN_NAMES = exports.CHAIN_IDS = exports.isEvmChain = exports.getChainCompatibility = exports.ChainCompatibility = exports.Chain = exports.WebacyClient = void 0;
+// Unified client
+var client_1 = require("./client");
+Object.defineProperty(exports, "WebacyClient", { enumerable: true, get: function () { return client_1.WebacyClient; } });
+// Re-export core types and utilities
+var sdk_core_1 = require("@rlajous/sdk-core");
+// Chain
+Object.defineProperty(exports, "Chain", { enumerable: true, get: function () { return sdk_core_1.Chain; } });
+Object.defineProperty(exports, "ChainCompatibility", { enumerable: true, get: function () { return sdk_core_1.ChainCompatibility; } });
+Object.defineProperty(exports, "getChainCompatibility", { enumerable: true, get: function () { return sdk_core_1.getChainCompatibility; } });
+Object.defineProperty(exports, "isEvmChain", { enumerable: true, get: function () { return sdk_core_1.isEvmChain; } });
+Object.defineProperty(exports, "CHAIN_IDS", { enumerable: true, get: function () { return sdk_core_1.CHAIN_IDS; } });
+Object.defineProperty(exports, "CHAIN_NAMES", { enumerable: true, get: function () { return sdk_core_1.CHAIN_NAMES; } });
+// Risk modules
+Object.defineProperty(exports, "RiskModule", { enumerable: true, get: function () { return sdk_core_1.RiskModule; } });
+// Enums
+Object.defineProperty(exports, "RiskScore", { enumerable: true, get: function () { return sdk_core_1.RiskScore; } });
+Object.defineProperty(exports, "RiskLevel", { enumerable: true, get: function () { return sdk_core_1.RiskLevel; } });
+Object.defineProperty(exports, "TypeOfAddress", { enumerable: true, get: function () { return sdk_core_1.TypeOfAddress; } });
+Object.defineProperty(exports, "TokenStandard", { enumerable: true, get: function () { return sdk_core_1.TokenStandard; } });
+// Errors
+Object.defineProperty(exports, "WebacyError", { enumerable: true, get: function () { return sdk_core_1.WebacyError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return sdk_core_1.AuthenticationError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return sdk_core_1.RateLimitError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return sdk_core_1.ValidationError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return sdk_core_1.NotFoundError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return sdk_core_1.NetworkError; } });
+// HTTP
+Object.defineProperty(exports, "DEFAULT_RETRY_CONFIG", { enumerable: true, get: function () { return sdk_core_1.DEFAULT_RETRY_CONFIG; } });
+// Utils
+Object.defineProperty(exports, "isValidAddress", { enumerable: true, get: function () { return sdk_core_1.isValidAddress; } });
+Object.defineProperty(exports, "isValidEvmAddress", { enumerable: true, get: function () { return sdk_core_1.isValidEvmAddress; } });
+Object.defineProperty(exports, "isValidSolanaAddress", { enumerable: true, get: function () { return sdk_core_1.isValidSolanaAddress; } });
+Object.defineProperty(exports, "isValidBitcoinAddress", { enumerable: true, get: function () { return sdk_core_1.isValidBitcoinAddress; } });
+Object.defineProperty(exports, "isValidTonAddress", { enumerable: true, get: function () { return sdk_core_1.isValidTonAddress; } });
+Object.defineProperty(exports, "isValidSuiAddress", { enumerable: true, get: function () { return sdk_core_1.isValidSuiAddress; } });
+Object.defineProperty(exports, "isValidStellarAddress", { enumerable: true, get: function () { return sdk_core_1.isValidStellarAddress; } });
+Object.defineProperty(exports, "normalizeAddress", { enumerable: true, get: function () { return sdk_core_1.normalizeAddress; } });
+Object.defineProperty(exports, "normalizeEvmAddress", { enumerable: true, get: function () { return sdk_core_1.normalizeEvmAddress; } });
+// Re-export individual clients for advanced usage
+var sdk_trading_1 = require("@rlajous/sdk-trading");
+Object.defineProperty(exports, "TradingClient", { enumerable: true, get: function () { return sdk_trading_1.TradingClient; } });
+var sdk_threat_1 = require("@rlajous/sdk-threat");
+Object.defineProperty(exports, "ThreatClient", { enumerable: true, get: function () { return sdk_threat_1.ThreatClient; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,iBAAiB;AACjB,mCAAqF;AAA5E,sGAAA,YAAY,OAAA;AA+FrB,qCAAqC;AACrC,8CAkC2B;AAjCzB,QAAQ;AACR,iGAAA,KAAK,OAAA;AACL,8GAAA,kBAAkB,OAAA;AAClB,iHAAA,qBAAqB,OAAA;AACrB,sGAAA,UAAU,OAAA;AACV,qGAAA,SAAS,OAAA;AACT,uGAAA,WAAW,OAAA;AACX,eAAe;AACf,sGAAA,UAAU,OAAA;AACV,QAAQ;AACR,qGAAA,SAAS,OAAA;AACT,qGAAA,SAAS,OAAA;AACT,yGAAA,aAAa,OAAA;AACb,yGAAA,aAAa,OAAA;AACb,SAAS;AACT,uGAAA,WAAW,OAAA;AACX,+GAAA,mBAAmB,OAAA;AACnB,0GAAA,cAAc,OAAA;AACd,2GAAA,eAAe,OAAA;AACf,yGAAA,aAAa,OAAA;AACb,wGAAA,YAAY,OAAA;AACZ,OAAO;AACP,gHAAA,oBAAoB,OAAA;AACpB,QAAQ;AACR,0GAAA,cAAc,OAAA;AACd,6GAAA,iBAAiB,OAAA;AACjB,gHAAA,oBAAoB,OAAA;AACpB,iHAAA,qBAAqB,OAAA;AACrB,6GAAA,iBAAiB,OAAA;AACjB,6GAAA,iBAAiB,OAAA;AACjB,iHAAA,qBAAqB,OAAA;AACrB,4GAAA,gBAAgB,OAAA;AAChB,+GAAA,mBAAmB,OAAA;AA4BrB,kDAAkD;AAClD,oDAAqD;AAA5C,4GAAA,aAAa,OAAA;AACtB,kDAAmD;AAA1C,0GAAA,YAAY,OAAA"}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/esm/client.js

@@ -0,0 +1,168 @@
+import { BaseClient, } from '@rlajous/sdk-core';
+import { HolderAnalysisResource, TradingLiteResource, TokensResource } from '@rlajous/sdk-trading';
+import { AddressesResource, ContractsResource, UrlResource, WalletsResource, LedgerResource, AccountTraceResource, UsageResource, } from '@rlajous/sdk-threat';
+/**
+ * Unified Webacy SDK Client
+ *
+ * Provides access to all Webacy features including:
+ * - **Trading**: Token holder analysis, sniper/bundler detection, trending tokens
+ * - **Threat**: Address risk, sanctions, contracts, URL safety, wallet security
+ *
+ * This is the recommended package for most users as it provides access to
+ * all Webacy features in a single client.
+ *
+ * @example
+ * ```typescript
+ * import { WebacyClient, Chain, RiskModule } from '@rlajous/sdk';
+ *
+ * const client = new WebacyClient({
+ *   apiKey: process.env.WEBACY_API_KEY!,
+ * });
+ *
+ * // Trading: Holder analysis with sniper/bundler detection
+ * const holders = await client.trading.holderAnalysis.get('token_address', {
+ *   chain: 'sol',
+ * });
+ *
+ * // Threat: Address risk analysis
+ * const risk = await client.threat.addresses.analyze('0x...', {
+ *   chain: 'eth',
+ *   modules: [RiskModule.FUND_FLOW_SCREENING],
+ * });
+ *
+ * // Analyze a token from both perspectives
+ * const [holderData, riskData] = await Promise.all([
+ *   client.trading.holderAnalysis.get('0x...', { chain: 'eth' }),
+ *   client.threat.addresses.analyze('0x...', { chain: 'eth' }),
+ * ]);
+ * ```
+ */
+export class WebacyClient extends BaseClient {
+    /**
+     * Trading namespace
+     *
+     * Contains all trading-related resources:
+     * - `holderAnalysis` - Token holder distribution and sniper detection
+     * - `tradingLite` - Simplified trading analysis (Solana)
+     * - `tokens` - Token pools and trending data
+     */
+    trading;
+    /**
+     * Threat namespace
+     *
+     * Contains all threat-related resources:
+     * - `addresses` - Address risk and sanctions screening
+     * - `contracts` - Smart contract security analysis
+     * - `url` - URL safety checking
+     * - `wallets` - Wallet transaction and approval analysis
+     * - `ledger` - Hardware wallet transaction scanning
+     * - `accountTrace` - Fund flow tracing
+     * - `usage` - API usage management
+     */
+    threat;
+    /**
+     * Create a new WebacyClient instance
+     *
+     * @param config - Client configuration
+     * @throws AuthenticationError if API key is not provided
+     *
+     * @example
+     * ```typescript
+     * // Basic setup
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     * });
+     *
+     * // With custom configuration
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     *   timeout: 60000,
+     *   retry: {
+     *     maxRetries: 5,
+     *     initialDelay: 2000,
+     *   },
+     * });
+     *
+     * // With custom headers
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     *   headers: {
+     *     'X-Custom-Header': 'value',
+     *   },
+     * });
+     * ```
+     */
+    constructor(config) {
+        super(config);
+        // Initialize trading namespace
+        this.trading = {
+            holderAnalysis: new HolderAnalysisResource(this.httpClient, this.defaultChain),
+            tradingLite: new TradingLiteResource(this.httpClient, this.defaultChain),
+            tokens: new TokensResource(this.httpClient, this.defaultChain),
+        };
+        // Initialize threat namespace
+        this.threat = {
+            addresses: new AddressesResource(this.httpClient, this.defaultChain),
+            contracts: new ContractsResource(this.httpClient, this.defaultChain),
+            url: new UrlResource(this.httpClient), // Chain-agnostic
+            wallets: new WalletsResource(this.httpClient, this.defaultChain),
+            ledger: new LedgerResource(this.httpClient), // Chain-agnostic
+            accountTrace: new AccountTraceResource(this.httpClient, this.defaultChain),
+            usage: new UsageResource(this.httpClient), // Chain-agnostic
+        };
+    }
+    /**
+     * Add a request interceptor
+     *
+     * Request interceptors are called before each request is sent.
+     * Use them to modify requests, add headers, or log requests.
+     *
+     * @example
+     * ```typescript
+     * client.addRequestInterceptor((url, config) => {
+     *   console.log(`Making request to ${url}`);
+     *   return config;
+     * });
+     * ```
+     */
+    addRequestInterceptor(interceptor) {
+        super.addRequestInterceptor(interceptor);
+    }
+    /**
+     * Add a response interceptor
+     *
+     * Response interceptors are called after each successful response.
+     * Use them to transform responses or log data.
+     *
+     * @example
+     * ```typescript
+     * client.addResponseInterceptor((response) => {
+     *   console.log(`Received ${response.status} response`);
+     *   return response;
+     * });
+     * ```
+     */
+    addResponseInterceptor(interceptor) {
+        super.addResponseInterceptor(interceptor);
+    }
+    /**
+     * Add an error interceptor
+     *
+     * Error interceptors are called when a request fails.
+     * Use them to handle errors globally or transform error types.
+     *
+     * @example
+     * ```typescript
+     * client.addErrorInterceptor((error) => {
+     *   if (error instanceof RateLimitError) {
+     *     console.warn('Rate limited, will retry...');
+     *   }
+     *   return error;
+     * });
+     * ```
+     */
+    addErrorInterceptor(interceptor) {
+        super.addErrorInterceptor(interceptor);
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/esm/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,GAKX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACnG,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAkC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,OAAO,YAAa,SAAQ,UAAU;IAC1C;;;;;;;OAOG;IACa,OAAO,CAAmB;IAE1C;;;;;;;;;;;OAWG;IACa,MAAM,CAAkB;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,YAAY,MAA0B;QACpC,KAAK,CAAC,MAAM,CAAC,CAAC;QAEd,+BAA+B;QAC/B,IAAI,CAAC,OAAO,GAAG;YACb,cAAc,EAAE,IAAI,sBAAsB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YAC9E,WAAW,EAAE,IAAI,mBAAmB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YACxE,MAAM,EAAE,IAAI,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;SAC/D,CAAC;QAEF,8BAA8B;QAC9B,IAAI,CAAC,MAAM,GAAG;YACZ,SAAS,EAAE,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YACpE,SAAS,EAAE,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YACpE,GAAG,EAAE,IAAI,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,iBAAiB;YACxD,OAAO,EAAE,IAAI,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YAChE,MAAM,EAAE,IAAI,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,iBAAiB;YAC9D,YAAY,EAAE,IAAI,oBAAoB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;YAC1E,KAAK,EAAE,IAAI,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,iBAAiB;SAC7D,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;OAaG;IACM,qBAAqB,CAAC,WAA+B;QAC5D,KAAK,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACM,sBAAsB,CAAC,WAAgC;QAC9D,KAAK,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACM,mBAAmB,CAAC,WAA6B;QACxD,KAAK,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACzC,CAAC;CACF"}

package/dist/esm/index.js

@@ -0,0 +1,20 @@
+// Unified client
+export { WebacyClient } from './client';
+// Re-export core types and utilities
+export { 
+// Chain
+Chain, ChainCompatibility, getChainCompatibility, isEvmChain, CHAIN_IDS, CHAIN_NAMES, 
+// Risk modules
+RiskModule, 
+// Enums
+RiskScore, RiskLevel, TypeOfAddress, TokenStandard, 
+// Errors
+WebacyError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, NetworkError, 
+// HTTP
+DEFAULT_RETRY_CONFIG, 
+// Utils
+isValidAddress, isValidEvmAddress, isValidSolanaAddress, isValidBitcoinAddress, isValidTonAddress, isValidSuiAddress, isValidStellarAddress, normalizeAddress, normalizeEvmAddress, } from '@rlajous/sdk-core';
+// Re-export individual clients for advanced usage
+export { TradingClient } from '@rlajous/sdk-trading';
+export { ThreatClient } from '@rlajous/sdk-threat';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,iBAAiB;AACjB,OAAO,EAAE,YAAY,EAA+C,MAAM,UAAU,CAAC;AA+FrF,qCAAqC;AACrC,OAAO;AACL,QAAQ;AACR,KAAK,EACL,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACV,SAAS,EACT,WAAW;AACX,eAAe;AACf,UAAU;AACV,QAAQ;AACR,SAAS,EACT,SAAS,EACT,aAAa,EACb,aAAa;AACb,SAAS;AACT,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,aAAa,EACb,YAAY;AACZ,OAAO;AACP,oBAAoB;AACpB,QAAQ;AACR,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AA2B3B,kDAAkD;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/types/client.d.ts

@@ -0,0 +1,174 @@
+import { BaseClient, WebacyClientConfig, RequestInterceptor, ResponseInterceptor, ErrorInterceptor } from '@rlajous/sdk-core';
+import { HolderAnalysisResource, TradingLiteResource, TokensResource } from '@rlajous/sdk-trading';
+import { AddressesResource, ContractsResource, UrlResource, WalletsResource, LedgerResource, AccountTraceResource, UsageResource } from '@rlajous/sdk-threat';
+/**
+ * Trading namespace containing all trading-related resources
+ */
+export interface TradingNamespace {
+    /** Holder analysis resource */
+    holderAnalysis: HolderAnalysisResource;
+    /** Trading lite resource */
+    tradingLite: TradingLiteResource;
+    /** Tokens resource */
+    tokens: TokensResource;
+}
+/**
+ * Threat namespace containing all threat-related resources
+ */
+export interface ThreatNamespace {
+    /** Addresses resource */
+    addresses: AddressesResource;
+    /** Contracts resource */
+    contracts: ContractsResource;
+    /** URL resource */
+    url: UrlResource;
+    /** Wallets resource */
+    wallets: WalletsResource;
+    /** Ledger resource */
+    ledger: LedgerResource;
+    /** Account trace resource */
+    accountTrace: AccountTraceResource;
+    /** Usage resource */
+    usage: UsageResource;
+}
+/**
+ * Unified Webacy SDK Client
+ *
+ * Provides access to all Webacy features including:
+ * - **Trading**: Token holder analysis, sniper/bundler detection, trending tokens
+ * - **Threat**: Address risk, sanctions, contracts, URL safety, wallet security
+ *
+ * This is the recommended package for most users as it provides access to
+ * all Webacy features in a single client.
+ *
+ * @example
+ * ```typescript
+ * import { WebacyClient, Chain, RiskModule } from '@rlajous/sdk';
+ *
+ * const client = new WebacyClient({
+ *   apiKey: process.env.WEBACY_API_KEY!,
+ * });
+ *
+ * // Trading: Holder analysis with sniper/bundler detection
+ * const holders = await client.trading.holderAnalysis.get('token_address', {
+ *   chain: 'sol',
+ * });
+ *
+ * // Threat: Address risk analysis
+ * const risk = await client.threat.addresses.analyze('0x...', {
+ *   chain: 'eth',
+ *   modules: [RiskModule.FUND_FLOW_SCREENING],
+ * });
+ *
+ * // Analyze a token from both perspectives
+ * const [holderData, riskData] = await Promise.all([
+ *   client.trading.holderAnalysis.get('0x...', { chain: 'eth' }),
+ *   client.threat.addresses.analyze('0x...', { chain: 'eth' }),
+ * ]);
+ * ```
+ */
+export declare class WebacyClient extends BaseClient {
+    /**
+     * Trading namespace
+     *
+     * Contains all trading-related resources:
+     * - `holderAnalysis` - Token holder distribution and sniper detection
+     * - `tradingLite` - Simplified trading analysis (Solana)
+     * - `tokens` - Token pools and trending data
+     */
+    readonly trading: TradingNamespace;
+    /**
+     * Threat namespace
+     *
+     * Contains all threat-related resources:
+     * - `addresses` - Address risk and sanctions screening
+     * - `contracts` - Smart contract security analysis
+     * - `url` - URL safety checking
+     * - `wallets` - Wallet transaction and approval analysis
+     * - `ledger` - Hardware wallet transaction scanning
+     * - `accountTrace` - Fund flow tracing
+     * - `usage` - API usage management
+     */
+    readonly threat: ThreatNamespace;
+    /**
+     * Create a new WebacyClient instance
+     *
+     * @param config - Client configuration
+     * @throws AuthenticationError if API key is not provided
+     *
+     * @example
+     * ```typescript
+     * // Basic setup
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     * });
+     *
+     * // With custom configuration
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     *   timeout: 60000,
+     *   retry: {
+     *     maxRetries: 5,
+     *     initialDelay: 2000,
+     *   },
+     * });
+     *
+     * // With custom headers
+     * const client = new WebacyClient({
+     *   apiKey: 'your-api-key',
+     *   headers: {
+     *     'X-Custom-Header': 'value',
+     *   },
+     * });
+     * ```
+     */
+    constructor(config: WebacyClientConfig);
+    /**
+     * Add a request interceptor
+     *
+     * Request interceptors are called before each request is sent.
+     * Use them to modify requests, add headers, or log requests.
+     *
+     * @example
+     * ```typescript
+     * client.addRequestInterceptor((url, config) => {
+     *   console.log(`Making request to ${url}`);
+     *   return config;
+     * });
+     * ```
+     */
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
+    /**
+     * Add a response interceptor
+     *
+     * Response interceptors are called after each successful response.
+     * Use them to transform responses or log data.
+     *
+     * @example
+     * ```typescript
+     * client.addResponseInterceptor((response) => {
+     *   console.log(`Received ${response.status} response`);
+     *   return response;
+     * });
+     * ```
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    /**
+     * Add an error interceptor
+     *
+     * Error interceptors are called when a request fails.
+     * Use them to handle errors globally or transform error types.
+     *
+     * @example
+     * ```typescript
+     * client.addErrorInterceptor((error) => {
+     *   if (error instanceof RateLimitError) {
+     *     console.warn('Rate limited, will retry...');
+     *   }
+     *   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,mBAAmB,CAAC;AAC3B,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACnG,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,aAAa,EACd,MAAM,qBAAqB,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,cAAc,EAAE,sBAAsB,CAAC;IACvC,4BAA4B;IAC5B,WAAW,EAAE,mBAAmB,CAAC;IACjC,sBAAsB;IACtB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,yBAAyB;IACzB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,yBAAyB;IACzB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,mBAAmB;IACnB,GAAG,EAAE,WAAW,CAAC;IACjB,uBAAuB;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,sBAAsB;IACtB,MAAM,EAAE,cAAc,CAAC;IACvB,6BAA6B;IAC7B,YAAY,EAAE,oBAAoB,CAAC;IACnC,qBAAqB;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,YAAa,SAAQ,UAAU;IAC1C;;;;;;;OAOG;IACH,SAAgB,OAAO,EAAE,gBAAgB,CAAC;IAE1C;;;;;;;;;;;OAWG;IACH,SAAgB,MAAM,EAAE,eAAe,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;gBACS,MAAM,EAAE,kBAAkB;IAsBtC;;;;;;;;;;;;;OAaG;IACM,qBAAqB,CAAC,WAAW,EAAE,kBAAkB,GAAG,IAAI;IAIrE;;;;;;;;;;;;;OAaG;IACM,sBAAsB,CAAC,WAAW,EAAE,mBAAmB,GAAG,IAAI;IAIvE;;;;;;;;;;;;;;;OAeG;IACM,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,GAAG,IAAI;CAGlE"}

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { WebacyClient, type TradingNamespace, type ThreatNamespace } from './client';
+export type { TokenHolder, TokenHolderActivity, BuyerHolding, FirstBuyersAnalysis, BlockRangeAnalysis, TimeSinceMintAnalysis, SniperAnalysis, ActivityPatterns, HolderAnalysisResult, HolderAnalysisOptions, AddressHolding, TradingLiteAnalysis, TradingLiteOptions, VolumeData, PoolData, TokenWithRisk, TokenRiskSummary, PoolsResponse, TrendingToken, TrendingTokensResponse, TrendingPoolsResponse, TokenPoolsOptions, TrendingOptions, } from '@rlajous/sdk-trading';
+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 '@rlajous/sdk-threat';
+export { Chain, ChainCompatibility, getChainCompatibility, isEvmChain, CHAIN_IDS, CHAIN_NAMES, RiskModule, RiskScore, RiskLevel, TypeOfAddress, TokenStandard, WebacyError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, NetworkError, DEFAULT_RETRY_CONFIG, isValidAddress, isValidEvmAddress, isValidSolanaAddress, isValidBitcoinAddress, isValidTonAddress, isValidSuiAddress, isValidStellarAddress, normalizeAddress, normalizeEvmAddress, } from '@rlajous/sdk-core';
+export type { WebacyClientConfig, RiskTag, InformationalTag, RiskCategory, ConsolidatedRiskResult, OwnershipDistribution, TopHolder, AddressLabelInfo, LiquidityPoolData, LpHolder, TokenMetadata, TokenLinks, BuySellTaxes, RequestOptions, PaginationOptions, PaginatedResponse, RetryConfig, HttpResponse, RequestInterceptor, ResponseInterceptor, ErrorInterceptor, } from '@rlajous/sdk-core';
+export { TradingClient } from '@rlajous/sdk-trading';
+export { ThreatClient } from '@rlajous/sdk-threat';
+//# 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,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAGrF,YAAY,EAEV,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EAErB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAElB,UAAU,EACV,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAG9B,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,qBAAqB,CAAC;AAG7B,OAAO,EAEL,KAAK,EACL,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACV,SAAS,EACT,WAAW,EAEX,UAAU,EAEV,SAAS,EACT,SAAS,EACT,aAAa,EACb,aAAa,EAEb,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,aAAa,EACb,YAAY,EAEZ,oBAAoB,EAEpB,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EACV,kBAAkB,EAClB,OAAO,EACP,gBAAgB,EAChB,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,EACrB,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@rlajous/sdk",
+  "version": "1.0.0",
+  "description": "Webacy SDK - Complete blockchain security and trading analysis toolkit",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@rlajous/sdk-core": "1.0.0",
+    "@rlajous/sdk-trading": "1.0.0",
+    "@rlajous/sdk-threat": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "webacy",
+    "sdk",
+    "blockchain",
+    "security",
+    "risk",
+    "trading",
+    "token-analysis",
+    "threat-detection",
+    "crypto",
+    "defi",
+    "web3"
+  ],
+  "author": "Webacy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Webacy-Prod/sdk.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/Webacy-Prod/sdk/issues"
+  },
+  "homepage": "https://github.com/Webacy-Prod/sdk#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "npm run build:esm && npm run build:cjs && npm run build:types && npm run postbuild",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "postbuild": "echo '{\"type\":\"module\"}' > dist/esm/package.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "test": "echo \"No tests yet\""
+  }
+}