@swivy/web 0.0.0-stage → 1.0.0

package/dist/packages/web/src/local-wallet.d.ts

@@ -0,0 +1,89 @@
+import type { Chain, TypedDataDescriptor } from "@swivy/core";
+export interface SwivyBrowserManagedAccountProvisioning {
+    publicKey: string;
+    address: string;
+    accountType: "smart" | "managed";
+    serverShare: {
+        commitment: string;
+        encryptedPayload: string;
+        metadata: Record<string, unknown>;
+    };
+    deviceShare: {
+        commitment: string;
+        metadata: Record<string, unknown>;
+    };
+    recoveryShare: {
+        commitment: string;
+        metadata: Record<string, unknown>;
+    };
+}
+export interface SwivyLocalWalletShareRecord {
+    version: 1;
+    scheme: "shamir_gf256_v1";
+    accountId?: string;
+    chain: Chain;
+    x: number;
+    shareBase64: string;
+    publicKey: string;
+    address: string;
+    createdAt: string;
+}
+export interface SwivyBrowserSplitWalletMaterial {
+    provisioning: SwivyBrowserManagedAccountProvisioning;
+    deviceShare: SwivyLocalWalletShareRecord;
+    recoveryShare: SwivyLocalWalletShareRecord;
+    recoveryPackage: string;
+}
+export interface SwivyLocalWalletStorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export declare function decodeRecoveryPackage(payload: string): SwivyLocalWalletShareRecord;
+export declare function storeDeviceShare(storage: SwivyLocalWalletStorageLike, prefix: string, accountId: string, record: SwivyLocalWalletShareRecord): void;
+export declare function loadDeviceShare(storage: SwivyLocalWalletStorageLike, prefix: string, accountId: string): SwivyLocalWalletShareRecord | null;
+export declare function clearDeviceShare(storage: SwivyLocalWalletStorageLike, prefix: string, accountId: string): void;
+export declare function createBrowserSplitWalletMaterial(chain: Chain, options?: {
+    label?: string;
+}): Promise<SwivyBrowserSplitWalletMaterial>;
+export declare function reconstructSecretFromShares(first: SwivyLocalWalletShareRecord, second: SwivyLocalWalletShareRecord): Uint8Array;
+export declare function parseServerShareRecord(payload: string, localShare: SwivyLocalWalletShareRecord): Promise<SwivyLocalWalletShareRecord>;
+export declare function exportPrivateKeyFromShares(chain: Chain, first: SwivyLocalWalletShareRecord, second: SwivyLocalWalletShareRecord): {
+    chain: Chain;
+    privateKey: string;
+    publicKey: string;
+    address: string;
+};
+export declare function signMessageLocallyWithShares(params: {
+    chain: Chain;
+    first: SwivyLocalWalletShareRecord;
+    second: SwivyLocalWalletShareRecord;
+    message?: string;
+    messageHex?: string;
+    messageBase64?: string;
+}): Promise<{
+    signature: string;
+    address: string;
+    publicKey: string;
+}>;
+export declare function signTypedDataLocallyWithShares(params: {
+    first: SwivyLocalWalletShareRecord;
+    second: SwivyLocalWalletShareRecord;
+    typedData: TypedDataDescriptor;
+}): Promise<{
+    signature: string;
+    address: string;
+    publicKey: string;
+}>;
+export declare function signTransactionLocallyWithShares(params: {
+    chain: Chain;
+    first: SwivyLocalWalletShareRecord;
+    second: SwivyLocalWalletShareRecord;
+    transaction?: Record<string, unknown>;
+    serializedTransactionBase64?: string;
+}): Promise<{
+    signedPayload: string;
+    address: string;
+    publicKey: string;
+    signature?: string;
+}>;

package/dist/packages/web/src/local-wallet.js

