@dzapio/sdk 1.0.1

package/dist/transactionHandlers/trade.d.ts

@@ -0,0 +1,11 @@
+import { TradeBuildTxnRequest, TradeBuildTxnResponse, DZapTransactionResponse } from '../types';
+import { Signer } from 'ethers';
+import { WalletClient } from 'viem';
+declare class TradeTxnHandler {
+    static buildAndSendTransaction: ({ request, signer, txnData, }: {
+        request: TradeBuildTxnRequest;
+        signer: Signer | WalletClient;
+        txnData?: TradeBuildTxnResponse;
+    }) => Promise<DZapTransactionResponse>;
+}
+export default TradeTxnHandler;

package/dist/transactionHandlers/zap.d.ts

@@ -0,0 +1,37 @@
+import { Signer } from 'ethers';
+import { StatusCodes, TxnStatus } from 'src/enums';
+import { DZapTransactionResponse, HexString } from 'src/types';
+import { WalletClient } from 'viem';
+import { ZapStep, ZapTxnDetails } from '../types/zap/step';
+import { ZapBuildTxnRequest } from 'src/types/zap';
+declare class ZapTxnHandler {
+    static execute: ({ chainId, txnData, signer, }: {
+        chainId: number;
+        txnData: ZapTxnDetails;
+        signer: Signer | WalletClient;
+    }) => Promise<DZapTransactionResponse>;
+    static approve: ({ chainId, data, signer }: {
+        chainId: number;
+        data: ZapTxnDetails;
+        signer: Signer | WalletClient;
+    }) => Promise<{
+        status: TxnStatus;
+        error: any;
+        errorMsg: any;
+        code: StatusCodes;
+    } | {
+        status: TxnStatus;
+        code: StatusCodes;
+        txnHash: HexString;
+    }>;
+    static zap: ({ request, steps, signer, }: {
+        request: ZapBuildTxnRequest;
+        steps?: ZapStep[];
+        signer: Signer | WalletClient;
+    }) => Promise<{
+        status: TxnStatus.success;
+        code: StatusCodes | number;
+        txnHash: HexString;
+    } | DZapTransactionResponse>;
+}
+export default ZapTxnHandler;

package/dist/types/axiosClient.d.ts

@@ -0,0 +1,6 @@
+import { AxiosRequestConfig, CancelToken } from 'axios';
+export type ExtendedAxiosRequestConfig = {
+    shouldRetry?: boolean;
+    retryCount?: number;
+    cancelToken?: CancelToken;
+} & AxiosRequestConfig;

package/dist/types/btc.d.ts

@@ -0,0 +1,45 @@
+export type Witness = {
+    value: number;
+    script: string;
+};
+type PsbtInputP2PKH = {
+    scriptType: 'p2pkh';
+    nonWitnessUtxo: Buffer;
+    redeemScript?: never;
+};
+type PsbtInputP2SH = {
+    scriptType: 'p2sh';
+    witnessUtxo: Witness;
+    redeemScript: Buffer;
+    redeemScriptArgumentByteLengths?: number[];
+};
+type PsbtInputP2WPKH = {
+    scriptType: 'p2wpkh';
+    witnessUtxo: Witness;
+    redeemScript?: never;
+};
+type PsbtInputP2WSH = {
+    scriptType: 'p2wsh';
+    witnessUtxo: Witness;
+    witnessScript: Buffer;
+};
+type PsbtInputP2TR = {
+    scriptType: 'p2tr';
+    witnessUtxo: Witness;
+    tapInternalKey: Buffer;
+};
+export type PsbtInput = {
+    hash: string;
+    index: number;
+    sequence: number;
+    value: number;
+} & (PsbtInputP2PKH | PsbtInputP2SH | PsbtInputP2WPKH | PsbtInputP2TR | PsbtInputP2WSH);
+export type PsbtOutput = {
+    address: string;
+    script?: Buffer;
+    value: number;
+} | {
+    script: string;
+    value: number;
+};
+export {};

package/dist/types/chains.d.ts

@@ -0,0 +1,2 @@
+import { exclusiveChainIds } from 'src/constants/chains';
+export type ExclusiveChainIds = (typeof exclusiveChainIds)[keyof typeof exclusiveChainIds];

package/dist/types/contract.d.ts

