@mayanfinance/blink-sdk 0.1.8 → 0.2.0

package/dist/svm.js

@@ -1,31 +1,25 @@
+import { addExtraAccountMetasForExecute, createAssociatedTokenAccountIdempotentInstruction, createHarvestWithheldTokensToMintInstruction, createSyncNativeInstruction, createTransferCheckedInstruction, createTransferCheckedWithFeeInstruction, getEpochFee, getTransferFeeConfig, getTransferHook, unpackMint, } from "@solana/spl-token";
 import { ComputeBudgetProgram, Connection, PublicKey, SystemProgram, Transaction, TransactionInstruction, TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
-import { ed25519 } from "@noble/curves/ed25519";
 import { Buffer } from "buffer";
 import { sha256 } from "viem";
+if (!("Buffer" in globalThis))
+    Object.assign(globalThis, { Buffer });
 const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 const TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const TOKEN_2022_PROGRAM_ID = new PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
 const WSOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
-export const DEFAULT_SWAP_PROGRAMS = [
-    new PublicKey("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"),
-];
-const SPL_TOKEN_ACCOUNT_RENT_LAMPORTS = 2039280n;
-const SWAP_LAMPORTS_ALLOWANCE = 3n * SPL_TOKEN_ACCOUNT_RENT_LAMPORTS;
-const TOKEN_INITIALIZE_ACCOUNT = 1;
-const TOKEN_TRANSFER = 3;
-const TOKEN_CLOSE_ACCOUNT = 9;
-const TOKEN_TRANSFER_CHECKED = 12;
-const TOKEN_INITIALIZE_ACCOUNT2 = 16;
-const TOKEN_SYNC_NATIVE = 17;
-const TOKEN_INITIALIZE_ACCOUNT3 = 18;
-const SYSTEM_CREATE_ACCOUNT = 0;
-const SYSTEM_TRANSFER = 2;
-const SYSTEM_CREATE_ACCOUNT_WITH_SEED = 3;
+const ONE_IN_BASIS_POINTS = 10000n;
 const TOKEN_ACCOUNT_LEN = 165;
 const TOKEN_2022_ACCOUNT_TYPE_ACCOUNT = 2;
 export const isNativeSvmToken = (address) => address === SystemProgram.programId.toBase58();
 const DEPOSIT_COMPUTE_UNIT_LIMIT = 50_000;
-const DEPOSIT_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS = 10_000;
+const MAX_COMPUTE_UNIT_LIMIT = 1_400_000;
+const SWAP_COMPUTE_UNIT_HEADROOM = 1.3;
+const computeBudgetInstructions = (units, microLamports) => [
+    ComputeBudgetProgram.setComputeUnitLimit({ units }),
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports }),
+];
+const swapComputeUnitLimit = (simulatedUnits) => Math.min(MAX_COMPUTE_UNIT_LIMIT, Math.ceil(simulatedUnits * SWAP_COMPUTE_UNIT_HEADROOM));
 const connection = (rpcUrl) => new Connection(rpcUrl, "confirmed");
 const tokenProgramOf = async (rpc, mint) => {
     const info = await rpc.getAccountInfo(mint);
@@ -36,6 +30,7 @@ const tokenProgramOf = async (rpc, mint) => {
 };
 const associatedTokenAddress = (owner, mint, tokenProgram) => PublicKey.findProgramAddressSync([owner.toBytes(), tokenProgram.toBytes(), mint.toBytes()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
 const escrowAuthority = (programId) => PublicKey.findProgramAddressSync([new TextEncoder().encode("escrow")], programId)[0];
+export const svmSwapAuthority = (programId, owner, quoteHash) => PublicKey.findProgramAddressSync([new TextEncoder().encode("swap_authority"), owner.toBytes(), hashBytes(quoteHash)], programId)[0];
 const discriminator = (name) => sha256(new TextEncoder().encode(`global:${name}`), "bytes").slice(0, 8);
 const hashBytes = (quoteHash) => {
     const hex = quoteHash.replace(/^0x/, "");
@@ -129,44 +124,6 @@ const toInstruction = (ix) => new TransactionInstruction({
 const rejectSwap = (reason) => {
     throw new Error(`swap instructions rejected: ${reason}`);
 };
-const hexBytes = (hex) => {
-    const raw = hex.replace(/^0x/, "");
-    if (raw.length % 2 !== 0) {
-        rejectSwap("signature is not valid hex");
-    }
-    const out = new Uint8Array(raw.length / 2);
-    for (let i = 0; i < out.length; i++) {
-        const byte = parseInt(raw.slice(i * 2, i * 2 + 2), 16);
-        if (Number.isNaN(byte)) {
-            rejectSwap("signature is not valid hex");
-        }
-        out[i] = byte;
-    }
-    return out;
-};
-export const resolveSwapPrograms = (chain, swap, expectedSigner) => {
-    if (swap.allowedSwapPrograms.length === 0) {
-        return DEFAULT_SWAP_PROGRAMS;
-    }
-    if (!expectedSigner) {
-        return rejectSwap("swap program allowlist has no expected signer to verify against");
-    }
-    if (!swap.swapProgramsSignature) {
-        rejectSwap("swap program allowlist is unsigned");
-    }
-    const message = new TextEncoder().encode(`blink-swap-programs:${chain}:${swap.allowedSwapPrograms.join(",")}`);
-    const valid = ed25519.verify(hexBytes(swap.swapProgramsSignature), message, new PublicKey(expectedSigner).toBytes());
-    if (!valid) {
-        rejectSwap("swap program allowlist signature is invalid");
-    }
-    return swap.allowedSwapPrograms.map((p) => new PublicKey(p));
-};
-const dataU64 = (data, offset) => {
-    if (data.length < offset + 8) {
-        rejectSwap("truncated instruction data");
-    }
-    return new DataView(data.buffer, data.byteOffset + offset, 8).getBigUint64(0, true);
-};
 const metaPubkey = (ix, index) => {
     const meta = ix.accounts[index];
     if (!meta) {
@@ -174,133 +131,62 @@ const metaPubkey = (ix, index) => {
     }
     return new PublicKey(meta.pubkey);
 };
-const checkSwapMetas = (authority, ix, writable) => {
-    for (const meta of ix.accounts) {
-        const pubkey = new PublicKey(meta.pubkey);
-        if (meta.isSigner && !pubkey.equals(authority)) {
-            rejectSwap(`instruction requires signature from ${pubkey.toBase58()}, only the depositor may sign`);
-        }
-        if (meta.isWritable) {
-            writable.push(pubkey);
-        }
-    }
-};
-const checkTokenInstruction = (authority, inputAccount, ix, data, budgets) => {
-    const tag = data[0];
-    switch (tag) {
-        case TOKEN_INITIALIZE_ACCOUNT:
-        case TOKEN_INITIALIZE_ACCOUNT2:
-        case TOKEN_INITIALIZE_ACCOUNT3:
-        case TOKEN_SYNC_NATIVE:
-            return;
-        case TOKEN_CLOSE_ACCOUNT: {
-            const destination = metaPubkey(ix, 1);
-            const owner = metaPubkey(ix, 2);
-            if (!destination.equals(authority) || !owner.equals(authority)) {
-                rejectSwap("close account must return funds to the depositor");
-            }
-            return;
-        }
-        case TOKEN_TRANSFER:
-        case TOKEN_TRANSFER_CHECKED: {
-            const source = metaPubkey(ix, 0);
-            const owner = metaPubkey(ix, tag === TOKEN_TRANSFER ? 2 : 3);
-            if (!source.equals(inputAccount)) {
-                rejectSwap(`token transfer from ${source.toBase58()} is not the swap input account`);
-            }
-            if (!owner.equals(authority)) {
-                rejectSwap("token transfer authority is not the depositor");
-            }
-            const amount = dataU64(data, 1);
-            if (amount > budgets.tokenIn) {
-                rejectSwap("token transfers exceed the swap input amount");
-            }
-            budgets.tokenIn -= amount;
-            return;
-        }
-        default:
-            rejectSwap(`token instruction tag ${tag} is not permitted`);
+const isTokenProgram = (program) => program.equals(TOKEN_PROGRAM_ID) || program.equals(TOKEN_2022_PROGRAM_ID);
+const authorityTokenAccountCreated = (depositor, authority, ix) => {
+    const program = new PublicKey(ix.programId);
+    if (!program.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+        rejectSwap(`setup instruction targets disallowed program ${program.toBase58()}`);
     }
-};
-const checkSystemInstruction = (authority, ix, data, budgets) => {
-    if (data.length < 4) {
-        rejectSwap("truncated system instruction");
+    const data = base64Bytes(ix.data);
+    if (data.length > 1 || (data.length === 1 && data[0] > 1)) {
+        rejectSwap("associated token instruction is not a create");
     }
-    const tag = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true);
-    let lamports;
-    let ownerOffset;
-    switch (tag) {
-        case SYSTEM_TRANSFER:
-            lamports = dataU64(data, 4);
-            ownerOffset = null;
-            break;
-        case SYSTEM_CREATE_ACCOUNT:
-            lamports = dataU64(data, 4);
-            ownerOffset = 20;
-            break;
-        case SYSTEM_CREATE_ACCOUNT_WITH_SEED: {
-            const seedLen = Number(dataU64(data, 36));
-            lamports = dataU64(data, 44 + seedLen);
-            ownerOffset = 60 + seedLen;
-            break;
+    ix.accounts.forEach((meta, index) => {
+        if (meta.isSigner && index !== 0) {
+            rejectSwap(`setup instruction requires signature from ${meta.pubkey}`);
         }
-        default:
-            rejectSwap(`system instruction tag ${tag} is not permitted`);
-            return;
-    }
+    });
     const funder = metaPubkey(ix, 0);
-    if (!funder.equals(authority)) {
-        rejectSwap(`system lamport spend from ${funder.toBase58()} is not the depositor`);
+    const address = metaPubkey(ix, 1);
+    const wallet = metaPubkey(ix, 2);
+    const mint = metaPubkey(ix, 3);
+    const tokenProgram = metaPubkey(ix, 5);
+    if (!funder.equals(depositor)) {
+        rejectSwap(`token account rent is paid by ${funder.toBase58()}, not the depositor`);
     }
-    if (ownerOffset !== null) {
-        const ownerBytes = data.slice(ownerOffset, ownerOffset + 32);
-        if (ownerBytes.length !== 32) {
-            rejectSwap("truncated system create instruction");
-        }
-        const owner = new PublicKey(ownerBytes);
-        if (!owner.equals(TOKEN_PROGRAM_ID) && !owner.equals(TOKEN_2022_PROGRAM_ID)) {
-            rejectSwap(`created account owner ${owner.toBase58()} is not a token program`);
-        }
-    }
-    if (lamports > budgets.lamportsIn) {
-        rejectSwap("lamport spends exceed the swap budget");
-    }
-    budgets.lamportsIn -= lamports;
-};
-const checkSupportInstruction = (authority, inputAccount, ix, budgets, writable) => {
-    checkSwapMetas(authority, ix, writable);
-    const program = new PublicKey(ix.programId);
-    const data = base64Bytes(ix.data);
-    if (program.equals(TOKEN_PROGRAM_ID) || program.equals(TOKEN_2022_PROGRAM_ID)) {
-        checkTokenInstruction(authority, inputAccount, ix, data, budgets);
-    }
-    else if (program.equals(SystemProgram.programId)) {
-        checkSystemInstruction(authority, ix, data, budgets);
+    if (!wallet.equals(authority)) {
+        rejectSwap(`setup creates a token account for ${wallet.toBase58()}, not the swap authority`);
     }
-    else if (program.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-        if (data.length > 1 || (data.length === 1 && data[0] > 1)) {
-            rejectSwap("associated token instruction is not a create");
-        }
+    if (!isTokenProgram(tokenProgram)) {
+        rejectSwap(`setup creates a token account under ${tokenProgram.toBase58()}`);
     }
-    else {
-        rejectSwap(`setup or cleanup instruction targets disallowed program ${program.toBase58()}`);
+    if (!address.equals(associatedTokenAddress(authority, mint, tokenProgram))) {
+        rejectSwap(`setup creates ${address.toBase58()}, not the swap authority's associated token account`);
     }
+    return { address, mint, tokenProgram };
 };
-const checkSwapInstructions = (authority, inputAccount, maxTokenIn, maxLamportsIn, swap, swapIx, allowedSwapPrograms) => {
-    const writable = [];
-    const budgets = {
-        tokenIn: maxTokenIn,
-        lamportsIn: maxLamportsIn,
-    };
-    for (const ix of [...swap.setup, ...swap.cleanup]) {
-        checkSupportInstruction(authority, inputAccount, ix, budgets, writable);
-    }
+const checkSwapStep = (depositor, authority, swapIx, allowedSwapPrograms) => {
     const program = new PublicKey(swapIx.programId);
     if (!allowedSwapPrograms.some((p) => p.equals(program))) {
         rejectSwap(`swap instruction targets non-allowlisted program ${program.toBase58()}`);
     }
-    checkSwapMetas(authority, swapIx, writable);
-    return writable;
+    for (const meta of swapIx.accounts) {
+        const pubkey = new PublicKey(meta.pubkey);
+        if (pubkey.equals(depositor)) {
+            rejectSwap("swap instruction is handed the depositor");
+        }
+        if (meta.isSigner && !pubkey.equals(authority)) {
+            rejectSwap(`swap instruction requires signature from ${pubkey.toBase58()}, only the swap authority may sign`);
+        }
+    }
+};
+const checkSwapInstructions = (depositor, authority, swap, swapIx, allowedSwapPrograms) => {
+    if (swap.cleanup.length > 0) {
+        rejectSwap("aggregator cleanup instructions are not permitted");
+    }
+    const created = swap.setup.map((ix) => authorityTokenAccountCreated(depositor, authority, ix));
+    checkSwapStep(depositor, authority, swapIx, allowedSwapPrograms);
+    return created;
 };
 const isDepositorTokenAccount = (owner, programId, data) => {
     if (!programId.equals(TOKEN_PROGRAM_ID) && !programId.equals(TOKEN_2022_PROGRAM_ID)) {
@@ -330,7 +216,8 @@ const describeSimulationError = (err, logs) => {
     }
     return `swap would fail on-chain (${JSON.stringify(err)}), see the console for logs`;
 };
-const collectDepositorTokenAccounts = async (rpc, writable, authority) => {
+const collectDepositorTokenAccounts = async (rpc, instructions, depositor, spend) => {
+    const writable = instructions.flatMap((ix) => ix.keys.filter((k) => k.isWritable).map((k) => k.pubkey));
     const unique = [...new Map(writable.map((k) => [k.toBase58(), k])).values()];
     const watched = [];
     for (let i = 0; i < unique.length; i += 100) {
@@ -342,17 +229,18 @@ const collectDepositorTokenAccounts = async (rpc, writable, authority) => {
                 continue;
             }
             const data = new Uint8Array(account.data);
-            if (isDepositorTokenAccount(authority, account.owner, data)) {
-                watched.push({ pubkey: chunk[j], preAmount: tokenAccountAmount(data) });
+            if (isDepositorTokenAccount(depositor, account.owner, data)) {
+                watched.push({
+                    pubkey: chunk[j],
+                    preAmount: tokenAccountAmount(data),
+                    maxDrop: spend && chunk[j].equals(spend.account) ? spend.amount : 0n,
+                });
             }
         }
     }
     return watched;
 };
-const assertSwapBalances = async (rpc, transaction, watched, inputAccount, maxInputSpend) => {
-    if (watched.length === 0) {
-        return;
-    }
+const simulateSwapDeposit = async (rpc, transaction, watched) => {
     const sim = await rpc.simulateTransaction(transaction, {
         sigVerify: false,
         replaceRecentBlockhash: true,
@@ -368,7 +256,7 @@ const assertSwapBalances = async (rpc, transaction, watched, inputAccount, maxIn
     }
     const postAccounts = sim.value.accounts ?? [];
     for (let i = 0; i < watched.length; i++) {
-        const { pubkey, preAmount } = watched[i];
+        const { pubkey, preAmount, maxDrop } = watched[i];
         const post = postAccounts[i];
         let postAmount = 0n;
         if (post && Array.isArray(post.data)) {
@@ -379,13 +267,91 @@ const assertSwapBalances = async (rpc, transaction, watched, inputAccount, maxIn
                 postAmount = tokenAccountAmount(data);
             }
         }
-        const floor = pubkey.equals(inputAccount)
-            ? preAmount - (preAmount < maxInputSpend ? preAmount : maxInputSpend)
-            : preAmount;
+        const floor = preAmount - (preAmount < maxDrop ? preAmount : maxDrop);
         if (postAmount < floor) {
             rejectSwap(`simulated balance of depositor token account ${pubkey.toBase58()} drops from ${preAmount} to ${postAmount}, beyond the swap input`);
         }
     }
+    if (sim.value.unitsConsumed === undefined) {
+        throw new Error("swap deposit simulation did not report compute units");
+    }
+    return sim.value.unitsConsumed;
+};
+const loadMint = async (rpc, address) => {
+    const info = await rpc.getAccountInfo(address);
+    if (!info) {
+        throw new Error(`mint ${address.toBase58()} not found`);
+    }
+    return {
+        address,
+        tokenProgram: info.owner,
+        state: unpackMint(address, info, info.owner),
+    };
+};
+const grossForNetTransfer = (fee, net) => {
+    const bps = BigInt(fee.transferFeeBasisPoints);
+    if (bps === 0n || net === 0n) {
+        return net;
+    }
+    if (bps === ONE_IN_BASIS_POINTS) {
+        return net + fee.maximumFee;
+    }
+    const denominator = ONE_IN_BASIS_POINTS - bps;
+    const raw = (net * ONE_IN_BASIS_POINTS + denominator - 1n) / denominator;
+    return raw - net >= fee.maximumFee ? net + fee.maximumFee : raw;
+};
+const fundAuthorityWithLamports = (depositor, authorityInput, amount) => ({
+    instructions: [
+        SystemProgram.transfer({
+            fromPubkey: depositor,
+            toPubkey: authorityInput,
+            lamports: amount,
+        }),
+        createSyncNativeInstruction(authorityInput),
+    ],
+});
+const fundAuthorityWithTokens = async (rpc, depositor, authorityInput, source, amount) => {
+    const depositorInput = associatedTokenAddress(depositor, source.address, source.tokenProgram);
+    const feeConfig = getTransferFeeConfig(source.state);
+    const gross = feeConfig
+        ? grossForNetTransfer(getEpochFee(feeConfig, BigInt((await rpc.getEpochInfo()).epoch)), amount)
+        : amount;
+    const transfer = feeConfig
+        ? createTransferCheckedWithFeeInstruction(depositorInput, source.address, authorityInput, depositor, gross, source.state.decimals, gross - amount, [], source.tokenProgram)
+        : createTransferCheckedInstruction(depositorInput, source.address, authorityInput, depositor, amount, source.state.decimals, [], source.tokenProgram);
+    const hook = getTransferHook(source.state);
+    if (hook && !hook.programId.equals(PublicKey.default)) {
+        await addExtraAccountMetasForExecute(rpc, transfer, hook.programId, depositorInput, source.address, authorityInput, depositor, gross, "confirmed");
+    }
+    return {
+        instructions: [transfer],
+        spend: { account: depositorInput, amount: gross },
+    };
+};
+const closeSwapAccountData = (quoteHash) => {
+    const out = new Uint8Array(40);
+    out.set(discriminator("close_swap_account"), 0);
+    out.set(hashBytes(quoteHash), 8);
+    return Buffer.from(out);
+};
+const closeAuthorityAccount = (programId, quoteHash, depositor, authority, account, mint) => {
+    const close = new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: depositor, isSigner: true, isWritable: true },
+            { pubkey: authority, isSigner: false, isWritable: false },
+            { pubkey: account.address, isSigner: false, isWritable: true },
+            { pubkey: account.tokenProgram, isSigner: false, isWritable: false },
+        ],
+        data: closeSwapAccountData(quoteHash),
+    });
+    if (!getTransferFeeConfig(mint.state)) {
+        return [close];
+    }
+    return [
+        createHarvestWithheldTokensToMintInstruction(mint.address, [account.address], account.tokenProgram),
+        close,
+    ];
 };
 const swapDepositData = (quoteHash, srcMint, srcAmount, minBridgeOut, swapData) => {
     const out = new Uint8Array(92 + swapData.length);
@@ -399,14 +365,17 @@ const swapDepositData = (quoteHash, srcMint, srcAmount, minBridgeOut, swapData)
     out.set(swapData, 92);
     return Buffer.from(out);
 };
-const compileSwapDeposit = async (rpc, owner, deposit) => {
+const compileSwapDeposit = async (rpc, owner, instructions, lookupTables) => {
     const message = new TransactionMessage({
         payerKey: owner,
         recentBlockhash: (await rpc.getLatestBlockhash()).blockhash,
-        instructions: deposit.instructions,
-    }).compileToV0Message(deposit.lookupTables);
+        instructions,
+    }).compileToV0Message(lookupTables);
     return new VersionedTransaction(message);
 };
+const uniqueAuthorityAccounts = (accounts) => [
+    ...new Map(accounts.map((a) => [a.address.toBase58(), a])).values(),
+];
 const assembleSvmSwapDeposit = async (request) => {
     const swapIx = request.swap.swap;
     if (!swapIx) {
@@ -414,18 +383,30 @@ const assembleSvmSwapDeposit = async (request) => {
     }
     const rpc = connection(request.rpcUrl);
     const owner = new PublicKey(request.owner);
-    const bridgeMint = new PublicKey(request.bridgeToken);
     const programId = new PublicKey(request.programId);
+    const authority = svmSwapAuthority(programId, owner, request.quoteHash);
+    const bridgeMint = new PublicKey(request.bridgeToken);
     const escrow = escrowAuthority(programId);
     const tokenProgram = await tokenProgramOf(rpc, bridgeMint);
-    const ownerWsolAta = associatedTokenAddress(owner, WSOL_MINT, TOKEN_PROGRAM_ID);
     const nativeSrc = isNativeSvmToken(request.srcToken);
-    const inputAccount = nativeSrc
-        ? ownerWsolAta
-        : associatedTokenAddress(owner, new PublicKey(request.srcToken), await tokenProgramOf(rpc, new PublicKey(request.srcToken)));
-    const swapPrograms = resolveSwapPrograms(request.chain, request.swap, request.swapProgramSigner);
-    const writable = checkSwapInstructions(owner, inputAccount, request.amount, (nativeSrc ? request.amount : 0n) + SWAP_LAMPORTS_ALLOWANCE, request.swap, swapIx, swapPrograms);
-    const watched = await collectDepositorTokenAccounts(rpc, writable, owner);
+    const source = await loadMint(rpc, nativeSrc ? WSOL_MINT : new PublicKey(request.srcToken));
+    const authorityInput = associatedTokenAddress(authority, source.address, source.tokenProgram);
+    const swapPrograms = request.swapPrograms.map((p) => new PublicKey(p));
+    const created = checkSwapInstructions(owner, authority, request.swap, swapIx, swapPrograms);
+    const funding = nativeSrc
+        ? fundAuthorityWithLamports(owner, authorityInput, request.amount)
+        : await fundAuthorityWithTokens(rpc, owner, authorityInput, source, request.amount);
+    const authorityAccounts = uniqueAuthorityAccounts([
+        {
+            address: authorityInput,
+            mint: source.address,
+            tokenProgram: source.tokenProgram,
+        },
+        ...created,
+    ]);
+    const authorityMints = await Promise.all(authorityAccounts.map((account) => account.mint.equals(source.address)
+        ? source
+        : loadMint(rpc, account.mint)));
     const depositIx = new TransactionInstruction({
         programId,
         keys: [
@@ -437,25 +418,32 @@ const assembleSvmSwapDeposit = async (request) => {
                 isSigner: false,
                 isWritable: true,
             },
+            { pubkey: authority, isSigner: false, isWritable: false },
             {
                 pubkey: new PublicKey(swapIx.programId),
                 isSigner: false,
                 isWritable: false,
             },
             { pubkey: tokenProgram, isSigner: false, isWritable: false },
-            ...swapIx.accounts.map((a) => ({
-                pubkey: new PublicKey(a.pubkey),
-                isSigner: a.isSigner,
-                isWritable: a.isWritable,
-            })),
+            ...swapIx.accounts.map((a) => {
+                const pubkey = new PublicKey(a.pubkey);
+                return {
+                    pubkey,
+                    isSigner: a.isSigner && !pubkey.equals(authority),
+                    isWritable: a.isWritable,
+                };
+            }),
         ],
         data: swapDepositData(request.quoteHash, new PublicKey(request.srcToken), request.amount, request.minBridgeOut, base64Bytes(swapIx.data)),
     });
     const instructions = [
+        createAssociatedTokenAccountIdempotentInstruction(owner, authorityInput, authority, source.address, source.tokenProgram),
+        ...funding.instructions,
         ...request.swap.setup.map(toInstruction),
         depositIx,
-        ...request.swap.cleanup.map(toInstruction),
+        ...authorityAccounts.flatMap((account, i) => closeAuthorityAccount(programId, request.quoteHash, owner, authority, account, authorityMints[i])),
     ];
+    const watched = await collectDepositorTokenAccounts(rpc, instructions, owner, funding.spend);
     const tables = await Promise.all(request.swap.lookupTables.map(async (t) => {
         const table = await rpc.getAddressLookupTable(new PublicKey(t.address));
         if (!table.value) {
@@ -463,18 +451,33 @@ const assembleSvmSwapDeposit = async (request) => {
         }
         return table.value;
     }));
-    return { rpc, owner, watched, inputAccount, instructions, lookupTables: tables };
+    return {
+        rpc,
+        owner,
+        watched,
+        instructions,
+        lookupTables: tables,
+    };
 };
-export const buildSvmSwapDepositInstructions = async (request) => {
-    const assembled = await assembleSvmSwapDeposit(request);
-    const transaction = await compileSwapDeposit(assembled.rpc, assembled.owner, assembled);
-    await assertSwapBalances(assembled.rpc, transaction, assembled.watched, assembled.inputAccount, request.amount);
-    return { instructions: assembled.instructions, lookupTables: assembled.lookupTables };
+const budgetedSwapDeposit = async (request, assembled) => {
+    const probe = await compileSwapDeposit(assembled.rpc, assembled.owner, [
+        ComputeBudgetProgram.setComputeUnitLimit({ units: MAX_COMPUTE_UNIT_LIMIT }),
+        ...assembled.instructions,
+    ], assembled.lookupTables);
+    const simulatedUnits = await simulateSwapDeposit(assembled.rpc, probe, assembled.watched);
+    return {
+        instructions: [
+            ...computeBudgetInstructions(swapComputeUnitLimit(simulatedUnits), request.computeUnitPriceMicroLamports),
+            ...assembled.instructions,
+        ],
+        lookupTables: assembled.lookupTables,
+    };
 };
+export const buildSvmSwapDepositInstructions = async (request) => budgetedSwapDeposit(request, await assembleSvmSwapDeposit(request));
 export const buildSvmSwapDeposit = async (request) => {
     const assembled = await assembleSvmSwapDeposit(request);
-    const transaction = await compileSwapDeposit(assembled.rpc, assembled.owner, assembled);
-    await assertSwapBalances(assembled.rpc, transaction, assembled.watched, assembled.inputAccount, request.amount);
+    const deposit = await budgetedSwapDeposit(request, assembled);
+    const transaction = await compileSwapDeposit(assembled.rpc, assembled.owner, deposit.instructions, deposit.lookupTables);
     return transaction.serialize();
 };
 export const buildSvmDepositInstructions = async (request) => {
@@ -483,12 +486,7 @@ export const buildSvmDepositInstructions = async (request) => {
         ? depositNativeInstruction(request)
         : await depositTokenInstruction(rpc, request);
     return [
-        ComputeBudgetProgram.setComputeUnitLimit({
-            units: DEPOSIT_COMPUTE_UNIT_LIMIT,
-        }),
-        ComputeBudgetProgram.setComputeUnitPrice({
-            microLamports: DEPOSIT_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS,
-        }),
+        ...computeBudgetInstructions(DEPOSIT_COMPUTE_UNIT_LIMIT, request.computeUnitPriceMicroLamports),
         instruction,
     ];
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.1.8";
+export declare const SDK_VERSION = "0.2.0";

package/dist/version.js

@@ -1 +1 @@
-export const SDK_VERSION = "0.1.8";
+export const SDK_VERSION = "0.2.0";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mayanfinance/blink-sdk",
   "description": "A SDK to swap with Blink",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -31,7 +31,7 @@
   "scripts": {
     "generate": "buf generate",
     "build": "npm run generate && tsc -b",
-    "test": "npm run build && node scripts/check-hash-vectors.mjs",
+    "test": "npm run build && node scripts/check-hash-vectors.mjs && node scripts/check-contracts.mjs",
     "prepack": "npm run build",
     "version": "node scripts/sync-version.js && git add src/version.ts",
     "postversion": "git commit -am \"$npm_package_version\" && git tag sdk-v$npm_package_version",
@@ -47,7 +47,7 @@
     "@connectrpc/connect": "^2.0.0",
     "@connectrpc/connect-web": "^2.0.0",
     "@mysten/sui": "^2.30.0",
-    "@noble/curves": "^1.9.7",
+    "@solana/spl-token": "^0.4.15",
     "@solana/web3.js": "^1.98.0",
     "@wallet-standard/app": "^1.1.1",
     "buffer": "^6.0.3",