@dzapio/sdk 2.0.6 → 2.0.7

package/dist/src/utils/index.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOtherAbis = exports.handleDecodeTxnData = exports.getDZapAbi = exports.isDZapNativeToken = exports.isTypeSigner = exports.estimateGasMultiplier = exports.getTrxId = exports.generateUUID = exports.isOneToMany = exports.calcTotalSrcTokenAmount = exports.writeContract = exports.readContract = exports.getPublicClient = void 0;
+exports.getTokensPairKey = getTokensPairKey;
+const viem_1 = require("viem");
+const ABI = require("../artifacts");
+const ethers_1 = require("ethers");
+const chains_1 = require("../chains");
+const constants_1 = require("../constants");
+const rpc_1 = require("../constants/rpc");
+const enums_1 = require("../enums");
+const inputDataDecoder_1 = require("./decoder/swap/inputDataDecoder");
+const tokens_1 = require("./tokens");
+const publicClientRpcConfig = { batch: { wait: rpc_1.RPC_BATCHING_WAIT_TIME }, retryDelay: rpc_1.RPC_RETRY_DELAY };
+const getPublicClient = ({ rpcUrls, chainId }) => {
+    const rpcs = rpcUrls && Array.isArray(rpcUrls) && rpcUrls.length > 0;
+    return (0, viem_1.createPublicClient)({
+        chain: chains_1.viemChainsById[chainId],
+        transport: (0, viem_1.fallback)(rpcs ? rpcUrls.map((rpc) => (0, viem_1.http)(rpc, publicClientRpcConfig)) : [(0, viem_1.http)()]),
+        batch: {
+            multicall: {
+                wait: rpc_1.RPC_BATCHING_WAIT_TIME,
+            },
+        },
+    });
+};
+exports.getPublicClient = getPublicClient;
+function getTokensPairKey({ srcToken, destToken, srcChainId, destChainId, srcChainNativeAddress = viem_1.zeroAddress, destChainNativeAddress = viem_1.zeroAddress, }) {
+    const srcFormattedAddress = (0, tokens_1.formatToken)(srcToken, srcChainNativeAddress);
+    const destFormattedAddress = (0, tokens_1.formatToken)(destToken, destChainNativeAddress);
+    return `${srcChainId}_${srcFormattedAddress}-${destChainId}_${destFormattedAddress}`;
+}
+const readContract = async ({ chainId, contractAddress, abi, functionName, rpcUrls, args = [], }) => {
+    try {
+        const result = await (0, exports.getPublicClient)({ chainId, rpcUrls }).readContract({
+            address: contractAddress,
+            abi,
+            functionName,
+            args,
+        });
+        return { data: result, status: enums_1.TxnStatus.success, code: enums_1.StatusCodes.Success };
+    }
+    catch (e) {
+        console.log({ e });
+        return { status: enums_1.TxnStatus.error, code: e.code || enums_1.StatusCodes.Error };
+    }
+};
+exports.readContract = readContract;
+const writeContract = async ({ chainId, contractAddress, abi, functionName, args = [], value = '0', rpcUrls = [''], signer, }) => {
+    const publicClient = (0, exports.getPublicClient)({ chainId, rpcUrls });
+    try {
+        const { request } = await publicClient.simulateContract({
+            address: contractAddress,
+            abi,
+            functionName,
+            args,
+            account: signer.account,
+            value: BigInt(value),
+        });
+        const hash = await signer.writeContract(request);
+        return { txnHash: hash, status: enums_1.TxnStatus.success, code: enums_1.StatusCodes.Success };
+    }
+    catch (e) {
+        console.log({ e });
+        if ((e === null || e === void 0 ? void 0 : e.code) === enums_1.StatusCodes.UserRejectedRequest) {
+            return { status: enums_1.TxnStatus.rejected, code: e === null || e === void 0 ? void 0 : e.code, txnHash: '' };
+        }
+        return { status: enums_1.TxnStatus.error, code: e === null || e === void 0 ? void 0 : e.code, txnHash: '' };
+    }
+};
+exports.writeContract = writeContract;
+const calcTotalSrcTokenAmount = (data) => {
+    return data.reduce((acc, obj) => {
+        return acc + BigInt(obj.amount);
+    }, BigInt(0));
+};
+exports.calcTotalSrcTokenAmount = calcTotalSrcTokenAmount;
+const isOneToMany = (firstTokenAddress, secondTokenAddress) => firstTokenAddress === secondTokenAddress;
+exports.isOneToMany = isOneToMany;
+const generateUUID = () => {
+    let d = new Date().getTime();
+    let d2 = (typeof performance !== 'undefined' && performance.now && performance.now() * 1000) || 0;
+    const uuid = 'xxxxxxxx-xxxx-4xxx-yxxxx-xxxxxxxxxxxx-xxxxxxxxxxxx-xxxxxx-xxxxxxxx'.replace(/[xy]/g, (c) => {
+        let r = Math.random() * 16;
+        if (d > 0) {
+            r = (d + r) % 16 | 0;
+            d = Math.floor(d / 16);
+        }
+        else {
+            r = (d2 + r) % 16 | 0;
+            d2 = Math.floor(d2 / 16);
+        }
+        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+    });
+    const uuidInBytes = (0, viem_1.stringToHex)(uuid, { size: 32 });
+    return uuidInBytes;
+};
+exports.generateUUID = generateUUID;
+const getTrxId = (account) => {
+    const uuid = `${account.slice(0, 6)}...${account.slice(36, 42)}-${Date.now()}`;
+    console.log(uuid);
+    const uuidInBytes = (0, viem_1.stringToHex)(uuid, { size: 32 });
+    return uuidInBytes;
+};
+exports.getTrxId = getTrxId;
+exports.estimateGasMultiplier = BigInt(15) / BigInt(10);
+const isTypeSigner = (variable) => {
+    return variable instanceof ethers_1.Signer;
+};
+exports.isTypeSigner = isTypeSigner;
+const isDZapNativeToken = (srcToken) => srcToken === constants_1.dZapNativeTokenFormat;
+exports.isDZapNativeToken = isDZapNativeToken;
+const getDZapAbi = (service, version) => {
+    switch (service) {
+        case constants_1.Services.trade:
+            switch (version) {
+                case enums_1.ContractVersion.v1:
+                    return ABI[constants_1.DZapAbis.dZapCoreAbi];
+                case enums_1.ContractVersion.v2:
+                    return ABI[constants_1.DZapAbis.dZapCoreV2Abi];
+                default:
+                    throw new Error('Invalid Version for Trade');
+            }
+        case constants_1.Services.dca:
+            return ABI[constants_1.DZapAbis.dZapDcaAbi];
+        case constants_1.Services.zap:
+        default:
+            throw new Error('Invalid Service');
+    }
+};
+exports.getDZapAbi = getDZapAbi;
+const handleDecodeTxnData = (transaction, receipt, service, chain) => {
+    var _a, _b, _c, _d, _e;
+    let events = [];
+    const dZapAbi = (0, exports.getDZapAbi)(service, (chain === null || chain === void 0 ? void 0 : chain.version) || enums_1.ContractVersion.v1);
+    try {
+        events = (0, viem_1.parseEventLogs)({
+            abi: dZapAbi,
+            logs: receipt.logs,
+        });
+    }
+    catch (e) {
+        events = [];
+    }
+    events = events === null || events === void 0 ? void 0 : events.filter((item) => item !== null);
+    const txLogArgs = (_a = events[0]) === null || _a === void 0 ? void 0 : _a.args;
+    const swapFailPairs = [];
+    let swapInfo = [];
+    if (Array.isArray(txLogArgs === null || txLogArgs === void 0 ? void 0 : txLogArgs.swapInfo)) {
+        swapInfo = txLogArgs.swapInfo.map((info) => {
+            var _a, _b, _c, _d;
+            if (BigInt(info.returnToAmount) === BigInt(0) || BigInt(info.fromAmount) === BigInt(0)) {
+                swapFailPairs.push(getTokensPairKey({
+                    srcToken: info.fromToken,
+                    destToken: info.toToken,
+                    srcChainId: chain.chainId,
+                    destChainId: chain.chainId,
+                    srcChainNativeAddress: (_a = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _a === void 0 ? void 0 : _a.contract,
+                    destChainNativeAddress: (_b = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _b === void 0 ? void 0 : _b.contract,
+                }));
+            }
+            return Object.assign(Object.assign({}, info), { fromToken: (0, tokens_1.formatToken)(info.fromToken, (_c = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _c === void 0 ? void 0 : _c.contract), toToken: (0, tokens_1.formatToken)(info.toToken, (_d = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _d === void 0 ? void 0 : _d.contract) });
+        });
+    }
+    else if (typeof (txLogArgs === null || txLogArgs === void 0 ? void 0 : txLogArgs.swapInfo) === 'object' && Object.keys(txLogArgs === null || txLogArgs === void 0 ? void 0 : txLogArgs.swapInfo).length > 0) {
+        const { fromAmount, returnToAmount, fromToken, toToken } = txLogArgs.swapInfo;
+        if (BigInt(returnToAmount) === BigInt(0) || BigInt(fromAmount) === BigInt(0)) {
+            swapFailPairs.push(getTokensPairKey({
+                srcToken: fromToken,
+                destToken: toToken,
+                srcChainId: chain.chainId,
+                destChainId: chain.chainId,
+                srcChainNativeAddress: (_b = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _b === void 0 ? void 0 : _b.contract,
+                destChainNativeAddress: (_c = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _c === void 0 ? void 0 : _c.contract,
+            }));
+        }
+        swapInfo = Object.assign(Object.assign({}, txLogArgs.swapInfo), { fromToken: (0, tokens_1.formatToken)(txLogArgs.swapInfo.fromToken, (_d = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _d === void 0 ? void 0 : _d.contract), toToken: (0, tokens_1.formatToken)(txLogArgs.swapInfo.toToken, (_e = chain === null || chain === void 0 ? void 0 : chain.nativeToken) === null || _e === void 0 ? void 0 : _e.contract) });
+    }
+    const updatedSwapInfo = new inputDataDecoder_1.SwapInputDataDecoder().updateSwapInfo({
+        data: transaction.input,
+        eventSwapInfo: swapInfo,
+    }) || swapInfo;
+    return { swapInfo: updatedSwapInfo, swapFailPairs };
+};
+exports.handleDecodeTxnData = handleDecodeTxnData;
+const getOtherAbis = (name) => {
+    switch (name) {
+        case constants_1.OtherAbis.permit2:
+            return ABI.permit2Abi;
+        case constants_1.OtherAbis.erc20:
+            return ABI.erc20Abi;
+        default:
+            throw new Error('Invalid Abi');
+    }
+};
+exports.getOtherAbis = getOtherAbis;

package/dist/src/utils/multicall.d.ts

@@ -0,0 +1,14 @@
+import { MulticallParameters } from 'viem';
+import { StatusCodes, TxnStatus } from '../enums';
+import { HexString } from '../types';
+export declare const multicall: ({ chainId, contracts, rpcUrls, multicallAddress, allowFailure, }: {
+    chainId: number;
+    contracts: MulticallParameters["contracts"];
+    rpcUrls?: string[];
+    multicallAddress?: HexString;
+    allowFailure?: boolean;
+}) => Promise<{
+    status: TxnStatus;
+    code: StatusCodes;
+    data: unknown[];
+}>;

package/dist/src/utils/multicall.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multicall = void 0;
+const enums_1 = require("../enums");
+const index_1 = require("./index");
+const multicall = async ({ chainId, contracts, rpcUrls, multicallAddress, allowFailure = false, }) => {
+    try {
+        const publicClient = (0, index_1.getPublicClient)({ chainId, rpcUrls });
+        const results = await publicClient.multicall(Object.assign(Object.assign({ contracts }, (multicallAddress && { multicallAddress })), { allowFailure }));
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            data: results,
+        };
+    }
+    catch (error) {
+        console.error('Multicall failed:', error);
+        return {
+            status: enums_1.TxnStatus.error,
+            code: error.code || enums_1.StatusCodes.Error,
+            data: [],
+        };
+    }
+};
+exports.multicall = multicall;

package/dist/src/utils/permit2/domain.d.ts

@@ -0,0 +1,2 @@
+import type { Address, TypedDataDomain } from 'viem';
+export declare function permit2Domain(permit2Address: Address, chainId: number): TypedDataDomain;

package/dist/src/utils/permit2/domain.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permit2Domain = permit2Domain;
+const PERMIT2_DOMAIN_NAME = 'Permit2';
+function permit2Domain(permit2Address, chainId) {
+    return {
+        name: PERMIT2_DOMAIN_NAME,
+        chainId,
+        verifyingContract: permit2Address,
+    };
+}

package/dist/src/utils/permit2/index.d.ts

@@ -0,0 +1,4 @@
+import { HexString } from '../../types';
+import { BasePermitResponse, Permit2Params } from '../../types/permit';
+export declare function getPermit2Address(chainId: number): HexString;
+export declare const getPermit2Signature: (params: Permit2Params) => Promise<BasePermitResponse>;

package/dist/src/utils/permit2/index.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermit2Signature = void 0;
+exports.getPermit2Address = getPermit2Address;
+const contract_1 = require("../../constants/contract");
+const permit_1 = require("../../constants/permit");
+const permit2_1 = require("../../constants/permit2");
+const enums_1 = require("../../enums");
+const viem_1 = require("viem");
+const permit_2 = require("../../types/permit");
+const date_1 = require("../date");
+const signTypedData_1 = require("../signTypedData");
+const permitData_1 = require("./permitData");
+const values_1 = require("./values");
+const witnessData_1 = require("./witnessData");
+const constants_1 = require("../../constants");
+function getPermit2Address(chainId) {
+    var _a;
+    return (_a = contract_1.exclusivePermit2Addresses[chainId]) !== null && _a !== void 0 ? _a : contract_1.DEFAULT_PERMIT2_ADDRESS;
+}
+const getPermit2Signature = async (params) => {
+    var _a, _b;
+    try {
+        const { chainId, account, tokens, spender, rpcUrls, deadline: sigDeadline, signer, permitType, firstTokenNonce, contractVersion, service, } = params;
+        const deadline = sigDeadline !== null && sigDeadline !== void 0 ? sigDeadline : (0, date_1.generateDeadline)(permit2_1.SignatureExpiryInSecs);
+        const expiration = (_a = params.expiration) !== null && _a !== void 0 ? _a : viem_1.maxUint48;
+        const permit2Address = getPermit2Address(chainId);
+        const updatedTokens = tokens.map((token) => {
+            return Object.assign(Object.assign({}, token), { amount: BigInt(token.amount || viem_1.maxUint256).toString() });
+        });
+        const { witnessData } = (0, witnessData_1.getPermit2WitnessData)(params);
+        const { permit2Values, nonce } = await (0, values_1.getPermit2Values)({
+            primaryType: permitType,
+            spender,
+            account,
+            deadline,
+            chainId,
+            permit2Address,
+            rpcUrls,
+            tokens: updatedTokens,
+            expiration,
+            firstTokenNonce: firstTokenNonce !== null && firstTokenNonce !== void 0 ? firstTokenNonce : null,
+            service,
+            contractVersion,
+        });
+        const signTypedPermit2Data = (0, permitData_1.getPermit2Data)(permit2Values, permit2Address, chainId, witnessData);
+        const signature = await (0, signTypedData_1.signTypedData)({
+            signer,
+            domain: signTypedPermit2Data.domain,
+            message: signTypedPermit2Data.message,
+            types: signTypedPermit2Data.types,
+            account,
+            primaryType: permitType,
+        });
+        let dZapDataForTransfer;
+        if (permitType === permit_1.permit2PrimaryType.PermitBatchWitnessTransferFrom) {
+            dZapDataForTransfer = (0, viem_1.encodeAbiParameters)(permit_2.BatchPermitAbiParams, [
+                {
+                    permitted: updatedTokens.map((token) => ({ token: token.address, amount: BigInt(token.amount) })),
+                    nonce,
+                    deadline,
+                },
+                signature,
+            ]);
+        }
+        else if (permitType === permit_1.permit2PrimaryType.PermitWitnessTransferFrom) {
+            dZapDataForTransfer = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)('uint256, uint256, bytes'), [nonce, deadline, signature]);
+        }
+        else if (contractVersion === enums_1.ContractVersion.v1 && service !== constants_1.Services.zap) {
+            dZapDataForTransfer = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)('uint160 allowanceAmount, uint48 nonce, uint48 expiration, uint256 sigDeadline, bytes signature'), [BigInt(tokens[0].amount), Number(nonce.toString()), Number(expiration.toString()), BigInt(deadline.toString()), signature]);
+        }
+        else {
+            dZapDataForTransfer = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)('uint48 nonce, uint48 expiration, uint256 sigDeadline, bytes signature'), [
+                Number(nonce.toString()),
+                Number(expiration.toString()),
+                BigInt(deadline.toString()),
+                signature,
+            ]);
+        }
+        const dzapPermitMode = service !== constants_1.Services.zap && contractVersion === enums_1.ContractVersion.v1 ? enums_1.DZapV1PermitMode.PERMIT2_APPROVE : permit_1.PermitToDZapPermitMode[permitType];
+        const permitData = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)('uint8, bytes'), [dzapPermitMode, dZapDataForTransfer]);
+        return {
+            status: enums_1.TxnStatus.success,
+            code: enums_1.StatusCodes.Success,
+            permitData,
+            nonce,
+        };
+    }
+    catch (error) {
+        console.log('Error generating permit2 witness transfer signature:', error);
+        if (((_b = error === null || error === void 0 ? void 0 : error.cause) === null || _b === void 0 ? void 0 : _b.code) === enums_1.StatusCodes.UserRejectedRequest || (error === null || error === void 0 ? void 0 : error.code) === enums_1.StatusCodes.UserRejectedRequest) {
+            return { status: enums_1.TxnStatus.rejected, code: enums_1.StatusCodes.UserRejectedRequest };
+        }
+        return { status: enums_1.TxnStatus.error, code: enums_1.StatusCodes.Error };
+    }
+};
+exports.getPermit2Signature = getPermit2Signature;

