@harukit/sdk 1.0.0

package/dist/haru-7702.js

@@ -0,0 +1,405 @@
+import { getAddress, } from 'viem';
+import { CHAIN_NAME_TO_ID, CHAIN_ID_TO_NAME } from '@harukit/shared';
+const HARU_BATCH_SPONSOR_DOMAIN_BASE = {
+    name: 'Haru7702BatchSponsor',
+    version: '1',
+};
+function resolveChainId(chain, defaultChain) {
+    const name = (chain || defaultChain || 'arbitrum').toLowerCase();
+    const id = CHAIN_NAME_TO_ID[name];
+    if (!id) {
+        throw new Error(`Unsupported chain: "${name}". ` +
+            `Supported: ${Object.keys(CHAIN_NAME_TO_ID).join(', ')}. ` +
+            `Set defaultChain in Haru7702 constructor to avoid specifying chain on every call.`);
+    }
+    return id;
+}
+function toHex(value) {
+    if (!value.startsWith('0x')) {
+        throw new Error(`Expected hex string (0x...), got: "${value.slice(0, 30)}..."`);
+    }
+    return value;
+}
+/**
+ * Haru7702 — EIP-7702 batch transaction client with gas sponsorship.
+ *
+ * @example Single-chain swap (one-shot)
+ * ```ts
+ * const haru = new Haru7702({ apiKey: '...' }); // defaultChain = 'arbitrum'
+ * await haru.executeSwap({ quote, wallet, signAuthorization });
+ * ```
+ *
+ * @example Multi-chain swap (automatic parallel execution)
+ * ```ts
+ * const haru = new Haru7702({ apiKey: '...' });
+ * const batches = haru.buildCalls(quote); // Map { 'arbitrum' → ChainCallBundle, 'base' → ChainCallBundle }
+ * await haru.executeSwap({ quote, wallet, signAuthorization }); // handles multi-chain automatically
+ * ```
+ *
+ * @example Transfer
+ * ```ts
+ * await haru.executeTransfer({ transfer, wallet, signAuthorization });
+ * ```
+ */
+export class Haru7702 {
+    defaultChain;
+    apiBaseUrl;
+    apiKey;
+    constructor(options = {}) {
+        this.defaultChain = options.defaultChain || 'arbitrum';
+        this.apiBaseUrl = options.baseUrl || 'https://api.haruapi.com';
+        this.apiKey = options.apiKey || '';
+    }
+    getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['X-API-Key'] = this.apiKey;
+        }
+        return headers;
+    }
+    serializeWithBigInt(obj) {
+        return JSON.stringify(obj, (key, value) => {
+            if (typeof value === 'bigint') {
+                return value.toString();
+            }
+            return value;
+        });
+    }
+    async createSignRawHash(wallet) {
+        if (!wallet) {
+            throw new Error('Wallet is required');
+        }
+        const provider = await wallet.getEthereumProvider();
+        return async (hash) => {
+            const signature = await provider.request({
+                method: 'secp256k1_sign',
+                params: [hash],
+            });
+            return signature;
+        };
+    }
+    async signAuthorization(signAuthorization, walletAddress, chain) {
+        const chainId = resolveChainId(chain, this.defaultChain);
+        const authorization = await signAuthorization({
+            contractAddress: await this.getContractAddress(chainId),
+            chainId,
+        }, { address: walletAddress });
+        return this.serializeWithBigInt(authorization);
+    }
+    async signBatchCall(calls, nonce, deadline, sponsor, signRawHash, walletAddress, chain) {
+        if (calls.length === 0) {
+            throw new Error('Cannot sign empty batch');
+        }
+        const chainId = resolveChainId(chain, this.defaultChain);
+        const { keccak256, toBytes, encodeAbiParameters, encodePacked } = await import('viem');
+        const EXECUTE_TYPEHASH_STRING = "Execute(bytes32 callsHash,uint256 nonce,uint256 deadline,address sponsor,address executor)";
+        const EXECUTE_TYPEHASH = keccak256(toBytes(EXECUTE_TYPEHASH_STRING));
+        const CALL_TYPEHASH_STRING = "Call(address to,uint256 value,bytes data,uint256 gasLimit)";
+        const CALL_TYPEHASH = keccak256(toBytes(CALL_TYPEHASH_STRING));
+        const callHashes = calls.map(call => {
+            const normalizedTo = getAddress(call.to);
+            const normalizedValue = BigInt(call.value || '0');
+            const normalizedData = toHex(call.data);
+            const normalizedGasLimit = 0n;
+            return keccak256(encodeAbiParameters([
+                { type: 'bytes32' },
+                { type: 'address' },
+                { type: 'uint256' },
+                { type: 'bytes32' },
+                { type: 'uint256' },
+            ], [
+                CALL_TYPEHASH,
+                normalizedTo,
+                normalizedValue,
+                keccak256(normalizedData),
+                normalizedGasLimit,
+            ]));
+        });
+        const concatenatedHashes = toHex('0x' + callHashes.map(h => h.slice(2)).join(''));
+        const callsHash = keccak256(concatenatedHashes);
+        const normalizedSponsor = getAddress(sponsor);
+        const normalizedExecutor = getAddress(walletAddress);
+        const structHash = keccak256(encodeAbiParameters([
+            { type: 'bytes32' },
+            { type: 'bytes32' },
+            { type: 'uint256' },
+            { type: 'uint256' },
+            { type: 'address' },
+            { type: 'address' },
+        ], [
+            EXECUTE_TYPEHASH,
+            callsHash,
+            nonce,
+            deadline,
+            normalizedSponsor,
+            normalizedExecutor,
+        ]));
+        const domainTypeHash = keccak256(toBytes('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'));
+        const nameHash = keccak256(toBytes(HARU_BATCH_SPONSOR_DOMAIN_BASE.name));
+        const versionHash = keccak256(toBytes(HARU_BATCH_SPONSOR_DOMAIN_BASE.version));
+        const verifyingContractAddress = getAddress(walletAddress);
+        const domainSeparator = keccak256(encodeAbiParameters([
+            { type: 'bytes32' },
+            { type: 'bytes32' },
+            { type: 'bytes32' },
+            { type: 'uint256' },
+            { type: 'address' },
+        ], [
+            domainTypeHash,
+            nameHash,
+            versionHash,
+            BigInt(chainId),
+            verifyingContractAddress,
+        ]));
+        const fullHash = keccak256(encodePacked(['bytes1', 'bytes1', 'bytes32', 'bytes32'], ['0x19', '0x01', domainSeparator, structHash]));
+        return signRawHash(fullHash);
+    }
+    /**
+     * Build execution calls from a swap quote or transfer.
+     * Always returns calls grouped by chain as Map<chain, ChainCallBundle>.
+     * Works for both single-chain and multi-chain operations.
+     */
+    buildCalls(quote) {
+        const batches = new Map();
+        if ('txData' in quote && quote.txData && 'steps' in quote.txData) {
+            for (const step of quote.txData.steps) {
+                const chainId = step.data.chainId;
+                const chain = CHAIN_ID_TO_NAME[chainId] || String(chainId);
+                const existing = batches.get(chain);
+                const call = {
+                    to: step.data.to,
+                    value: BigInt(step.data.value || '0'),
+                    data: step.data.data,
+                };
+                if (existing) {
+                    existing.calls.push(call);
+                }
+                else {
+                    batches.set(chain, { calls: [call], chain, chainId });
+                }
+            }
+        }
+        else if ('steps' in quote && quote.steps) {
+            for (const step of quote.steps) {
+                if (step.kind !== 'transaction')
+                    continue;
+                const chainId = step.chainId;
+                const chain = CHAIN_ID_TO_NAME[chainId] || String(chainId);
+                const existing = batches.get(chain);
+                for (const item of step.items) {
+                    const newCall = {
+                        to: item.data.to,
+                        value: BigInt(item.data.value || '0'),
+                        data: item.data.data,
+                    };
+                    if (existing) {
+                        existing.calls.push(newCall);
+                    }
+                    else {
+                        batches.set(chain, { calls: [newCall], chain, chainId });
+                    }
+                }
+            }
+        }
+        else if ('txData' in quote && quote.txData && 'chainId' in quote.txData) {
+            const txData = quote.txData;
+            const chainId = txData.chainId;
+            const chain = CHAIN_ID_TO_NAME[chainId] || String(chainId);
+            batches.set(chain, {
+                calls: [{
+                        to: txData.to,
+                        value: BigInt(txData.value || '0'),
+                        data: toHex(txData.data),
+                    }],
+                chain,
+                chainId,
+            });
+        }
+        else {
+            throw new Error('Quote/transfer has no transaction data');
+        }
+        return batches;
+    }
+    /**
+     * Execute a swap in one call. Handles multi-chain automatically.
+     * Returns immediately with transaction hashes (does not wait for confirmation).
+     */
+    async executeSwap(params) {
+        const { quote, wallet, signAuthorization, deadline = BigInt(Math.floor(Date.now() / 1000) + 3600) } = params;
+        const batches = this.buildCalls(quote);
+        const results = new Map();
+        await Promise.all(Array.from(batches.entries()).map(async ([chain, bundle]) => {
+            const [authorization, signRawHash] = await Promise.all([
+                this.signAuthorization(signAuthorization, wallet.address, chain),
+                this.createSignRawHash(wallet),
+            ]);
+            const [nonce, sponsorAddress] = await Promise.all([
+                this.getNonce(wallet.address, chain),
+                this.getSponsorAddress(),
+            ]);
+            const batchSignature = await this.signBatchCall(bundle.calls, nonce, deadline, sponsorAddress, signRawHash, wallet.address, chain);
+            const result = await this.sponsorTx({ calls: bundle.calls, signature: batchSignature, nonce, deadline }, authorization, wallet.address, chain);
+            results.set(chain, result);
+        }));
+        return results;
+    }
+    /**
+     * Execute a transfer in one call.
+     * Returns immediately with transaction hash (does not wait for confirmation).
+     */
+    async executeTransfer(params) {
+        const { transfer, wallet, signAuthorization, deadline = BigInt(Math.floor(Date.now() / 1000) + 3600) } = params;
+        const batches = this.buildCalls(transfer);
+        const results = new Map();
+        await Promise.all(Array.from(batches.entries()).map(async ([chain, bundle]) => {
+            const [authorization, signRawHash] = await Promise.all([
+                this.signAuthorization(signAuthorization, wallet.address, chain),
+                this.createSignRawHash(wallet),
+            ]);
+            const [nonce, sponsorAddress] = await Promise.all([
+                this.getNonce(wallet.address, chain),
+                this.getSponsorAddress(),
+            ]);
+            const batchSignature = await this.signBatchCall(bundle.calls, nonce, deadline, sponsorAddress, signRawHash, wallet.address, chain);
+            const result = await this.sponsorTx({ calls: bundle.calls, signature: batchSignature, nonce, deadline }, authorization, wallet.address, chain);
+            results.set(chain, result);
+        }));
+        return results;
+    }
+    /**
+     * Execute a pre-built bundle (from buildCalls) in one call.
+     * Useful when you've combined multiple quotes into a single bundle.
+     * Returns immediately with transaction hash (does not wait for confirmation).
+     */
+    async executeBatch(params) {
+        const { bundle, wallet, signAuthorization, deadline = BigInt(Math.floor(Date.now() / 1000) + 3600) } = params;
+        const results = new Map();
+        const [authorization, signRawHash] = await Promise.all([
+            this.signAuthorization(signAuthorization, wallet.address, bundle.chain),
+            this.createSignRawHash(wallet),
+        ]);
+        const [nonce, sponsorAddress] = await Promise.all([
+            this.getNonce(wallet.address, bundle.chain),
+            this.getSponsorAddress(),
+        ]);
+        const batchSignature = await this.signBatchCall(bundle.calls, nonce, deadline, sponsorAddress, signRawHash, wallet.address, bundle.chain);
+        const result = await this.sponsorTx({ calls: bundle.calls, signature: batchSignature, nonce, deadline }, authorization, wallet.address, bundle.chain);
+        results.set(bundle.chain, result);
+        return results;
+    }
+    /**
+     * Get the contract address for a specific chain.
+     * Fetches from the dedicated contract-address endpoint.
+     */
+    async getContractAddress(chainId) {
+        const response = await fetch(`${this.apiBaseUrl}/v1/relay/contract-address?chainId=${chainId}`, { headers: this.getHeaders() });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Failed to get contract address for chain ${chainId}: ${response.status} ${body}`);
+        }
+        const data = await response.json();
+        return getAddress(data.address);
+    }
+    async getSponsorAddress() {
+        const response = await fetch(`${this.apiBaseUrl}/v1/relay/sponsor`, {
+            headers: this.getHeaders(),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Failed to get sponsor address: ${response.status} ${body}`);
+        }
+        const data = await response.json();
+        return getAddress(data.sponsorAddress);
+    }
+    async getNonce(userAddress, chain) {
+        const chainId = resolveChainId(chain, this.defaultChain);
+        const metadata = await this.getNonceMetadata(userAddress, chainId);
+        return BigInt(metadata.nonce);
+    }
+    async getNonceMetadata(userAddress, chainId) {
+        const id = chainId ?? resolveChainId(undefined, this.defaultChain);
+        const response = await fetch(`${this.apiBaseUrl}/v1/relay/nonce/${userAddress}?chainId=${id}`, {
+            headers: this.getHeaders(),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Failed to get nonce metadata: ${response.status} ${body}`);
+        }
+        return response.json();
+    }
+    async simulateTx(authorization, signedBatch, userEOA, chain) {
+        const chainId = resolveChainId(chain, this.defaultChain);
+        const response = await fetch(`${this.apiBaseUrl}/v1/relay/simulate`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({
+                userEOA,
+                authorization,
+                calls: signedBatch.calls.map((c) => ({
+                    to: c.to,
+                    value: c.value.toString(),
+                    data: c.data,
+                })),
+                batchSignature: signedBatch.signature,
+                nonce: signedBatch.nonce.toString(),
+                deadline: signedBatch.deadline.toString(),
+                chainId,
+            }),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Simulation failed: ${response.status} ${body}`);
+        }
+        return response.json();
+    }
+    async sponsorTx(signedBatch, authorization, userEOA, chain) {
+        const chainId = resolveChainId(chain, this.defaultChain);
+        const response = await fetch(`${this.apiBaseUrl}/v1/relay/execute`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({
+                userEOA,
+                authorization,
+                calls: signedBatch.calls.map((c) => ({
+                    to: c.to,
+                    value: c.value.toString(),
+                    data: c.data,
+                })),
+                batchSignature: signedBatch.signature,
+                nonce: signedBatch.nonce.toString(),
+                deadline: signedBatch.deadline.toString(),
+                chainId,
+            }),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Failed to sponsor transaction: ${response.status} ${body}`);
+        }
+        return response.json();
+    }
+    async waitForTx(txHash, chain) {
+        const maxAttempts = 30;
+        const delayMs = 2000;
+        for (let i = 0; i < maxAttempts; i++) {
+            const status = await this.getTxStatus(txHash, chain);
+            if (status.status === 'confirmed' || status.status === 'failed') {
+                return status;
+            }
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+        return { status: 'pending' };
+    }
+    async getTxStatus(txHash, chain) {
+        const chainId = resolveChainId(chain, this.defaultChain);
+        const response = await fetch(`${this.apiBaseUrl}/v1/relay/transactions/${txHash}/status?chainId=${chainId}`, {
+            headers: this.getHeaders(),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Failed to get transaction status: ${response.status} ${body}`);
+        }
+        return response.json();
+    }
+}

