@mayanfinance/blink-sdk 0.1.8

package/dist/svm.js

@@ -0,0 +1,504 @@
+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";
+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 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 connection = (rpcUrl) => new Connection(rpcUrl, "confirmed");
+const tokenProgramOf = async (rpc, mint) => {
+    const info = await rpc.getAccountInfo(mint);
+    if (!info) {
+        throw new Error(`mint ${mint.toBase58()} not found`);
+    }
+    return info.owner;
+};
+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];
+const discriminator = (name) => sha256(new TextEncoder().encode(`global:${name}`), "bytes").slice(0, 8);
+const hashBytes = (quoteHash) => {
+    const hex = quoteHash.replace(/^0x/, "");
+    const out = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+};
+const depositData = (name, quoteHash, amount) => {
+    const out = new Uint8Array(48);
+    out.set(discriminator(name), 0);
+    out.set(hashBytes(quoteHash), 8);
+    new DataView(out.buffer).setBigUint64(40, amount, true);
+    return Buffer.from(out);
+};
+export const svmBalance = async (rpcUrl, token, owner) => {
+    const rpc = connection(rpcUrl);
+    if (isNativeSvmToken(token)) {
+        return BigInt(await rpc.getBalance(new PublicKey(owner)));
+    }
+    const mint = new PublicKey(token);
+    const ata = associatedTokenAddress(new PublicKey(owner), mint, await tokenProgramOf(rpc, mint));
+    const balance = await rpc.getTokenAccountBalance(ata).catch(() => null);
+    return balance ? BigInt(balance.value.amount) : 0n;
+};
+const depositNativeInstruction = (request) => {
+    const programId = new PublicKey(request.programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: new PublicKey(request.owner), isSigner: true, isWritable: true },
+            {
+                pubkey: escrowAuthority(programId),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: SystemProgram.programId,
+                isSigner: false,
+                isWritable: false,
+            },
+        ],
+        data: depositData("deposit_native", request.quoteHash, request.amount),
+    });
+};
+const depositTokenInstruction = async (rpc, request) => {
+    const mint = new PublicKey(request.token);
+    const owner = new PublicKey(request.owner);
+    const programId = new PublicKey(request.programId);
+    const escrow = escrowAuthority(programId);
+    const tokenProgram = await tokenProgramOf(rpc, mint);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: owner, isSigner: true, isWritable: true },
+            { pubkey: mint, isSigner: false, isWritable: false },
+            {
+                pubkey: associatedTokenAddress(owner, mint, tokenProgram),
+                isSigner: false,
+                isWritable: true,
+            },
+            { pubkey: escrow, isSigner: false, isWritable: false },
+            {
+                pubkey: associatedTokenAddress(escrow, mint, tokenProgram),
+                isSigner: false,
+                isWritable: true,
+            },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+        ],
+        data: depositData("deposit_token", request.quoteHash, request.amount),
+    });
+};
+const base64Bytes = (data) => {
+    const raw = atob(data);
+    const out = new Uint8Array(raw.length);
+    for (let i = 0; i < raw.length; i++) {
+        out[i] = raw.charCodeAt(i);
+    }
+    return out;
+};
+const toInstruction = (ix) => new TransactionInstruction({
+    programId: new PublicKey(ix.programId),
+    keys: ix.accounts.map((a) => ({
+        pubkey: new PublicKey(a.pubkey),
+        isSigner: a.isSigner,
+        isWritable: a.isWritable,
+    })),
+    data: Buffer.from(base64Bytes(ix.data)),
+});
+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) {
+        rejectSwap(`instruction is missing account ${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 checkSystemInstruction = (authority, ix, data, budgets) => {
+    if (data.length < 4) {
+        rejectSwap("truncated system instruction");
+    }
+    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;
+        }
+        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`);
+    }
+    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);
+    }
+    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");
+        }
+    }
+    else {
+        rejectSwap(`setup or cleanup instruction targets disallowed program ${program.toBase58()}`);
+    }
+};
+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 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;
+};
+const isDepositorTokenAccount = (owner, programId, data) => {
+    if (!programId.equals(TOKEN_PROGRAM_ID) && !programId.equals(TOKEN_2022_PROGRAM_ID)) {
+        return false;
+    }
+    if (data.length < TOKEN_ACCOUNT_LEN) {
+        return false;
+    }
+    if (data.length > TOKEN_ACCOUNT_LEN &&
+        data[TOKEN_ACCOUNT_LEN] !== TOKEN_2022_ACCOUNT_TYPE_ACCOUNT) {
+        return false;
+    }
+    return new PublicKey(data.slice(32, 64)).equals(owner);
+};
+const tokenAccountAmount = (data) => new DataView(data.buffer, data.byteOffset + 64, 8).getBigUint64(0, true);
+const JUPITER_SLIPPAGE_EXCEEDED = 6001;
+const describeSimulationError = (err, logs) => {
+    for (let i = logs.length - 1; i >= 0; i--) {
+        const anchor = logs[i].match(/Error Message: (.+?)\.?$/);
+        if (anchor) {
+            return `swap would fail on-chain: ${anchor[1]}`;
+        }
+    }
+    const custom = JSON.stringify(err).match(/"Custom":(\d+)/);
+    if (custom && Number(custom[1]) === JUPITER_SLIPPAGE_EXCEEDED) {
+        return "swap would fail on-chain: price moved beyond the slippage tolerance, try again";
+    }
+    return `swap would fail on-chain (${JSON.stringify(err)}), see the console for logs`;
+};
+const collectDepositorTokenAccounts = async (rpc, writable, authority) => {
+    const unique = [...new Map(writable.map((k) => [k.toBase58(), k])).values()];
+    const watched = [];
+    for (let i = 0; i < unique.length; i += 100) {
+        const chunk = unique.slice(i, i + 100);
+        const accounts = await rpc.getMultipleAccountsInfo(chunk);
+        for (let j = 0; j < chunk.length; j++) {
+            const account = accounts[j];
+            if (!account) {
+                continue;
+            }
+            const data = new Uint8Array(account.data);
+            if (isDepositorTokenAccount(authority, account.owner, data)) {
+                watched.push({ pubkey: chunk[j], preAmount: tokenAccountAmount(data) });
+            }
+        }
+    }
+    return watched;
+};
+const assertSwapBalances = async (rpc, transaction, watched, inputAccount, maxInputSpend) => {
+    if (watched.length === 0) {
+        return;
+    }
+    const sim = await rpc.simulateTransaction(transaction, {
+        sigVerify: false,
+        replaceRecentBlockhash: true,
+        accounts: {
+            encoding: "base64",
+            addresses: watched.map((w) => w.pubkey.toBase58()),
+        },
+    });
+    if (sim.value.err) {
+        const logs = sim.value.logs ?? [];
+        console.error("swap deposit simulation failed", sim.value.err, logs);
+        rejectSwap(describeSimulationError(sim.value.err, logs));
+    }
+    const postAccounts = sim.value.accounts ?? [];
+    for (let i = 0; i < watched.length; i++) {
+        const { pubkey, preAmount } = watched[i];
+        const post = postAccounts[i];
+        let postAmount = 0n;
+        if (post && Array.isArray(post.data)) {
+            const data = base64Bytes(post.data[0]);
+            const programId = new PublicKey(post.owner);
+            if ((programId.equals(TOKEN_PROGRAM_ID) || programId.equals(TOKEN_2022_PROGRAM_ID)) &&
+                data.length >= TOKEN_ACCOUNT_LEN) {
+                postAmount = tokenAccountAmount(data);
+            }
+        }
+        const floor = pubkey.equals(inputAccount)
+            ? preAmount - (preAmount < maxInputSpend ? preAmount : maxInputSpend)
+            : preAmount;
+        if (postAmount < floor) {
+            rejectSwap(`simulated balance of depositor token account ${pubkey.toBase58()} drops from ${preAmount} to ${postAmount}, beyond the swap input`);
+        }
+    }
+};
+const swapDepositData = (quoteHash, srcMint, srcAmount, minBridgeOut, swapData) => {
+    const out = new Uint8Array(92 + swapData.length);
+    out.set(discriminator("deposit_swap"), 0);
+    out.set(hashBytes(quoteHash), 8);
+    out.set(srcMint.toBytes(), 40);
+    const view = new DataView(out.buffer);
+    view.setBigUint64(72, srcAmount, true);
+    view.setBigUint64(80, minBridgeOut, true);
+    view.setUint32(88, swapData.length, true);
+    out.set(swapData, 92);
+    return Buffer.from(out);
+};
+const compileSwapDeposit = async (rpc, owner, deposit) => {
+    const message = new TransactionMessage({
+        payerKey: owner,
+        recentBlockhash: (await rpc.getLatestBlockhash()).blockhash,
+        instructions: deposit.instructions,
+    }).compileToV0Message(deposit.lookupTables);
+    return new VersionedTransaction(message);
+};
+const assembleSvmSwapDeposit = async (request) => {
+    const swapIx = request.swap.swap;
+    if (!swapIx) {
+        throw new Error("swap instructions are missing the swap step");
+    }
+    const rpc = connection(request.rpcUrl);
+    const owner = new PublicKey(request.owner);
+    const bridgeMint = new PublicKey(request.bridgeToken);
+    const programId = new PublicKey(request.programId);
+    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 depositIx = new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: owner, isSigner: true, isWritable: true },
+            { pubkey: bridgeMint, isSigner: false, isWritable: false },
+            { pubkey: escrow, isSigner: false, isWritable: false },
+            {
+                pubkey: associatedTokenAddress(escrow, bridgeMint, tokenProgram),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                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,
+            })),
+        ],
+        data: swapDepositData(request.quoteHash, new PublicKey(request.srcToken), request.amount, request.minBridgeOut, base64Bytes(swapIx.data)),
+    });
+    const instructions = [
+        ...request.swap.setup.map(toInstruction),
+        depositIx,
+        ...request.swap.cleanup.map(toInstruction),
+    ];
+    const tables = await Promise.all(request.swap.lookupTables.map(async (t) => {
+        const table = await rpc.getAddressLookupTable(new PublicKey(t.address));
+        if (!table.value) {
+            throw new Error(`lookup table ${t.address} not found`);
+        }
+        return table.value;
+    }));
+    return { rpc, owner, watched, inputAccount, 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 };
+};
+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);
+    return transaction.serialize();
+};
+export const buildSvmDepositInstructions = async (request) => {
+    const rpc = connection(request.rpcUrl);
+    const instruction = isNativeSvmToken(request.token)
+        ? depositNativeInstruction(request)
+        : await depositTokenInstruction(rpc, request);
+    return [
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: DEPOSIT_COMPUTE_UNIT_LIMIT,
+        }),
+        ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: DEPOSIT_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS,
+        }),
+        instruction,
+    ];
+};
+export const buildSvmDeposit = async (request) => {
+    const rpc = connection(request.rpcUrl);
+    const transaction = new Transaction().add(...(await buildSvmDepositInstructions(request)));
+    transaction.feePayer = new PublicKey(request.feePayer ?? request.owner);
+    transaction.recentBlockhash = (await rpc.getLatestBlockhash()).blockhash;
+    return new Uint8Array(transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false,
+    }));
+};