@@ -0,0 +1,485 @@
+import { Keypair, Transaction, VersionedTransaction } from "@solana/web3.js";
+import bs58 from "bs58";
+import { Wallet, getBytes } from "ethers";
+import nacl from "tweetnacl";
+const GF_REDUCTION = 0x1b;
+function randomBytes(length) {
+    const buffer = new Uint8Array(length);
+    globalThis.crypto.getRandomValues(buffer);
+    return buffer;
+}
+function gfMultiply(left, right) {
+    let a = left & 0xff;
+    let b = right & 0xff;
+    let result = 0;
+    for (let index = 0; index < 8; index += 1) {
+        if (b & 1) {
+            result ^= a;
+        }
+        const highBit = a & 0x80;
+        a = (a << 1) & 0xff;
+        if (highBit) {
+            a ^= GF_REDUCTION;
+        }
+        b >>= 1;
+    }
+    return result & 0xff;
+}
+function gfPow(value, exponent) {
+    let result = 1;
+    let base = value & 0xff;
+    let power = exponent;
+    while (power > 0) {
+        if (power & 1) {
+            result = gfMultiply(result, base);
+        }
+        base = gfMultiply(base, base);
+        power >>= 1;
+    }
+    return result;
+}
+function gfInverse(value) {
+    if (value === 0) {
+        throw new Error("gf_zero_inverse");
+    }
+    return gfPow(value, 254);
+}
+function gfDivide(left, right) {
+    if (left === 0) {
+        return 0;
+    }
+    return gfMultiply(left, gfInverse(right));
+}
+function bytesToBase64(bytes) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+function base64ToBytes(value) {
+    if (typeof Buffer !== "undefined") {
+        return new Uint8Array(Buffer.from(value, "base64"));
+    }
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+function toArrayBuffer(bytes) {
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function utf8ToBase64(value) {
+    return bytesToBase64(new TextEncoder().encode(value));
+}
+function base64ToUtf8(value) {
+    return new TextDecoder().decode(base64ToBytes(value));
+}
+function bytesEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index] !== right[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+async function sha256Hex(value) {
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+    return Array.from(new Uint8Array(digest))
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+function splitSecret(secret) {
+    const coefficients = randomBytes(secret.length);
+    const shareIndexes = [1, 2, 3];
+    const shares = shareIndexes.map((x) => ({
+        x,
+        bytes: new Uint8Array(secret.length),
+    }));
+    for (let offset = 0; offset < secret.length; offset += 1) {
+        const constant = secret[offset] ?? 0;
+        const coefficient = coefficients[offset] ?? 0;
+        for (const share of shares) {
+            share.bytes[offset] = constant ^ gfMultiply(coefficient, share.x);
+        }
+    }
+    return shares;
+}
+function combineTwoShares(left, right) {
+    if (left.bytes.length !== right.bytes.length) {
+        throw new Error("share_length_mismatch");
+    }
+    if (left.x === right.x) {
+        throw new Error("share_index_conflict");
+    }
+    const recovered = new Uint8Array(left.bytes.length);
+    const leftDenominator = left.x ^ right.x;
+    const rightDenominator = right.x ^ left.x;
+    for (let offset = 0; offset < recovered.length; offset += 1) {
+        const leftTerm = gfMultiply(left.bytes[offset] ?? 0, gfDivide(right.x, leftDenominator));
+        const rightTerm = gfMultiply(right.bytes[offset] ?? 0, gfDivide(left.x, rightDenominator));
+        recovered[offset] = leftTerm ^ rightTerm;
+    }
+    return recovered;
+}
+function serializeShareRecord(record) {
+    return JSON.stringify(record);
+}
+function isChain(value) {
+    return value === "evm" || value === "solana";
+}
+function deserializeShareRecord(payload, errorCode = "invalid_share_record") {
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw new Error(errorCode);
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(errorCode);
+    }
+    const record = parsed;
+    if (record.version !== 1
+        || record.scheme !== "shamir_gf256_v1"
+        || !isChain(record.chain)
+        || !Number.isInteger(record.x)
+        || (record.x ?? 0) <= 0
+        || typeof record.shareBase64 !== "string"
+        || !record.shareBase64
+        || typeof record.publicKey !== "string"
+        || !record.publicKey
+        || typeof record.address !== "string"
+        || !record.address
+        || typeof record.createdAt !== "string"
+        || Number.isNaN(Date.parse(record.createdAt))
+        || (record.accountId !== undefined && typeof record.accountId !== "string")) {
+        throw new Error(errorCode);
+    }
+    try {
+        if (base64ToBytes(record.shareBase64).length === 0) {
+            throw new Error(errorCode);
+        }
+    }
+    catch {
+        throw new Error(errorCode);
+    }
+    return record;
+}
+function encodeRecoveryPackage(record) {
+    return utf8ToBase64(serializeShareRecord(record));
+}
+export function decodeRecoveryPackage(payload) {
+    try {
+        return deserializeShareRecord(base64ToUtf8(payload), "invalid_recovery_package");
+    }
+    catch {
+        throw new Error("invalid_recovery_package");
+    }
+}
+function createShareMetadata(x, chain, label) {
+    return {
+        scheme: "shamir_gf256_v1",
+        threshold: 2,
+        totalShares: 3,
+        shareIndex: x,
+        encoding: "json",
+        encrypted: false,
+        chain,
+        label,
+    };
+}
+function serializeShareKeyMaterial(record) {
+    return JSON.stringify({
+        version: record.version,
+        scheme: record.scheme,
+        chain: record.chain,
+        x: record.x,
+        shareBase64: record.shareBase64,
+        publicKey: record.publicKey,
+        address: record.address,
+        createdAt: record.createdAt,
+    });
+}
+async function deriveShareWrapKey(record) {
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(serializeShareKeyMaterial(record)));
+    return globalThis.crypto.subtle.importKey("raw", digest, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+}
+async function encryptServerShareForLocalShare(payload, record) {
+    const key = await deriveShareWrapKey(record);
+    const iv = randomBytes(12);
+    const ciphertext = await globalThis.crypto.subtle.encrypt({ name: "AES-GCM", iv: toArrayBuffer(iv) }, key, new TextEncoder().encode(payload));
+    return {
+        shareIndex: record.x,
+        ivBase64: bytesToBase64(iv),
+        ciphertextBase64: bytesToBase64(new Uint8Array(ciphertext)),
+    };
+}
+async function decryptServerShareForLocalShare(payload, record) {
+    const entry = payload.entries.find((candidate) => candidate.shareIndex === record.x);
+    if (!entry) {
+        throw new Error("server_share_unwrap_not_available_for_local_share");
+    }
+    const key = await deriveShareWrapKey(record);
+    const plaintext = await globalThis.crypto.subtle.decrypt({ name: "AES-GCM", iv: toArrayBuffer(base64ToBytes(entry.ivBase64)) }, key, toArrayBuffer(base64ToBytes(entry.ciphertextBase64)));
+    const parsed = deserializeShareRecord(new TextDecoder().decode(new Uint8Array(plaintext)));
+    if (parsed.publicKey !== record.publicKey || parsed.address !== record.address) {
+        throw new Error("server_share_unwrap_identity_mismatch");
+    }
+    return parsed;
+}
+function parseWrappedServerSharePayload(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        if (parsed?.version === 1
+            && parsed?.scheme === "share_wrap_aes_gcm_v1"
+            && Array.isArray(parsed.entries)
+            && parsed.entries.every((entry) => typeof entry?.shareIndex === "number"
+                && typeof entry?.ivBase64 === "string"
+                && typeof entry?.ciphertextBase64 === "string")) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function getStorageKey(prefix, accountId) {
+    return `${prefix}:${accountId}`;
+}
+export function storeDeviceShare(storage, prefix, accountId, record) {
+    storage.setItem(getStorageKey(prefix, accountId), serializeShareRecord({ ...record, accountId }));
+}
+export function loadDeviceShare(storage, prefix, accountId) {
+    const storageKey = getStorageKey(prefix, accountId);
+    const stored = storage.getItem(storageKey);
+    if (!stored) {
+        return null;
+    }
+    try {
+        const record = deserializeShareRecord(stored);
+        if (record.accountId !== undefined && record.accountId !== accountId) {
+            throw new Error("device_share_account_mismatch");
+        }
+        return record;
+    }
+    catch {
+        storage.removeItem(storageKey);
+        return null;
+    }
+}
+export function clearDeviceShare(storage, prefix, accountId) {
+    storage.removeItem(getStorageKey(prefix, accountId));
+}
+export async function createBrowserSplitWalletMaterial(chain, options) {
+    const createdAt = new Date().toISOString();
+    const label = options?.label ?? `${chain}-browser-wallet`;
+    let secretBytes;
+    let publicKey;
+    let address;
+    if (chain === "evm") {
+        const wallet = Wallet.createRandom();
+        secretBytes = getBytes(wallet.privateKey);
+        publicKey = wallet.signingKey.publicKey;
+        address = wallet.address;
+    }
+    else {
+        const seed = randomBytes(32);
+        const keypair = Keypair.fromSeed(seed);
+        secretBytes = seed;
+        publicKey = keypair.publicKey.toBase58();
+        address = keypair.publicKey.toBase58();
+    }
+    const [serverShare, deviceShare, recoveryShare] = splitSecret(secretBytes).map((share) => ({
+        x: share.x,
+        record: {
+            version: 1,
+            scheme: "shamir_gf256_v1",
+            chain,
+            x: share.x,
+            shareBase64: bytesToBase64(share.bytes),
+            publicKey,
+            address,
+            createdAt,
+        },
+    }));
+    const serverPayload = serializeShareRecord(serverShare.record);
+    const wrappedServerPayload = JSON.stringify({
+        version: 1,
+        scheme: "share_wrap_aes_gcm_v1",
+        entries: await Promise.all([
+            encryptServerShareForLocalShare(serverPayload, deviceShare.record),
+            encryptServerShareForLocalShare(serverPayload, recoveryShare.record),
+        ]),
+    });
+    return {
+        provisioning: {
+            publicKey,
+            address,
+            accountType: "smart",
+            serverShare: {
+                commitment: await sha256Hex(serverPayload),
+                encryptedPayload: wrappedServerPayload,
+                metadata: {
+                    ...createShareMetadata(serverShare.x, chain, label),
+                    encrypted: true,
+                    wrappingScheme: "share_wrap_aes_gcm_v1",
+                    decryptableWithShareIndexes: [deviceShare.x, recoveryShare.x],
+                },
+            },
+            deviceShare: {
+                commitment: await sha256Hex(serializeShareRecord(deviceShare.record)),
+                metadata: createShareMetadata(deviceShare.x, chain, label),
+            },
+            recoveryShare: {
+                commitment: await sha256Hex(serializeShareRecord(recoveryShare.record)),
+                metadata: createShareMetadata(recoveryShare.x, chain, label),
+            },
+        },
+        deviceShare: deviceShare.record,
+        recoveryShare: recoveryShare.record,
+        recoveryPackage: encodeRecoveryPackage(recoveryShare.record),
+    };
+}
+export function reconstructSecretFromShares(first, second) {
+    if (first.chain !== second.chain) {
+        throw new Error("share_chain_mismatch");
+    }
+    if (first.address !== second.address || first.publicKey !== second.publicKey) {
+        throw new Error("share_identity_mismatch");
+    }
+    return combineTwoShares({ x: first.x, bytes: base64ToBytes(first.shareBase64) }, { x: second.x, bytes: base64ToBytes(second.shareBase64) });
+}
+export async function parseServerShareRecord(payload, localShare) {
+    const wrapped = parseWrappedServerSharePayload(payload);
+    if (wrapped) {
+        return decryptServerShareForLocalShare(wrapped, localShare);
+    }
+    const parsed = deserializeShareRecord(payload, "invalid_server_share_record");
+    if (parsed.publicKey !== localShare.publicKey || parsed.address !== localShare.address) {
+        throw new Error("server_share_identity_mismatch");
+    }
+    const localShareBytes = base64ToBytes(localShare.shareBase64);
+    const serverShareBytes = base64ToBytes(parsed.shareBase64);
+    if (bytesEqual(localShareBytes, serverShareBytes)) {
+        throw new Error("server_share_matches_local_share");
+    }
+    return parsed;
+}
+export function exportPrivateKeyFromShares(chain, first, second) {
+    const secret = reconstructSecretFromShares(first, second);
+    if (chain === "evm") {
+        const privateKey = `0x${bytesToHex(secret)}`;
+        const wallet = new Wallet(privateKey);
+        if (wallet.address !== first.address || wallet.signingKey.publicKey !== first.publicKey) {
+            throw new Error("reconstructed_wallet_mismatch");
+        }
+        return {
+            chain,
+            privateKey,
+            publicKey: wallet.signingKey.publicKey,
+            address: wallet.address,
+        };
+    }
+    const keypair = Keypair.fromSeed(secret);
+    if (keypair.publicKey.toBase58() !== first.address || keypair.publicKey.toBase58() !== first.publicKey) {
+        throw new Error("reconstructed_wallet_mismatch");
+    }
+    return {
+        chain,
+        privateKey: bs58.encode(keypair.secretKey),
+        publicKey: keypair.publicKey.toBase58(),
+        address: keypair.publicKey.toBase58(),
+    };
+}
+export async function signMessageLocallyWithShares(params) {
+    const exported = exportPrivateKeyFromShares(params.chain, params.first, params.second);
+    if (params.chain === "evm") {
+        const wallet = new Wallet(exported.privateKey);
+        const payload = params.messageHex
+            ? getBytes(params.messageHex)
+            : params.messageBase64
+                ? base64ToBytes(params.messageBase64)
+                : params.message ?? "";
+        return {
+            signature: await wallet.signMessage(payload),
+            address: wallet.address,
+            publicKey: wallet.signingKey.publicKey,
+        };
+    }
+    const secretKey = bs58.decode(exported.privateKey);
+    const payload = params.messageBase64
+        ? base64ToBytes(params.messageBase64)
+        : new TextEncoder().encode(params.message ?? "");
+    const signature = nacl.sign.detached(payload, secretKey);
+    return {
+        signature: bytesToBase64(signature),
+        address: exported.address,
+        publicKey: exported.publicKey,
+    };
+}
+export async function signTypedDataLocallyWithShares(params) {
+    const exported = exportPrivateKeyFromShares("evm", params.first, params.second);
+    const wallet = new Wallet(exported.privateKey);
+    return {
+        signature: await wallet.signTypedData(params.typedData.domain ?? {}, params.typedData.types, params.typedData.message),
+        address: wallet.address,
+        publicKey: wallet.signingKey.publicKey,
+    };
+}
+export async function signTransactionLocallyWithShares(params) {
+    const exported = exportPrivateKeyFromShares(params.chain, params.first, params.second);
+    if (params.chain === "evm") {
+        if (!params.transaction) {
+            throw new Error("missing_evm_transaction");
+        }
+        const wallet = new Wallet(exported.privateKey);
+        return {
+            signedPayload: await wallet.signTransaction(params.transaction),
+            address: wallet.address,
+            publicKey: wallet.signingKey.publicKey,
+        };
+    }
+    if (!params.serializedTransactionBase64) {
+        throw new Error("missing_solana_transaction");
+    }
+    const seed = reconstructSecretFromShares(params.first, params.second);
+    const keypair = Keypair.fromSeed(seed);
+    const serializedBytes = base64ToBytes(params.serializedTransactionBase64);
+    try {
+        const transaction = VersionedTransaction.deserialize(serializedBytes);
+        transaction.sign([keypair]);
+        const signature = transaction.signatures[0];
+        return {
+            signedPayload: bytesToBase64(transaction.serialize()),
+            address: keypair.publicKey.toBase58(),
+            publicKey: keypair.publicKey.toBase58(),
+            signature: signature ? bs58.encode(signature) : undefined,
+        };
+    }
+    catch {
+        const transaction = Transaction.from(serializedBytes);
+        transaction.partialSign(keypair);
+        const firstSignature = transaction.signatures.find((candidate) => candidate.signature)?.signature;
+        return {
+            signedPayload: bytesToBase64(transaction.serialize()),
+            address: keypair.publicKey.toBase58(),
+            publicKey: keypair.publicKey.toBase58(),
+            signature: firstSignature ? bs58.encode(firstSignature) : undefined,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@swivy/web",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Swivy browser SDK",
+  "type": "module",
+  "main": "dist/packages/web/src/index.js",
+  "types": "dist/packages/web/src/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run test/*.test.ts"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.99.0",
+    "@simplewebauthn/browser": "^13.3.0",
+    "@swivy/core": "^1.0.0",
+    "bs58": "^6.0.0",
+    "ethers": "^6.17.0",
+    "tweetnacl": "^1.0.3"
+  },
+  "files": [
+    "dist/packages/web/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/packages/web/src/index.d.ts",
+      "import": "./dist/packages/web/src/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Travisswop/Swivy.git",
+    "directory": "packages/web"
+  }
+}