@@ -0,0 +1,14 @@
+import { Versions } from 'src/enums';
+import { AvailableDZapServices } from '.';
+export type ContractConfig = {
+    [serviceKey in AvailableDZapServices]: {
+        [versionKey in Versions]?: {
+            address: ContractAddress;
+            abi: string;
+        };
+    };
+};
+export type ContractAddress = {
+    otherChains: string;
+    zkSync: string;
+};

package/dist/types/eip-2612.d.ts

@@ -0,0 +1,6 @@
+export declare const EIP2612Types: {
+    Permit: {
+        name: string;
+        type: string;
+    }[];
+};

package/dist/types/index.d.ts

@@ -0,0 +1,317 @@
+import { DZapAbis, OtherAbis, QuoteFilters, Services, STATUS_RESPONSE } from 'src/constants';
+import { AppEnv, StatusCodes, TxnStatus } from 'src/enums';
+import { PsbtInput, PsbtOutput } from './btc';
+import { PermitTypes } from 'src/constants/permit';
+import { ApprovalModes } from 'src/constants/approval';
+export type HexString = `0x${string}`;
+export type ChainData = {
+    [key in number]: Chain;
+};
+export type NativeTokenInfo = {
+    contract: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    balance: string;
+    price?: string;
+};
+export declare const contractErrorActions: {
+    readonly TRY_ANOTHER_ROUTE: "TRY_ANOTHER_ROUTE";
+    readonly INCREASE_SLIPPAGE: "INCREASE_SLIPPAGE";
+    readonly INCREASE_ALLOWANCE: "INCREASE_ALLOWANCE";
+};
+export type ContractErrorResponse = {
+    status: string;
+    txId: string;
+    code: number;
+    message: string;
+    error: unknown;
+    action: keyof typeof contractErrorActions;
+    details?: unknown;
+};
+export type CalculatePointsRequest = {
+    srcTokens: {
+        amount: string;
+        address: string;
+        decimals: number;
+    }[];
+    destTokens: {
+        amount: string;
+        address: string;
+        decimals: number;
+    }[];
+    providers: string[];
+    chainId: number;
+    account: string;
+    txType: 'swap' | 'bridge';
+};
+export type DisabledPermitTokens = {
+    eip2612: string[];
+};
+export type Chain = {
+    coinKey: string;
+    chainId: number;
+    chainType: string;
+    name: string;
+    coin: string;
+    dcaContract: string;
+    swapBridgeContract: string;
+    logo: string;
+    tokenlistUrl?: string;
+    multicallAddress: string;
+    blockExplorerUrl: string;
+    nativeToken: NativeTokenInfo;
+    rpcProviders: ApiRpcResponse[];
+    pricingAvailable: boolean;
+    balanceAvailable: boolean;
+    supportedAs: {
+        source: boolean;
+        destination: boolean;
+    };
+    contracts?: Partial<{
+        router: string;
+        dca: string;
+        zap: string;
+    }>;
+    coingecko?: {
+        chainKey: string;
+        nativeTokenKey: string;
+    };
+    defiLlama?: {
+        chainKey: string;
+        nativeTokenKey: string;
+    };
+    disableMultiTxn: boolean;
+    isEnabled: boolean;
+    mainnet: boolean;
+    tags?: Tag[];
+    permitDisabledTokens?: DisabledPermitTokens;
+};
+export type ApiRpcResponse = {
+    url: string;
+    keyRequired: boolean;
+    keyType?: 'ALCHEMY_KEY' | 'BLASTAPI_KEY';
+};
+export type ProviderDetails = {
+    id: string;
+    name: string;
+    icon: string;
+};
+export type FeeDetails = {
+    address: string;
+    decimals: number;
+    chainId: number;
+    symbol: string;
+    logo?: string;
+    amount: string;
+    amountUSD: string;
+    included: boolean;
+};
+export type Fee = {
+    gasFee: FeeDetails[];
+    protocolFee: FeeDetails[];
+    providerFee: FeeDetails[];
+};
+export type QuoteFilter = keyof typeof QuoteFilters;
+export type TradeQuotesRequest = {
+    integratorId: string;
+    fromChain: number;
+    data: TradeQuotesRequestData[];
+    disableEstimation?: boolean;
+    account?: string;
+    allowedSources?: string[];
+    filter?: QuoteFilter;
+};
+export type TradeQuotesRequestData = {
+    amount: string;
+    srcToken: string;
+    srcDecimals: number;
+    destToken: string;
+    destDecimals: number;
+    toChain: number;
+    slippage: number;
+    selectedSource?: string;
+};
+export type TradeStep = {
+    type: string;
+    exchange: {
+        logo: string;
+        name: string;
+    };
+};
+export type TradePath = {
+    type: string;
+    exchange: ProviderDetails;
+    srcToken: Token;
+    srcAmount: string;
+    srcAmountUSD: string;
+    destToken: Token;
+    destAmount: string;
+    destAmountUSD: string;
+    fee: Fee;
+};
+export type Tag = {
+    title: string;
+    link?: string;
+    message?: string;
+};
+export type TradeQuote = {
+    bridgeDetails?: ProviderDetails;
+    providerDetails: ProviderDetails;
+    srcAmount: string;
+    srcAmountUSD: string;
+    destAmount: string;
+    destAmountUSD: string;
+    minDestAmount: string;
+    swapPerUnit: string;
+    srcToken: Token;
+    destToken: Token;
+    fee: Fee;
+    priceImpactPercent: string;
+    duration: string;
+    steps: TradeStep[];
+    path: TradePath[];
+    tags?: Tag[];
+    additionalInfo?: AdditionalInfo;
+};
+export type TradeQuotesByProviderId = {
+    [providerAndBridge: string]: TradeQuote;
+};
+export type TradeQuotesResponse = {
+    [pair: string]: {
+        status?: string;
+        message?: string;
+        recommendedSource: string;
+        fastestSource?: string;
+        bestReturnSource: string;
+        questSource?: string;
+        quoteRates?: TradeQuotesByProviderId;
+        tokensWithoutPrice: Record<number, string[]>;
+    };
+};
+export type AdditionalInfo = {
+    [key: string]: unknown;
+};
+export type Token = {
+    address: HexString;
+    decimals: number;
+    chainId: number;
+    logo: string;
+    symbol: string;
+    price?: string;
+};
+export type TokenInfo = NativeTokenInfo & {
+    chainId: number;
+    balanceInUsd?: number | null;
+    isDisabledOnSwapBridge?: {
+        source: boolean;
+        destination: boolean;
+    };
+    isDisabledOnZap?: {
+        source: boolean;
+        destination: boolean;
+    };
+};
+export type TokenResponse = {
+    [key: string]: TokenInfo;
+};
+export type TradeBuildTxnRequest = {
+    sender: HexString;
+    refundee: HexString;
+    integratorId: string;
+    fromChain: number;
+    disableEstimation?: boolean;
+    data: TradeBuildTxnRequestData[];
+    publicKey?: string;
+};
+export type TradeBuildTxnRequestData = {
+    amount: string;
+    srcToken: string;
+    srcDecimals: number;
+    destToken: string;
+    destDecimals: number;
+    toChain: number;
+    selectedRoute: string;
+    recipient: string;
+    slippage: number;
+    additionalInfo?: AdditionalInfo;
+    permitData?: string;
+};
+export type ExecuteTxnData = {
+    data: HexString;
+    to: HexString;
+    from: HexString;
+    chainId: number;
+    value: string;
+    gasLimit: string;
+};
+export type TradeBuildTxnResponse = ExecuteTxnData & {
+    additionalInfo?: AdditionalInfo;
+    btcTxData?: {
+        inputs: PsbtInput[];
+        outputs: PsbtOutput[];
+        feeRate: number;
+    };
+    svmTxData?: {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    };
+    updatedQuotes: Record<string, string>;
+};
+export type AvailableDZapServices = (typeof Services)[keyof typeof Services];
+export type DZapAvailableAbis = (typeof DZapAbis)[keyof typeof DZapAbis];
+export type OtherAvailableAbis = (typeof OtherAbis)[keyof typeof OtherAbis];
+export type AppEnvType = `${AppEnv}`;
+export type DZapTransactionResponse = {
+    status: TxnStatus;
+    errorMsg?: string;
+    code: StatusCodes | number;
+    action?: keyof typeof contractErrorActions;
+    txnHash?: HexString;
+    error?: unknown;
+    additionalInfo?: Record<string, unknown>;
+    updatedQuotes?: Record<string, string>;
+};
+export type SwapInfo = {
+    dex: string;
+    fromToken: string;
+    fromAmount: bigint;
+    toToken: string;
+    returnToAmount: bigint;
+};
+export type PartialStatusData = {
+    receiveToken?: string;
+    receiveAmount?: string;
+    receiveAmountUSD?: string;
+};
+export type RefundStatusData = {
+    refundTxHash?: string;
+    refundToken?: string;
+    refundAmount?: string;
+    refundAmountUSD?: string;
+    refundTimeStamp?: string;
+};
+export type TradeStatusResponseData = PartialStatusData & RefundStatusData & {
+    srcChainId: number;
+    srcToken: string;
+    srcAmount: string;
+    srcAmountUSD: string;
+    srcTxHash: string;
+    destChainId: number;
+    destToken: string;
+    destAmount: string;
+    destAmountUSD: string;
+    destTxHash: string;
+    account: string;
+    recipient: string;
+    provider: string;
+    allowUserTxOnDestChain: boolean;
+    status: keyof typeof STATUS_RESPONSE;
+    outputToken?: string;
+    refundTxHash?: string;
+};
+export type TradeStatusResponse = {
+    [pair: string]: TradeStatusResponseData;
+};
+export type PermitMode = keyof typeof PermitTypes;
+export type ApprovalMode = Exclude<keyof typeof ApprovalModes, 'EIP2612Permit'>;

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

