@mayanfinance/blink-sdk 0.1.8

package/dist/evm.js

@@ -0,0 +1,679 @@
+import { createPublicClient, encodeAbiParameters, encodeFunctionData, erc20Abi, http, keccak256, stringToHex, toHex, } from "viem";
+const ROUTER_ABI = [
+    {
+        type: "function",
+        name: "depositNative",
+        stateMutability: "payable",
+        inputs: [{ name: "quoteHash", type: "bytes32" }],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "depositToken",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "token", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "depositWithSwap",
+        stateMutability: "payable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "srcToken", type: "address" },
+            { name: "amountIn", type: "uint256" },
+            { name: "aggregator", type: "address" },
+            { name: "swapData", type: "bytes" },
+            { name: "bridgeToken", type: "address" },
+            { name: "minBridgeOut", type: "uint256" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "swapAndForward",
+        stateMutability: "payable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "srcToken", type: "address" },
+            { name: "amountIn", type: "uint256" },
+            { name: "aggregator", type: "address" },
+            { name: "swapData", type: "bytes" },
+            { name: "dstToken", type: "address" },
+            { name: "minAmountOut", type: "uint256" },
+            { name: "amountOut", type: "uint256" },
+            { name: "referrerBps", type: "uint16" },
+            { name: "recipient", type: "address" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "depositTokenWithPermit",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "token", type: "address" },
+            { name: "amount", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "v", type: "uint8" },
+            { name: "r", type: "bytes32" },
+            { name: "s", type: "bytes32" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "depositTokenWithPermit2",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "token", type: "address" },
+            { name: "amount", type: "uint256" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "signature", type: "bytes" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "depositWithSwapAndPermit",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "srcToken", type: "address" },
+            { name: "amountIn", type: "uint256" },
+            { name: "aggregator", type: "address" },
+            { name: "swapData", type: "bytes" },
+            { name: "bridgeToken", type: "address" },
+            { name: "minBridgeOut", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "v", type: "uint8" },
+            { name: "r", type: "bytes32" },
+            { name: "s", type: "bytes32" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "depositWithSwapAndPermit2",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "srcToken", type: "address" },
+            { name: "amountIn", type: "uint256" },
+            { name: "aggregator", type: "address" },
+            { name: "swapData", type: "bytes" },
+            { name: "bridgeToken", type: "address" },
+            { name: "minBridgeOut", type: "uint256" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "signature", type: "bytes" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "swapAndForwardWithPermit",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "srcToken", type: "address" },
+            { name: "amountIn", type: "uint256" },
+            { name: "aggregator", type: "address" },
+            { name: "swapData", type: "bytes" },
+            { name: "dstToken", type: "address" },
+            { name: "minAmountOut", type: "uint256" },
+            { name: "amountOut", type: "uint256" },
+            { name: "referrerBps", type: "uint16" },
+            { name: "recipient", type: "address" },
+            { name: "deadline", type: "uint256" },
+            { name: "v", type: "uint8" },
+            { name: "r", type: "bytes32" },
+            { name: "s", type: "bytes32" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "swapAndForwardWithPermit2",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "srcToken", type: "address" },
+            { name: "amountIn", type: "uint256" },
+            { name: "aggregator", type: "address" },
+            { name: "swapData", type: "bytes" },
+            { name: "dstToken", type: "address" },
+            { name: "minAmountOut", type: "uint256" },
+            { name: "amountOut", type: "uint256" },
+            { name: "referrerBps", type: "uint16" },
+            { name: "recipient", type: "address" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "signature", type: "bytes" },
+        ],
+        outputs: [],
+    },
+];
+const PERMIT_ABI = [
+    {
+        type: "function",
+        name: "nonces",
+        stateMutability: "view",
+        inputs: [{ name: "owner", type: "address" }],
+        outputs: [{ type: "uint256" }],
+    },
+    {
+        type: "function",
+        name: "DOMAIN_SEPARATOR",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: "bytes32" }],
+    },
+    {
+        type: "function",
+        name: "name",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: "string" }],
+    },
+    {
+        type: "function",
+        name: "version",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: "string" }],
+    },
+    {
+        type: "function",
+        name: "PERMIT_TYPEHASH",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: "bytes32" }],
+    },
+];
+export const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+const EIP712_DOMAIN_TYPEHASH = keccak256(stringToHex("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"));
+const STANDARD_PERMIT_TYPEHASH = keccak256(stringToHex("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"));
+export const isNativeEvmToken = (address) => /^0x0*$/i.test(address);
+const hex = (value) => (value.startsWith("0x") ? value : `0x${value}`);
+const client = (rpcUrl) => createPublicClient({ transport: http(rpcUrl) });
+export const evmGasPrice = (rpcUrl) => client(rpcUrl).getGasPrice();
+export const evmEstimateGas = (rpcUrl, from, call, allowance) => client(rpcUrl).estimateGas({
+    account: from,
+    to: call.to,
+    data: call.data,
+    value: call.value === undefined ? undefined : BigInt(call.value),
+    stateOverride: allowance && [
+        {
+            address: allowance.token,
+            stateDiff: [
+                { slot: allowance.slot, value: toHex(allowance.amount, { size: 32 }) },
+            ],
+        },
+    ],
+});
+export const evmAllowanceSlot = async (rpcUrl, token, owner, spender) => {
+    const rpc = client(rpcUrl);
+    const slotsOf = async (holder) => {
+        const { accessList } = await rpc.createAccessList({
+            account: holder,
+            to: token,
+            data: encodeFunctionData({
+                abi: erc20Abi,
+                functionName: "allowance",
+                args: [holder, spender],
+            }),
+        });
+        return accessList
+            .filter((entry) => entry.address.toLowerCase() === token.toLowerCase())
+            .flatMap((entry) => entry.storageKeys);
+    };
+    const other = toHex(BigInt(owner) ^ 1n, { size: 20 });
+    const [slots, shared] = await Promise.all([slotsOf(owner), slotsOf(other)]);
+    const own = slots.filter((slot) => !shared.includes(slot));
+    return own.length === 1 ? own[0] : undefined;
+};
+export const evmBalance = async (rpcUrl, token, owner) => {
+    if (isNativeEvmToken(token)) {
+        return client(rpcUrl).getBalance({ address: owner });
+    }
+    return client(rpcUrl).readContract({
+        address: token,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [owner],
+    });
+};
+export const evmAllowance = (rpcUrl, token, owner, spender) => client(rpcUrl).readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [owner, spender],
+});
+const domainSeparator = (name, version, chainId, token) => keccak256(encodeAbiParameters([
+    { type: "bytes32" },
+    { type: "bytes32" },
+    { type: "bytes32" },
+    { type: "uint256" },
+    { type: "address" },
+], [
+    EIP712_DOMAIN_TYPEHASH,
+    keccak256(stringToHex(name)),
+    keccak256(stringToHex(version)),
+    chainId,
+    token,
+]));
+export const detectPermit = async (rpcUrl, token, owner, chainId) => {
+    const rpc = client(rpcUrl);
+    const contract = { address: token, abi: PERMIT_ABI };
+    let nonce;
+    let separator;
+    let name;
+    try {
+        [nonce, separator, name] = await Promise.all([
+            rpc.readContract({ ...contract, functionName: "nonces", args: [owner] }),
+            rpc.readContract({ ...contract, functionName: "DOMAIN_SEPARATOR" }),
+            rpc.readContract({ ...contract, functionName: "name" }),
+        ]);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const typehash = await rpc.readContract({
+            ...contract,
+            functionName: "PERMIT_TYPEHASH",
+        });
+        if (typehash !== STANDARD_PERMIT_TYPEHASH) {
+            return undefined;
+        }
+    }
+    catch { }
+    const versions = ["1", "2"];
+    try {
+        versions.unshift(await rpc.readContract({ ...contract, functionName: "version" }));
+    }
+    catch { }
+    for (const version of versions) {
+        if (domainSeparator(name, version, chainId, token) === separator) {
+            return { name, version, nonce };
+        }
+    }
+    return undefined;
+};
+export const permitTypedData = (support, chainId, token, owner, spender, value, deadline) => ({
+    types: {
+        EIP712Domain: [
+            { name: "name", type: "string" },
+            { name: "version", type: "string" },
+            { name: "chainId", type: "uint256" },
+            { name: "verifyingContract", type: "address" },
+        ],
+        Permit: [
+            { name: "owner", type: "address" },
+            { name: "spender", type: "address" },
+            { name: "value", type: "uint256" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+        ],
+    },
+    primaryType: "Permit",
+    domain: {
+        name: support.name,
+        version: support.version,
+        chainId: Number(chainId),
+        verifyingContract: token,
+    },
+    message: {
+        owner,
+        spender,
+        value: value.toString(),
+        nonce: support.nonce.toString(),
+        deadline: deadline.toString(),
+    },
+});
+const permit2WitnessBase = {
+    EIP712Domain: [
+        { name: "name", type: "string" },
+        { name: "chainId", type: "uint256" },
+        { name: "verifyingContract", type: "address" },
+    ],
+    TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" },
+    ],
+};
+export const permit2WitnessDepositTypedData = (chainId, token, amount, spender, nonce, deadline, quoteHash) => ({
+    types: {
+        ...permit2WitnessBase,
+        PermitWitnessTransferFrom: [
+            { name: "permitted", type: "TokenPermissions" },
+            { name: "spender", type: "address" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "witness", type: "BlinkDeposit" },
+        ],
+        BlinkDeposit: [{ name: "quoteHash", type: "bytes32" }],
+    },
+    primaryType: "PermitWitnessTransferFrom",
+    domain: {
+        name: "Permit2",
+        chainId: Number(chainId),
+        verifyingContract: PERMIT2_ADDRESS,
+    },
+    message: {
+        permitted: { token, amount: amount.toString() },
+        spender,
+        nonce: nonce.toString(),
+        deadline: deadline.toString(),
+        witness: { quoteHash: hex(quoteHash) },
+    },
+});
+export const permit2WitnessSwapDepositTypedData = (chainId, token, amount, spender, nonce, deadline, quoteHash, bridgeToken, minBridgeOut) => ({
+    types: {
+        ...permit2WitnessBase,
+        PermitWitnessTransferFrom: [
+            { name: "permitted", type: "TokenPermissions" },
+            { name: "spender", type: "address" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "witness", type: "BlinkSwapDeposit" },
+        ],
+        BlinkSwapDeposit: [
+            { name: "quoteHash", type: "bytes32" },
+            { name: "bridgeToken", type: "address" },
+            { name: "minBridgeOut", type: "uint256" },
+        ],
+    },
+    primaryType: "PermitWitnessTransferFrom",
+    domain: {
+        name: "Permit2",
+        chainId: Number(chainId),
+        verifyingContract: PERMIT2_ADDRESS,
+    },
+    message: {
+        permitted: { token, amount: amount.toString() },
+        spender,
+        nonce: nonce.toString(),
+        deadline: deadline.toString(),
+        witness: {
+            quoteHash: hex(quoteHash),
+            bridgeToken,
+            minBridgeOut: minBridgeOut.toString(),
+        },
+    },
+});
+export const permit2TypedData = (chainId, token, amount, spender, nonce, deadline) => ({
+    types: {
+        EIP712Domain: [
+            { name: "name", type: "string" },
+            { name: "chainId", type: "uint256" },
+            { name: "verifyingContract", type: "address" },
+        ],
+        PermitTransferFrom: [
+            { name: "permitted", type: "TokenPermissions" },
+            { name: "spender", type: "address" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+        ],
+        TokenPermissions: [
+            { name: "token", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+    },
+    primaryType: "PermitTransferFrom",
+    domain: {
+        name: "Permit2",
+        chainId: Number(chainId),
+        verifyingContract: PERMIT2_ADDRESS,
+    },
+    message: {
+        permitted: { token, amount: amount.toString() },
+        spender,
+        nonce: nonce.toString(),
+        deadline: deadline.toString(),
+    },
+});
+export const randomPermit2Nonce = () => {
+    const bytes = crypto.getRandomValues(new Uint8Array(32));
+    return BigInt(toHex(bytes));
+};
+export const permitDeadline = () => BigInt(Math.floor(Date.now() / 1000) + 1800);
+export const splitSignature = (signature) => {
+    const raw = signature.startsWith("0x") ? signature.slice(2) : signature;
+    const v = parseInt(raw.slice(128, 130), 16);
+    return {
+        v: v < 27 ? v + 27 : v,
+        r: `0x${raw.slice(0, 64)}`,
+        s: `0x${raw.slice(64, 128)}`,
+    };
+};
+export const waitForEvmTransaction = async (rpcUrl, hash) => {
+    const receipt = await client(rpcUrl).waitForTransactionReceipt({
+        hash: hash,
+    });
+    if (receipt.status === "reverted") {
+        throw new Error("transaction reverted");
+    }
+};
+export const encodeApprove = (spender, amount) => encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [spender, amount],
+});
+export const encodeDirectTransfer = (inventory, amount, quoteHash) => encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [inventory, amount],
+}) + hex(quoteHash).slice(2);
+export const encodeDepositNative = (quoteHash) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "depositNative",
+    args: [hex(quoteHash)],
+});
+export const encodeDepositToken = (quoteHash, token, amount) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "depositToken",
+    args: [hex(quoteHash), token, amount],
+});
+export const encodeDepositTokenWithPermit = (quoteHash, token, amount, deadline, signature) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "depositTokenWithPermit",
+    args: [
+        hex(quoteHash),
+        token,
+        amount,
+        deadline,
+        signature.v,
+        signature.r,
+        signature.s,
+    ],
+});
+export const encodeDepositTokenWithPermit2 = (quoteHash, token, amount, nonce, deadline, signature) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "depositTokenWithPermit2",
+    args: [hex(quoteHash), token, amount, nonce, deadline, hex(signature)],
+});
+export const encodeDepositWithSwap = (quoteHash, swap) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "depositWithSwap",
+    args: [
+        hex(quoteHash),
+        swap.srcToken,
+        BigInt(swap.amountIn),
+        swap.aggregator,
+        hex(swap.swapCalldata),
+        swap.bridgeToken,
+        BigInt(swap.minBridgeOut),
+    ],
+});
+export const encodeDepositWithSwapAndPermit = (quoteHash, swap, deadline, signature) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "depositWithSwapAndPermit",
+    args: [
+        hex(quoteHash),
+        swap.srcToken,
+        BigInt(swap.amountIn),
+        swap.aggregator,
+        hex(swap.swapCalldata),
+        swap.bridgeToken,
+        BigInt(swap.minBridgeOut),
+        deadline,
+        signature.v,
+        signature.r,
+        signature.s,
+    ],
+});
+export const encodeDepositWithSwapAndPermit2 = (quoteHash, swap, nonce, deadline, signature) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "depositWithSwapAndPermit2",
+    args: [
+        hex(quoteHash),
+        swap.srcToken,
+        BigInt(swap.amountIn),
+        swap.aggregator,
+        hex(swap.swapCalldata),
+        swap.bridgeToken,
+        BigInt(swap.minBridgeOut),
+        nonce,
+        deadline,
+        hex(signature),
+    ],
+});
+const referrerTotalBps = (referrers) => referrers.reduce((total, r) => total + r.bps, 0);
+export const encodeSwapAndForward = (quoteHash, params, swap) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "swapAndForward",
+    args: [
+        hex(quoteHash),
+        params.srcToken,
+        BigInt(params.amountIn),
+        swap.aggregator,
+        hex(swap.swapCalldata),
+        params.dstToken,
+        BigInt(params.minAmountOut),
+        BigInt(params.amountOut),
+        referrerTotalBps(params.referrers),
+        params.recipient,
+    ],
+});
+export const encodeSwapAndForwardWithPermit = (quoteHash, params, swap, deadline, signature) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "swapAndForwardWithPermit",
+    args: [
+        hex(quoteHash),
+        params.srcToken,
+        BigInt(params.amountIn),
+        swap.aggregator,
+        hex(swap.swapCalldata),
+        params.dstToken,
+        BigInt(params.minAmountOut),
+        BigInt(params.amountOut),
+        referrerTotalBps(params.referrers),
+        params.recipient,
+        deadline,
+        signature.v,
+        signature.r,
+        signature.s,
+    ],
+});
+export const encodeSwapAndForwardWithPermit2 = (quoteHash, params, swap, nonce, deadline, signature) => encodeFunctionData({
+    abi: ROUTER_ABI,
+    functionName: "swapAndForwardWithPermit2",
+    args: [
+        hex(quoteHash),
+        params.srcToken,
+        BigInt(params.amountIn),
+        swap.aggregator,
+        hex(swap.swapCalldata),
+        params.dstToken,
+        BigInt(params.minAmountOut),
+        BigInt(params.amountOut),
+        referrerTotalBps(params.referrers),
+        params.recipient,
+        nonce,
+        deadline,
+        hex(signature),
+    ],
+});
+export const hexValue = (value) => toHex(value);
+export const evmSwapOf = (instructions) => {
+    if (instructions.payload.case !== "evm") {
+        throw new Error("expected evm swap instructions");
+    }
+    const evm = instructions.payload.value;
+    return {
+        srcToken: instructions.srcToken,
+        amountIn: instructions.amountIn,
+        aggregator: evm.aggregator,
+        swapCalldata: evm.swapCalldata,
+        bridgeToken: instructions.bridgeToken,
+        minBridgeOut: instructions.minBridgeOut,
+        value: evm.value,
+    };
+};
+export const usesDirectTransfer = (request) => !!request.directTransfer &&
+    !isNativeEvmToken(request.params.srcToken) &&
+    request.params.srcChain !== request.params.dstChain &&
+    request.params.srcToken === request.params.bridgeTokenSrc;
+const permitRouterOf = (request) => {
+    if (!request.router) {
+        throw new Error("permit deposits without a swap need the chain router");
+    }
+    return request.router;
+};
+export const buildEvmDepositCall = (request, signature) => {
+    const { quoteHash, params } = request;
+    const amountIn = BigInt(params.amountIn);
+    const native = isNativeEvmToken(params.srcToken);
+    if (!signature && usesDirectTransfer(request)) {
+        return {
+            to: params.srcToken,
+            data: encodeDirectTransfer(params.routerAddress, amountIn, quoteHash),
+            value: hexValue(0n),
+        };
+    }
+    if (native && signature) {
+        throw new Error("native deposits do not take a permit");
+    }
+    const sameChain = params.srcChain === params.dstChain;
+    const evmSwap = request.swap ? evmSwapOf(request.swap) : undefined;
+    const to = request.swap
+        ? request.swap.routerAddress
+        : signature
+            ? permitRouterOf(request)
+            : params.routerAddress;
+    const value = evmSwap ? BigInt(evmSwap.value) : native ? amountIn : 0n;
+    let data;
+    if (!signature) {
+        data = evmSwap
+            ? sameChain
+                ? encodeSwapAndForward(quoteHash, params, evmSwap)
+                : encodeDepositWithSwap(quoteHash, evmSwap)
+            : native
+                ? encodeDepositNative(quoteHash)
+                : encodeDepositToken(quoteHash, params.srcToken, amountIn);
+    }
+    else if (signature.kind === "permit") {
+        data = evmSwap
+            ? sameChain
+                ? encodeSwapAndForwardWithPermit(quoteHash, params, evmSwap, signature.deadline, signature.signature)
+                : encodeDepositWithSwapAndPermit(quoteHash, evmSwap, signature.deadline, signature.signature)
+            : encodeDepositTokenWithPermit(quoteHash, params.srcToken, amountIn, signature.deadline, signature.signature);
+    }
+    else {
+        data = evmSwap
+            ? sameChain
+                ? encodeSwapAndForwardWithPermit2(quoteHash, params, evmSwap, signature.nonce, signature.deadline, signature.signature)
+                : encodeDepositWithSwapAndPermit2(quoteHash, evmSwap, signature.nonce, signature.deadline, signature.signature)
+            : encodeDepositTokenWithPermit2(quoteHash, params.srcToken, amountIn, signature.nonce, signature.deadline, signature.signature);
+    }
+    return { to, data, value: hexValue(value) };
+};