@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/sdk/evmCryptoWasm-DWklhEEb.js

@@ -1,196 +0,0 @@
-import { t as executeWorkerOperation } from "./executeWorkerOperation-Cl9whMK7.js";
-//#region src/core/signingEngine/chains/evm/evmCryptoWasm.ts
-function toDec(v) {
-	if (v < 0n) throw new Error("[evmCryptoWasm] negative bigint not supported");
-	return v.toString(10);
-}
-function toChainIdNumber(v) {
-	if (typeof v === "bigint") {
-		if (v < 0n) throw new Error("[evmCryptoWasm] chainId must be a non-negative integer");
-		const asNumber = Number(v);
-		if (!Number.isSafeInteger(asNumber)) throw new Error("[evmCryptoWasm] chainId must be a non-negative safe integer");
-		return asNumber;
-	}
-	if (!Number.isSafeInteger(v) || v < 0) throw new Error("[evmCryptoWasm] chainId must be a non-negative safe integer");
-	return v;
-}
-function requireTxNonce(nonce) {
-	if (typeof nonce === "bigint") return nonce;
-	throw new Error("[evmCryptoWasm] missing tx nonce");
-}
-function toWasmTx(tx) {
-	return {
-		chainId: toChainIdNumber(tx.chainId),
-		nonce: toDec(requireTxNonce(tx.nonce)),
-		maxPriorityFeePerGas: toDec(tx.maxPriorityFeePerGas),
-		maxFeePerGas: toDec(tx.maxFeePerGas),
-		gasLimit: toDec(tx.gasLimit),
-		to: tx.to ?? null,
-		value: toDec(tx.value),
-		data: tx.data ?? "0x",
-		accessList: (tx.accessList ?? []).map((item) => ({
-			address: item.address,
-			storageKeys: item.storageKeys
-		}))
-	};
-}
-const EVM_CRYPTO_WORKER_KIND = "evmCrypto";
-const EVM_CRYPTO_WORKER_TIMEOUT_MS = 2e4;
-async function computeEip1559TxHashWasm(tx, workerCtx) {
-	const ab = await executeWorkerOperation({
-		ctx: workerCtx,
-		kind: EVM_CRYPTO_WORKER_KIND,
-		request: {
-			type: "computeEip1559TxHash",
-			payload: { tx: toWasmTx(tx) },
-			timeoutMs: EVM_CRYPTO_WORKER_TIMEOUT_MS
-		}
-	});
-	return new Uint8Array(ab);
-}
-async function encodeEip1559SignedTxFromSignature65Wasm(args) {
-	const signature65 = args.signature65.slice().buffer;
-	const ab = await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: EVM_CRYPTO_WORKER_KIND,
-		request: {
-			type: "encodeEip1559SignedTxFromSignature65",
-			payload: {
-				tx: toWasmTx(args.tx),
-				signature65
-			},
-			timeoutMs: EVM_CRYPTO_WORKER_TIMEOUT_MS,
-			transfer: [signature65]
-		}
-	});
-	return new Uint8Array(ab);
-}
-async function verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm(args) {
-	if (!(args.digest32 instanceof Uint8Array) || args.digest32.length !== 32) throw new Error("digest32 must be 32 bytes");
-	if (!(args.signature65 instanceof Uint8Array) || args.signature65.length !== 65) throw new Error("signature65 must be 65 bytes");
-	if (!(args.publicKey33 instanceof Uint8Array) || args.publicKey33.length !== 33) throw new Error("publicKey33 must be 33 bytes");
-	const digest32 = args.digest32.slice().buffer;
-	const signature65 = args.signature65.slice().buffer;
-	const publicKey33 = args.publicKey33.slice().buffer;
-	const ab = await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: EVM_CRYPTO_WORKER_KIND,
-		request: {
-			type: "verifySecp256k1RecoverableSignatureAgainstPublicKey33",
-			payload: {
-				digest32,
-				signature65,
-				publicKey33
-			},
-			timeoutMs: EVM_CRYPTO_WORKER_TIMEOUT_MS,
-			transfer: [
-				digest32,
-				signature65,
-				publicKey33
-			]
-		}
-	});
-	const recoveredPublicKey33 = new Uint8Array(ab);
-	if (recoveredPublicKey33.length !== 33) throw new Error(`verifySecp256k1RecoverableSignatureAgainstPublicKey33 expected 33-byte output (got ${recoveredPublicKey33.length})`);
-	return recoveredPublicKey33;
-}
-async function validateSecp256k1PublicKey33Wasm(args) {
-	if (!(args.publicKey33 instanceof Uint8Array) || args.publicKey33.length !== 33) throw new Error("publicKey33 must be 33 bytes");
-	const publicKey33 = args.publicKey33.slice();
-	const ab = await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: EVM_CRYPTO_WORKER_KIND,
-		request: {
-			type: "validateSecp256k1PublicKey33",
-			payload: { publicKey33: publicKey33.buffer },
-			timeoutMs: EVM_CRYPTO_WORKER_TIMEOUT_MS,
-			transfer: [publicKey33.buffer]
-		}
-	});
-	const validated = new Uint8Array(ab);
-	if (validated.length !== 33) throw new Error(`validateSecp256k1PublicKey33 expected 33-byte output (got ${validated.length})`);
-	return validated;
-}
-async function addSecp256k1PublicKeys33Wasm(args) {
-	if (!(args.left33 instanceof Uint8Array) || args.left33.length !== 33) throw new Error("left33 must be 33 bytes");
-	if (!(args.right33 instanceof Uint8Array) || args.right33.length !== 33) throw new Error("right33 must be 33 bytes");
-	const left33 = args.left33.slice();
-	const right33 = args.right33.slice();
-	const ab = await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: EVM_CRYPTO_WORKER_KIND,
-		request: {
-			type: "addSecp256k1PublicKeys33",
-			payload: {
-				left33: left33.buffer,
-				right33: right33.buffer
-			},
-			timeoutMs: EVM_CRYPTO_WORKER_TIMEOUT_MS,
-			transfer: [left33.buffer, right33.buffer]
-		}
-	});
-	const groupPublicKey33 = new Uint8Array(ab);
-	if (groupPublicKey33.length !== 33) throw new Error(`addSecp256k1PublicKeys33 expected 33-byte output (got ${groupPublicKey33.length})`);
-	return groupPublicKey33;
-}
-async function buildWebauthnP256SignatureWasm(args) {
-	if (!(args.challenge32 instanceof Uint8Array) || args.challenge32.length !== 32) throw new Error("challenge32 must be 32 bytes");
-	if (!(args.pubKeyX32 instanceof Uint8Array) || args.pubKeyX32.length !== 32) throw new Error("pubKeyX32 must be 32 bytes");
-	if (!(args.pubKeyY32 instanceof Uint8Array) || args.pubKeyY32.length !== 32) throw new Error("pubKeyY32 must be 32 bytes");
-	if (!(args.authenticatorData instanceof Uint8Array) || !args.authenticatorData.length) throw new Error("authenticatorData must be non-empty");
-	if (!(args.clientDataJSON instanceof Uint8Array) || !args.clientDataJSON.length) throw new Error("clientDataJSON must be non-empty");
-	if (!(args.signatureDer instanceof Uint8Array) || !args.signatureDer.length) throw new Error("signatureDer must be non-empty");
-	const challenge32 = args.challenge32.slice();
-	const authenticatorData = args.authenticatorData.slice();
-	const clientDataJSON = args.clientDataJSON.slice();
-	const signatureDer = args.signatureDer.slice();
-	const pubKeyX32 = args.pubKeyX32.slice();
-	const pubKeyY32 = args.pubKeyY32.slice();
-	const ab = await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: EVM_CRYPTO_WORKER_KIND,
-		request: {
-			type: "buildWebauthnP256Signature",
-			payload: {
-				challenge32: challenge32.buffer,
-				authenticatorData: authenticatorData.buffer,
-				clientDataJSON: clientDataJSON.buffer,
-				signatureDer: signatureDer.buffer,
-				pubKeyX32: pubKeyX32.buffer,
-				pubKeyY32: pubKeyY32.buffer
-			},
-			timeoutMs: EVM_CRYPTO_WORKER_TIMEOUT_MS,
-			transfer: [
-				challenge32.buffer,
-				authenticatorData.buffer,
-				clientDataJSON.buffer,
-				signatureDer.buffer,
-				pubKeyX32.buffer,
-				pubKeyY32.buffer
-			]
-		}
-	});
-	return new Uint8Array(ab);
-}
-async function decodeCoseP256PublicKeyWasm(args) {
-	if (!(args.cosePublicKey instanceof Uint8Array) || args.cosePublicKey.length === 0) throw new Error("cosePublicKey must be non-empty");
-	const cosePublicKey = args.cosePublicKey.slice();
-	const ab = await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: EVM_CRYPTO_WORKER_KIND,
-		request: {
-			type: "decodeCoseP256PublicKey",
-			payload: { cosePublicKey: cosePublicKey.buffer },
-			timeoutMs: EVM_CRYPTO_WORKER_TIMEOUT_MS,
-			transfer: [cosePublicKey.buffer]
-		}
-	});
-	const decoded = new Uint8Array(ab);
-	if (decoded.length !== 64) throw new Error(`decodeCoseP256PublicKey expected 64-byte output (got ${decoded.length})`);
-	return {
-		pubKeyX32: decoded.slice(0, 32),
-		pubKeyY32: decoded.slice(32, 64)
-	};
-}
-//#endregion
-export { encodeEip1559SignedTxFromSignature65Wasm as a, decodeCoseP256PublicKeyWasm as i, buildWebauthnP256SignatureWasm as n, validateSecp256k1PublicKey33Wasm as o, computeEip1559TxHashWasm as r, verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm as s, addSecp256k1PublicKeys33Wasm as t };