package/dist/src/utils/permit2/nonce.d.ts

@@ -0,0 +1,15 @@
+import { HexString } from '../../types';
+import { Address, PublicClient } from 'viem';
+export declare class NonceManager {
+    private static readonly POSITION_BITS;
+    private static readonly MAX_POSITION;
+    private static readonly POSITION_MASK;
+    private static readonly MAX_WORD_ITERATIONS;
+    private readonly permit2Contract;
+    constructor(publicClient: PublicClient, permit2Address: HexString);
+    nextNonce(owner: Address): Promise<bigint>;
+    private nonceFromWordAndPos;
+    getNonceBitmap(owner: Address, word: bigint): Promise<bigint>;
+    isNonceUsed(owner: Address, nonce: bigint): Promise<boolean>;
+}
+export declare const getNextPermit2Nonce: (permitAddress: HexString, account: HexString, chainId: number, rpcUrls?: string[]) => Promise<bigint>;

package/dist/src/utils/permit2/nonce.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextPermit2Nonce = exports.NonceManager = void 0;
+const artifacts_1 = require("../../artifacts");
+const viem_1 = require("viem");
+const __1 = require("..");
+class NonceManager {
+    constructor(publicClient, permit2Address) {
+        this.permit2Contract = (0, viem_1.getContract)({
+            address: permit2Address,
+            abi: artifacts_1.permit2Abi,
+            client: publicClient,
+        });
+    }
+    async nextNonce(owner) {
+        let word = BigInt(0);
+        let pos = 0;
+        for (let iteration = 0; iteration < NonceManager.MAX_WORD_ITERATIONS; iteration++) {
+            const bitmap = await this.permit2Contract.read.nonceBitmap([owner, word]);
+            if (bitmap === viem_1.maxUint256) {
+                ++word;
+                pos = 0;
+                continue;
+            }
+            let workingBitmap = bitmap;
+            if (pos !== 0) {
+                workingBitmap = workingBitmap >> BigInt(pos);
+            }
+            while (pos < NonceManager.MAX_POSITION && (workingBitmap & BigInt(1)) === BigInt(1)) {
+                workingBitmap = workingBitmap >> BigInt(1);
+                ++pos;
+            }
+            return this.nonceFromWordAndPos(word, pos);
+        }
+        throw new Error('Max iterations reached');
+    }
+    nonceFromWordAndPos(word, pos) {
+        const nonce = word << NonceManager.POSITION_BITS;
+        return nonce | BigInt(pos);
+    }
+    async getNonceBitmap(owner, word) {
+        return this.permit2Contract.read.nonceBitmap([owner, word]);
+    }
+    async isNonceUsed(owner, nonce) {
+        const word = nonce >> NonceManager.POSITION_BITS;
+        const pos = Number(nonce & NonceManager.POSITION_MASK);
+        const bitmap = await this.getNonceBitmap(owner, word);
+        return ((bitmap >> BigInt(pos)) & BigInt(1)) === BigInt(1);
+    }
+}
+exports.NonceManager = NonceManager;
+NonceManager.POSITION_BITS = BigInt(8);
+NonceManager.MAX_POSITION = 256;
+NonceManager.POSITION_MASK = BigInt(0xff);
+NonceManager.MAX_WORD_ITERATIONS = 1000;
+const getNextPermit2Nonce = async (permitAddress, account, chainId, rpcUrls) => {
+    const publicClient = (0, __1.getPublicClient)({ chainId, rpcUrls });
+    const nonceManager = new NonceManager(publicClient, permitAddress);
+    return nonceManager.nextNonce(account);
+};
+exports.getNextPermit2Nonce = getNextPermit2Nonce;