@@ -0,0 +1,65 @@
+import { HexString, ProviderDetails } from 'src/types';
+import { ZapPath, ZapPathAsset } from './path';
+import { ZapStep } from './step';
+export type ZapBuildTxnResponse = {
+    amountOut: string;
+    approvalData: {
+        callTo: HexString;
+        approveTo: HexString;
+        amount: string;
+    } | null;
+    steps: ZapStep[];
+    path: ZapPath[];
+};
+export type ZapQuoteResponse = Omit<ZapBuildTxnResponse, 'steps'>;
+export type ZapBuildTxnRequest = {
+    srcToken: HexString;
+    srcChainId: number;
+    destToken: HexString;
+    destChainId: number;
+    recipient: HexString;
+    refundee: HexString;
+    slippage: number;
+    account: HexString;
+    permitData?: HexString;
+    amount?: string;
+    estimateGas?: boolean;
+    positionDetails?: ZapRouteRequestPositionDetails;
+    poolDetails?: ZapRouteRequestPoolDetails;
+    allowedBridges?: string[];
+    allowedDexes?: string[];
+};
+export type ZapQuoteRequest = ZapBuildTxnRequest;
+export type ZapRouteRequestPositionDetails = {
+    nftId: string;
+};
+export type ZapRouteRequestPoolDetails = {
+    lowerTick: number;
+    upperTick: number;
+    metadata?: unknown;
+};
+export type ZapStatus = 'PENDING' | 'COMPLETED' | 'FAILED';
+export type ZapStatusAsset = {
+    asset: ZapPathAsset;
+    amount: string;
+    amountUSD: string;
+};
+export type ZapStatusStep = {
+    chainId: number;
+    hash?: string;
+    status: ZapStatus;
+    action: string;
+    protocol: ProviderDetails;
+    input: ZapStatusAsset[];
+    output: ZapStatusAsset[];
+};
+export type ZapStatusResponse = {
+    status: ZapStatus;
+    steps: ZapStatusStep[];
+};
+export type ZapStatusRequest = {
+    chainId: number;
+    txnHash: string;
+};
+export * from './path';
+export * from './step';