package/dist/haru-v1.d.ts

@@ -0,0 +1,56 @@
+import type { Config, BaseHaruOptions } from '@harukit/types';
+import { TokensClient } from './clients/tokens';
+import { BalancesClient } from './clients/balances';
+import { SwapsClient } from './clients/swaps';
+import { TransfersClient } from './clients/transfers';
+import { RelayClient } from './clients/relay';
+export interface HaruOptions extends BaseHaruOptions {
+    apiKey: string;
+}
+/**
+ * Haru SDK v1 - Namespaced Client
+ *
+ * @example
+ * ```typescript
+ * const haru = new Haru({
+ *   apiKey: 'haru_live_demo123',
+ *   config: { chains: ['arbitrum'] },
+ * });
+ *
+ * // Tokens
+ * const tokens = await haru.tokens.search('USDC');
+ *
+ * // Balances
+ * const balances = await haru.balances.get('0x...');
+ *
+ * // Swaps
+ * const quote = await haru.swaps.getQuoteByUsd({
+ *   userAddress: '0x...',
+ *   fromSymbol: 'USDC',
+ *   toSymbol: 'WETH',
+ *   usdValue: '1000',
+ * });
+ *
+ * // Build transaction calls
+ * const calls = haru.swaps.buildCalls(quote);
+ * ```
+ */
+export declare class Haru {
+    readonly tokens: TokensClient;
+    readonly balances: BalancesClient;
+    readonly swaps: SwapsClient;
+    readonly transfers: TransfersClient;
+    readonly relay: RelayClient;
+    constructor(options: HaruOptions);
+    setConfig(config: Config): void;
+    /**
+     * Get current config
+     */
+    getConfig(): Config;
+}
+export * from './clients/tokens';
+export * from './clients/balances';
+export * from './clients/swaps';
+export * from './clients/transfers';
+export * from './clients/relay';
+//# sourceMappingURL=haru-v1.d.ts.map

