@dzapio/sdk 2.0.4 → 2.0.5

package/dist/examples/chain-utils.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/chain-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+const dZapClient = src_1.DZapClient.getInstance();
+async function runChainUtilsExamples() {
+    console.log('Running Chain Utilities examples...');
+    console.log('\nFetching all supported chains...');
+    try {
+        const allChains = await dZapClient.getAllSupportedChains();
+        console.log(`Found ${Object.keys(allChains).length} supported chains.`);
+        const chainSubset = Object.fromEntries(Object.entries(allChains)
+            .slice(0, 3)
+            .map(([key, value]) => [key, { name: value.name, chainId: value.chainId, coin: value.coin }]));
+        console.log('Chain subset:', JSON.stringify(chainSubset, null, 2));
+    }
+    catch (error) {
+        console.error('Error fetching all chains:', error);
+    }
+}
+runChainUtilsExamples();

package/dist/examples/permit-utils.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/permit-utils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const src_1 = require("../src");
+const dZapClient = src_1.DZapClient.getInstance();
+const walletClient = (0, viem_1.createWalletClient)({
+    transport: (0, viem_1.http)(),
+    account: '0xYourWalletAddress',
+    chain: chains_1.arbitrum,
+});
+async function runPermitExamples() {
+    console.log('Running Permit examples...');
+    const chainId = 42161;
+    const senderAddress = '0xYourWalletAddress';
+    const tokenToApprove = '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1';
+    const amountToTrade = (0, viem_1.parseUnits)('1000', 18).toString();
+    const rpcUrls = ['https://arb1.arbitrum.io/rpc'];
+    console.log('\nChecking allowance...');
+    try {
+        const allowanceResponse = await dZapClient.getAllowance({
+            chainId,
+            sender: senderAddress,
+            service: src_1.Services.trade,
+            tokens: [{ address: tokenToApprove, amount: amountToTrade }],
+            rpcUrls,
+            mode: src_1.ApprovalModes.PermitWitnessTransferFrom,
+        });
+        console.log('Allowance details:', JSON.stringify(allowanceResponse, null, 2));
+        const { approvalNeeded } = allowanceResponse.data[tokenToApprove];
+        if (walletClient.account && approvalNeeded) {
+            console.log('\nAllowance is insufficient. Requesting approval...');
+            try {
+                await dZapClient.approve({
+                    chainId,
+                    signer: walletClient,
+                    service: src_1.Services.trade,
+                    mode: src_1.ApprovalModes.PermitWitnessTransferFrom,
+                    tokens: [{ address: tokenToApprove, amount: amountToTrade }],
+                    approvalTxnCallback: async ({ txnDetails, address, }) => {
+                        console.log(`Approval transaction sent for ${address}:`, txnDetails);
+                        return null;
+                    },
+                });
+                console.log('Approval transaction sent. Please confirm in your wallet.');
+            }
+            catch (error) {
+                console.error('Error during approval:', error);
+            }
+        }
+        else if (!walletClient.account) {
+            console.log('\nSkipping approval check as no wallet client is available.');
+        }
+        else {
+            console.log('\nSufficient allowance already granted.');
+        }
+    }
+    catch (error) {
+        console.error('An error occurred checking allowance:', error);
+    }
+    console.log('\nSigning permit...');
+    if (walletClient.account) {
+        try {
+            const signResponse = await dZapClient.sign({
+                chainId,
+                signer: walletClient,
+                sender: senderAddress,
+                service: src_1.Services.trade,
+                permitType: src_1.PermitTypes.PermitWitnessTransferFrom,
+                tokens: [
+                    {
+                        address: tokenToApprove,
+                        amount: amountToTrade.toString(),
+                    },
+                ],
+                signatureCallback: async (params) => {
+                    console.log(`Signature received for`, params);
+                },
+            });
+            console.log('Sign response:', signResponse);
+        }
+        catch (error) {
+            console.error('Error signing permit:', error);
+        }
+    }
+    else {
+        console.log('Skipping sign permit as no wallet client is available.');
+    }
+}
+runPermitExamples();

