@mayanfinance/blink-sdk 0.1.9 → 0.2.0

package/dist/sui.js

@@ -1,7 +1,6 @@
-import { bcs } from "@mysten/sui/bcs";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 import { Transaction, } from "@mysten/sui/transactions";
-import { fromBase64, normalizeStructTag, normalizeSuiAddress, toHex, } from "@mysten/sui/utils";
+import { normalizeStructTag } from "@mysten/sui/utils";
 export const SUI_COIN_TYPE = "0x2::sui::SUI";
 export const isNativeSuiToken = (address) => address === SUI_COIN_TYPE;
 const client = (rpcUrl) => new SuiGrpcClient({ network: "mainnet", baseUrl: rpcUrl });
@@ -86,183 +85,62 @@ export const sponsorSuiTransaction = async (rpcUrl, transaction, sponsor, maxGas
     transaction.setGasBudget(needed < maxGasBudget ? needed : maxGasBudget);
     return Transaction.from(await transaction.build({ client: rpc }));
 };
-const rejectSwap = (reason) => {
-    throw new Error(`swap instructions rejected: ${reason}`);
-};
-export const suiSwapFragmentOf = (swap) => ({
-    fragment: bcs.ProgrammableTransaction.parse(fromBase64(swap.fragment)),
-    coinOut: swap.coinOutResult === undefined
-        ? { $kind: "Result", Result: swap.coinOutCommand }
-        : {
-            $kind: "NestedResult",
-            NestedResult: [swap.coinOutCommand, swap.coinOutResult],
-        },
-});
-const inputKind = (input) => input.$kind === "Object" ? input.Object.$kind : input.$kind;
-const commandArguments = (command) => {
-    switch (command.$kind) {
-        case "MoveCall":
-            return command.MoveCall.arguments;
-        case "TransferObjects":
-            return [
-                ...command.TransferObjects.objects,
-                command.TransferObjects.address,
-            ];
-        case "SplitCoins":
-            return [command.SplitCoins.coin, ...command.SplitCoins.amounts];
-        case "MergeCoins":
-            return [command.MergeCoins.destination, ...command.MergeCoins.sources];
-        case "MakeMoveVec":
-            return command.MakeMoveVec.elements;
-        default:
-            return rejectSwap(`command ${command.$kind} is not allowed`);
-    }
-};
-const referencedCommand = (arg) => arg.$kind === "Result"
-    ? arg.Result
-    : arg.$kind === "NestedResult"
-        ? arg.NestedResult[0]
-        : undefined;
-const isSenderInput = (fragment, arg, sender) => {
-    if (arg.$kind !== "Input") {
-        return false;
-    }
-    const input = fragment.inputs[arg.Input];
-    if (input?.$kind !== "Pure") {
-        return false;
-    }
-    const bytes = fromBase64(input.Pure.bytes);
-    return (bytes.length === 32 &&
-        normalizeSuiAddress(toHex(bytes)) === normalizeSuiAddress(sender));
-};
-const isCoinInStandIn = (command, srcToken) => command?.$kind === "MoveCall" &&
-    normalizeSuiAddress(command.MoveCall.package) ===
-        normalizeSuiAddress("0x2") &&
-    command.MoveCall.module === "coin" &&
-    command.MoveCall.function === "zero" &&
-    command.MoveCall.arguments.length === 0 &&
-    command.MoveCall.typeArguments.length === 1 &&
-    normalizeStructTag(command.MoveCall.typeArguments[0]) ===
-        normalizeStructTag(srcToken);
-export const checkSuiSwapFragment = (fragment, coinOut, rules) => {
-    if (!isCoinInStandIn(fragment.commands[0], rules.srcToken)) {
-        rejectSwap("first command is not the input coin stand-in");
-    }
-    for (const input of fragment.inputs) {
-        if (input.$kind !== "Pure" &&
-            !(input.$kind === "Object" && input.Object.$kind === "SharedObject")) {
-            rejectSwap(`input ${inputKind(input)} is not allowed`);
-        }
-    }
-    fragment.commands.forEach((command, index) => {
-        if (index === 0) {
-            return;
-        }
-        for (const arg of commandArguments(command)) {
-            if (arg.$kind === "GasCoin") {
-                rejectSwap("gas coin is not allowed");
-            }
-            if (arg.$kind === "Input" && arg.Input >= fragment.inputs.length) {
-                rejectSwap("argument references a missing input");
-            }
-            if (arg.$kind === "NestedResult" && arg.NestedResult[0] === 0) {
-                rejectSwap("nested result of the input coin stand-in");
-            }
-            const target = referencedCommand(arg);
-            if (target !== undefined && target >= index) {
-                rejectSwap("argument references a later command");
-            }
-        }
-        if (command.$kind === "TransferObjects" &&
-            !isSenderInput(fragment, command.TransferObjects.address, rules.sender)) {
-            rejectSwap("transfer recipient is not the sender");
-        }
+const SOURCE_SWAP_WINDOW_MS = 300000n;
+const SOURCE_SWAP_ALLOWANCE_NAME = "blink source swap";
+export const suiSourceSwapExpiry = async (rpcUrl) => {
+    const { response } = await client(rpcUrl).ledgerService.getCheckpoint({
+        checkpointId: { oneofKind: undefined },
+        readMask: { paths: ["summary.timestamp"] },
     });
-    const outCommand = referencedCommand(coinOut);
-    if (outCommand === undefined ||
-        outCommand === 0 ||
-        outCommand >= fragment.commands.length) {
-        rejectSwap("output coin does not reference a swap command");
+    const timestamp = response.checkpoint?.summary?.timestamp;
+    if (!timestamp) {
+        throw new Error("sui checkpoint has no timestamp");
     }
+    const nowMs = timestamp.seconds * 1000n + BigInt(Math.floor(timestamp.nanos / 1_000_000));
+    return nowMs + SOURCE_SWAP_WINDOW_MS;
 };
-export const appendSwapFragment = (tx, fragment, payment, coinOut) => {
-    const inputs = fragment.inputs.map((input) => {
-        if (input.$kind === "Pure") {
-            return tx.pure(fromBase64(input.Pure.bytes));
-        }
-        if (input.$kind === "Object" && input.Object.$kind === "SharedObject") {
-            return tx.sharedObjectRef(input.Object.SharedObject);
-        }
-        return rejectSwap(`input ${inputKind(input)} is not allowed`);
-    });
-    const results = [];
-    const resolve = (arg) => {
-        switch (arg.$kind) {
-            case "Input":
-                return inputs[arg.Input];
-            case "Result":
-                return arg.Result === 0 ? payment : results[arg.Result];
-            case "NestedResult":
-                return results[arg.NestedResult[0]][arg.NestedResult[1]];
-            default:
-                return rejectSwap("gas coin is not allowed");
-        }
-    };
-    fragment.commands.forEach((command, index) => {
-        if (index === 0) {
-            return;
-        }
-        switch (command.$kind) {
-            case "MoveCall":
-                results[index] = tx.moveCall({
-                    target: `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`,
-                    typeArguments: command.MoveCall.typeArguments,
-                    arguments: command.MoveCall.arguments.map(resolve),
-                });
-                return;
-            case "TransferObjects":
-                results[index] = tx.transferObjects(command.TransferObjects.objects.map(resolve), resolve(command.TransferObjects.address));
-                return;
-            case "SplitCoins":
-                results[index] = tx.splitCoins(resolve(command.SplitCoins.coin), command.SplitCoins.amounts.map(resolve));
-                return;
-            case "MergeCoins":
-                results[index] = tx.mergeCoins(resolve(command.MergeCoins.destination), command.MergeCoins.sources.map(resolve));
-                return;
-            case "MakeMoveVec":
-                results[index] = tx.makeMoveVec({
-                    type: command.MakeMoveVec.type ?? undefined,
-                    elements: command.MakeMoveVec.elements.map(resolve),
-                });
-                return;
-            default:
-                rejectSwap(`command ${command.$kind} is not allowed`);
-        }
+export const addSuiSourceSwapOpenCall = (tx, call) => {
+    if (call.payment) {
+        tx.moveCall({
+            target: "0x2::coin::send_funds",
+            typeArguments: [call.srcToken],
+            arguments: [call.payment, tx.pure.address(call.sender)],
+        });
+    }
+    const noRateLimit = tx.moveCall({
+        target: "0x1::option::none",
+        typeArguments: ["0x2::allowance::RateLimit"],
     });
-    return resolve(coinOut);
-};
-export const addSuiSwapDepositCall = (tx, call) => {
-    const { fragment, coinOut } = suiSwapFragmentOf(call.swap);
-    checkSuiSwapFragment(fragment, coinOut, {
-        sender: call.sender,
-        srcToken: call.srcToken,
+    const proposal = tx.moveCall({
+        target: "0x2::allowance::propose_for_app",
+        typeArguments: [
+            `0x2::balance::Balance<${call.srcToken}>`,
+            `${call.packageId}::blink::SourceSwapFunding`,
+        ],
+        arguments: [
+            tx.pure.string(SOURCE_SWAP_ALLOWANCE_NAME),
+            tx.pure.address(call.swapExecutor),
+            tx.pure.option("u256", call.amountIn),
+            tx.pure.option("u64", null),
+            tx.pure.option("u64", call.expiresAtMs),
+            noRateLimit,
+        ],
     });
-    const bridged = appendSwapFragment(tx, fragment, call.payment, coinOut);
     tx.moveCall({
-        target: `${call.packageId}::blink::deposit_swap`,
+        target: `${call.packageId}::blink::open_source_swap`,
         typeArguments: [call.srcToken, call.bridgeToken],
         arguments: [
             tx.object(call.escrowObject),
+            proposal,
             tx.pure.vector("u8", hexBytes(call.quoteHash)),
-            bridged,
-            tx.pure.u64(call.amountIn),
             tx.pure.u64(call.minBridgeOut),
+            tx.object.clock(),
         ],
     });
 };
 const isSuiCoinType = (coinType) => normalizeStructTag(coinType) === normalizeStructTag(SUI_COIN_TYPE);
-const addPayment = async (tx, rpcUrl, owner, coinType, amount) => {
-    if (isSuiCoinType(coinType)) {
+const addPayment = async (tx, rpcUrl, owner, coinType, amount, gasless) => {
+    if (isSuiCoinType(coinType) && !gasless) {
         const [payment] = tx.splitCoins(tx.gas, [amount]);
         return payment;
     }
@@ -274,20 +152,29 @@ const addPayment = async (tx, rpcUrl, owner, coinType, amount) => {
     const [payment] = tx.splitCoins(primary, [amount]);
     return payment;
 };
-export const buildSuiSwapDeposit = async (request) => {
+const suiAddressBalance = async (rpcUrl, owner, coinType) => {
+    const { balance } = await client(rpcUrl).getBalance({ owner, coinType });
+    return BigInt(balance.addressBalance);
+};
+export const buildSuiSourceSwapOpen = async (request) => {
     const tx = new Transaction();
     tx.setSender(request.owner);
-    const payment = await addPayment(tx, request.rpcUrl, request.owner, request.srcToken, request.amountIn);
-    addSuiSwapDepositCall(tx, {
+    const shortfall = request.amountIn -
+        (await suiAddressBalance(request.rpcUrl, request.owner, request.srcToken));
+    const payment = shortfall > 0n
+        ? await addPayment(tx, request.rpcUrl, request.owner, request.srcToken, shortfall, request.gasless)
+        : undefined;
+    addSuiSourceSwapOpenCall(tx, {
         packageId: request.packageId,
         escrowObject: request.escrowObject,
+        swapExecutor: request.swapExecutor,
         sender: request.owner,
         srcToken: request.srcToken,
         bridgeToken: request.bridgeToken,
         amountIn: request.amountIn,
         minBridgeOut: request.minBridgeOut,
         quoteHash: request.quoteHash,
-        swap: request.swap,
+        expiresAtMs: await suiSourceSwapExpiry(request.rpcUrl),
         payment,
     });
     return tx;

package/dist/svm.d.ts

@@ -1,7 +1,7 @@
 import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from "@solana/web3.js";
 import type { SvmSwapInstructions } from "./gen/blink/v1/api_pb.js";
-export declare const DEFAULT_SWAP_PROGRAMS: PublicKey[];
 export declare const isNativeSvmToken: (address: string) => boolean;
+export declare const svmSwapAuthority: (programId: PublicKey, owner: PublicKey, quoteHash: string) => PublicKey;
 export declare const svmBalance: (rpcUrl: string, token: string, owner: string) => Promise<bigint>;
 export interface SvmDepositRequest {
     rpcUrl: string;
@@ -13,10 +13,8 @@ export interface SvmDepositRequest {
     computeUnitPriceMicroLamports: bigint;
     feePayer?: string;
 }
-export declare const resolveSwapPrograms: (chain: string, swap: SvmSwapInstructions, expectedSigner: string | undefined) => PublicKey[];
 export interface SvmSwapDepositRequest {
     rpcUrl: string;
-    chain: string;
     programId: string;
     owner: string;
     srcToken: string;
@@ -26,7 +24,7 @@ export interface SvmSwapDepositRequest {
     quoteHash: string;
     swap: SvmSwapInstructions;
     computeUnitPriceMicroLamports: bigint;
-    swapProgramSigner?: string;
+    swapPrograms: string[];
 }
 export interface SvmDepositInstructions {
     instructions: TransactionInstruction[];