package/dist/haru-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"haru-v1.d.ts","sourceRoot":"","sources":["../src/haru-v1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,MAAM,WAAW,WAAY,SAAQ,eAAe;IAClD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,IAAI;IACf,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;gBAEhB,OAAO,EAAE,WAAW;IAehC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ/B;;OAEG;IACH,SAAS,IAAI,MAAM;CAGpB;AAED,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

package/dist/haru-v1.js

@@ -0,0 +1,71 @@
+import { TokensClient } from './clients/tokens';
+import { BalancesClient } from './clients/balances';
+import { SwapsClient } from './clients/swaps';
+import { TransfersClient } from './clients/transfers';
+import { RelayClient } from './clients/relay';
+/**
+ * Haru SDK v1 - Namespaced Client
+ *
+ * @example
+ * ```typescript
+ * const haru = new Haru({
+ *   apiKey: 'haru_live_demo123',
+ *   config: { chains: ['arbitrum'] },
+ * });
+ *
+ * // Tokens
+ * const tokens = await haru.tokens.search('USDC');
+ *
+ * // Balances
+ * const balances = await haru.balances.get('0x...');
+ *
+ * // Swaps
+ * const quote = await haru.swaps.getQuoteByUsd({
+ *   userAddress: '0x...',
+ *   fromSymbol: 'USDC',
+ *   toSymbol: 'WETH',
+ *   usdValue: '1000',
+ * });
+ *
+ * // Build transaction calls
+ * const calls = haru.swaps.buildCalls(quote);
+ * ```
+ */
+export class Haru {
+    tokens;
+    balances;
+    swaps;
+    transfers;
+    relay;
+    constructor(options) {
+        const baseUrl = options.baseUrl || 'https://api.haruapi.com';
+        const clientOptions = {
+            apiKey: options.apiKey,
+            baseUrl,
+            config: options.config,
+        };
+        this.tokens = new TokensClient(clientOptions);
+        this.balances = new BalancesClient(clientOptions);
+        this.swaps = new SwapsClient(clientOptions);
+        this.transfers = new TransfersClient(clientOptions);
+        this.relay = new RelayClient(clientOptions);
+    }
+    setConfig(config) {
+        this.tokens.setConfig(config);
+        this.balances.setConfig(config);
+        this.swaps.setConfig(config);
+        this.transfers.setConfig(config);
+        this.relay.setConfig(config);
+    }
+    /**
+     * Get current config
+     */
+    getConfig() {
+        return this.tokens.getConfig();
+    }
+}
+export * from './clients/tokens';
+export * from './clients/balances';
+export * from './clients/swaps';
+export * from './clients/transfers';
+export * from './clients/relay';

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Haru7702 } from './haru-7702';
+export type { Haru7702Options, ChainCallBundle } from '@harukit/types';
+export { Haru, type HaruOptions } from './haru-v1';
+export { BalancesClient } from './clients/balances';
+export { SwapsClient, type SwapByUsdParams, type SwapByAmountParams } from './clients/swaps';
+export { TransfersClient, type TransferByUsdParams, type TransferByAmountParams } from './clients/transfers';
+export type { Config, HydratedToken, CategorizedBalanceResult, CleanSwapQuote, CleanTransfer, } from '@harukit/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGvE,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,KAAK,mBAAmB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAG7G,YAAY,EACV,MAAM,EACN,aAAa,EACb,wBAAwB,EACxB,cAAc,EACd,aAAa,GACd,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// v1 SDK - Namespaced client with EIP-7702 batch transactions
+export { Haru7702 } from './haru-7702';
+// v1 SDK - Namespaced client for swaps, transfers, and balances
+export { Haru } from './haru-v1';
+export { BalancesClient } from './clients/balances';
+export { SwapsClient } from './clients/swaps';
+export { TransfersClient } from './clients/transfers';

