@mayanfinance/blink-sdk 0.1.8 → 0.2.0

package/README.md

@@ -13,3 +13,16 @@ const { blink } = createBlinkClient({ apiKey: process.env.BLINK_API_KEY });
 ```
 
 The client talks to `https://api.hular.dev` unless `baseUrl` is passed. Full documentation is at https://docs.hular.dev.
+
+## Contract registry
+
+Every contract address a deposit touches is checked against a signed manifest served by `GetContracts`. The SDK pins the genesis guardian set, verifies each later set was approved by a majority of the previous one, and accepts the manifest only when every member of the latest set has signed it. `client.contracts` caches the manifest for two hours, refetches when a quote references a newer guardian set or an address outside the cache, and throws `UnregisteredAddressError` if the address is still unknown.
+
+Guardians sign with `scripts/sign-contracts.mjs`:
+
+```
+CONTRACTS_SIGNER_KEY=0x... node scripts/sign-contracts.mjs manifest ../config/contracts.json
+CONTRACTS_SIGNER_KEY=0x... node scripts/sign-contracts.mjs guardians ../config/guardians.json 1
+```
+
+The first form writes the signature next to the manifest in `contracts.sig.json`; the second approves the guardian set with that index on behalf of a member of the previous set.

package/dist/client.d.ts

@@ -1,4 +1,5 @@
 import { type Client } from "@connectrpc/connect";
+import { type ContractRegistry } from "./contracts.js";
 import { BlinkApi } from "./gen/blink/v1/api_pb.js";
 import { AdminApi } from "./gen/blink/v1/admin_pb.js";
 import { PartnerApi } from "./gen/blink/v1/partner_pb.js";
@@ -13,5 +14,6 @@ export interface BlinkClient {
     blink: Client<typeof BlinkApi>;
     partner: Client<typeof PartnerApi>;
     admin: Client<typeof AdminApi>;
+    contracts: ContractRegistry;
 }
 export declare const createBlinkClient: ({ baseUrl, apiKey, token, telemetry, }: BlinkClientOptions) => BlinkClient;

package/dist/client.js

@@ -1,5 +1,6 @@
 import { createClient } from "@connectrpc/connect";
 import { createGrpcWebTransport } from "@connectrpc/connect-web";
+import { ApiContractRegistry } from "./contracts.js";
 import { BlinkApi } from "./gen/blink/v1/api_pb.js";
 import { AdminApi } from "./gen/blink/v1/admin_pb.js";
 import { PartnerApi } from "./gen/blink/v1/partner_pb.js";
@@ -24,9 +25,11 @@ export const createBlinkClient = ({ baseUrl = BLINK_API_URL, apiKey, token, tele
         baseUrl,
         interceptors: [headers],
     });
+    const blink = createClient(BlinkApi, transport);
     return {
-        blink: createClient(BlinkApi, transport),
+        blink,
         partner: createClient(PartnerApi, transport),
         admin: createClient(AdminApi, transport),
+        contracts: new ApiContractRegistry(blink),
     };
 };

package/dist/contracts.d.ts

@@ -0,0 +1,40 @@
+import type { Client } from "@connectrpc/connect";
+import type { BlinkApi, ContractsResponse, GuardianSet } from "./gen/blink/v1/api_pb.js";
+export declare const GENESIS_GUARDIANS: readonly string[];
+export declare const CONTRACTS_REFRESH_MS: number;
+export interface ChainContracts {
+    router: string;
+    escrow?: string;
+    swapPrograms: string[];
+}
+export interface ContractManifest {
+    guardianSetIndex: number;
+    chains: Record<string, ChainContracts>;
+}
+export declare class UnregisteredAddressError extends Error {
+    readonly chain: string;
+    readonly address: string;
+    constructor(chain: string, address: string);
+}
+export interface ContractRegistry {
+    contracts(chain: string, guardianSetIndex?: number): Promise<ChainContracts>;
+    assertRegistered(chain: string, address: string, guardianSetIndex?: number): Promise<void>;
+}
+export declare const sameAddress: (a: string, b: string) => boolean;
+export declare const guardianMessage: (index: number, members: string[]) => string;
+export declare const verifyGuardianSets: (sets: GuardianSet[], genesis?: readonly string[]) => Promise<GuardianSet>;
+export declare const verifyManifestSignatures: (manifest: string, signatures: string[], members: string[]) => Promise<void>;
+export declare const verifyContracts: (response: ContractsResponse, genesis?: readonly string[]) => Promise<ContractManifest>;
+export declare class ApiContractRegistry implements ContractRegistry {
+    private api;
+    private cached?;
+    private inflight?;
+    constructor(api: Client<typeof BlinkApi>);
+    contracts(chain: string, guardianSetIndex?: number): Promise<ChainContracts>;
+    assertRegistered(chain: string, address: string, guardianSetIndex?: number): Promise<void>;
+    private lookup;
+    private manifest;
+    private current;
+    private refresh;
+    private fetch;
+}

