@seams/wallet-server 0.7.1 → 0.8.0

package/dist/esm/core/authService/identity.js

@@ -1,57 +0,0 @@
-import { normalizeOptionalTrimmedString } from "../../shared-ts/src/utils/normalize.js";
-import "../../shared-ts/src/utils/validation.js";
-import { errorMessage } from "../../shared-ts/src/utils/errors.js";
-//#region src/core/authService/identity.ts
-async function listIdentitiesWithStore(input) {
-	try {
-		const userId = normalizeOptionalTrimmedString(input.userId);
-		if (!userId) return {
-			ok: false,
-			code: "invalid_args",
-			message: "Missing userId"
-		};
-		return {
-			ok: true,
-			subjects: await input.store.listSubjectsByUserId(userId)
-		};
-	} catch (e) {
-		return {
-			ok: false,
-			code: "internal",
-			message: errorMessage(e) || "Failed to list identities"
-		};
-	}
-}
-async function linkIdentityWithStore(input) {
-	try {
-		return await input.store.linkSubjectToUserId({
-			userId: input.userId,
-			subject: input.subject,
-			allowMoveIfSoleIdentity: input.allowMoveIfSoleIdentity
-		});
-	} catch (e) {
-		return {
-			ok: false,
-			code: "internal",
-			message: errorMessage(e) || "Failed to link identity"
-		};
-	}
-}
-async function unlinkIdentityWithStore(input) {
-	try {
-		return await input.store.unlinkSubjectFromUserId({
-			userId: input.userId,
-			subject: input.subject
-		});
-	} catch (e) {
-		return {
-			ok: false,
-			code: "internal",
-			message: errorMessage(e) || "Failed to unlink identity"
-		};
-	}
-}
-//#endregion
-export { linkIdentityWithStore, listIdentitiesWithStore, unlinkIdentityWithStore };
-
-//# sourceMappingURL=identity.js.map

package/dist/esm/core/authService/identityOperations.js

@@ -1,32 +0,0 @@
-import { linkIdentityWithStore, listIdentitiesWithStore, unlinkIdentityWithStore } from "./identity.js";
-//#region src/core/authService/identityOperations.ts
-var IdentityOperations = class {
-	constructor(store) {
-		this.store = store;
-	}
-	async listIdentities(input) {
-		return await listIdentitiesWithStore({
-			store: this.store,
-			userId: input.userId
-		});
-	}
-	async linkIdentity(input) {
-		return await linkIdentityWithStore({
-			store: this.store,
-			userId: input.userId,
-			subject: input.subject,
-			allowMoveIfSoleIdentity: Boolean(input.allowMoveIfSoleIdentity)
-		});
-	}
-	async unlinkIdentity(input) {
-		return await unlinkIdentityWithStore({
-			store: this.store,
-			userId: input.userId,
-			subject: input.subject
-		});
-	}
-};
-//#endregion
-export { IdentityOperations };
-
-//# sourceMappingURL=identityOperations.js.map

package/dist/esm/core/authService/nearAccountOperations.js

