@mayanfinance/blink-sdk 0.1.8

package/dist/wallets.js

@@ -0,0 +1,409 @@
+import { getWallets } from "@wallet-standard/app";
+const STORAGE_KEY = "blink_wallets";
+const REMOVED_KEY = "blink_removed_wallets";
+const removedIds = () => JSON.parse(localStorage.getItem(REMOVED_KEY) ?? "[]");
+export const visibleWallets = (wallets) => {
+    const removed = removedIds();
+    return wallets.filter((w) => !removed.includes(w.id));
+};
+export const rememberRemoved = (wallet, remaining) => {
+    const kept = remaining.some((w) => w.walletId === wallet.walletId);
+    const removed = removedIds().filter((id) => kept || !id.startsWith(`${wallet.walletId}:`));
+    localStorage.setItem(REMOVED_KEY, JSON.stringify(kept ? [...removed, wallet.id] : removed));
+};
+export const clearRemoved = (wallets) => {
+    const ids = new Set(wallets.map((w) => w.id));
+    localStorage.setItem(REMOVED_KEY, JSON.stringify(removedIds().filter((id) => !ids.has(id))));
+};
+const evmWallets = async () => {
+    const found = new Map();
+    const listener = (event) => {
+        const detail = event.detail;
+        found.set(detail.info.rdns, detail);
+    };
+    window.addEventListener("eip6963:announceProvider", listener);
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    window.removeEventListener("eip6963:announceProvider", listener);
+    return [...found.values()].map((d) => ({
+        id: `evm:${d.info.rdns}`,
+        kind: "evm",
+        name: d.info.name,
+        icon: d.info.icon,
+        provider: d.provider,
+    }));
+};
+const svmWallets = () => getWallets()
+    .get()
+    .filter((w) => "solana:signAndSendTransaction" in w.features &&
+    "standard:connect" in w.features)
+    .map((w) => ({
+    id: `solana:${w.name}`,
+    kind: "svm",
+    name: w.name,
+    icon: w.icon,
+    wallet: w,
+}));
+const suiWallets = () => getWallets()
+    .get()
+    .filter((w) => "sui:signAndExecuteTransaction" in w.features &&
+    "standard:connect" in w.features)
+    .map((w) => ({
+    id: `sui:${w.name}`,
+    kind: "sui",
+    name: w.name,
+    icon: w.icon,
+    wallet: w,
+}));
+export const discoverWallets = async () => [
+    ...(await evmWallets()),
+    ...svmWallets(),
+    ...suiWallets(),
+];
+const CHAIN_PREFIXES = {
+    svm: "solana:",
+    sui: "sui:",
+};
+const standardAccounts = (kind, accounts) => accounts.filter((a) => a.chains.some((c) => c.startsWith(CHAIN_PREFIXES[kind])));
+const pendingConnects = new Map();
+const exclusiveConnect = async (id, run) => {
+    await pendingConnects.get(id)?.catch(() => undefined);
+    const promise = run();
+    pendingConnects.set(id, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        if (pendingConnects.get(id) === promise) {
+            pendingConnects.delete(id);
+        }
+    }
+};
+const connectedFrom = (wallet, addresses, accounts) => {
+    if (wallet.kind === "evm") {
+        return addresses.map((address) => ({
+            ...wallet,
+            walletId: wallet.id,
+            id: `${wallet.id}:${address.toLowerCase()}`,
+            address,
+        }));
+    }
+    return accounts.map((account) => ({
+        ...wallet,
+        walletId: wallet.id,
+        id: `${wallet.id}:${account.address}`,
+        address: account.address,
+    }));
+};
+const availableFrom = (wallet) => wallet.kind === "evm"
+    ? {
+        id: wallet.walletId,
+        kind: "evm",
+        name: wallet.name,
+        icon: wallet.icon,
+        provider: wallet.provider,
+    }
+    : {
+        id: wallet.walletId,
+        kind: wallet.kind,
+        name: wallet.name,
+        icon: wallet.icon,
+        wallet: wallet.wallet,
+    };
+export const walletCanSign = (wallet) => wallet.kind === "evm" ||
+    wallet.wallet.accounts.some((a) => a.address === wallet.address);
+const UNSUPPORTED_METHOD = [4200, -32601];
+const isUnsupportedMethod = (e) => UNSUPPORTED_METHOD.includes(e.code ?? 0);
+export const connectWallet = async (wallet, pickAnother) => {
+    if (wallet.kind === "evm") {
+        const addresses = await exclusiveConnect(wallet.id, async () => {
+            if (pickAnother) {
+                try {
+                    await wallet.provider.request({
+                        method: "wallet_requestPermissions",
+                        params: [{ eth_accounts: {} }],
+                    });
+                }
+                catch (e) {
+                    if (!isUnsupportedMethod(e)) {
+                        throw e;
+                    }
+                }
+            }
+            return (await wallet.provider.request({
+                method: "eth_requestAccounts",
+            }));
+        });
+        if (addresses.length === 0) {
+            throw new Error("no account connected");
+        }
+        return connectedFrom(wallet, addresses, []);
+    }
+    const feature = wallet.wallet.features["standard:connect"];
+    const { accounts } = await exclusiveConnect(wallet.id, () => feature.connect());
+    const usable = standardAccounts(wallet.kind, accounts);
+    if (usable.length === 0) {
+        throw new Error(`no ${wallet.kind} account connected`);
+    }
+    return connectedFrom(wallet, [], usable);
+};
+const restoreWallet = async (wallet) => {
+    if (wallet.kind === "evm") {
+        const addresses = (await wallet.provider.request({
+            method: "eth_accounts",
+        }));
+        return connectedFrom(wallet, addresses, []);
+    }
+    const feature = wallet.wallet.features["standard:connect"];
+    const accounts = wallet.wallet.accounts.length > 0
+        ? wallet.wallet.accounts
+        : pendingConnects.has(wallet.id)
+            ? []
+            : await exclusiveConnect(wallet.id, () => feature.connect({ silent: true }))
+                .then((r) => r.accounts)
+                .catch(() => []);
+    return connectedFrom(wallet, [], standardAccounts(wallet.kind, accounts));
+};
+export const rememberWallets = (wallets) => localStorage.setItem(STORAGE_KEY, JSON.stringify(wallets.map((w) => w.id)));
+export const restoreWallets = async () => {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (!stored) {
+        return [];
+    }
+    const ids = JSON.parse(stored);
+    if (ids.length === 0) {
+        return [];
+    }
+    const available = await discoverWallets();
+    const wallets = available.filter((w) => ids.some((id) => id.startsWith(`${w.id}:`)));
+    const restored = await Promise.all(wallets.map(restoreWallet));
+    return visibleWallets(restored.flatMap((accounts) => {
+        const remembered = accounts.filter((w) => ids.includes(w.id));
+        return remembered.length === 0 ? accounts : remembered;
+    }));
+};
+export const watchWallets = (connected, onAccounts) => {
+    const wallets = new Map();
+    for (const wallet of connected) {
+        if (!wallets.has(wallet.walletId)) {
+            wallets.set(wallet.walletId, availableFrom(wallet));
+        }
+    }
+    const listeners = [];
+    for (const wallet of wallets.values()) {
+        if (wallet.kind === "evm") {
+            const provider = wallet.provider;
+            const off = provider.off ?? provider.removeListener;
+            if (!provider.on || !off) {
+                continue;
+            }
+            const listener = (addresses) => {
+                if (addresses.length > 0) {
+                    onAccounts(connectedFrom(wallet, addresses, []));
+                }
+            };
+            provider.on("accountsChanged", listener);
+            listeners.push(() => off.call(provider, "accountsChanged", listener));
+            continue;
+        }
+        const feature = wallet.wallet.features["standard:events"];
+        if (feature) {
+            listeners.push(feature.on("change", ({ accounts }) => {
+                if (accounts && accounts.length > 0) {
+                    onAccounts(connectedFrom(wallet, [], standardAccounts(wallet.kind, accounts)));
+                }
+            }));
+        }
+    }
+    const rescan = () => {
+        for (const wallet of wallets.values()) {
+            restoreWallet(wallet).then((accounts) => {
+                if (accounts.length > 0) {
+                    onAccounts(accounts);
+                }
+            });
+        }
+    };
+    window.addEventListener("focus", rescan);
+    listeners.push(() => window.removeEventListener("focus", rescan));
+    return () => listeners.forEach((off) => off());
+};
+export const disconnectWallet = async (wallet) => {
+    if (wallet.kind !== "evm") {
+        const feature = wallet.wallet.features["standard:disconnect"];
+        await feature?.disconnect();
+    }
+};
+const UNKNOWN_CHAIN = 4902;
+export const switchEvmChain = async (provider, chainId, chainName, nativeSymbol, rpcUrl) => {
+    const wanted = `0x${chainId.toString(16)}`;
+    const current = (await provider.request({ method: "eth_chainId" }));
+    if (current.toLowerCase() === wanted.toLowerCase()) {
+        return;
+    }
+    const switchChain = () => provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: wanted }],
+    });
+    try {
+        await switchChain();
+    }
+    catch (e) {
+        const unknown = e.code === UNKNOWN_CHAIN;
+        if (!unknown || !rpcUrl) {
+            throw e;
+        }
+        await provider.request({
+            method: "wallet_addEthereumChain",
+            params: [
+                {
+                    chainId: wanted,
+                    chainName,
+                    rpcUrls: [rpcUrl],
+                    nativeCurrency: {
+                        name: nativeSymbol,
+                        symbol: nativeSymbol,
+                        decimals: 18,
+                    },
+                },
+            ],
+        });
+        await switchChain();
+    }
+};
+export const sendEvmTransaction = async (provider, tx) => (await provider.request({
+    method: "eth_sendTransaction",
+    params: [tx],
+}));
+export const signEvmTypedData = async (provider, from, typedData) => (await provider.request({
+    method: "eth_signTypedData_v4",
+    params: [from, JSON.stringify(typedData)],
+}));
+export const supportsAtomicBatch = async (provider, from, chainId) => {
+    const wanted = `0x${chainId.toString(16)}`;
+    try {
+        const capabilities = (await provider.request({
+            method: "wallet_getCapabilities",
+            params: [from, [wanted]],
+        }));
+        const status = capabilities?.[wanted]?.atomic?.status;
+        return status === "supported" || status === "ready";
+    }
+    catch {
+        return false;
+    }
+};
+export const sendEvmCalls = async (provider, from, chainId, calls) => {
+    const { id } = (await provider.request({
+        method: "wallet_sendCalls",
+        params: [
+            {
+                version: "2.0.0",
+                chainId: `0x${chainId.toString(16)}`,
+                from,
+                atomicRequired: true,
+                calls,
+            },
+        ],
+    }));
+    for (;;) {
+        const result = (await provider.request({
+            method: "wallet_getCallsStatus",
+            params: [id],
+        }));
+        if (result.status === 200) {
+            const receipt = result.receipts?.at(-1);
+            if (!receipt) {
+                throw new Error("batch confirmed without a receipt");
+            }
+            return receipt.transactionHash;
+        }
+        if (result.status >= 300) {
+            throw new Error("batch transaction failed");
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+};
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+export const base58 = (bytes) => {
+    const digits = [];
+    for (const byte of bytes) {
+        let carry = byte;
+        for (let i = 0; i < digits.length; i++) {
+            carry += digits[i] << 8;
+            digits[i] = carry % 58;
+            carry = (carry / 58) | 0;
+        }
+        while (carry > 0) {
+            digits.push(carry % 58);
+            carry = (carry / 58) | 0;
+        }
+    }
+    let out = "";
+    for (const byte of bytes) {
+        if (byte !== 0)
+            break;
+        out += "1";
+    }
+    for (let i = digits.length - 1; i >= 0; i--) {
+        out += BASE58_ALPHABET[digits[i]];
+    }
+    return out;
+};
+export const signSvmTransaction = async (wallet, address, transaction) => {
+    const account = wallet.accounts.find((a) => a.address === address);
+    if (!account) {
+        throw new Error(`switch ${wallet.name} to ${address} to sign this deposit`);
+    }
+    const feature = wallet.features["solana:signTransaction"];
+    if (!feature) {
+        throw new Error(`${wallet.name} does not support signing transactions`);
+    }
+    const chain = account.chains.find((c) => c.startsWith("solana:")) ?? "solana:mainnet";
+    const [result] = await feature.signTransaction({
+        transaction,
+        account,
+        chain,
+    });
+    return result.signedTransaction;
+};
+export const signAndSendSvmTransaction = async (wallet, address, transaction) => {
+    const account = wallet.accounts.find((a) => a.address === address);
+    if (!account) {
+        throw new Error(`switch ${wallet.name} to ${address} to sign this deposit`);
+    }
+    const feature = wallet.features["solana:signAndSendTransaction"];
+    const chain = account.chains.find((c) => c.startsWith("solana:")) ?? "solana:mainnet";
+    const [result] = await feature.signAndSendTransaction({
+        transaction,
+        account,
+        chain,
+    });
+    return base58(result.signature);
+};
+export const signSuiTransaction = async (wallet, address, transaction) => {
+    const account = wallet.accounts.find((a) => a.address === address);
+    if (!account) {
+        throw new Error(`switch ${wallet.name} to ${address} to sign this deposit`);
+    }
+    const feature = wallet.features["sui:signTransaction"];
+    if (!feature) {
+        throw new Error(`${wallet.name} does not support signing transactions`);
+    }
+    const chain = account.chains.find((c) => c.startsWith("sui:")) ?? "sui:mainnet";
+    return feature.signTransaction({ transaction, account, chain });
+};
+export const signAndSendSuiTransaction = async (wallet, address, transaction) => {
+    const account = wallet.accounts.find((a) => a.address === address);
+    if (!account) {
+        throw new Error(`switch ${wallet.name} to ${address} to sign this deposit`);
+    }
+    const feature = wallet.features["sui:signAndExecuteTransaction"];
+    const chain = account.chains.find((c) => c.startsWith("sui:")) ?? "sui:mainnet";
+    const result = await feature.signAndExecuteTransaction({
+        transaction,
+        account,
+        chain,
+    });
+    return result.digest;
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@mayanfinance/blink-sdk",
+  "description": "A SDK to swap with Blink",
+  "version": "0.1.8",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "homepage": "https://github.com/mayan-finance/blink/tree/main/sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mayan-finance/blink.git",
+    "directory": "sdk"
+  },
+  "keywords": [
+    "mayan",
+    "mayanfinance",
+    "blink",
+    "blink-sdk"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "generate": "buf generate",
+    "build": "npm run generate && tsc -b",
+    "test": "npm run build && node scripts/check-hash-vectors.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",
+    "release": "npm run prepack && npx np --no-tests"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.2.0",
+    "@connectrpc/connect": "^2.0.0",
+    "@connectrpc/connect-web": "^2.0.0",
+    "@mysten/sui": "^2.30.0",
+    "@noble/curves": "^1.9.7",
+    "@solana/web3.js": "^1.98.0",
+    "@wallet-standard/app": "^1.1.1",
+    "buffer": "^6.0.3",
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.47.2",
+    "@bufbuild/protoc-gen-es": "^2.2.0",
+    "@types/node": "^26.4.1",
+    "typescript": "~5.6.3"
+  }
+}