package/dist/contracts.js

@@ -0,0 +1,160 @@
+import { recoverMessageAddress } from "viem";
+export const GENESIS_GUARDIANS = [
+    "0x4FbA3CE3CC1eb4297E274f42B1C252Ba42F886a6",
+    "0x024721C2d41739BCdE70EEc65e73E2B27726dDA9",
+    "0x9E497d060D1543Bd360db003Da7a13924a2dB8cb",
+];
+export const CONTRACTS_REFRESH_MS = 2 * 60 * 60 * 1000;
+export class UnregisteredAddressError extends Error {
+    chain;
+    address;
+    constructor(chain, address) {
+        super(`${address} is not a registered contract on ${chain}`);
+        this.chain = chain;
+        this.address = address;
+        this.name = "UnregisteredAddressError";
+    }
+}
+export const sameAddress = (a, b) => a.startsWith("0x") ? a.toLowerCase() === b.toLowerCase() : a === b;
+export const guardianMessage = (index, members) => `blink-guardians:${index}:${members.map((m) => m.toLowerCase()).join(",")}`;
+const recoveredSigners = async (message, signatures) => {
+    const signers = new Set();
+    for (const signature of signatures) {
+        const signer = await recoverMessageAddress({
+            message,
+            signature: signature,
+        });
+        signers.add(signer.toLowerCase());
+    }
+    return signers;
+};
+const sameMembers = (a, b) => a.length === b.length && a.every((m, i) => sameAddress(m, b[i]));
+export const verifyGuardianSets = async (sets, genesis = GENESIS_GUARDIANS) => {
+    const first = sets[0];
+    if (!first || first.index !== 0 || !sameMembers(first.members, genesis)) {
+        throw new Error("guardian set 0 does not match the pinned genesis set");
+    }
+    for (let i = 1; i < sets.length; i++) {
+        const previous = sets[i - 1];
+        const set = sets[i];
+        if (set.index !== i) {
+            throw new Error(`guardian set ${set.index} is out of sequence`);
+        }
+        if (set.members.length === 0 ||
+            new Set(set.members.map((m) => m.toLowerCase())).size !==
+                set.members.length) {
+            throw new Error(`guardian set ${i} members must be non-empty and distinct`);
+        }
+        const signers = await recoveredSigners(guardianMessage(i, set.members), set.signatures);
+        const approvals = previous.members.filter((m) => signers.has(m.toLowerCase())).length;
+        const quorum = Math.floor(previous.members.length / 2) + 1;
+        if (approvals < quorum) {
+            throw new Error(`guardian set ${i} has ${approvals} of ${previous.members.length} approvals, quorum is ${quorum}`);
+        }
+    }
+    return sets[sets.length - 1];
+};
+export const verifyManifestSignatures = async (manifest, signatures, members) => {
+    const signers = await recoveredSigners({ raw: new TextEncoder().encode(manifest) }, signatures);
+    const missing = members.find((m) => !signers.has(m.toLowerCase()));
+    if (missing) {
+        throw new Error(`guardian ${missing} has not signed the contract manifest`);
+    }
+};
+const isStringList = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
+const parseManifest = (raw) => {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        typeof parsed.guardian_set_index !==
+            "number" ||
+        typeof parsed.chains !== "object") {
+        throw new Error("contract manifest is malformed");
+    }
+    const { guardian_set_index, chains } = parsed;
+    const out = {};
+    for (const [chain, entry] of Object.entries(chains)) {
+        const { router, escrow, swap_programs } = entry;
+        if (typeof router !== "string" ||
+            (escrow !== undefined && typeof escrow !== "string") ||
+            (swap_programs !== undefined && !isStringList(swap_programs))) {
+            throw new Error(`contract manifest entry for ${chain} is malformed`);
+        }
+        out[chain] = { router, escrow, swapPrograms: swap_programs ?? [] };
+    }
+    return { guardianSetIndex: guardian_set_index, chains: out };
+};
+export const verifyContracts = async (response, genesis = GENESIS_GUARDIANS) => {
+    const latest = await verifyGuardianSets(response.guardianSets, genesis);
+    await verifyManifestSignatures(response.manifest, response.signatures, latest.members);
+    const manifest = parseManifest(response.manifest);
+    if (manifest.guardianSetIndex !== latest.index) {
+        throw new Error(`contract manifest is signed under guardian set ${manifest.guardianSetIndex}, latest is ${latest.index}`);
+    }
+    return manifest;
+};
+export class ApiContractRegistry {
+    api;
+    cached;
+    inflight;
+    constructor(api) {
+        this.api = api;
+    }
+    async contracts(chain, guardianSetIndex) {
+        return this.lookup(guardianSetIndex, (manifest) => manifest.chains[chain], () => new UnregisteredAddressError(chain, "every contract"));
+    }
+    async assertRegistered(chain, address, guardianSetIndex) {
+        await this.lookup(guardianSetIndex, (manifest) => {
+            const contracts = manifest.chains[chain];
+            return [contracts?.router, contracts?.escrow].find((registered) => registered !== undefined && sameAddress(registered, address));
+        }, () => new UnregisteredAddressError(chain, address));
+    }
+    async lookup(guardianSetIndex, pick, missing) {
+        const first = pick(await this.manifest(guardianSetIndex));
+        if (first !== undefined) {
+            return first;
+        }
+        await this.refresh();
+        const second = pick(await this.manifest(guardianSetIndex));
+        if (second !== undefined) {
+            return second;
+        }
+        throw missing();
+    }
+    async manifest(guardianSetIndex) {
+        let current = await this.current();
+        if (guardianSetIndex !== undefined &&
+            guardianSetIndex > current.guardianSetIndex) {
+            current = await this.refresh();
+        }
+        if (guardianSetIndex !== undefined &&
+            guardianSetIndex !== current.guardianSetIndex) {
+            throw new Error(`quote was issued under guardian set ${guardianSetIndex}, latest is ${current.guardianSetIndex}`);
+        }
+        return current;
+    }
+    current() {
+        if (!this.cached ||
+            Date.now() - this.cached.fetchedAt > CONTRACTS_REFRESH_MS) {
+            return this.refresh();
+        }
+        return Promise.resolve(this.cached.manifest);
+    }
+    refresh() {
+        if (!this.inflight) {
+            this.inflight = this.fetch().finally(() => {
+                this.inflight = undefined;
+            });
+        }
+        return this.inflight;
+    }
+    async fetch() {
+        const manifest = await verifyContracts(await this.api.getContracts({}));
+        if (this.cached &&
+            manifest.guardianSetIndex < this.cached.manifest.guardianSetIndex) {
+            throw new Error(`contract manifest rolled back to guardian set ${manifest.guardianSetIndex}`);
+        }
+        this.cached = { manifest, fetchedAt: Date.now() };
+        return manifest;
+    }
+}