package/dist/version.d.ts

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

package/dist/version.js

@@ -0,0 +1 @@
+export const SDK_VERSION = "0.1.8";

package/dist/wallets.d.ts

@@ -0,0 +1,84 @@
+import type { Transaction } from "@mysten/sui/transactions";
+export type WalletKind = "evm" | "svm" | "sui";
+export interface Eip1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on?(event: "accountsChanged", listener: (addresses: string[]) => void): void;
+    off?(event: "accountsChanged", listener: (addresses: string[]) => void): void;
+    removeListener?(event: "accountsChanged", listener: (addresses: string[]) => void): void;
+}
+export interface StandardWalletAccount {
+    address: string;
+    chains: readonly string[];
+}
+export interface StandardWallet {
+    name: string;
+    icon: string;
+    features: Record<string, unknown>;
+    accounts: readonly StandardWalletAccount[];
+}
+export type AvailableWallet = {
+    id: string;
+    kind: "evm";
+    name: string;
+    icon: string;
+    provider: Eip1193Provider;
+} | {
+    id: string;
+    kind: "svm" | "sui";
+    name: string;
+    icon: string;
+    wallet: StandardWallet;
+};
+export type ConnectedWallet = {
+    id: string;
+    walletId: string;
+    kind: "evm";
+    name: string;
+    icon: string;
+    provider: Eip1193Provider;
+    address: string;
+} | {
+    id: string;
+    walletId: string;
+    kind: "svm" | "sui";
+    name: string;
+    icon: string;
+    wallet: StandardWallet;
+    address: string;
+};
+export declare const visibleWallets: (wallets: ConnectedWallet[]) => ConnectedWallet[];
+export declare const rememberRemoved: (wallet: ConnectedWallet, remaining: ConnectedWallet[]) => void;
+export declare const clearRemoved: (wallets: ConnectedWallet[]) => void;
+export declare const discoverWallets: () => Promise<AvailableWallet[]>;
+export declare const walletCanSign: (wallet: ConnectedWallet) => boolean;
+export declare const connectWallet: (wallet: AvailableWallet, pickAnother: boolean) => Promise<ConnectedWallet[]>;
+export declare const rememberWallets: (wallets: ConnectedWallet[]) => void;
+export declare const restoreWallets: () => Promise<ConnectedWallet[]>;
+export declare const watchWallets: (connected: ConnectedWallet[], onAccounts: (accounts: ConnectedWallet[]) => void) => (() => void);
+export declare const disconnectWallet: (wallet: ConnectedWallet) => Promise<void>;
+export declare const switchEvmChain: (provider: Eip1193Provider, chainId: bigint, chainName: string, nativeSymbol: string, rpcUrl?: string) => Promise<void>;
+export declare const sendEvmTransaction: (provider: Eip1193Provider, tx: {
+    from: string;
+    to: string;
+    data: string;
+    value?: string;
+}) => Promise<string>;
+export declare const signEvmTypedData: (provider: Eip1193Provider, from: string, typedData: object) => Promise<string>;
+export declare const supportsAtomicBatch: (provider: Eip1193Provider, from: string, chainId: bigint) => Promise<boolean>;
+export declare const sendEvmCalls: (provider: Eip1193Provider, from: string, chainId: bigint, calls: {
+    to: string;
+    data: string;
+    value?: string;
+}[]) => Promise<string>;
+export declare const base58: (bytes: Uint8Array) => string;
+export declare const signSvmTransaction: (wallet: StandardWallet, address: string, transaction: Uint8Array) => Promise<Uint8Array>;
+export declare const signAndSendSvmTransaction: (wallet: StandardWallet, address: string, transaction: Uint8Array) => Promise<string>;
+export interface SignedSuiTransaction {
+    bytes: string;
+    signature: string;
+}
+export declare const signSuiTransaction: (wallet: StandardWallet, address: string, transaction: Transaction) => Promise<SignedSuiTransaction>;
+export declare const signAndSendSuiTransaction: (wallet: StandardWallet, address: string, transaction: Transaction) => Promise<string>;