package/dist/utils/callBuilder.d.ts

@@ -0,0 +1,4 @@
+import type { SwapQuoteStep, EIP7702Call, PrivyCall } from '@harukit/types';
+export declare function extractCallsFromSteps(steps: SwapQuoteStep[]): EIP7702Call[];
+export declare function extractPrivyCalls(steps: SwapQuoteStep[]): PrivyCall[];
+//# sourceMappingURL=callBuilder.d.ts.map

package/dist/utils/callBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callBuilder.d.ts","sourceRoot":"","sources":["../../src/utils/callBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE5E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,WAAW,EAAE,CAS3E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,CASrE"}

package/dist/utils/callBuilder.js

@@ -0,0 +1,20 @@
+export function extractCallsFromSteps(steps) {
+    if (!steps || steps.length === 0) {
+        return [];
+    }
+    return steps.map((step) => ({
+        to: step.data.to,
+        value: BigInt(step.data.value || '0'),
+        data: step.data.data,
+    }));
+}
+export function extractPrivyCalls(steps) {
+    if (!steps || steps.length === 0) {
+        return [];
+    }
+    return steps.map((step) => ({
+        to: step.data.to,
+        data: step.data.data,
+        value: BigInt(step.data.value || '0'),
+    }));
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@harukit/sdk",
+  "version": "1.0.0",
+  "description": "Haru SDK for chain abstraction",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run build"
+  },
+  "files": ["dist"],
+  "dependencies": {
+    "@harukit/types": "workspace:*",
+    "@harukit/shared": "workspace:*",
+    "viem": "^2.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0"
+  }
+}