package/dist/deposit.d.ts

@@ -2,18 +2,22 @@ import type { BlinkClient } from "./client.js";
 import type { ChainStatus, OrderParams } from "./gen/blink/v1/api_pb.js";
 import { type ConnectedWallet, type WalletKind } from "./wallets.js";
 export interface DepositStep {
-    kind: "approve" | "deposit";
+    kind: "approve" | "deposit" | "swap";
     fee?: bigint;
     run: () => Promise<string>;
 }
 export interface GaslessQuote {
+    guardianSetIndex?: number;
     sponsorAddress?: string;
     sponsorGasBudget?: bigint;
     depositDeadline?: string;
 }
+export type SvmComputeUnitPrice = "auto" | bigint;
 export interface DepositOptions {
+    guardianSetIndex?: number;
     directTransfer?: boolean;
     depositDeadline?: string;
+    svmComputeUnitPrice?: SvmComputeUnitPrice;
 }
 export interface ChainAdapter {
     readonly kind: WalletKind;
@@ -41,20 +45,20 @@ export declare class EvmChainAdapter implements ChainAdapter {
     gaslessSteps(wallet: ConnectedWallet, quoteHash: string, params: OrderParams, quote: GaslessQuote): Promise<DepositStep[]>;
 }
 export declare class SvmChainAdapter implements ChainAdapter {
+    private client;
     private chain;
-    private client?;
     readonly kind = "svm";
-    constructor(chain: ChainStatus, client?: BlinkClient | undefined);
+    constructor(client: BlinkClient, chain: ChainStatus);
     balance(owner: string, token: string): Promise<bigint>;
     canPayGas(owner: string): Promise<boolean>;
     steps(wallet: ConnectedWallet, quoteHash: string, params: OrderParams, options?: DepositOptions): Promise<DepositStep[]>;
     gaslessSteps(wallet: ConnectedWallet, quoteHash: string, params: OrderParams, quote: GaslessQuote): Promise<DepositStep[]>;
 }
 export declare class SuiChainAdapter implements ChainAdapter {
+    private client;
     private chain;
-    private client?;
     readonly kind = "sui";
-    constructor(chain: ChainStatus, client?: BlinkClient | undefined);
+    constructor(client: BlinkClient, chain: ChainStatus);
     balance(owner: string, token: string): Promise<bigint>;
     canPayGas(owner: string): Promise<boolean>;
     steps(wallet: ConnectedWallet, quoteHash: string, params: OrderParams, options?: DepositOptions): Promise<DepositStep[]>;

package/dist/deposit.js

@@ -1,8 +1,9 @@
+import { Code, ConnectError } from "@connectrpc/connect";
 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 { SUI_COIN_TYPE, buildSuiDeposit, buildSuiSourceSwapOpen, 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) => {
@@ -17,14 +18,59 @@ const trackGaslessSubmission = async (client, quoteHash) => {
         await new Promise((resolve) => setTimeout(resolve, 2000));
     }
 };
+const SOURCE_SWAP_POLL_MS = 2000;
+const SOURCE_SWAP_SETTLE_MS = 120_000;
+const SOURCE_SWAP_UNSEEN_MS = 420_000;
+const unlessNotFound = async (call) => {
+    try {
+        return await call();
+    }
+    catch (e) {
+        if (e instanceof ConnectError && e.code === Code.NotFound) {
+            return undefined;
+        }
+        throw e;
+    }
+};
+const trackSourceSwap = async (client, quoteHash) => {
+    const started = Date.now();
+    for (;;) {
+        const swap = await unlessNotFound(() => client.blink.getSourceSwap({ quoteHash }));
+        if (swap?.status === "executed") {
+            return swap.swapTx ?? swap.openTx;
+        }
+        const overdue = swap
+            ? Date.parse(swap.expiresAt) + SOURCE_SWAP_SETTLE_MS < Date.now()
+            : Date.now() - started > SOURCE_SWAP_UNSEEN_MS;
+        if (swap?.status === "lapsed" || overdue) {
+            const detail = await unlessNotFound(() => client.blink.getOrder({ quoteHash }));
+            if (detail?.order?.srcTx) {
+                return detail.order.srcTx;
+            }
+            throw new Error(`the source swap did not run (${swap?.reason ?? "expired"}); your funds never left your wallet`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, SOURCE_SWAP_POLL_MS));
+    }
+};
+const sourceSwapStep = (client, quoteHash, params) => isSourceSwap(params)
+    ? [{ kind: "swap", run: () => trackSourceSwap(client, quoteHash) }]
+    : [];
 const rpcUrlOf = (chain) => {
     if (!chain.rpcUrl) {
         throw new Error(`no public rpc configured for ${chain.chain}`);
     }
     return chain.rpcUrl;
 };
+const svmComputeUnitPriceMicroLamports = async (client, chain, price) => {
+    if (price !== "auto") {
+        return price;
+    }
+    const fee = await client.blink.getPriorityFee({ chain });
+    return fee.computeUnitPriceMicroLamports;
+};
 const NATIVE_EVM_TOKEN = "0x0000000000000000000000000000000000000000";
 const SVM_MIN_FEE_LAMPORTS = 2000000n;
+const SVM_GASLESS_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS = 10000n;
 const SUI_MIN_FEE_MIST = 20000000n;
 export class InsufficientGasError extends Error {
     required;
@@ -91,6 +137,9 @@ export class EvmChainAdapter {
                 ...call,
             });
         };
+        const registry = this.client.contracts;
+        const guardianSetIndex = options?.guardianSetIndex;
+        await registry.assertRegistered(params.srcChain, params.routerAddress, guardianSetIndex);
         const base = {
             quoteHash,
             params,
@@ -102,16 +151,17 @@ export class EvmChainAdapter {
             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 swap = isSourceSwap(params)
+            ? await this.client.blink.getSwapInstructions({ quoteHash })
+            : undefined;
+        if (swap) {
+            await registry.assertRegistered(params.srcChain, swap.routerAddress, guardianSetIndex);
+        }
+        const { router } = await registry.contracts(params.srcChain, guardianSetIndex);
+        const request = { ...base, swap, router };
         const call = buildEvmDepositCall(request);
         const target = call.to;
-        const permitTarget = request.swap ? target : this.chain.router;
+        const permitTarget = swap ? target : router;
         const deposit = { kind: "deposit", run: () => send(call) };
         if (native) {
             deposit.fee = await feeOf(call);
@@ -211,10 +261,7 @@ export class EvmChainAdapter {
         }
         assertQuoteHash(quoteHash, params);
         assertDepositDeadline(quote.depositDeadline);
-        const spender = this.chain.router;
-        if (!spender) {
-            throw new Error(`no router configured for ${this.chain.chain}`);
-        }
+        const { router: spender } = await this.client.contracts.contracts(params.srcChain, quote.guardianSetIndex);
         const rpcUrl = rpcUrlOf(this.chain);
         const amountIn = BigInt(params.amountIn);
         if (isNativeEvmToken(params.srcToken)) {
@@ -281,12 +328,12 @@ export class EvmChainAdapter {
     }
 }
 export class SvmChainAdapter {
-    chain;
     client;
+    chain;
     kind = "svm";
-    constructor(chain, client) {
-        this.chain = chain;
+    constructor(client, chain) {
         this.client = client;
+        this.chain = chain;
     }
     balance(owner, token) {
         return svmBalance(rpcUrlOf(this.chain), token, owner);
@@ -301,15 +348,12 @@ export class SvmChainAdapter {
         }
         assertQuoteHash(quoteHash, params);
         assertDepositDeadline(options?.depositDeadline);
-        if (!this.chain.treasury) {
-            throw new Error("svm deposits are unavailable");
-        }
+        const client = this.client;
+        const registry = client.contracts;
+        const guardianSetIndex = options?.guardianSetIndex;
         const rpcUrl = rpcUrlOf(this.chain);
+        const computeUnitPrice = options?.svmComputeUnitPrice ?? "auto";
         if (isSourceSwap(params)) {
-            const client = this.client;
-            if (!client) {
-                throw new Error("svm swap deposits need an api client");
-            }
             return [
                 {
                     kind: "deposit",
@@ -320,9 +364,10 @@ export class SvmChainAdapter {
                         if (instructions.payload.case !== "svm") {
                             throw new Error("expected svm swap instructions");
                         }
+                        await registry.assertRegistered(params.srcChain, instructions.routerAddress, guardianSetIndex);
+                        const { swapPrograms } = await registry.contracts(params.srcChain, guardianSetIndex);
                         const transaction = await buildSvmSwapDeposit({
                             rpcUrl,
-                            chain: this.chain.chain,
                             programId: instructions.routerAddress,
                             owner: wallet.address,
                             srcToken: params.srcToken,
@@ -331,7 +376,8 @@ export class SvmChainAdapter {
                             minBridgeOut: BigInt(params.minBridgeOut),
                             quoteHash,
                             swap: instructions.payload.value,
-                            swapProgramSigner: this.chain.treasury,
+                            computeUnitPriceMicroLamports: await svmComputeUnitPriceMicroLamports(client, this.chain.chain, computeUnitPrice),
+                            swapPrograms,
                         });
                         return signAndSendSvmTransaction(wallet.wallet, wallet.address, transaction);
                     },
@@ -342,6 +388,7 @@ export class SvmChainAdapter {
             {
                 kind: "deposit",
                 run: async () => {
+                    await registry.assertRegistered(params.srcChain, params.routerAddress, guardianSetIndex);
                     const transaction = await buildSvmDeposit({
                         rpcUrl,
                         programId: params.routerAddress,
@@ -349,6 +396,7 @@ export class SvmChainAdapter {
                         token: params.srcToken,
                         amount: BigInt(params.amountIn),
                         quoteHash,
+                        computeUnitPriceMicroLamports: await svmComputeUnitPriceMicroLamports(client, this.chain.chain, computeUnitPrice),
                     });
                     return signAndSendSvmTransaction(wallet.wallet, wallet.address, transaction);
                 },
@@ -371,15 +419,13 @@ export class SvmChainAdapter {
         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 () => {
+                    await client.contracts.assertRegistered(params.srcChain, params.routerAddress, quote.guardianSetIndex);
                     const transaction = await buildSvmDeposit({
                         rpcUrl,
                         programId: params.routerAddress,
@@ -387,6 +433,7 @@ export class SvmChainAdapter {
                         token: params.srcToken,
                         amount: BigInt(params.amountIn),
                         quoteHash,
+                        computeUnitPriceMicroLamports: SVM_GASLESS_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS,
                         feePayer: sponsor,
                     });
                     const signed = await signSvmTransaction(wallet.wallet, wallet.address, transaction);
@@ -404,12 +451,12 @@ export class SvmChainAdapter {
     }
 }
 export class SuiChainAdapter {
-    chain;
     client;
+    chain;
     kind = "sui";
-    constructor(chain, client) {
-        this.chain = chain;
+    constructor(client, chain) {
         this.client = client;
+        this.chain = chain;
     }
     balance(owner, token) {
         return suiBalance(rpcUrlOf(this.chain), token, owner);
@@ -424,20 +471,17 @@ export class SuiChainAdapter {
         }
         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);
+        const chain = this.chain;
         return [
             {
                 kind: "deposit",
-                run: async () => signAndSendSuiTransaction(wallet.wallet, wallet.address, await suiDepositTransaction(client, rpcUrl, escrow, wallet.address, quoteHash, params)),
+                run: async () => signAndSendSuiTransaction(wallet.wallet, wallet.address, await suiDepositTransaction(client, chain, wallet.address, quoteHash, params, {
+                    guardianSetIndex: options?.guardianSetIndex,
+                    gasless: false,
+                })),
             },
+            ...sourceSwapStep(client, quoteHash, params),
         ];
     }
     async gaslessSteps(wallet, quoteHash, params, quote) {
@@ -446,25 +490,22 @@ export class SuiChainAdapter {
         }
         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);
+        const chain = this.chain;
+        const rpcUrl = rpcUrlOf(chain);
         return [
             {
                 kind: "deposit",
                 run: async () => {
-                    const transaction = await sponsorSuiTransaction(rpcUrl, await suiDepositTransaction(client, rpcUrl, escrow, wallet.address, quoteHash, params), sponsor, gasBudget);
+                    const transaction = await sponsorSuiTransaction(rpcUrl, await suiDepositTransaction(client, chain, wallet.address, quoteHash, params, {
+                        guardianSetIndex: quote.guardianSetIndex,
+                        gasless: true,
+                    }), sponsor, gasBudget);
                     const signed = await signSuiTransaction(wallet.wallet, wallet.address, transaction);
                     await client.blink.submitGaslessOrder({
                         quoteHash,
@@ -476,10 +517,18 @@ export class SuiChainAdapter {
                     return trackGaslessSubmission(client, quoteHash);
                 },
             },
+            ...sourceSwapStep(client, quoteHash, params),
         ];
     }
 }
-const suiDepositTransaction = async (client, rpcUrl, escrow, owner, quoteHash, params) => {
+const suiDepositTransaction = async (client, chain, owner, quoteHash, params, { guardianSetIndex, gasless }) => {
+    const rpcUrl = rpcUrlOf(chain);
+    const registry = client.contracts;
+    await registry.assertRegistered(params.srcChain, params.routerAddress, guardianSetIndex);
+    const { escrow } = await registry.contracts(params.srcChain, guardianSetIndex);
+    if (!escrow) {
+        throw new Error("sui deposits are unavailable");
+    }
     if (!isSourceSwap(params)) {
         return buildSuiDeposit({
             rpcUrl,
@@ -491,32 +540,29 @@ const suiDepositTransaction = async (client, rpcUrl, escrow, owner, quoteHash, p
             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");
+    if (!chain.swapExecutor) {
+        throw new Error("sui source swaps are unavailable");
     }
-    return buildSuiSwapDeposit({
+    return buildSuiSourceSwapOpen({
         rpcUrl,
         packageId: params.routerAddress,
         escrowObject: escrow,
+        swapExecutor: chain.swapExecutor,
         owner,
         srcToken: params.srcToken,
         bridgeToken: params.bridgeTokenSrc,
         amountIn: BigInt(params.amountIn),
         minBridgeOut: BigInt(params.minBridgeOut),
         quoteHash,
-        swap: instructions.payload.value,
+        gasless,
     });
 };
 export const createChainAdapter = (client, chain, chainId) => {
     if (chain.vm === "svm") {
-        return new SvmChainAdapter(chain, client);
+        return new SvmChainAdapter(client, chain);
     }
     if (chain.vm === "sui") {
-        return new SuiChainAdapter(chain, client);
+        return new SuiChainAdapter(client, chain);
     }
     if (chainId === undefined) {
         throw new Error(`unknown chain id for ${chain.chain}`);