package/dist/src/utils/permit2/permitData.d.ts

@@ -0,0 +1,23 @@
+import { TypedDataField } from 'ethers';
+import { PermitBatchTransferFromValues, PermitSingleValues, PermitTransferFromValues, WitnessData } from '../../types/permit';
+import type { Address, TypedDataDomain } from 'viem';
+type PermitSingleData = {
+    domain: TypedDataDomain;
+    types: Record<string, Array<TypedDataField>>;
+    message: PermitSingleValues;
+};
+type PermitTransferFromData = {
+    domain: TypedDataDomain;
+    types: Record<string, Array<TypedDataField>>;
+    message: PermitTransferFromValues;
+};
+type PermitBatchTransferFromData = {
+    domain: TypedDataDomain;
+    types: Record<string, Array<TypedDataField>>;
+    message: PermitBatchTransferFromValues;
+};
+export declare function getPermitSingleData(permit: PermitSingleValues, permit2Address: Address, chainId: number): PermitSingleData;
+export declare function getPermitTransferData(permit: PermitTransferFromValues, permit2Address: Address, chainId: number, witness: WitnessData): PermitTransferFromData;
+export declare function getPermitBatchTransferData(permit: PermitBatchTransferFromValues, permit2Address: Address, chainId: number, witness: WitnessData): PermitBatchTransferFromData;
+export declare function getPermit2Data(permit: PermitTransferFromValues | PermitBatchTransferFromValues | PermitSingleValues, permit2Address: Address, chainId: number, witness?: WitnessData): PermitTransferFromData | PermitBatchTransferFromData | PermitSingleData;
+export {};

