@mayanfinance/blink-sdk 0.1.8

package/dist/deposit.js

@@ -0,0 +1,526 @@
+import { formatAmount } from "./amount.js";
+import { buildEvmDepositCall, detectPermit, encodeApprove, evmAllowance, evmAllowanceSlot, evmEstimateGas, evmGasPrice, permit2WitnessDepositTypedData, permit2WitnessSwapDepositTypedData, evmBalance, isNativeEvmToken, PERMIT2_ADDRESS, permit2TypedData, permitDeadline, permitTypedData, randomPermit2Nonce, splitSignature, usesDirectTransfer, waitForEvmTransaction, } from "./evm.js";
+import { assertQuoteHash } from "./hash.js";
+import { assertDepositDeadline, isSourceSwap } from "./order.js";
+import { SUI_COIN_TYPE, buildSuiDeposit, buildSuiSwapDeposit, sponsorSuiTransaction, suiBalance, } from "./sui.js";
+import { buildSvmDeposit, buildSvmSwapDeposit, svmBalance } from "./svm.js";
+import { sendEvmCalls, sendEvmTransaction, signAndSendSuiTransaction, signAndSendSvmTransaction, signSuiTransaction, signSvmTransaction, signEvmTypedData, supportsAtomicBatch, switchEvmChain, } from "./wallets.js";
+const trackGaslessSubmission = async (client, quoteHash) => {
+    for (;;) {
+        const submission = await client.blink.submitGaslessOrder({ quoteHash });
+        if (submission.status === "failed" || submission.status === "rejected") {
+            throw new Error(submission.error ?? "gasless submission failed");
+        }
+        if (submission.txHash) {
+            return submission.txHash;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+};
+const rpcUrlOf = (chain) => {
+    if (!chain.rpcUrl) {
+        throw new Error(`no public rpc configured for ${chain.chain}`);
+    }
+    return chain.rpcUrl;
+};
+const NATIVE_EVM_TOKEN = "0x0000000000000000000000000000000000000000";
+const SVM_MIN_FEE_LAMPORTS = 2000000n;
+const SUI_MIN_FEE_MIST = 20000000n;
+export class InsufficientGasError extends Error {
+    required;
+    balance;
+    constructor(symbol, decimals, required, balance) {
+        super(`not enough ${symbol} for network fees: need ${formatAmount(required, decimals)}, have ${formatAmount(balance, decimals)}`);
+        this.required = required;
+        this.balance = balance;
+        this.name = "InsufficientGasError";
+    }
+}
+export class EvmChainAdapter {
+    client;
+    chain;
+    chainId;
+    kind = "evm";
+    constructor(client, chain, chainId) {
+        this.client = client;
+        this.chain = chain;
+        this.chainId = chainId;
+    }
+    balance(owner, token) {
+        return evmBalance(rpcUrlOf(this.chain), token, owner);
+    }
+    async canPayGas(owner) {
+        const balance = await evmBalance(rpcUrlOf(this.chain), NATIVE_EVM_TOKEN, owner);
+        return balance > 0n;
+    }
+    async gasWithAllowance(owner, call, token, spender, amount) {
+        const rpcUrl = rpcUrlOf(this.chain);
+        try {
+            const slot = await evmAllowanceSlot(rpcUrl, token, owner, spender);
+            return slot && (await evmEstimateGas(rpcUrl, owner, call, { token, slot, amount }));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async assertCanPay(owner, required) {
+        if (required === undefined) {
+            return;
+        }
+        const balance = await evmBalance(rpcUrlOf(this.chain), NATIVE_EVM_TOKEN, owner);
+        if (balance < required) {
+            throw new InsufficientGasError(this.chain.nativeSymbol, this.chain.nativeDecimals, required, balance);
+        }
+    }
+    async steps(wallet, quoteHash, params, options) {
+        if (wallet.kind !== "evm") {
+            throw new Error(`${this.chain.chain} needs an evm wallet`);
+        }
+        assertQuoteHash(quoteHash, params);
+        assertDepositDeadline(options?.depositDeadline);
+        const rpcUrl = rpcUrlOf(this.chain);
+        const amountIn = BigInt(params.amountIn);
+        const native = isNativeEvmToken(params.srcToken);
+        const gasPrice = await evmGasPrice(rpcUrl);
+        const feeOf = async (call) => gasPrice * (await evmEstimateGas(rpcUrl, wallet.address, call));
+        const selectChain = () => switchEvmChain(wallet.provider, this.chainId, this.chain.chain, this.chain.nativeSymbol, rpcUrl);
+        const send = async (call) => {
+            await selectChain();
+            return sendEvmTransaction(wallet.provider, {
+                from: wallet.address,
+                ...call,
+            });
+        };
+        const base = {
+            quoteHash,
+            params,
+            directTransfer: options?.directTransfer,
+        };
+        if (usesDirectTransfer(base)) {
+            const call = buildEvmDepositCall(base);
+            const fee = await feeOf(call);
+            await this.assertCanPay(wallet.address, fee);
+            return [{ kind: "deposit", fee, run: () => send(call) }];
+        }
+        const request = {
+            ...base,
+            swap: isSourceSwap(params)
+                ? await this.client.blink.getSwapInstructions({ quoteHash })
+                : undefined,
+            router: this.chain.router,
+        };
+        const call = buildEvmDepositCall(request);
+        const target = call.to;
+        const permitTarget = request.swap ? target : this.chain.router;
+        const deposit = { kind: "deposit", run: () => send(call) };
+        if (native) {
+            deposit.fee = await feeOf(call);
+            await this.assertCanPay(wallet.address, deposit.fee + BigInt(call.value));
+            return [deposit];
+        }
+        const allowance = await evmAllowance(rpcUrl, params.srcToken, wallet.address, target);
+        if (allowance >= amountIn) {
+            deposit.fee = await feeOf(call);
+            await this.assertCanPay(wallet.address, deposit.fee);
+            return [deposit];
+        }
+        const depositGas = await this.gasWithAllowance(wallet.address, call, params.srcToken, target, amountIn);
+        deposit.fee = depositGas === undefined ? undefined : depositGas * gasPrice;
+        const permit = permitTarget
+            ? await detectPermit(rpcUrl, params.srcToken, wallet.address, this.chainId)
+            : undefined;
+        if (permitTarget && permit) {
+            await this.assertCanPay(wallet.address, deposit.fee);
+            return [
+                {
+                    kind: "deposit",
+                    fee: deposit.fee,
+                    run: async () => {
+                        await selectChain();
+                        const deadline = permitDeadline();
+                        const signature = splitSignature(await signEvmTypedData(wallet.provider, wallet.address, permitTypedData(permit, this.chainId, params.srcToken, wallet.address, permitTarget, amountIn, deadline)));
+                        return send(buildEvmDepositCall(request, { kind: "permit", deadline, signature }));
+                    },
+                },
+            ];
+        }
+        const permit2Allowance = permitTarget
+            ? await evmAllowance(rpcUrl, params.srcToken, wallet.address, PERMIT2_ADDRESS)
+            : 0n;
+        if (permitTarget && permit2Allowance >= amountIn) {
+            await this.assertCanPay(wallet.address, deposit.fee);
+            return [
+                {
+                    kind: "deposit",
+                    fee: deposit.fee,
+                    run: async () => {
+                        await selectChain();
+                        const nonce = randomPermit2Nonce();
+                        const deadline = permitDeadline();
+                        const signature = await signEvmTypedData(wallet.provider, wallet.address, permit2TypedData(this.chainId, params.srcToken, amountIn, permitTarget, nonce, deadline));
+                        return send(buildEvmDepositCall(request, {
+                            kind: "permit2",
+                            nonce,
+                            deadline,
+                            signature,
+                        }));
+                    },
+                },
+            ];
+        }
+        const approveCall = {
+            to: params.srcToken,
+            data: encodeApprove(target, amountIn),
+        };
+        const approveFee = await feeOf(approveCall);
+        const totalFee = deposit.fee === undefined ? undefined : approveFee + deposit.fee;
+        await this.assertCanPay(wallet.address, totalFee ?? approveFee);
+        if (await supportsAtomicBatch(wallet.provider, wallet.address, this.chainId)) {
+            return [
+                {
+                    kind: "deposit",
+                    fee: totalFee,
+                    run: async () => {
+                        await selectChain();
+                        return sendEvmCalls(wallet.provider, wallet.address, this.chainId, [
+                            approveCall,
+                            call,
+                        ]);
+                    },
+                },
+            ];
+        }
+        const approve = {
+            kind: "approve",
+            fee: approveFee,
+            run: async () => {
+                await selectChain();
+                const hash = await sendEvmTransaction(wallet.provider, {
+                    from: wallet.address,
+                    ...approveCall,
+                });
+                await waitForEvmTransaction(rpcUrl, hash);
+                return hash;
+            },
+        };
+        return [approve, deposit];
+    }
+    async gaslessSteps(wallet, quoteHash, params, quote) {
+        if (wallet.kind !== "evm") {
+            throw new Error(`${this.chain.chain} needs an evm wallet`);
+        }
+        assertQuoteHash(quoteHash, params);
+        assertDepositDeadline(quote.depositDeadline);
+        const spender = this.chain.router;
+        if (!spender) {
+            throw new Error(`no router configured for ${this.chain.chain}`);
+        }
+        const rpcUrl = rpcUrlOf(this.chain);
+        const amountIn = BigInt(params.amountIn);
+        if (isNativeEvmToken(params.srcToken)) {
+            throw new Error("gasless deposits require an erc20 input token");
+        }
+        const steps = [];
+        const permit2Allowance = await evmAllowance(rpcUrl, params.srcToken, wallet.address, PERMIT2_ADDRESS);
+        const permit = permit2Allowance < amountIn
+            ? await detectPermit(rpcUrl, params.srcToken, wallet.address, this.chainId)
+            : undefined;
+        if (permit2Allowance < amountIn && !permit) {
+            const approveCall = {
+                to: params.srcToken,
+                data: encodeApprove(PERMIT2_ADDRESS, (1n << 256n) - 1n),
+            };
+            const fee = (await evmGasPrice(rpcUrl)) *
+                (await evmEstimateGas(rpcUrl, wallet.address, approveCall));
+            await this.assertCanPay(wallet.address, fee);
+            steps.push({
+                kind: "approve",
+                fee,
+                run: async () => {
+                    await switchEvmChain(wallet.provider, this.chainId, this.chain.chain, this.chain.nativeSymbol, rpcUrl);
+                    const hash = await sendEvmTransaction(wallet.provider, {
+                        from: wallet.address,
+                        ...approveCall,
+                    });
+                    await waitForEvmTransaction(rpcUrl, hash);
+                    return hash;
+                },
+            });
+        }
+        const swap = isSourceSwap(params);
+        steps.push({
+            kind: "deposit",
+            run: async () => {
+                await switchEvmChain(wallet.provider, this.chainId, this.chain.chain, this.chain.nativeSymbol, rpcUrl);
+                const nonce = randomPermit2Nonce();
+                const deadline = permitDeadline();
+                const permitSignature = permit
+                    ? await signEvmTypedData(wallet.provider, wallet.address, permitTypedData(permit, this.chainId, params.srcToken, wallet.address, PERMIT2_ADDRESS, (1n << 256n) - 1n, deadline))
+                    : undefined;
+                const typedData = swap
+                    ? permit2WitnessSwapDepositTypedData(this.chainId, params.srcToken, amountIn, spender, nonce, deadline, quoteHash, params.bridgeTokenSrc, BigInt(params.minBridgeOut))
+                    : permit2WitnessDepositTypedData(this.chainId, params.srcToken, amountIn, spender, nonce, deadline, quoteHash);
+                const signature = await signEvmTypedData(wallet.provider, wallet.address, typedData);
+                await this.client.blink.submitGaslessOrder({
+                    quoteHash,
+                    order: {
+                        case: "evm",
+                        value: {
+                            owner: wallet.address,
+                            permit2Nonce: nonce.toString(),
+                            deadline,
+                            signature,
+                            permitSignature,
+                        },
+                    },
+                });
+                return trackGaslessSubmission(this.client, quoteHash);
+            },
+        });
+        return steps;
+    }
+}
+export class SvmChainAdapter {
+    chain;
+    client;
+    kind = "svm";
+    constructor(chain, client) {
+        this.chain = chain;
+        this.client = client;
+    }
+    balance(owner, token) {
+        return svmBalance(rpcUrlOf(this.chain), token, owner);
+    }
+    async canPayGas(owner) {
+        const balance = await svmBalance(rpcUrlOf(this.chain), "11111111111111111111111111111111", owner);
+        return balance >= SVM_MIN_FEE_LAMPORTS;
+    }
+    async steps(wallet, quoteHash, params, options) {
+        if (wallet.kind !== "svm") {
+            throw new Error("svm needs an svm wallet");
+        }
+        assertQuoteHash(quoteHash, params);
+        assertDepositDeadline(options?.depositDeadline);
+        if (!this.chain.treasury) {
+            throw new Error("svm deposits are unavailable");
+        }
+        const rpcUrl = rpcUrlOf(this.chain);
+        if (isSourceSwap(params)) {
+            const client = this.client;
+            if (!client) {
+                throw new Error("svm swap deposits need an api client");
+            }
+            return [
+                {
+                    kind: "deposit",
+                    run: async () => {
+                        const instructions = await client.blink.getSwapInstructions({
+                            quoteHash,
+                        });
+                        if (instructions.payload.case !== "svm") {
+                            throw new Error("expected svm swap instructions");
+                        }
+                        const transaction = await buildSvmSwapDeposit({
+                            rpcUrl,
+                            chain: this.chain.chain,
+                            programId: instructions.routerAddress,
+                            owner: wallet.address,
+                            srcToken: params.srcToken,
+                            bridgeToken: params.bridgeTokenSrc,
+                            amount: BigInt(params.amountIn),
+                            minBridgeOut: BigInt(params.minBridgeOut),
+                            quoteHash,
+                            swap: instructions.payload.value,
+                            swapProgramSigner: this.chain.treasury,
+                        });
+                        return signAndSendSvmTransaction(wallet.wallet, wallet.address, transaction);
+                    },
+                },
+            ];
+        }
+        return [
+            {
+                kind: "deposit",
+                run: async () => {
+                    const transaction = await buildSvmDeposit({
+                        rpcUrl,
+                        programId: params.routerAddress,
+                        owner: wallet.address,
+                        token: params.srcToken,
+                        amount: BigInt(params.amountIn),
+                        quoteHash,
+                    });
+                    return signAndSendSvmTransaction(wallet.wallet, wallet.address, transaction);
+                },
+            },
+        ];
+    }
+    async gaslessSteps(wallet, quoteHash, params, quote) {
+        if (wallet.kind !== "svm") {
+            throw new Error("svm needs an svm wallet");
+        }
+        assertQuoteHash(quoteHash, params);
+        assertDepositDeadline(quote.depositDeadline);
+        if (isSourceSwap(params)) {
+            throw new Error("gasless swap deposits are unavailable on svm");
+        }
+        if (!this.chain.treasury) {
+            throw new Error("svm deposits are unavailable");
+        }
+        const sponsor = quote.sponsorAddress;
+        if (!sponsor) {
+            throw new Error("gasless deposits are unavailable on svm");
+        }
+        if (!this.client) {
+            throw new Error("gasless deposits need an api client");
+        }
+        const client = this.client;
+        const rpcUrl = rpcUrlOf(this.chain);
+        return [
+            {
+                kind: "deposit",
+                run: async () => {
+                    const transaction = await buildSvmDeposit({
+                        rpcUrl,
+                        programId: params.routerAddress,
+                        owner: wallet.address,
+                        token: params.srcToken,
+                        amount: BigInt(params.amountIn),
+                        quoteHash,
+                        feePayer: sponsor,
+                    });
+                    const signed = await signSvmTransaction(wallet.wallet, wallet.address, transaction);
+                    await client.blink.submitGaslessOrder({
+                        quoteHash,
+                        order: {
+                            case: "svm",
+                            value: { txBase64: btoa(String.fromCharCode(...signed)) },
+                        },
+                    });
+                    return trackGaslessSubmission(client, quoteHash);
+                },
+            },
+        ];
+    }
+}
+export class SuiChainAdapter {
+    chain;
+    client;
+    kind = "sui";
+    constructor(chain, client) {
+        this.chain = chain;
+        this.client = client;
+    }
+    balance(owner, token) {
+        return suiBalance(rpcUrlOf(this.chain), token, owner);
+    }
+    async canPayGas(owner) {
+        const balance = await suiBalance(rpcUrlOf(this.chain), SUI_COIN_TYPE, owner);
+        return balance >= SUI_MIN_FEE_MIST;
+    }
+    async steps(wallet, quoteHash, params, options) {
+        if (wallet.kind !== "sui") {
+            throw new Error("sui needs a sui wallet");
+        }
+        assertQuoteHash(quoteHash, params);
+        assertDepositDeadline(options?.depositDeadline);
+        const escrow = this.chain.escrow;
+        if (!escrow) {
+            throw new Error("sui deposits are unavailable");
+        }
+        if (isSourceSwap(params) && !this.client) {
+            throw new Error("sui swap deposits need an api client");
+        }
+        const client = this.client;
+        const rpcUrl = rpcUrlOf(this.chain);
+        return [
+            {
+                kind: "deposit",
+                run: async () => signAndSendSuiTransaction(wallet.wallet, wallet.address, await suiDepositTransaction(client, rpcUrl, escrow, wallet.address, quoteHash, params)),
+            },
+        ];
+    }
+    async gaslessSteps(wallet, quoteHash, params, quote) {
+        if (wallet.kind !== "sui") {
+            throw new Error("sui needs a sui wallet");
+        }
+        assertQuoteHash(quoteHash, params);
+        assertDepositDeadline(quote.depositDeadline);
+        const escrow = this.chain.escrow;
+        if (!escrow) {
+            throw new Error("sui deposits are unavailable");
+        }
+        const sponsor = quote.sponsorAddress;
+        const gasBudget = quote.sponsorGasBudget;
+        if (!sponsor || gasBudget === undefined) {
+            throw new Error("gasless deposits are unavailable on sui");
+        }
+        if (!this.client) {
+            throw new Error("gasless deposits need an api client");
+        }
+        const client = this.client;
+        const rpcUrl = rpcUrlOf(this.chain);
+        return [
+            {
+                kind: "deposit",
+                run: async () => {
+                    const transaction = await sponsorSuiTransaction(rpcUrl, await suiDepositTransaction(client, rpcUrl, escrow, wallet.address, quoteHash, params), sponsor, gasBudget);
+                    const signed = await signSuiTransaction(wallet.wallet, wallet.address, transaction);
+                    await client.blink.submitGaslessOrder({
+                        quoteHash,
+                        order: {
+                            case: "sui",
+                            value: { txBase64: signed.bytes, signature: signed.signature },
+                        },
+                    });
+                    return trackGaslessSubmission(client, quoteHash);
+                },
+            },
+        ];
+    }
+}
+const suiDepositTransaction = async (client, rpcUrl, escrow, owner, quoteHash, params) => {
+    if (!isSourceSwap(params)) {
+        return buildSuiDeposit({
+            rpcUrl,
+            packageId: params.routerAddress,
+            escrowObject: escrow,
+            owner,
+            coinType: params.srcToken,
+            amount: BigInt(params.amountIn),
+            quoteHash,
+        });
+    }
+    if (!client) {
+        throw new Error("sui swap deposits need an api client");
+    }
+    const instructions = await client.blink.getSwapInstructions({ quoteHash });
+    if (instructions.payload.case !== "sui") {
+        throw new Error("expected sui swap instructions");
+    }
+    return buildSuiSwapDeposit({
+        rpcUrl,
+        packageId: params.routerAddress,
+        escrowObject: escrow,
+        owner,
+        srcToken: params.srcToken,
+        bridgeToken: params.bridgeTokenSrc,
+        amountIn: BigInt(params.amountIn),
+        minBridgeOut: BigInt(params.minBridgeOut),
+        quoteHash,
+        swap: instructions.payload.value,
+    });
+};
+export const createChainAdapter = (client, chain, chainId) => {
+    if (chain.vm === "svm") {
+        return new SvmChainAdapter(chain, client);
+    }
+    if (chain.vm === "sui") {
+        return new SuiChainAdapter(chain, client);
+    }
+    if (chainId === undefined) {
+        throw new Error(`unknown chain id for ${chain.chain}`);
+    }
+    return new EvmChainAdapter(client, chain, chainId);
+};
+export const walletKindOf = (chain) => chain?.vm === "svm" ? "svm" : chain?.vm === "sui" ? "sui" : "evm";