package/dist/types/zap/path.d.ts

@@ -0,0 +1,36 @@
+import { HexString, ProviderDetails } from 'src/types';
+import { zapPathAction } from '../../zap/constants/path';
+export type ZapPathAction = keyof typeof zapPathAction;
+export type ZapPathAsset = {
+    chainId: number;
+    address: HexString;
+    symbol: string;
+    logo: string;
+    decimals: number;
+    price: string;
+    type: string;
+    name: string;
+};
+export type ZapFee = {
+    amount: string;
+    amountUSD: string;
+    asset: ZapPathAsset;
+    included: boolean;
+};
+export type ZapPath = {
+    action: ZapPathAction;
+    protocol: ProviderDetails;
+    fee: ZapFee[];
+    estimatedDuration: number;
+    input: {
+        asset: ZapPathAsset;
+        amount: string;
+        amountUSD: string;
+    }[];
+    output: {
+        asset: ZapPathAsset;
+        amount: string;
+        amountUSD: string;
+        dust?: boolean;
+    }[];
+};

package/dist/types/zap/step.d.ts

@@ -0,0 +1,15 @@
+import { HexString } from 'src/types';
+import { zapStepAction } from '../../zap/constants/step';
+export type StepAction = keyof typeof zapStepAction;
+export type ZapTxnDetails = {
+    txnId: HexString;
+    callData: HexString;
+    callTo: HexString;
+    value: string;
+    estimatedGas: string;
+};
+export type ZapTransactionStep = {
+    action: StepAction;
+    data: ZapTxnDetails;
+};
+export type ZapStep = ZapTransactionStep;