package/dist/src/utils/permit2/permitData.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermitSingleData = getPermitSingleData;
+exports.getPermitTransferData = getPermitTransferData;
+exports.getPermitBatchTransferData = getPermitBatchTransferData;
+exports.getPermit2Data = getPermit2Data;
+const domain_1 = require("./domain");
+function isPermitSingle(permit) {
+    return 'details' in permit && permit.details !== undefined;
+}
+function isPermitTransferFrom(permit) {
+    return 'permitted' in permit && !Array.isArray(permit.permitted);
+}
+function getPermitSingleData(permit, permit2Address, chainId) {
+    const domain = (0, domain_1.permit2Domain)(permit2Address, chainId);
+    const types = {
+        PermitSingle: [
+            { name: 'details', type: 'PermitDetails' },
+            { name: 'spender', type: 'address' },
+            { name: 'sigDeadline', type: 'uint256' },
+        ],
+        PermitDetails: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint160' },
+            { name: 'expiration', type: 'uint48' },
+            { name: 'nonce', type: 'uint48' },
+        ],
+    };
+    const message = permit;
+    return {
+        domain,
+        types,
+        message,
+    };
+}
+function getPermitTransferData(permit, permit2Address, chainId, witness) {
+    const domain = (0, domain_1.permit2Domain)(permit2Address, chainId);
+    const types = Object.assign(Object.assign({}, witness.witnessType), { TokenPermissions: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ], PermitWitnessTransferFrom: [
+            { name: 'permitted', type: 'TokenPermissions' },
+            { name: 'spender', type: 'address' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+            { name: 'witness', type: witness.witnessTypeName },
+        ] });
+    const message = Object.assign(permit, { witness: witness.witness });
+    return {
+        domain,
+        types,
+        message,
+    };
+}
+function getPermitBatchTransferData(permit, permit2Address, chainId, witness) {
+    const domain = (0, domain_1.permit2Domain)(permit2Address, chainId);
+    const types = Object.assign(Object.assign({}, witness.witnessType), { TokenPermissions: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ], PermitBatchWitnessTransferFrom: [
+            { name: 'permitted', type: 'TokenPermissions[]' },
+            { name: 'spender', type: 'address' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+            { name: 'witness', type: witness.witnessTypeName },
+        ] });
+    const message = Object.assign(Object.assign({}, permit), { witness: witness.witness });
+    return {
+        domain,
+        types,
+        message,
+    };
+}
+function getPermit2Data(permit, permit2Address, chainId, witness) {
+    if (isPermitSingle(permit)) {
+        return getPermitSingleData(permit, permit2Address, chainId);
+    }
+    if (!witness) {
+        throw new Error('Witness is required for PermitTransferFrom');
+    }
+    if (isPermitTransferFrom(permit)) {
+        return getPermitTransferData(permit, permit2Address, chainId, witness);
+    }
+    return getPermitBatchTransferData(permit, permit2Address, chainId, witness);
+}