@@ -1,229 +0,0 @@
-import { isValidAccountId } from "../../shared-ts/src/utils/near.js";
-import "../../shared-ts/src/utils/validation.js";
-import { ActionType, validateActionArgsWasm } from "../../shared-ts/src/near/actions.js";
-import { executeSignedDelegateWithRelayer } from "../../delegateAction/index.js";
-import { errorMessage } from "../../shared-ts/src/utils/errors.js";
-import { checkNearAccountExistsWithClient, dispatchNearSignedTransactionBorshWithClient, fetchNearTxContextWithClient, signGasRelayerNearTransactionWithDeps, verifyAccountAccessKeysPresentWithClient, viewAccessKeyListWithClient } from "./nearTransactions.js";
-import { fundImplicitNearAccountWithRelayer } from "../nearRelayerAccountProvisioning.js";
-import { buildFullAccessAddKeyAction, normalizeBootstrapPublicKeys } from "./registrationThresholdHelpers.js";
-//#region src/core/authService/nearAccountOperations.ts
-const ACCOUNT_CREATE_BROADCAST_WAIT_UNTIL = "EXECUTED_OPTIMISTIC";
-const ACCOUNT_CREATE_FAST_KEY_VISIBILITY_CHECK = {
-	attempts: 2,
-	delayMs: 100,
-	finality: "optimistic"
-};
-const ACCOUNT_CREATE_BACKGROUND_KEY_VISIBILITY_AUDIT = {
-	attempts: 8,
-	delayMs: 250,
-	finality: "final"
-};
-var NearAccountOperations = class {
-	constructor(input) {
-		this.input = input;
-		this.transactionQueue = Promise.resolve();
-		this.queueStats = {
-			pending: 0,
-			completed: 0,
-			failed: 0
-		};
-	}
-	async viewAccessKeyList(accountId) {
-		await this.input.ensureSignerAndRelayerAccount();
-		return await viewAccessKeyListWithClient({
-			nearClient: this.input.nearClient,
-			accountId
-		});
-	}
-	async dispatchNearSignedTransactionBorsh(input) {
-		await this.input.ensureSignerAndRelayerAccount();
-		return await dispatchNearSignedTransactionBorshWithClient({
-			nearClient: this.input.nearClient,
-			signedTransactionBorshB64u: input.signedTransactionBorshB64u
-		});
-	}
-	async txStatus(txHash, senderAccountId) {
-		await this.input.ensureSignerAndRelayerAccount();
-		return this.input.nearClient.txStatus(txHash, senderAccountId);
-	}
-	async createAccount(request) {
-		await this.input.ensureSignerAndRelayerAccount();
-		return this.queueTransaction(this.createAccountQueueTask(request), `create account ${request.accountId}`);
-	}
-	async fundImplicitNearAccount(request) {
-		await this.input.ensureSignerAndRelayerAccount();
-		return await this.queueTransaction(this.createFundImplicitNearAccountQueueTask(request), `fund implicit NEAR account ${request.nearAccountId}`);
-	}
-	async checkAccountExists(accountId) {
-		await this.input.ensureSignerAndRelayerAccount();
-		return await checkNearAccountExistsWithClient({
-			nearClient: this.input.nearClient,
-			logger: this.input.logger,
-			accountId
-		});
-	}
-	async executeSignedDelegate(input) {
-		await this.input.ensureSignerAndRelayerAccount();
-		if (!input?.hash || !input?.signedDelegate) return {
-			ok: false,
-			code: "invalid_delegate_request",
-			error: "hash and signedDelegate are required"
-		};
-		const senderId = input.signedDelegate?.delegateAction?.senderId ?? "unknown-sender";
-		return this.queueTransaction(() => executeSignedDelegateWithRelayer({
-			nearClient: this.input.nearClient,
-			relayerAccount: this.input.config.relayerAccount,
-			relayerPublicKey: this.input.getRelayerPublicKey(),
-			hash: input.hash,
-			signedDelegate: input.signedDelegate,
-			policy: input.policy,
-			signGasRelayerNearTransaction: (args) => this.signGasRelayerNearTransaction(args)
-		}), `execute signed delegate for ${senderId}`);
-	}
-	async fetchTxContext(accountId, publicKey) {
-		return await fetchNearTxContextWithClient({
-			nearClient: this.input.nearClient,
-			accountId,
-			publicKey
-		});
-	}
-	async signGasRelayerNearTransaction(input) {
-		return await signGasRelayerNearTransactionWithDeps({
-			ensureSignerWasm: this.input.ensureSignerWasm,
-			relayerAccount: this.input.config.relayerAccount,
-			relayerPrivateKey: this.input.config.relayerPrivateKey,
-			receiverId: input.receiverId,
-			nonce: input.nonce,
-			blockHash: input.blockHash,
-			actions: input.actions
-		});
-	}
-	async queueTransaction(operation, description) {
-		this.queueStats.pending++;
-		this.input.logger.debug(`[AuthService] Queueing: ${description} (pending: ${this.queueStats.pending})`);
-		const next = this.transactionQueue.then(async () => {
-			try {
-				this.input.logger.debug(`[AuthService] Executing: ${description}`);
-				const result = await operation();
-				this.queueStats.completed++;
-				this.queueStats.pending--;
-				this.input.logger.debug(`[AuthService] Completed: ${description} (pending: ${this.queueStats.pending})`);
-				return result;
-			} catch (error) {
-				this.queueStats.failed++;
-				this.queueStats.pending--;
-				this.input.logger.error(`[AuthService] Failed: ${description} (failed: ${this.queueStats.failed}):`, errorMessage(error) || "unknown error");
-				throw error;
-			}
-		});
-		this.transactionQueue = next.catch(() => void 0);
-		return await next;
-	}
-	createAccountQueueTask(request) {
-		return this.createAccountFromQueue.bind(this, request);
-	}
-	async createAccountFromQueue(request) {
-		try {
-			if (!isValidAccountId(request.accountId)) throw new Error(`Invalid account ID format: ${request.accountId}`);
-			this.input.logger.info(`Checking if account ${request.accountId} already exists...`);
-			if (await this.checkAccountExists(request.accountId)) throw new Error(`Account ${request.accountId} already exists. Cannot create duplicate account.`);
-			this.input.logger.info(`Account ${request.accountId} is available for creation`);
-			const initialBalance = this.input.config.accountInitialBalance;
-			const { publicKey, recoveryPublicKey, expectedPublicKeys } = normalizeBootstrapPublicKeys({
-				publicKey: request.publicKey,
-				recoveryPublicKey: request.recoveryPublicKey
-			});
-			this.input.logger.info(`Creating account: ${request.accountId}`);
-			this.input.logger.info(`Initial balance: ${initialBalance} yoctoNEAR`);
-			const actions = [
-				{ action_type: ActionType.CreateAccount },
-				{
-					action_type: ActionType.Transfer,
-					deposit: String(initialBalance)
-				},
-				buildFullAccessAddKeyAction(publicKey),
-				...recoveryPublicKey ? [buildFullAccessAddKeyAction(recoveryPublicKey)] : []
-			];
-			actions.forEach(validateActionArgsWasm);
-			const { nextNonce, blockHash } = await this.fetchTxContext(this.input.config.relayerAccount, this.input.getRelayerPublicKey());
-			const signed = await this.signGasRelayerNearTransaction({
-				receiverId: request.accountId,
-				nonce: nextNonce,
-				blockHash,
-				actions
-			});
-			const createAccountBroadcastStartedAt = Date.now();
-			const result = await this.input.nearClient.sendTransaction(signed, ACCOUNT_CREATE_BROADCAST_WAIT_UNTIL);
-			this.input.logger.info(`Account creation for ${request.accountId} reached ${ACCOUNT_CREATE_BROADCAST_WAIT_UNTIL} in ${Date.now() - createAccountBroadcastStartedAt}ms`);
-			const createAccountKeyCheckStartedAt = Date.now();
-			const keysVerified = await this.verifyAccountAccessKeysPresent(request.accountId, expectedPublicKeys, ACCOUNT_CREATE_FAST_KEY_VISIBILITY_CHECK);
-			this.input.logger.info(`Account creation for ${request.accountId} key visibility verified=${keysVerified} in ${Date.now() - createAccountKeyCheckStartedAt}ms`);
-			if (!keysVerified) {
-				this.input.logger.warn(recoveryPublicKey ? "Bootstrap committed before both access keys were visible on final state; scheduling background audit" : "Bootstrap committed before the operational access key was visible on final state; scheduling background audit");
-				this.scheduleAccountAccessKeyVisibilityAudit({
-					accountId: request.accountId,
-					expectedPublicKeys,
-					contextLabel: `Account creation for ${request.accountId}`
-				});
-			}
-			this.input.logger.info(`Account creation completed: ${result.transaction.hash}`);
-			const nearAmount = (Number(BigInt(initialBalance)) / 1e24).toFixed(6);
-			return {
-				success: true,
-				transactionHash: result.transaction.hash,
-				accountId: request.accountId,
-				message: `Account ${request.accountId} created with ${nearAmount} NEAR initial balance`
-			};
-		} catch (error) {
-			this.input.logger.error(`Account creation failed for ${request.accountId}:`, error);
-			const msg = errorMessage(error) || "Unknown account creation error";
-			return {
-				success: false,
-				error: msg,
-				message: `Failed to create account ${request.accountId}: ${msg}`
-			};
-		}
-	}
-	createFundImplicitNearAccountQueueTask(request) {
-		return this.fundImplicitNearAccountFromQueue.bind(this, request);
-	}
-	async fundImplicitNearAccountFromQueue(request) {
-		return await fundImplicitNearAccountWithRelayer({
-			...request,
-			relayerAccount: this.input.config.relayerAccount,
-			relayerPrivateKey: this.input.config.relayerPrivateKey,
-			relayerPublicKey: this.input.getRelayerPublicKey(),
-			nearRpcUrl: this.input.config.nearRpcUrl,
-			fundedAmountYocto: this.input.config.accountInitialBalance,
-			nearClient: this.input.nearClient,
-			ensureSignerWasm: this.input.ensureSignerWasm
-		});
-	}
-	async verifyAccountAccessKeysPresent(accountId, expectedPublicKeys, opts) {
-		return await verifyAccountAccessKeysPresentWithClient({
-			nearClient: this.input.nearClient,
-			accountId,
-			expectedPublicKeys,
-			options: opts
-		});
-	}
-	scheduleAccountAccessKeyVisibilityAudit(input) {
-		this.runAccountAccessKeyVisibilityAudit(input);
-	}
-	async runAccountAccessKeyVisibilityAudit(input) {
-		try {
-			const startedAt = Date.now();
-			if (await this.verifyAccountAccessKeysPresent(input.accountId, input.expectedPublicKeys, ACCOUNT_CREATE_BACKGROUND_KEY_VISIBILITY_AUDIT)) {
-				this.input.logger.info(`${input.contextLabel} final key visibility verified=true in ${Date.now() - startedAt}ms`);
-				return;
-			}
-			this.input.logger.warn(`${input.contextLabel} final key visibility is still pending after ${Date.now() - startedAt}ms`);
-		} catch (error) {
-			this.input.logger.warn(`${input.contextLabel} final key visibility audit failed`, error);
-		}
-	}
-};
-//#endregion
-export { NearAccountOperations };
-
-//# sourceMappingURL=nearAccountOperations.js.map

