@dzapio/sdk 2.0.6 → 2.0.7

package/dist/src/transactionHandlers/trade.js

@@ -0,0 +1,263 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../api");
+const chains_1 = require("../constants/chains");
+const permit_1 = require("../constants/permit");
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+const chains_2 = require("../chains");
+const batchApproveTokens_1 = require("../utils/eip-5792/batchApproveTokens");
+const sendBatchCalls_1 = require("../utils/eip-5792/sendBatchCalls");
+const waitForBatchTransactionReceipt_1 = require("../utils/eip-5792/waitForBatchTransactionReceipt");
+const errors_1 = require("../utils/errors");
+const permit_2 = require("./permit");
+const custom_1 = require("../utils/signIntent/custom");
+class TradeTxnHandler {
+}
+_a = TradeTxnHandler;
+TradeTxnHandler.sendTransaction = async (signer, txnParams, chainId, additionalInfo, updatedQuotes) => {
+    let txnHash;
+    if ((0, utils_1.isTypeSigner)(signer)) {
+        const txnRes = await signer.sendTransaction({
+            from: txnParams.from,
+            to: txnParams.to,
+            data: txnParams.data,
+            value: txnParams.value,
+            gasLimit: txnParams.gasLimit,
+        });
+        txnHash = txnRes.hash;
+    }
+    else {
+        txnHash = await signer.sendTransaction({
+            chain: chains_2.viemChainsById[chainId],
+            account: txnParams.from,
+            to: txnParams.to,
+            data: txnParams.data,
+            value: BigInt(txnParams.value),
+        });
+    }
+    return {
+        status: enums_1.TxnStatus.success,
+        code: enums_1.StatusCodes.Success,
+        txnHash,
+        additionalInfo,
+        updatedQuotes,
+    };
+};
+TradeTxnHandler.sendTxnWithBatch = async (request, signer, txnParams, chainId, additionalInfo, updatedQuotes, multicallAddress, rpcUrls) => {
+    const approvalBatchCalls = await (0, batchApproveTokens_1.generateApprovalBatchCalls)({
+        tokens: request.data.map((token) => ({
+            address: token.srcToken,
+            amount: token.amount,
+        })),
+        chainId,
+        multicallAddress,
+        sender: txnParams.from,
+        spender: txnParams.to,
+        rpcUrls,
+    });
+    const batchCalls = [
+        ...approvalBatchCalls,
+        {
+            to: txnParams.to,
+            data: txnParams.data,
+            value: BigInt(txnParams.value),
+        },
+    ];
+    if (approvalBatchCalls.length === 0) {
+        return _a.sendTransaction(signer, txnParams, chainId, additionalInfo, updatedQuotes);
+    }
+    const batchResult = await (0, sendBatchCalls_1.sendBatchCalls)(signer, batchCalls);
+    if (!batchResult) {
+        return {
+            status: enums_1.TxnStatus.error,
+            errorMsg: 'Batch call failed',
+            code: enums_1.StatusCodes.Error,
+        };
+    }
+    console.log('Waiting for batch transaction completion...');
+    const receipt = await (0, waitForBatchTransactionReceipt_1.waitForBatchTransactionReceipt)(signer, batchResult.id);
+    console.log({ receipt });
+    return {
+        status: enums_1.TxnStatus.success,
+        code: enums_1.StatusCodes.Success,
+        txnHash: receipt.transactionHash,
+        additionalInfo,
+        updatedQuotes,
+    };
+};
+TradeTxnHandler.sendHyperLiquidTransaction = async (signer, txnParams, txnData, chainId, additionalInfo, updatedQuotes) => {
+    var _b;
+    let txnDetails;
+    if (chainId === chains_1.exclusiveChainIds.hyperLiquid) {
+        const providerData = additionalInfo ? Object.values(additionalInfo)[0] : null;
+        const typedData = providerData && 'typedData' in providerData
+            ? providerData.typedData
+            : null;
+        if (!additionalInfo || !typedData) {
+            return {
+                status: enums_1.TxnStatus.error,
+                errorMsg: 'Missing additional info for HyperLiquid transaction',
+                code: enums_1.StatusCodes.Error,
+            };
+        }
+        const resp = await (0, custom_1.signCustomTypedData)({
+            signer,
+            account: txnParams.from,
+            domain: typedData.domain,
+            types: typedData.types,
+            message: typedData.message,
+            primaryType: typedData.primaryType,
+        });
+        if (resp.status !== enums_1.TxnStatus.success) {
+            throw new Error('Failed to sign transaction');
+        }
+        txnDetails = (_b = resp.data) === null || _b === void 0 ? void 0 : _b.signature;
+    }
+    else {
+        const resp = await _a.sendTransaction(signer, txnParams, chainId, additionalInfo, updatedQuotes);
+        if (resp.status !== enums_1.TxnStatus.success) {
+            throw new Error('Failed to sign transaction');
+        }
+        txnDetails = resp.txnHash;
+    }
+    const txResp = await (0, api_1.broadcastTradeTx)({
+        chainId,
+        txData: txnDetails,
+        txId: txnData.txId,
+    });
+    if (txResp.status !== enums_1.TxnStatus.success) {
+        throw new Error('Failed to broadcast or save transaction');
+    }
+    return {
+        status: enums_1.TxnStatus.success,
+        code: enums_1.StatusCodes.Success,
+        txnHash: txResp.txnHash,
+        additionalInfo,
+        updatedQuotes,
+    };
+};
+TradeTxnHandler.buildAndSendTransaction = async ({ request, signer, txnData, multicallAddress, batchTransaction = false, rpcUrls, }) => {
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    try {
+        const chainId = request.fromChain;
+        let buildTxnResponseData;
+        if (txnData) {
+            buildTxnResponseData = txnData;
+        }
+        else {
+            buildTxnResponseData = await (0, api_1.fetchTradeBuildTxnData)(request);
+        }
+        const { data, from, to, value, gasLimit, additionalInfo, updatedQuotes } = buildTxnResponseData;
+        const txnParams = { from, to: to, data, value: value, gasLimit: gasLimit };
+        if ([chainId, ...request.data.map((e) => e.toChain)].some((chain) => chain === chains_1.exclusiveChainIds.hyperLiquid)) {
+            return _a.sendHyperLiquidTransaction(signer, txnParams, buildTxnResponseData, chainId, additionalInfo, updatedQuotes);
+        }
+        if (batchTransaction && !(0, utils_1.isTypeSigner)(signer)) {
+            return _a.sendTxnWithBatch(request, signer, txnParams, chainId, additionalInfo, updatedQuotes, multicallAddress, rpcUrls);
+        }
+        console.log('Using viem walletClient - sending regular transaction.');
+        return _a.sendTransaction(signer, txnParams, chainId, additionalInfo, updatedQuotes);
+    }
+    catch (error) {
+        console.log({ error });
+        if ((0, errors_1.isAxiosError)(error)) {
+            if (((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status) === enums_1.StatusCodes.SimulationFailure) {
+                return {
+                    status: enums_1.TxnStatus.error,
+                    errorMsg: 'Simulation Failed',
+                    error: ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data).message,
+                    code: ((_d = error.response) === null || _d === void 0 ? void 0 : _d.data).code,
+                    action: ((_e = error.response) === null || _e === void 0 ? void 0 : _e.data).action,
+                };
+            }
+            return {
+                status: enums_1.TxnStatus.error,
+                errorMsg: 'Params Failed: ' + JSON.stringify((_g = (_f = error === null || error === void 0 ? void 0 : error.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.message),
+                error: (_j = (_h = error === null || error === void 0 ? void 0 : error.response) === null || _h === void 0 ? void 0 : _h.data) !== null && _j !== void 0 ? _j : error,
+                code: (_l = (_k = error === null || error === void 0 ? void 0 : error.response) === null || _k === void 0 ? void 0 : _k.status) !== null && _l !== void 0 ? _l : enums_1.StatusCodes.Error,
+            };
+        }
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+TradeTxnHandler.buildGaslessTxAndSignPermit = async ({ request, signer, rpcUrls, spender, txnData, }) => {
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    try {
+        const chainId = request.fromChain;
+        let buildTxnResponseData;
+        if (txnData) {
+            buildTxnResponseData = txnData;
+        }
+        else {
+            buildTxnResponseData = await (0, api_1.fetchTradeBuildTxnData)(Object.assign(Object.assign({}, request), { gasless: true }));
+        }
+        const permitType = request.hasPermit2ApprovalForAllTokens ? permit_1.PermitTypes.PermitBatchWitnessTransferFrom : permit_1.PermitTypes.EIP2612Permit;
+        const txId = buildTxnResponseData.txId;
+        const resp = await permit_2.default.signGaslessUserIntent(Object.assign({ tokens: request.data.map((req, index) => {
+                return {
+                    address: req.srcToken,
+                    amount: req.amount,
+                    index: index,
+                };
+            }), chainId,
+            rpcUrls, sender: request.sender, spender,
+            permitType,
+            signer, gasless: true, txId, service: 'trade', contractVersion: enums_1.ContractVersion.v2 }, buildTxnResponseData.transaction));
+        if (resp.status === enums_1.TxnStatus.success && resp.data) {
+            const permit = resp.data.type === permit_1.PermitTypes.EIP2612Permit
+                ? {
+                    permitData: request.data.map((req) => {
+                        return {
+                            token: req.srcToken,
+                            amount: req.amount,
+                            permit: req.permitData,
+                        };
+                    }),
+                    gaslessIntentNonce: (_b = resp.data.nonce) === null || _b === void 0 ? void 0 : _b.toString(),
+                    gaslessIntentSignature: resp.data.signature,
+                    gaslessIntentDeadline: (_c = resp.data.deadline) === null || _c === void 0 ? void 0 : _c.toString(),
+                }
+                : {
+                    batchPermitData: resp.data.batchPermitData,
+                };
+            const gaslessTxResp = await (0, api_1.executeGaslessTxnData)({
+                chainId: request.fromChain,
+                txId,
+                permit,
+            });
+            if (gaslessTxResp.status !== enums_1.TxnStatus.success) {
+                throw new Error('Failed to execute gasless transaction');
+            }
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                txnHash: gaslessTxResp.txnHash,
+            };
+        }
+        throw new Error('Gasless Transaction Failed');
+    }
+    catch (error) {
+        console.log({ error });
+        if ((0, errors_1.isAxiosError)(error)) {
+            if (((_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.status) === enums_1.StatusCodes.SimulationFailure) {
+                return {
+                    status: enums_1.TxnStatus.error,
+                    errorMsg: 'Simulation Failed',
+                    error: ((_e = error.response) === null || _e === void 0 ? void 0 : _e.data).message,
+                    code: ((_f = error.response) === null || _f === void 0 ? void 0 : _f.data).code,
+                    action: ((_g = error.response) === null || _g === void 0 ? void 0 : _g.data).action,
+                };
+            }
+            return {
+                status: enums_1.TxnStatus.error,
+                errorMsg: 'Params Failed: ' + JSON.stringify((_j = (_h = error === null || error === void 0 ? void 0 : error.response) === null || _h === void 0 ? void 0 : _h.data) === null || _j === void 0 ? void 0 : _j.message),
+                error: (_l = (_k = error === null || error === void 0 ? void 0 : error.response) === null || _k === void 0 ? void 0 : _k.data) !== null && _l !== void 0 ? _l : error,
+                code: (_o = (_m = error === null || error === void 0 ? void 0 : error.response) === null || _m === void 0 ? void 0 : _m.status) !== null && _o !== void 0 ? _o : enums_1.StatusCodes.Error,
+            };
+        }
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+exports.default = TradeTxnHandler;

package/dist/src/transactionHandlers/zap.d.ts

@@ -0,0 +1,37 @@
+import { Signer } from 'ethers';
+import { WalletClient } from 'viem';
+import { StatusCodes, TxnStatus } from '../enums';
+import { DZapTransactionResponse, HexString } from '../types';
+import { ZapBuildTxnRequest } from '../types/zap';
+import { ZapStep, ZapEvmTxnDetails } from '../types/zap/step';
+declare class ZapTxnHandler {
+    static execute: ({ chainId, txnData, signer, }: {
+        chainId: number;
+        txnData: ZapEvmTxnDetails;
+        signer: Signer | WalletClient;
+    }) => Promise<DZapTransactionResponse>;
+    static approve: ({ chainId, data, signer }: {
+        chainId: number;
+        data: ZapEvmTxnDetails;
+        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/src/transactionHandlers/zap.js

@@ -0,0 +1,135 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../api");
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+const chains_1 = require("../chains");
+const errors_1 = require("../utils/errors");
+const step_1 = require("../zap/constants/step");
+class ZapTxnHandler {
+}
+_a = ZapTxnHandler;
+ZapTxnHandler.execute = async ({ chainId, txnData, signer, }) => {
+    var _b;
+    try {
+        const { callData, callTo, value, estimatedGas } = txnData;
+        if ((0, utils_1.isTypeSigner)(signer)) {
+            console.log('Using ethers signer.');
+            const from = await signer.getAddress();
+            const txnRes = await signer.sendTransaction({
+                from,
+                to: callTo,
+                data: callData,
+                value: BigInt(value),
+                gasLimit: BigInt(estimatedGas) ? BigInt(estimatedGas) : undefined,
+            });
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                txnHash: txnRes.hash,
+            };
+        }
+        else {
+            console.log('Using viem walletClient.');
+            const txnHash = await signer.sendTransaction({
+                chain: chains_1.viemChainsById[chainId],
+                account: (_b = signer.account) === null || _b === void 0 ? void 0 : _b.address,
+                to: txnData.callTo,
+                data: txnData.callData,
+                value: BigInt(txnData.value),
+            });
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                txnHash,
+            };
+        }
+    }
+    catch (error) {
+        console.log({ error });
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+ZapTxnHandler.approve = async ({ chainId, data, signer }) => {
+    var _b;
+    try {
+        const { callData, callTo, value, estimatedGas } = data;
+        const publicClient = (0, utils_1.getPublicClient)({ chainId, rpcUrls: undefined });
+        const blockNumber = await publicClient.getBlockNumber();
+        console.log('block Number and data');
+        console.dir(Object.assign({ blockNumber }, data), { depth: null });
+        if ((0, utils_1.isTypeSigner)(signer)) {
+            console.log('Using ethers signer.');
+            const from = await signer.getAddress();
+            const txnRes = await signer.sendTransaction({
+                from,
+                to: callTo,
+                data: callData,
+                value: BigInt(value),
+                gasLimit: BigInt(estimatedGas) ? BigInt(estimatedGas) : undefined,
+            });
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                txnHash: txnRes.hash,
+            };
+        }
+        else {
+            console.log('Using viem walletClient.');
+            const txnHash = await signer.sendTransaction({
+                chain: chains_1.viemChainsById[chainId],
+                account: (_b = signer.account) === null || _b === void 0 ? void 0 : _b.address,
+                to: data.callTo,
+                data: data.callData,
+                value: BigInt(data.value),
+            });
+            return {
+                status: enums_1.TxnStatus.success,
+                code: enums_1.StatusCodes.Success,
+                txnHash,
+            };
+        }
+    }
+    catch (error) {
+        console.log({ error });
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+ZapTxnHandler.zap = async ({ request, steps, signer, }) => {
+    try {
+        const { srcChainId: chainId } = request;
+        if (!steps || steps.length === 0) {
+            const route = (await (0, api_1.fetchZapBuildTxnData)(request)).data;
+            steps = route.steps;
+            if (!steps || steps.length === 0) {
+                return {
+                    status: enums_1.TxnStatus.error,
+                    code: enums_1.StatusCodes.FunctionNotFound,
+                    errorMsg: 'No steps found in the zap route.',
+                };
+            }
+        }
+        let txnHash;
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            if (step.action === step_1.zapStepAction.execute) {
+                const result = await _a.execute({ chainId, txnData: step.data, signer });
+                if (result.status !== enums_1.TxnStatus.success) {
+                    return result;
+                }
+                txnHash = result.txnHash;
+            }
+        }
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            txnHash,
+        };
+    }
+    catch (error) {
+        console.log({ error });
+        return (0, errors_1.handleViemTransactionError)({ error });
+    }
+};
+exports.default = ZapTxnHandler;

package/dist/src/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/src/types/axiosClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/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/src/types/btc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/chains.d.ts

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

package/dist/src/types/chains.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/contract.d.ts

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

package/dist/src/types/contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,24 @@
+export declare const EIP2612DefaultTypes: {
+    Permit: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const DzapUserIntentSwapTypes: {
+    SignedGasLessSwapData: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const DzapUserIntentBridgeTypes: {
+    SignedGasLessBridgeData: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const DzapUserIntentSwapBridgeTypes: {
+    SignedGasLessSwapBridgeData: {
+        name: string;
+        type: string;
+    }[];
+};

package/dist/src/types/eip-2612.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DzapUserIntentSwapBridgeTypes = exports.DzapUserIntentBridgeTypes = exports.DzapUserIntentSwapTypes = exports.EIP2612DefaultTypes = void 0;
+exports.EIP2612DefaultTypes = {
+    Permit: [
+        {
+            name: 'owner',
+            type: 'address',
+        },
+        {
+            name: 'spender',
+            type: 'address',
+        },
+        {
+            name: 'value',
+            type: 'uint256',
+        },
+        {
+            name: 'nonce',
+            type: 'uint256',
+        },
+        {
+            name: 'deadline',
+            type: 'uint256',
+        },
+    ],
+};
+exports.DzapUserIntentSwapTypes = {
+    SignedGasLessSwapData: [
+        { name: 'txId', type: 'bytes32' },
+        { name: 'user', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+        { name: 'executorFeesHash', type: 'bytes32' },
+        { name: 'swapDataHash', type: 'bytes32' },
+    ],
+};
+exports.DzapUserIntentBridgeTypes = {
+    SignedGasLessBridgeData: [
+        { name: 'txId', type: 'bytes32' },
+        { name: 'user', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+        { name: 'executorFeesHash', type: 'bytes32' },
+        { name: 'adapterDataHash', type: 'bytes32' },
+    ],
+};
+exports.DzapUserIntentSwapBridgeTypes = {
+    SignedGasLessSwapBridgeData: [
+        { name: 'txId', type: 'bytes32' },
+        { name: 'user', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+        { name: 'executorFeesHash', type: 'bytes32' },
+        { name: 'swapDataHash', type: 'bytes32' },
+        { name: 'adapterDataHash', type: 'bytes32' },
+    ],
+};