package/dist/utils/amount.d.ts

@@ -0,0 +1,82 @@
+import { TradeQuote, Fee } from 'src/types';
+export declare const calculateAmountUSD: (amountInWei: string, decimals: number, price: string) => string;
+export declare const calculateNetGasFeeUsd: (item: TradeQuote) => string;
+export declare const calculateNetAmountUsd: (item: TradeQuote) => string;
+export declare const calculateNetGasFee: (item: TradeQuote) => bigint;
+export declare const updateFee: (fee: Fee, tokensPrice: Record<number, Record<string, string | null>>) => {
+    isUpdated: boolean;
+    fee: {
+        gasFee: {
+            amountUSD: string;
+            address: string;
+            decimals: number;
+            chainId: number;
+            symbol: string;
+            logo?: string;
+            amount: string;
+            included: boolean;
+        }[];
+        providerFee: {
+            amountUSD: string;
+            address: string;
+            decimals: number;
+            chainId: number;
+            symbol: string;
+            logo?: string;
+            amount: string;
+            included: boolean;
+        }[];
+        protocolFee: {
+            amountUSD: string;
+            address: string;
+            decimals: number;
+            chainId: number;
+            symbol: string;
+            logo?: string;
+            amount: string;
+            included: boolean;
+        }[];
+    };
+};
+export declare const updatePath: (data: TradeQuote, tokensPrice: Record<number, Record<string, string | null>>) => {
+    fee: {
+        gasFee: {
+            amountUSD: string;
+            address: string;
+            decimals: number;
+            chainId: number;
+            symbol: string;
+            logo?: string;
+            amount: string;
+            included: boolean;
+        }[];
+        providerFee: {
+            amountUSD: string;
+            address: string;
+            decimals: number;
+            chainId: number;
+            symbol: string;
+            logo?: string;
+            amount: string;
+            included: boolean;
+        }[];
+        protocolFee: {
+            amountUSD: string;
+            address: string;
+            decimals: number;
+            chainId: number;
+            symbol: string;
+            logo?: string;
+            amount: string;
+            included: boolean;
+        }[];
+    };
+    srcAmountUSD: string;
+    destAmountUSD: string;
+    type: string;
+    exchange: import("src/types").ProviderDetails;
+    srcToken: import("src/types").Token;
+    srcAmount: string;
+    destToken: import("src/types").Token;
+    destAmount: string;
+}[];

package/dist/utils/axios.d.ts

@@ -0,0 +1,13 @@
+import { CancelToken, Method } from 'axios';
+import AxiosClient from 'src/axios';
+type Invoke = {
+    endpoint: string;
+    data?: any;
+    method?: Method;
+    cancelToken?: CancelToken;
+    shouldRetry?: boolean;
+    baseClient?: AxiosClient;
+};
+export declare const invoke: ({ endpoint, data, method, cancelToken, shouldRetry }: Invoke) => Promise<any>;
+export declare const invokeZap: ({ endpoint, data, method, cancelToken, shouldRetry }: Invoke) => Promise<any>;
+export {};

package/dist/utils/chains.d.ts

@@ -0,0 +1,2 @@
+import * as viemChains from 'viem/chains';
+export declare const viemChainsById: Record<number, viemChains.Chain>;

package/dist/utils/date.d.ts

@@ -0,0 +1 @@
+export declare const generateDeadline: (expiryInSecs: number) => bigint;