package/dist/esm/core/authService/nearPublicKeyMetadata.js

@@ -1,127 +0,0 @@
-import { parseWebAuthnRpId } from "../../shared-ts/src/utils/domainIds.js";
-import { normalizeOptionalTrimmedString } from "../../shared-ts/src/utils/normalize.js";
-import "../../shared-ts/src/utils/validation.js";
-import { errorMessage } from "../../shared-ts/src/utils/errors.js";
-//#region src/core/authService/nearPublicKeyMetadata.ts
-function optionalPositiveInteger(input) {
-	const value = typeof input === "number" ? input : Number(input);
-	return Number.isFinite(value) && value >= 1 ? Math.floor(value) : null;
-}
-function optionalPositiveTimestamp(input) {
-	const value = typeof input === "number" ? input : Number(input);
-	return Number.isFinite(value) && value > 0 ? Math.floor(value) : null;
-}
-function nearPublicKeyAuthBinding(input) {
-	if (!input.credentialIdB64u && !input.rpIdRaw) return { ok: true };
-	if (!input.credentialIdB64u || !input.rpIdRaw) return {
-		ok: false,
-		message: "passkey near public key binding requires rpId and credentialIdB64u"
-	};
-	const rpId = parseWebAuthnRpId(input.rpIdRaw);
-	if (!rpId.ok) return {
-		ok: false,
-		message: rpId.error.message
-	};
-	return {
-		ok: true,
-		binding: {
-			kind: "passkey",
-			rpId: rpId.value,
-			credentialIdB64u: input.credentialIdB64u
-		}
-	};
-}
-function nearPublicKeyRecord(input) {
-	const record = {
-		version: "near_public_key_v1",
-		userId: input.userId,
-		publicKey: input.publicKey,
-		kind: input.kind,
-		createdAtMs: input.nowMs,
-		updatedAtMs: input.nowMs
-	};
-	if (input.signerSlot !== null) record.signerSlot = input.signerSlot;
-	if (input.authBinding) record.authBinding = input.authBinding;
-	if (input.addedTxHash) record.addedTxHash = input.addedTxHash;
-	if (input.removedAtMs !== null) record.removedAtMs = input.removedAtMs;
-	return record;
-}
-function nearPublicKeyListEntry(record) {
-	const entry = {
-		publicKey: record.publicKey,
-		kind: record.kind,
-		createdAtMs: record.createdAtMs,
-		updatedAtMs: record.updatedAtMs
-	};
-	if (typeof record.signerSlot === "number") entry.signerSlot = record.signerSlot;
-	if (record.authBinding) entry.authBinding = record.authBinding;
-	return entry;
-}
-async function recordNearPublicKeyMetadataWithStore(input) {
-	const userId = normalizeOptionalTrimmedString(input.userId);
-	const publicKey = normalizeOptionalTrimmedString(input.publicKey);
-	if (!userId || !publicKey) return {
-		ok: false,
-		code: "invalid_args",
-		message: "userId and publicKey are required"
-	};
-	const authBinding = nearPublicKeyAuthBinding({
-		credentialIdB64u: normalizeOptionalTrimmedString(input.credentialIdB64u),
-		rpIdRaw: normalizeOptionalTrimmedString(input.rpId)
-	});
-	if (!authBinding.ok) return {
-		ok: false,
-		code: "invalid_args",
-		message: authBinding.message
-	};
-	const record = nearPublicKeyRecord({
-		userId,
-		publicKey,
-		kind: input.kind,
-		signerSlot: optionalPositiveInteger(input.signerSlot),
-		authBinding: authBinding.binding,
-		addedTxHash: normalizeOptionalTrimmedString(input.addedTxHash),
-		removedAtMs: optionalPositiveTimestamp(input.removedAtMs),
-		nowMs: Date.now()
-	});
-	try {
-		await input.store.put(record);
-		return { ok: true };
-	} catch (error) {
-		const source = normalizeOptionalTrimmedString(input.source) || "near-public-key-metadata";
-		const message = errorMessage(error) || "Failed to persist NEAR public key metadata";
-		input.logger.warn(`[AuthService] ${source} failed for ${userId}`, error);
-		return {
-			ok: false,
-			code: "internal",
-			message
-		};
-	}
-}
-async function listNearPublicKeysForUserWithStore(input) {
-	try {
-		const userId = String(input.userId || "").trim();
-		if (!userId) return {
-			ok: false,
-			code: "invalid_args",
-			message: "Missing userId"
-		};
-		const records = await input.store.listByUserId(userId);
-		const keys = [];
-		for (const record of records || []) keys.push(nearPublicKeyListEntry(record));
-		return {
-			ok: true,
-			keys
-		};
-	} catch (e) {
-		return {
-			ok: false,
-			code: "internal",
-			message: errorMessage(e) || "Failed to list keys"
-		};
-	}
-}
-//#endregion
-export { listNearPublicKeysForUserWithStore, recordNearPublicKeyMetadataWithStore };
-
-//# sourceMappingURL=nearPublicKeyMetadata.js.map