package/dist/src/utils/permit2/values.d.ts

@@ -0,0 +1,54 @@
+import { BasePermitParams, Permit2PrimaryType, PermitBatchTransferFromValues, PermitSingleValues, PermitTransferFromValues, TokenWithIndex } from '../../types/permit';
+import type { Address } from 'viem';
+import { HexString } from '../../types';
+type Permit2ValuesParams = {
+    deadline: bigint;
+    permit2Address: HexString;
+    tokens: TokenWithIndex[];
+    expiration?: bigint;
+    firstTokenNonce: bigint | null;
+    primaryType: Permit2PrimaryType;
+} & Omit<BasePermitParams, 'deadline' | 'signer'>;
+export declare const getPermitSingleValues: ({ spender, deadline, chainId, rpcUrls, account, expiration, token, permit2Address, }: {
+    spender: Address;
+    deadline: bigint;
+    chainId: number;
+    account: HexString;
+    expiration: bigint;
+    token: TokenWithIndex;
+    permit2Address: HexString;
+    rpcUrls?: string[];
+}) => Promise<{
+    permit2Values: PermitSingleValues;
+    nonce: bigint;
+}>;
+export declare const getPermitTransferFromValues: ({ spender, deadline, chainId, rpcUrls, account, token, permit2Address, firstTokenNonce, }: {
+    spender: Address;
+    deadline: bigint;
+    chainId: number;
+    account: HexString;
+    token: TokenWithIndex;
+    permit2Address: HexString;
+    firstTokenNonce: bigint | null;
+    rpcUrls?: string[];
+}) => Promise<{
+    permit2Values: PermitTransferFromValues;
+    nonce: bigint;
+}>;
+export declare const getPermitBatchTransferFromValues: ({ spender, deadline, chainId, rpcUrls, account, permit2Address, tokens, }: {
+    spender: Address;
+    deadline: bigint;
+    chainId: number;
+    account: HexString;
+    permit2Address: HexString;
+    tokens: TokenWithIndex[];
+    rpcUrls?: string[];
+}) => Promise<{
+    permit2Values: PermitBatchTransferFromValues;
+    nonce: bigint;
+}>;
+export declare function getPermit2Values(params: Permit2ValuesParams): Promise<{
+    permit2Values: PermitTransferFromValues | PermitBatchTransferFromValues | PermitSingleValues;
+    nonce: bigint;
+}>;
+export {};