package/dist/examples/token-utils.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/token-utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+const dZapClient = src_1.DZapClient.getInstance();
+async function runTokenUtilsExamples() {
+    console.log('Running Token Utilities examples...');
+    const arbitrumChainId = 42161;
+    console.log(`\nFetching all tokens for chain ${arbitrumChainId}...`);
+    try {
+        const allTokens = await dZapClient.getAllTokens(arbitrumChainId);
+        console.log(`Found ${Object.keys(allTokens).length} tokens.`);
+        console.log('First 5 tokens:', Object.fromEntries(Object.entries(allTokens).slice(0, 5)));
+    }
+    catch (error) {
+        console.error('Error fetching all tokens:', error);
+    }
+    const usdcAddress = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
+    const userAddress = '0xYourWalletAddress';
+    console.log(`\nFetching details for USDC on arbitrum...`);
+    try {
+        const tokenDetails = await dZapClient.getTokenDetails(usdcAddress, arbitrumChainId, userAddress, true, true);
+        console.log('Token details:', JSON.stringify(tokenDetails, null, 2));
+    }
+    catch (error) {
+        console.error('Error fetching token details:', error);
+    }
+    const tokensToPrice = [
+        '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+        '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619',
+        '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+    ];
+    console.log(`\nFetching prices for ${tokensToPrice.length} tokens...`);
+    try {
+        const tokenPrices = await dZapClient.getTokenPrices(tokensToPrice, arbitrumChainId);
+        console.log('Token prices:', JSON.stringify(tokenPrices, null, 2));
+    }
+    catch (error) {
+        console.error('Error fetching token prices:', error);
+    }
+}
+runTokenUtilsExamples();

package/dist/examples/trade-operations.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/trade-operations.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const src_1 = require("../src");
+const dZapClient = src_1.DZapClient.getInstance();
+const walletClient = (0, viem_1.createWalletClient)({
+    transport: (0, viem_1.http)(),
+    account: '0xYourWalletAddress',
+    chain: chains_1.arbitrum,
+});
+async function runTradeExamples() {
+    console.log('Running Swap and Bridge examples...');
+    console.log('\nFetching quotes...');
+    const userAddress = walletClient.account.address;
+    const quotesRequest = {
+        fromChain: 42161,
+        data: [
+            {
+                amount: '374980',
+                srcToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                destToken: '0x4200000000000000000000000000000000000006',
+                toChain: 8453,
+                slippage: 1,
+            },
+        ],
+        account: userAddress,
+    };
+    try {
+        const quotesResponse = await dZapClient.getTradeQuotes(quotesRequest);
+        console.log('Quotes received:', JSON.stringify(quotesResponse, null, 2));
+        const pairKey = Object.keys(quotesResponse)[0];
+        const pairQuoteData = quotesResponse[pairKey];
+        if (!pairQuoteData.quoteRates || Object.keys(pairQuoteData.quoteRates).length === 0) {
+            console.log('No routes found for the requested trade.');
+            return;
+        }
+        const bestRouteKey = pairQuoteData.recommendedSource;
+        const bestQuote = pairQuoteData.quoteRates[bestRouteKey];
+        console.log(`\nBest route found via ${bestRouteKey}`);
+        console.log('\nApproval is likely required for non-native tokens.');
+        console.log('\nBuilding and sending transaction...');
+        const buildTxRequest = {
+            fromChain: 42161,
+            sender: userAddress,
+            refundee: userAddress,
+            gasless: false,
+            data: [
+                {
+                    amount: bestQuote.srcAmount,
+                    srcToken: bestQuote.srcToken.address,
+                    destToken: bestQuote.destToken.address,
+                    toChain: 8453,
+                    protocol: bestRouteKey,
+                    recipient: userAddress,
+                    slippage: 1,
+                },
+            ],
+        };
+        const txResult = await dZapClient.trade({
+            request: buildTxRequest,
+            signer: walletClient,
+        });
+        console.log('Transaction response:', txResult);
+        if (txResult.status === 'success' && txResult.txnHash) {
+            console.log(`Transaction sent successfully! Hash: ${txResult.txnHash}`);
+            console.log('\nFetching transaction status in 15 seconds...');
+            setTimeout(async () => {
+                try {
+                    const statusResponse = (await dZapClient.getTradeTxnStatus({
+                        txHash: txResult.txnHash,
+                        chainId: 42161,
+                    }));
+                    console.log('Transaction status:', JSON.stringify(statusResponse, null, 2));
+                }
+                catch (e) {
+                    console.error('Error getting status:', e);
+                }
+            }, 15000);
+        }
+        else {
+            console.error('Transaction failed or hash not found:', txResult.errorMsg);
+        }
+    }
+    catch (error) {
+        console.error('An error occurred during swap/bridge operations:', error);
+    }
+}
+runTradeExamples();

package/dist/examples/zap-operations.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/zap-operations.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const src_1 = require("../src");
+const dZapClient = src_1.DZapClient.getInstance();
+const walletClient = (0, viem_1.createWalletClient)({
+    transport: (0, viem_1.http)(),
+    account: '0xYourWalletAddress',
+    chain: chains_1.arbitrum,
+});
+async function runZapExamples() {
+    console.log('Running Zap examples...');
+    const userAddress = '0xYourWalletAddress';
+    console.log('\nFetching zap quote...');
+    const zapQuoteRequest = {
+        srcChainId: 42161,
+        destChainId: 42161,
+        account: userAddress,
+        srcToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        destToken: '0x724dc807b04555b71ed48a6896b6F41593b8C637',
+        amount: '374980',
+        recipient: userAddress,
+        refundee: userAddress,
+        slippage: 1,
+    };
+    try {
+        const zapQuoteResponse = await dZapClient.getZapQuote(zapQuoteRequest);
+        console.log('Zap quote received:', JSON.stringify(zapQuoteResponse, null, 2));
+        if (!zapQuoteResponse) {
+            console.log('Could not generate a zap transaction plan.');
+            return;
+        }
+        console.log('\nApproval is likely required for non-native tokens.');
+        console.log('\nExecuting zap...');
+        if (walletClient.account) {
+            try {
+                const zapResult = await dZapClient.zap({
+                    request: zapQuoteRequest,
+                    signer: walletClient,
+                });
+                console.log('Zap execution result:', zapResult);
+                if (zapResult.status !== src_1.TxnStatus.success || !zapResult.txnHash) {
+                    throw new Error('Zap execution failed');
+                }
+                const txnHash = zapResult.txnHash;
+                setTimeout(async () => {
+                    try {
+                        const statusResponse = await dZapClient.getZapTxnStatus({ chainId: 42161, txnHash });
+                        console.log('Zap transaction status:', JSON.stringify(statusResponse, null, 2));
+                    }
+                    catch (e) {
+                        console.error('Error getting zap status:', e);
+                    }
+                }, 15000);
+            }
+            catch (error) {
+                console.error('Error during zap execution:', error);
+            }
+        }
+        else {
+            console.log('Skipping zap execution as no wallet client is available.');
+        }
+    }
+    catch (error) {
+        console.error('An error occurred during zap operations:', error);
+    }
+}
+runZapExamples();

package/dist/src/api/index.d.ts

@@ -0,0 +1,26 @@
+import { CancelToken } from 'axios';
+import { BroadcastTxParams, CalculatePointsRequest, GaslessExecuteTxParams, TradeBuildTxnRequest, TradeQuotesRequest } from '../types';
+import { ZapBuildTxnRequest, ZapPoolDetailsRequest, ZapPoolsRequest, ZapPositionsRequest, ZapQuoteRequest, ZapStatusRequest } from '../types/zap';
+export declare const fetchTradeQuotes: (request: TradeQuotesRequest) => Promise<any>;
+export declare const fetchTradeBuildTxnData: (request: TradeBuildTxnRequest) => Promise<any>;
+export declare const executeGaslessTxnData: (request: GaslessExecuteTxParams) => Promise<any>;
+export declare const broadcastTx: (request: BroadcastTxParams) => Promise<any>;
+export declare const fetchZapBuildTxnData: (request: ZapBuildTxnRequest, cancelToken?: CancelToken) => Promise<any>;
+export declare const fetchZapQuote: (request: ZapQuoteRequest, cancelToken?: CancelToken) => Promise<any>;
+export declare const fetchZapTxnStatus: (request: ZapStatusRequest) => Promise<any>;
+export declare const fetchZapPositions: (request: ZapPositionsRequest) => Promise<any>;
+export declare const fetchZapPools: (request: ZapPoolsRequest) => Promise<any>;
+export declare const fetchZapPoolDetails: (request: ZapPoolDetailsRequest) => Promise<any>;
+export declare const fetchZapChains: () => Promise<any>;
+export declare const fetchZapProviders: () => Promise<any>;
+export declare const fetchAllSupportedChains: () => Promise<any>;
+export declare const fetchAllTokens: (chainId: number, source?: string, account?: string) => Promise<any>;
+export declare const fetchTokenDetails: (tokenAddress: string | string[], chainId: number, account?: string, includeBalance?: boolean, includePrice?: boolean) => Promise<any>;
+export declare const fetchTokenPrice: (tokenAddresses: string[], chainId: number) => Promise<any>;
+export declare const fetchStatus: ({ txHash, txIds, chainId }: {
+    txHash?: string;
+    txIds?: string;
+    chainId?: number;
+}) => Promise<any>;
+export declare const fetchCalculatedPoints: (request: CalculatePointsRequest) => Promise<any>;
+export declare const fetchBalances: (chainId: number, account: string) => Promise<any>;

package/dist/src/api/index.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchBalances = exports.fetchCalculatedPoints = exports.fetchStatus = exports.fetchTokenPrice = exports.fetchTokenDetails = exports.fetchAllTokens = exports.fetchAllSupportedChains = exports.fetchZapProviders = exports.fetchZapChains = exports.fetchZapPoolDetails = exports.fetchZapPools = exports.fetchZapPositions = exports.fetchZapTxnStatus = exports.fetchZapQuote = exports.fetchZapBuildTxnData = exports.broadcastTx = exports.executeGaslessTxnData = exports.fetchTradeBuildTxnData = exports.fetchTradeQuotes = void 0;
+const httpMethods_1 = require("../constants/httpMethods");
+const urlConstants_1 = require("../constants/urlConstants");
+const axios_1 = require("../utils/axios");
+const urls_1 = require("../zap/constants/urls");
+const fetchTradeQuotes = (request) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.QUOTES_URL,
+    data: request,
+    method: httpMethods_1.POST,
+    shouldRetry: true,
+});
+exports.fetchTradeQuotes = fetchTradeQuotes;
+const fetchTradeBuildTxnData = (request) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.BUILD_TX_URL,
+    data: request,
+    method: httpMethods_1.POST,
+});
+exports.fetchTradeBuildTxnData = fetchTradeBuildTxnData;
+const executeGaslessTxnData = (request) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.GASLESS_EXECUTE_TX_URL,
+    data: request,
+    method: httpMethods_1.POST,
+});
+exports.executeGaslessTxnData = executeGaslessTxnData;
+const broadcastTx = (request) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.BROADCAST_TX,
+    data: request,
+    method: httpMethods_1.POST,
+});
+exports.broadcastTx = broadcastTx;
+const fetchZapBuildTxnData = (request, cancelToken) => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.buildTx,
+    data: request,
+    method: httpMethods_1.POST,
+    cancelToken,
+});
+exports.fetchZapBuildTxnData = fetchZapBuildTxnData;
+const fetchZapQuote = (request, cancelToken) => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.quote,
+    data: request,
+    method: httpMethods_1.POST,
+    cancelToken,
+});
+exports.fetchZapQuote = fetchZapQuote;
+const fetchZapTxnStatus = (request) => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.status,
+    data: request,
+    method: httpMethods_1.GET,
+});
+exports.fetchZapTxnStatus = fetchZapTxnStatus;
+const fetchZapPositions = (request) => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.positions,
+    data: request,
+    method: httpMethods_1.GET,
+});
+exports.fetchZapPositions = fetchZapPositions;
+const fetchZapPools = (request) => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.pools,
+    data: request,
+    method: httpMethods_1.GET,
+});
+exports.fetchZapPools = fetchZapPools;
+const fetchZapPoolDetails = (request) => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.poolDetails,
+    data: request,
+    method: httpMethods_1.GET,
+});
+exports.fetchZapPoolDetails = fetchZapPoolDetails;
+const fetchZapChains = () => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.config.chains,
+    method: httpMethods_1.GET,
+});
+exports.fetchZapChains = fetchZapChains;
+const fetchZapProviders = () => (0, axios_1.invokeZap)({
+    endpoint: urls_1.ZAP_ENDPOINTS.config.providers,
+    method: httpMethods_1.GET,
+});
+exports.fetchZapProviders = fetchZapProviders;
+const fetchAllSupportedChains = () => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.GET_ALL_CHAINS_URL,
+    data: {},
+    method: httpMethods_1.GET,
+    shouldRetry: true,
+});
+exports.fetchAllSupportedChains = fetchAllSupportedChains;
+const fetchAllTokens = (chainId, source, account) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.GET_ALL_TOKENS_URL,
+    data: { chainId, source, account },
+    method: httpMethods_1.GET,
+    shouldRetry: true,
+});
+exports.fetchAllTokens = fetchAllTokens;
+const fetchTokenDetails = (tokenAddress, chainId, account, includeBalance, includePrice) => {
+    const data = {
+        tokenAddress: Array.isArray(tokenAddress) ? undefined : tokenAddress,
+        tokenAddresses: Array.isArray(tokenAddress) ? tokenAddress.join(',') : undefined,
+        chainId,
+        account,
+        includeBalance,
+        includePrice,
+    };
+    return (0, axios_1.invoke)({
+        endpoint: urlConstants_1.GET_TOKEN_DETAILS_URL,
+        data,
+        method: httpMethods_1.GET,
+    });
+};
+exports.fetchTokenDetails = fetchTokenDetails;
+const fetchTokenPrice = (tokenAddresses, chainId) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.GET_TOKEN_PRICE,
+    data: { tokenAddresses, chainId },
+    method: httpMethods_1.GET,
+});
+exports.fetchTokenPrice = fetchTokenPrice;
+const fetchStatus = ({ txHash, txIds, chainId }) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.GET_STATUS,
+    data: {
+        txHash,
+        txIds,
+        chainId,
+    },
+    method: httpMethods_1.GET,
+});
+exports.fetchStatus = fetchStatus;
+const fetchCalculatedPoints = (request) => (0, axios_1.invoke)({
+    endpoint: urlConstants_1.CALCULATE_POINTS_URL,
+    data: request,
+    method: httpMethods_1.POST,
+});
+exports.fetchCalculatedPoints = fetchCalculatedPoints;
+const fetchBalances = (chainId, account) => {
+    return (0, axios_1.invoke)({
+        endpoint: urlConstants_1.GET_BALANCES,
+        data: { chainId, account },
+        method: httpMethods_1.GET,
+    });
+};
+exports.fetchBalances = fetchBalances;