@renegade-fi/renegade-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Renegade
+
+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,31 @@
+# Renegade External Match Client
+
+A TypeScript client for interacting with the Renegade Darkpool's External Match API.
+
+## Installation
+
+```bash
+# Using npm
+npm install renegade-sdk
+
+# Using yarn
+yarn add renegade-sdk
+
+# Using bun
+bun add renegade-sdk
+```
+
+## Usage
+
+See the [examples](examples) for usage examples.
+
+## Documentation
+
+See the following resources for more information:
+- [Examples From the Existing SDK](https://github.com/renegade-fi/typescript-sdk/tree/main/examples)
+- [Renegade Docs](https://docs.renegade.fi/technical-reference/typescript-sdk#external-atomic-matching)
+- [OpenAPI spec](https://github.com/renegade-fi/renegade-docs/blob/main/api-specs/external-match-openapi.yaml)
+
+## License
+
+MIT

package/examples/basic.ts

@@ -0,0 +1,121 @@
+/**
+ * Basic example of using the Renegade External Match Client
+ * 
+ * This example demonstrates how to create a client, request a quote, assemble a match, and submit the transaction on-chain.
+ */
+
+import {
+    ExternalMatchClient,
+    OrderSide,
+} from '../index';
+import type { ExternalOrder } from '../index';
+import { stringifyBigJSON } from '../src/http';
+
+// Viem imports for on-chain transactions
+import { http, createWalletClient } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { arbitrumSepolia } from 'viem/chains';
+
+// Get API credentials from environment variables
+const API_KEY = process.env.EXTERNAL_MATCH_KEY || '';
+const API_SECRET = process.env.EXTERNAL_MATCH_SECRET || '';
+const PRIVATE_KEY = process.env.PKEY || '';
+const RPC_URL = process.env.RPC_URL || 'https://sepolia-rollup.arbitrum.io/rpc';
+
+// Validate API credentials
+if (!API_KEY || !API_SECRET) {
+    console.error('Error: Missing API credentials');
+    console.error('Please set EXTERNAL_MATCH_KEY and EXTERNAL_MATCH_SECRET environment variables');
+    process.exit(1);
+}
+
+// Validate wallet private key
+if (!PRIVATE_KEY) {
+    console.error('Error: Missing private key');
+    console.error('Please set PRIVATE_KEY environment variable');
+    process.exit(1);
+}
+
+// Set up wallet client for blockchain transactions
+const privateKey = PRIVATE_KEY.startsWith('0x') ? PRIVATE_KEY : `0x${PRIVATE_KEY}`;
+const walletClient = createWalletClient({
+    account: privateKeyToAccount(privateKey as `0x${string}`),
+    chain: arbitrumSepolia,
+    transport: http(RPC_URL),
+});
+
+// Create the external match client
+console.log('API KEY', API_KEY);
+const client = ExternalMatchClient.newSepoliaClient(API_KEY, API_SECRET);
+
+// Example order for USDC/WETH pair
+const order: ExternalOrder = {
+    quote_mint: '0xdf8d259c04020562717557f2b5a3cf28e92707d1', // USDC
+    base_mint: '0xc3414a7ef14aaaa9c4522dfc00a4e66e74e9c25a',  // WETH
+    side: OrderSide.BUY,
+    quote_amount: BigInt(20_000_000), // 20 USDC
+};
+
+/**
+ * Submit a transaction to the chain
+ * @param settlementTx The settlement transaction
+ * @returns The transaction hash
+ */
+async function submitTransaction(settlementTx: any): Promise<`0x${string}`> {
+    console.log('Submitting transaction...');
+
+    const tx = await walletClient.sendTransaction({
+        to: settlementTx.to as `0x${string}`,
+        data: settlementTx.data as `0x${string}`,
+        value: settlementTx.value ? BigInt(settlementTx.value) : BigInt(0),
+    });
+
+    return tx;
+}
+
+// Full example with on-chain submission
+async function fullExample() {
+    try {
+        // Step 1: Request a quote
+        console.log('Requesting quote...');
+        const quote = await client.requestQuote(order);
+
+        if (!quote) {
+            console.log('No quote available');
+            return;
+        }
+
+        console.log('Quote received!');
+
+        // Step 2: Assemble the quote into a match bundle
+        console.log('Assembling match...');
+        const bundle = await client.assembleQuote(quote);
+
+        if (!bundle) {
+            console.log('No match available');
+            return;
+        }
+
+        console.log('Match assembled!');
+
+        // Step 3: Submit the transaction on-chain
+        const txHash = await submitTransaction(bundle.match_bundle.settlement_tx);
+        console.log(
+            'Transaction submitted:',
+            `${walletClient.chain.blockExplorers?.default.url}/tx/${txHash}`
+        );
+    } catch (error) {
+        console.error('Error:', error);
+    }
+}
+
+// Run the examples
+async function main() {
+    console.log('Running full example with on-chain submission...');
+    await fullExample();
+}
+
+// Only run if this file is being executed directly
+if (require.main === module) {
+    main().catch(console.error);
+} 

package/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Renegade External Match Client
+ * A TypeScript client for interacting with the Renegade Darkpool API.
+ */
+
+// Export main client
+export { ExternalMatchClient, ExternalMatchClientError, RequestQuoteOptions, AssembleExternalMatchOptions } from './src/client';
+
+// Export types
+export type {
+    ApiExternalAssetTransfer,
+    ApiTimestampedPrice,
+    ApiExternalMatchResult,
+    FeeTake,
+    ExternalOrder,
+    ApiExternalQuote,
+    ApiSignedExternalQuote,
+    GasSponsorshipInfo,
+    SignedGasSponsorshipInfo,
+    SignedExternalQuote,
+    SettlementTransaction,
+    AtomicMatchApiBundle,
+    ExternalQuoteRequest,
+    ExternalQuoteResponse,
+    AssembleExternalMatchRequest,
+    ExternalMatchResponse
+} from './src/types';
+
+// Export enums
+export { OrderSide } from './src/types';

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@renegade-fi/renegade-sdk",
+  "version": "0.1.0",
+  "description": "A TypeScript client for interacting with the Renegade Darkpool API",
+  "module": "index.ts",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "update-version": "bash scripts/update-version.sh",
+    "prepublishOnly": "npm run update-version && npm run build"
+  },
+  "keywords": [
+    "renegade",
+    "darkpool",
+    "trading",
+    "api",
+    "client",
+    "cryptocurrency",
+    "defi"
+  ],
+  "author": "Renegade",
+  "license": "MIT",
+  "dependencies": {
+    "@noble/hashes": "^1.7.1",
+    "json-bigint": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/json-bigint": "^1.0.4",
+    "typescript": "^5",
+    "viem": "^2.23.15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/renegade-fi/typescript-external-match-client"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/update-version.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# Script to update the SDK version in the version.ts file
+# This should be run as part of the prepublishOnly npm script
+
+set -e
+
+# Get the package version from package.json using jq
+VERSION=$(jq -r '.version' package.json)
+
+if [ -z "$VERSION" ]; then
+  echo "Error: Could not find version in package.json"
+  exit 1
+fi
+
+# Path to version.ts file
+VERSION_FILE="src/version.ts"
+
+# Generate version file content
+cat > $VERSION_FILE << EOF
+/**
+ * SDK version information
+ * This file is automatically updated during the build process
+ * Last updated: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+ */
+
+export const VERSION = '$VERSION';
+EOF
+
+echo "Successfully updated version to $VERSION in $VERSION_FILE" 

package/src/client.ts

@@ -0,0 +1,371 @@
+/**
+ * Client for interacting with the Renegade external matching API.
+ * 
+ * This client handles authentication and provides methods for requesting quotes,
+ * assembling matches, and executing trades.
+ */
+
+import { RelayerHttpClient, RENEGADE_HEADER_PREFIX } from './http';
+import { VERSION } from './version';
+import type {
+    ExternalOrder,
+    SignedExternalQuote,
+    ExternalQuoteRequest,
+    ExternalQuoteResponse,
+    AssembleExternalMatchRequest,
+    ExternalMatchResponse,
+    ApiSignedExternalQuote,
+    AtomicMatchApiBundle
+} from './types';
+
+// Constants for API URLs
+const SEPOLIA_BASE_URL = "https://testnet.auth-server.renegade.fi";
+const MAINNET_BASE_URL = "https://mainnet.auth-server.renegade.fi";
+
+// Header constants
+const RENEGADE_API_KEY_HEADER = "x-renegade-api-key";
+const RENEGADE_SDK_VERSION_HEADER = "x-renegade-sdk-version";
+
+// API Routes
+const REQUEST_EXTERNAL_QUOTE_ROUTE = "/v0/matching-engine/quote";
+const ASSEMBLE_EXTERNAL_MATCH_ROUTE = "/v0/matching-engine/assemble-external-match";
+
+// Query Parameters
+const DISABLE_GAS_SPONSORSHIP_QUERY_PARAM = "disable_gas_sponsorship";
+const GAS_REFUND_ADDRESS_QUERY_PARAM = "refund_address";
+const REFUND_NATIVE_ETH_QUERY_PARAM = "refund_native_eth";
+
+/**
+ * Get the SDK version string.
+ * 
+ * @returns The SDK version prefixed with "typescript-v"
+ */
+function getSdkVersion(): string {
+    return `typescript-v${VERSION}`;
+}
+
+/**
+ * Options for requesting a quote.
+ */
+export class RequestQuoteOptions {
+    disableGasSponsorship: boolean = false;
+    gasRefundAddress?: string;
+    refundNativeEth: boolean = false;
+
+    /**
+     * Create a new instance of RequestQuoteOptions.
+     */
+    static new(): RequestQuoteOptions {
+        return new RequestQuoteOptions();
+    }
+
+    /**
+     * Set whether gas sponsorship should be disabled.
+     */
+    withGasSponsorshipDisabled(disableGasSponsorship: boolean): RequestQuoteOptions {
+        this.disableGasSponsorship = disableGasSponsorship;
+        return this;
+    }
+
+    /**
+     * Set the gas refund address.
+     */
+    withGasRefundAddress(gasRefundAddress: string): RequestQuoteOptions {
+        this.gasRefundAddress = gasRefundAddress;
+        return this;
+    }
+
+    /**
+     * Set whether to refund in native ETH.
+     */
+    withRefundNativeEth(refundNativeEth: boolean): RequestQuoteOptions {
+        this.refundNativeEth = refundNativeEth;
+        return this;
+    }
+
+    /**
+     * Build the request path with query parameters.
+     */
+    buildRequestPath(): string {
+        const params = new URLSearchParams();
+        params.set(DISABLE_GAS_SPONSORSHIP_QUERY_PARAM, this.disableGasSponsorship.toString());
+        if (this.gasRefundAddress) {
+            params.set(GAS_REFUND_ADDRESS_QUERY_PARAM, this.gasRefundAddress);
+        }
+
+        if (this.refundNativeEth) {
+            params.set(REFUND_NATIVE_ETH_QUERY_PARAM, this.refundNativeEth.toString());
+        }
+
+        return `${REQUEST_EXTERNAL_QUOTE_ROUTE}?${params.toString()}`;
+    }
+}
+
+/**
+ * Options for assembling an external match.
+ */
+export class AssembleExternalMatchOptions {
+    doGasEstimation: boolean = false;
+    receiverAddress?: string;
+    updatedOrder?: ExternalOrder;
+    requestGasSponsorship: boolean = false;
+    gasRefundAddress?: string;
+
+    /**
+     * Create a new instance of AssembleExternalMatchOptions.
+     */
+    static new(): AssembleExternalMatchOptions {
+        return new AssembleExternalMatchOptions();
+    }
+
+    /**
+     * Set whether to do gas estimation.
+     */
+    withGasEstimation(doGasEstimation: boolean): AssembleExternalMatchOptions {
+        this.doGasEstimation = doGasEstimation;
+        return this;
+    }
+
+    /**
+     * Set the receiver address.
+     */
+    withReceiverAddress(receiverAddress: string): AssembleExternalMatchOptions {
+        this.receiverAddress = receiverAddress;
+        return this;
+    }
+
+    /**
+     * Set the updated order.
+     */
+    withUpdatedOrder(updatedOrder: ExternalOrder): AssembleExternalMatchOptions {
+        this.updatedOrder = updatedOrder;
+        return this;
+    }
+
+    /**
+     * Set whether to request gas sponsorship.
+     * @deprecated Request gas sponsorship when requesting a quote instead
+     */
+    withGasSponsorship(requestGasSponsorship: boolean): AssembleExternalMatchOptions {
+        this.requestGasSponsorship = requestGasSponsorship;
+        return this;
+    }
+
+    /**
+     * Set the gas refund address.
+     * @deprecated Request gas sponsorship when requesting a quote instead
+     */
+    withGasRefundAddress(gasRefundAddress: string): AssembleExternalMatchOptions {
+        this.gasRefundAddress = gasRefundAddress;
+        return this;
+    }
+
+    /**
+     * Build the request path with query parameters.
+     */
+    buildRequestPath(): string {
+        // If no query parameters are needed, return the base path
+        if (!this.requestGasSponsorship && !this.gasRefundAddress) {
+            return ASSEMBLE_EXTERNAL_MATCH_ROUTE;
+        }
+
+        const params = new URLSearchParams();
+        if (this.requestGasSponsorship) {
+            // We only write this query parameter if it was explicitly set
+            params.set(DISABLE_GAS_SPONSORSHIP_QUERY_PARAM, (!this.requestGasSponsorship).toString());
+        }
+
+        if (this.gasRefundAddress) {
+            params.set(GAS_REFUND_ADDRESS_QUERY_PARAM, this.gasRefundAddress);
+        }
+
+        return `${ASSEMBLE_EXTERNAL_MATCH_ROUTE}?${params.toString()}`;
+    }
+}
+
+/**
+ * Error thrown by the ExternalMatchClient.
+ */
+export class ExternalMatchClientError extends Error {
+    statusCode?: number;
+
+    constructor(message: string, statusCode?: number) {
+        super(message);
+        this.name = 'ExternalMatchClientError';
+        this.statusCode = statusCode;
+    }
+}
+
+/**
+ * Client for interacting with the Renegade external matching API.
+ */
+export class ExternalMatchClient {
+    private apiKey: string;
+    private httpClient: RelayerHttpClient;
+
+    /**
+     * Initialize a new ExternalMatchClient.
+     * 
+     * @param apiKey The API key for authentication
+     * @param apiSecret The API secret for request signing
+     * @param baseUrl The base URL of the Renegade API
+     */
+    constructor(apiKey: string, apiSecret: string, baseUrl: string) {
+        this.apiKey = apiKey;
+        this.httpClient = new RelayerHttpClient(baseUrl, apiSecret);
+    }
+
+    /**
+     * Create a new client configured for the Sepolia testnet.
+     * 
+     * @param apiKey The API key for authentication
+     * @param apiSecret The API secret for request signing
+     * @returns A new ExternalMatchClient configured for Sepolia
+     */
+    static newSepoliaClient(apiKey: string, apiSecret: string): ExternalMatchClient {
+        return new ExternalMatchClient(apiKey, apiSecret, SEPOLIA_BASE_URL);
+    }
+
+    /**
+     * Create a new client configured for mainnet.
+     * 
+     * @param apiKey The API key for authentication
+     * @param apiSecret The API secret for request signing
+     * @returns A new ExternalMatchClient configured for mainnet
+     */
+    static newMainnetClient(apiKey: string, apiSecret: string): ExternalMatchClient {
+        return new ExternalMatchClient(apiKey, apiSecret, MAINNET_BASE_URL);
+    }
+
+    /**
+     * Request a quote for the given order.
+     * 
+     * @param order The order to request a quote for
+     * @returns A promise that resolves to a signed quote if one is available, null otherwise
+     * @throws ExternalMatchClientError if the request fails
+     */
+    async requestQuote(order: ExternalOrder): Promise<SignedExternalQuote | null> {
+        return this.requestQuoteWithOptions(order, RequestQuoteOptions.new());
+    }
+
+    /**
+     * Request a quote for the given order with custom options.
+     * 
+     * @param order The order to request a quote for
+     * @param options Custom options for the quote request
+     * @returns A promise that resolves to a signed quote if one is available, null otherwise
+     * @throws ExternalMatchClientError if the request fails
+     */
+    async requestQuoteWithOptions(
+        order: ExternalOrder,
+        options: RequestQuoteOptions
+    ): Promise<SignedExternalQuote | null> {
+        const request: ExternalQuoteRequest = {
+            external_order: order
+        };
+
+        const path = options.buildRequestPath();
+        const headers = this.getHeaders();
+
+        try {
+            const response = await this.httpClient.post<ExternalQuoteResponse>(path, request, headers);
+
+            // Handle 204 No Content (no quotes available)
+            if (response.status === 204 || !response.data) {
+                return null;
+            }
+
+            const quoteResp = response.data;
+            const signedQuote: SignedExternalQuote = {
+                quote: quoteResp.signed_quote.quote,
+                signature: quoteResp.signed_quote.signature,
+                gas_sponsorship_info: quoteResp.gas_sponsorship_info
+            };
+
+            return signedQuote;
+        } catch (error: any) {
+            // Handle HTTP-related errors from fetch implementation
+            if (error.status === 204) {
+                return null;
+            }
+
+            throw new ExternalMatchClientError(
+                error.message || 'Failed to request quote',
+                error.status
+            );
+        }
+    }
+
+    /**
+     * Assemble a quote into a match bundle with default options.
+     * 
+     * @param quote The signed quote to assemble
+     * @returns A promise that resolves to a match response if assembly succeeds, null otherwise
+     * @throws ExternalMatchClientError if the request fails
+     */
+    async assembleQuote(quote: SignedExternalQuote): Promise<ExternalMatchResponse | null> {
+        return this.assembleQuoteWithOptions(quote, AssembleExternalMatchOptions.new());
+    }
+
+    /**
+     * Assemble a quote into a match bundle with custom options.
+     * 
+     * @param quote The signed quote to assemble
+     * @param options Custom options for quote assembly
+     * @returns A promise that resolves to a match response if assembly succeeds, null otherwise
+     * @throws ExternalMatchClientError if the request fails
+     */
+    async assembleQuoteWithOptions(
+        quote: SignedExternalQuote,
+        options: AssembleExternalMatchOptions
+    ): Promise<ExternalMatchResponse | null> {
+        const signedQuote: ApiSignedExternalQuote = {
+            quote: quote.quote,
+            signature: quote.signature,
+        };
+
+        const request: AssembleExternalMatchRequest = {
+            do_gas_estimation: options.doGasEstimation,
+            receiver_address: options.receiverAddress,
+            signed_quote: signedQuote,
+            updated_order: options.updatedOrder,
+            gas_sponsorship_info: quote.gas_sponsorship_info,
+        };
+
+        const path = options.buildRequestPath();
+        const headers = this.getHeaders();
+
+        try {
+            const response = await this.httpClient.post<ExternalMatchResponse>(path, request, headers);
+
+            // Handle 204 No Content
+            if (response.status === 204 || !response.data) {
+                return null;
+            }
+
+            return response.data;
+        } catch (error: any) {
+            // Handle HTTP-related errors from fetch implementation
+            if (error.status === 204) {
+                return null;
+            }
+
+            throw new ExternalMatchClientError(
+                error.message || 'Failed to assemble quote',
+                error.status
+            );
+        }
+    }
+
+    /**
+     * Get the headers required for API requests.
+     * 
+     * @returns Headers containing the API key and SDK version
+     */
+    private getHeaders(): Record<string, string> {
+        return {
+            [RENEGADE_API_KEY_HEADER]: this.apiKey,
+            [RENEGADE_SDK_VERSION_HEADER]: getSdkVersion(),
+        };
+    }
+}

package/src/http.ts

@@ -0,0 +1,238 @@
+/**
+ * HTTP client for making authenticated requests to the Renegade relayer API.
+ * This client handles request signing and authentication using HMAC-SHA256.
+ */
+
+import { sha256 } from '@noble/hashes/sha256';
+import { hmac } from '@noble/hashes/hmac';
+import { bytesToHex } from '@noble/hashes/utils';
+import JSONBigInt from 'json-bigint';
+
+// Constants for authentication
+export const RENEGADE_HEADER_PREFIX = 'x-renegade';
+export const RENEGADE_AUTH_HEADER = 'x-renegade-auth';
+export const RENEGADE_AUTH_EXPIRATION_HEADER = 'x-renegade-auth-expiration';
+
+// Authentication constants
+const REQUEST_SIGNATURE_DURATION_MS = 10 * 1000; // 10 seconds in milliseconds
+
+// Configure JSON-BigInt for parsing and stringifying
+const jsonProcessor = JSONBigInt({
+    alwaysParseAsBig: true,
+    useNativeBigInt: true,
+});
+
+/**
+ * Parse JSON string that may contain BigInt values
+ */
+export const parseBigJSON = (data: string) => {
+    try {
+        return jsonProcessor.parse(data);
+    } catch (error) {
+        // If parsing fails, return original data
+        console.error('Failed to parse JSON with BigInt', error);
+        return data;
+    }
+};
+
+/**
+ * Stringify object that may contain BigInt values
+ */
+export const stringifyBigJSON = (data: any) => {
+    return jsonProcessor.stringify(data);
+};
+
+// Define interface for HTTP response similar to Axios response
+export interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+
+/**
+ * HTTP client for making authenticated requests to the Renegade relayer API.  
+ */
+export class RelayerHttpClient {
+    private baseUrl: string;
+    private authKey: Uint8Array;
+    private defaultHeaders: Record<string, string>;
+
+    /**
+     * Initialize a new RelayerHttpClient.
+     * 
+     * @param baseUrl The base URL of the relayer API
+     * @param authKey The base64-encoded authentication key for request signing
+     */
+    constructor(baseUrl: string, authKey: string) {
+        this.baseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+        this.authKey = this.decodeBase64(authKey);
+        this.defaultHeaders = {
+            'Content-Type': 'application/json'
+        };
+    }
+
+    /**
+     * Make a GET request with custom headers.
+     * 
+     * @param path The API endpoint path
+     * @param headers Additional headers to include
+     * @returns The API response
+     */
+    public async get<T>(path: string, headers: Record<string, string> = {}): Promise<HttpResponse<T>> {
+        return this.request<T>('GET', path, undefined, headers);
+    }
+
+    /**
+     * Make a POST request with custom headers.
+     * 
+     * @param path The API endpoint path
+     * @param data The request body to send
+     * @param headers Additional headers to include
+     * @returns The API response
+     */
+    public async post<T, D = any>(path: string, data: D, headers: Record<string, string> = {}): Promise<HttpResponse<T>> {
+        return this.request<T>('POST', path, data, headers);
+    }
+
+    /**
+     * Make an HTTP request with authentication.
+     * 
+     * @param method The HTTP method
+     * @param path The API endpoint path
+     * @param data The request body data
+     * @param customHeaders Additional headers to include
+     * @returns The API response
+     */
+    private async request<T>(
+        method: string,
+        path: string,
+        data?: any,
+        customHeaders: Record<string, string> = {}
+    ): Promise<HttpResponse<T>> {
+        const urlPath = path.startsWith('/') ? path.slice(1) : path;
+        const url = new URL(urlPath, this.baseUrl);
+
+        // Prepare headers, and add authentication headers
+        const headers = { ...this.defaultHeaders, ...customHeaders };
+        const fullHeaders = this.addAuthHeaders(
+            url.pathname + url.search,
+            headers,
+            data
+        );
+
+        // Prepare request body
+        let body: string | undefined;
+        if (data) {
+            body = typeof data === 'string' ? data : stringifyBigJSON(data);
+        }
+
+        // Make the fetch request
+        const response = await fetch(url.toString(), {
+            method,
+            headers: fullHeaders,
+            body
+        });
+
+        // Read the response body
+        let responseData: any;
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            const text = await response.text();
+            responseData = parseBigJSON(text);
+        } else {
+            responseData = await response.text();
+        }
+
+        // Convert headers to a simple object
+        const responseHeaders: Record<string, string> = {};
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+
+        // Return a response object similar to Axios response
+        return {
+            data: responseData,
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders
+        };
+    }
+
+    /**
+     * Add authentication headers to a request.
+     */
+    private addAuthHeaders(
+        path: string,
+        headers: Record<string, string>,
+        data?: any
+    ): Record<string, string> {
+        // Add timestamp and expiry
+        const timestamp = Date.now();
+        const expiry = timestamp + REQUEST_SIGNATURE_DURATION_MS;
+        headers[RENEGADE_AUTH_EXPIRATION_HEADER] = expiry.toString();
+
+        // Compute the MAC signature and 
+        const macDigest = this.computeRequestMac(path, headers, data);
+        headers[RENEGADE_AUTH_HEADER] = this.encodeBase64(Buffer.from(macDigest));
+        return headers;
+    }
+
+    /**
+     * Compute the HMAC-SHA256 MAC for a request.
+     * 
+     * @param path The API endpoint path with query parameters
+     * @param headers The request headers
+     * @param data The request body data
+     * @returns The computed MAC digest
+     */
+    private computeRequestMac(
+        path: string,
+        headers: Record<string, string>,
+        data?: any
+    ): Uint8Array {
+        // Initialize MAC with auth key
+        const mac = hmac.create(sha256, this.authKey);
+
+        // Add path to signature
+        const pathBytes = new TextEncoder().encode(path);
+        mac.update(pathBytes);
+
+        // Add Renegade headers to signature
+        const renegadeHeaders = Object.entries(headers)
+            .filter(([key]) => key.toLowerCase().startsWith(RENEGADE_HEADER_PREFIX))
+            .filter(([key]) => key.toLowerCase() !== RENEGADE_AUTH_HEADER.toLowerCase())
+            .sort(([a], [b]) => a.localeCompare(b));
+
+        for (const [key, value] of renegadeHeaders) {
+            mac.update(new TextEncoder().encode(key));
+            mac.update(new TextEncoder().encode(value.toString()));
+        }
+
+        // Add body to signature
+        let body = '';
+        if (data) {
+            body = typeof data === 'string'
+                ? data
+                : stringifyBigJSON(data);
+        }
+        mac.update(new TextEncoder().encode(body));
+
+        // Return the digest
+        return mac.digest();
+    }
+
+    /**
+     * Decode a base64 string to a Uint8Array.
+     */
+    private decodeBase64(base64: string): Uint8Array {
+        return Buffer.from(base64, 'base64');
+    }
+
+    /**
+     * Encode a Uint8Array or Buffer to a base64 string.
+     */
+    private encodeBase64(data: Uint8Array | Buffer): string {
+        return Buffer.from(data).toString('base64').replace(/=+$/, '');
+    }
+} 

package/src/types.ts

@@ -0,0 +1,112 @@
+/**
+ * Type definitions for the Renegade Darkpool API.
+ */
+
+export enum OrderSide {
+    BUY = "Buy",
+    SELL = "Sell",
+}
+
+export interface ApiExternalAssetTransfer {
+    mint: string;
+    amount: bigint;
+}
+
+export interface ApiTimestampedPrice {
+    price: string;
+    timestamp: bigint;
+}
+
+export interface ApiExternalMatchResult {
+    quote_mint: string;
+    base_mint: string;
+    quote_amount: bigint;
+    base_amount: bigint;
+    direction: OrderSide;
+}
+
+export interface FeeTake {
+    relayer_fee: bigint;
+    protocol_fee: bigint;
+}
+
+export interface ExternalOrder {
+    quote_mint: string;
+    base_mint: string;
+    side: OrderSide;
+    base_amount?: bigint;
+    quote_amount?: bigint;
+    exact_base_output?: bigint;
+    exact_quote_output?: bigint;
+    min_fill_size?: bigint;
+}
+
+export interface ApiExternalQuote {
+    order: ExternalOrder;
+    match_result: ApiExternalMatchResult;
+    fees: FeeTake;
+    send: ApiExternalAssetTransfer;
+    receive: ApiExternalAssetTransfer;
+    price: ApiTimestampedPrice;
+    timestamp: bigint;
+}
+
+export interface ApiSignedExternalQuote {
+    quote: ApiExternalQuote;
+    signature: string;
+}
+
+export interface GasSponsorshipInfo {
+    refund_amount: bigint;
+    refund_native_eth: boolean;
+    refund_address?: string;
+}
+
+export interface SignedGasSponsorshipInfo {
+    gas_sponsorship_info: GasSponsorshipInfo;
+    signature: string;
+}
+
+export interface SignedExternalQuote {
+    quote: ApiExternalQuote;
+    signature: string;
+    gas_sponsorship_info?: SignedGasSponsorshipInfo;
+}
+
+export interface SettlementTransaction {
+    tx_type: string;
+    to: string;
+    data: string;
+    value: string;
+}
+
+export interface AtomicMatchApiBundle {
+    match_result: ApiExternalMatchResult;
+    fees: FeeTake;
+    receive: ApiExternalAssetTransfer;
+    send: ApiExternalAssetTransfer;
+    settlement_tx: SettlementTransaction;
+}
+
+export interface ExternalQuoteRequest {
+    external_order: ExternalOrder;
+}
+
+export interface ExternalQuoteResponse {
+    signed_quote: ApiSignedExternalQuote;
+    gas_sponsorship_info?: SignedGasSponsorshipInfo;
+}
+
+export interface AssembleExternalMatchRequest {
+    do_gas_estimation?: boolean;
+    receiver_address?: string;
+    signed_quote: ApiSignedExternalQuote;
+    updated_order?: ExternalOrder;
+    gas_sponsorship_info?: SignedGasSponsorshipInfo;
+}
+
+export interface ExternalMatchResponse {
+    match_bundle: AtomicMatchApiBundle;
+    gas_sponsored: boolean;
+    gas_sponsorship_info?: GasSponsorshipInfo;
+} 

package/src/version.ts

@@ -0,0 +1,7 @@
+/**
+ * SDK version information
+ * This file is automatically updated during the build process
+ * Last updated: 2025-03-27T00:13:04Z
+ */
+
+export const VERSION = '0.1.0';

package/tsconfig.build.json

@@ -0,0 +1,17 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "declaration": true,
+        "noEmit": false,
+        "allowImportingTsExtensions": false
+    },
+    "include": [
+        "index.ts",
+        "src/**/*.ts"
+    ],
+    "exclude": [
+        "node_modules",
+        "**/*.test.ts"
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["esnext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}