@seams/wallet-server 0.6.2 → 0.7.3

package/dist/esm/hosted-wallet-gateway.js

@@ -16,6 +16,8 @@ import { handleWalletControlRequest } from "./router/cloudflare/runtime/walletCo
 import { resolveRuntimeTenantRootLineage } from "./router/cloudflare/runtime/walletConsoleTenantRootLineage.js";
 import { ROUTER_AB_MPC_ROUTER_ORIGIN, ROUTER_AB_SIGNING_WORKER_ORIGIN, createRouterAbServiceBindingFetch } from "./router/cloudflare/runtime/routerAbServiceBindings.js";
 import { readEnvironmentCsv, readEnvironmentString, requireEnvironmentString } from "./router/cloudflare/runtime/environment.js";
+import { createD1LinkedDeviceSourceContributionPreparationPlannerV1 } from "./router/cloudflare/d1/deviceLinking/d1LinkedDeviceSourceContributionPreparationPlanner.js";
+import { readD1LinkedDeviceEcdsaSourceV1, readD1LinkedDeviceEd25519SourceV1 } from "./router/cloudflare/d1/deviceLinking/d1LinkedDeviceAuthorityInstallService.js";
 import { RouterAbEd25519YaoExportOwnerProofAuthorizationAdapter } from "./router/domains/ed25519Yao/export/routerAbEd25519YaoExport.js";
 import { createRouterAbEd25519YaoHttpRegistrationBackendFromEnv } from "./router/domains/ed25519Yao/registration/routerAbEd25519YaoHttpRegistrationBackend.js";
 import { createRouterAbEd25519YaoProductRegistrationPartitionedStateStoreFromD1V1 } from "./router/cloudflare/d1/ed25519Yao/d1Ed25519YaoProductRegistrationPartitionedStateStore.js";
@@ -25,7 +27,6 @@ import { handleRouterAbEd25519YaoRegistrationRequestScopedCloudflareV1 } from ".
 import { CloudflareD1RouterAbEd25519YaoCapabilityPersistence } from "./router/cloudflare/d1/ed25519Yao/d1Ed25519YaoCapabilityPersistence.js";
 import { createSigningSessionSealOptions } from "./threshold/session/signingSessionSeal/options.js";
 import { createRouterAbEcdsaEd25519CeremonyTokenIssuer, createRouterAbEcdsaStrictPostRegistrationPort, createRouterAbEcdsaStrictRegistrationPort, parseRouterAbEcdsaEd25519PrivateJwk, parseRouterAbEcdsaStrictRegistrationTopology } from "./router/domains/ecdsa/routerAbEcdsaStrictRegistration.js";
-import { createD1LinkedDeviceSourceContributionPreparationPlannerV1 } from "./router/cloudflare/d1/deviceLinking/d1LinkedDeviceSourceContributionPreparationPlanner.js";
 import { D1LinkedDeviceTargetCredentialProviderV1 } from "./router/cloudflare/d1/deviceLinking/d1LinkedDeviceTargetCredentialProvider.js";
 import { createD1LinkedDeviceOwnerSourceChildReaderV1 } from "./router/cloudflare/d1/deviceLinking/d1LinkedDeviceOwnerAuthorizationProvider.js";
 import { createCloudflareD1RouterApiAuthService } from "./router/cloudflare/d1/auth/d1RouterApiAuthService.js";
@@ -83,7 +84,7 @@ function createStagingEd25519YaoBackend(env, resolveTenantRoot) {
 		env: {
 			MPC_ROUTER_URL: ROUTER_AB_MPC_ROUTER_ORIGIN,
 			SIGNING_WORKER_ID: requireEnvironmentString(env, "SIGNING_WORKER_ID"),
-			ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET: requireEnvironmentString(env, "ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET"),
+			ROUTER_AB_GATEWAY_TO_ROUTER_AUTH_SECRET: requireEnvironmentString(env, "ROUTER_AB_GATEWAY_TO_ROUTER_AUTH_SECRET"),
 			DERIVER_A_ED25519_YAO_INPUT_PUBLIC_KEY: keyEnvironment.DERIVER_A_ED25519_YAO_INPUT_PUBLIC_KEY,
 			DERIVER_B_ED25519_YAO_INPUT_PUBLIC_KEY: keyEnvironment.DERIVER_B_ED25519_YAO_INPUT_PUBLIC_KEY,
 			SIGNING_WORKER_SERVER_OUTPUT_HPKE_PUBLIC_KEY: keyEnvironment.SIGNING_WORKER_SERVER_OUTPUT_HPKE_PUBLIC_KEY
@@ -133,7 +134,10 @@ async function resolveStagingDeploymentTenantRoot(scope, tenantRootCustodyLineag
 	const identity = stagingTenantRootIdentity(scope, applicationBinding, signingRootVersion);
 	const tenantRoot = await tenantRootCustodyLineage.resolveActiveLineage(identity);
 	if (!tenantRoot) throw new Error("Ed25519 tenant root is not active");
-	return tenantRoot;
+	return {
+		identity,
+		...tenantRoot
+	};
 }
 async function resolveStagingRegistrationTenantRoot(context, input) {
 	switch (input.operation) {
@@ -208,7 +212,7 @@ async function createStagingRouterApiAuthComposition(env, scope, yaoRuntime, ten
 			relayerPublicKey: readEnvironmentString(env, "RELAYER_PUBLIC_KEY"),
 			relayerPrivateKey: readEnvironmentString(env, "RELAYER_PRIVATE_KEY"),
 			nearRpcUrl: readEnvironmentString(env, "NEAR_RPC_URL"),
-			signerWasmModuleOrPath: loadCloudflareSignerWasmModule,
+			signerWasmModuleOrPath: dependencies.signerWasm ?? loadCloudflareSignerWasmModule,
 			accountInitialBalance: readEnvironmentString(env, "ACCOUNT_INITIAL_BALANCE"),
 			implicitNearAccountTestFundingEnabled: readEnvironmentString(env, "ENABLE_IMPLICIT_NEAR_ACCOUNT_TEST_FUNDING"),
 			googleOidcClientId: readEnvironmentString(env, "GOOGLE_OIDC_CLIENT_ID"),
@@ -278,7 +282,15 @@ function stagingLinkedDeviceSessionComposition(env, scope, tenantRootCustodyLine
 			...scope,
 			ensureSchema: false
 		}),
-		walletStore
+		walletStore,
+		readLinkedEd25519SourceV1: readD1LinkedDeviceEd25519SourceV1.bind(void 0, {
+			database: env.SIGNER_DB,
+			scope
+		}),
+		readLinkedEcdsaSourceV1: readD1LinkedDeviceEcdsaSourceV1.bind(void 0, {
+			database: env.SIGNER_DB,
+			scope
+		})
 	});
 	const serviceFetch = createRouterAbServiceBindingFetch(env);
 	const internalServiceAuthSecret = requireEnvironmentString(env, "ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET");
@@ -306,30 +318,33 @@ function stagingLinkedDeviceSessionComposition(env, scope, tenantRootCustodyLine
 		authorityInstallation: {
 			reservationEndpoint: createCloudflareOrdinaryInactiveSignerMaterialReservationEndpointV1({
 				fetch: serviceFetch,
-				internalServiceAuthSecret
+				internalServiceAuthSecret,
+				tenant: scope
 			}),
 			activationEndpoint: createCloudflareOrdinaryInactiveSignerMaterialActivationEndpointV1({
 				fetch: serviceFetch,
-				internalServiceAuthSecret
+				internalServiceAuthSecret,
+				tenant: scope
 			}),
 			deactivationEndpoint: createCloudflareOrdinaryInactiveSignerMaterialDeactivationEndpointV1({
 				fetch: serviceFetch,
-				internalServiceAuthSecret
+				internalServiceAuthSecret,
+				tenant: scope
 			})
 		},
 		sourceContributionRouter: createCloudflareLinkedDeviceEd25519SourcePreservingRouterEndpointV1({
 			fetch: serviceFetch,
-			internalServiceAuthSecret,
+			internalServiceAuthSecret: requireEnvironmentString(env, "ROUTER_AB_GATEWAY_TO_ROUTER_AUTH_SECRET"),
 			resolveTenantRoot: createStagingLinkedDeviceTenantRootResolver(scope, tenantRootCustodyLineage)
 		})
 	} };
 }
 /**
-* The split Wallet Gateway (R105 Phase 4 cutover target): serves the Wallet
-* runtime only, holds no Console database binding, and reaches the Wallet
-* Console deployment exclusively through the exact service-binding ops.
-* The sponsored-relay route extensions stay on the Wallet Console deployment
-* until policy/sponsorship resolution operations join the binding.
+* The split Wallet Gateway: serves the Wallet runtime only, holds no Console
+* database binding, and reaches the Wallet Console deployment exclusively
+* through the exact service-binding ops. The sponsored-relay route extensions
+* stay on the Wallet Console deployment until policy/sponsorship resolution
+* operations join the binding.
 */
 async function createHostedWalletGatewayCompositionV1(env, dependencies = {}) {
 	const scope = stagingTenantScope(env);
@@ -352,7 +367,7 @@ async function createHostedWalletGatewayCompositionV1(env, dependencies = {}) {
 				sessionCookieName: readEnvironmentString(env, "SESSION_COOKIE_NAME"),
 				routerAbPublicKeyset: requireStagingRouterAbPublicKeyset(env),
 				routerAbNormalSigningRouterProxy: {
-					internalServiceAuthSecret: requireEnvironmentString(env, "ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET"),
+					internalServiceAuthSecret: requireEnvironmentString(env, "ROUTER_AB_GATEWAY_TO_ROUTER_AUTH_SECRET"),
 					fetch: (request) => env.MPC_ROUTER.fetch(request)
 				},
 				routerAbEcdsaStrictPostRegistration: ecdsaStrictPostRegistration,
@@ -494,6 +509,8 @@ function stagingSigningSessionSealOptions(env) {
 	return cachedStagingSigningSessionSealOptions;
 }
 function createStagingEcdsaPresignRuntime(env) {
+	const presignAuthSecret = requireEnvironmentString(env, "ROUTER_AB_GATEWAY_TO_SIGNING_WORKER_PRESIGN_AUTH_SECRET");
+	if (presignAuthSecret === requireEnvironmentString(env, "ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET") || presignAuthSecret === requireEnvironmentString(env, "ROUTER_AB_GATEWAY_TO_ROUTER_AUTH_SECRET")) throw new Error("Gateway-to-SigningWorker presign auth secret must be role-specific");
 	return new RouterAbEcdsaPresignRuntime({
 		config: {
 			nodeRole: "coordinator",
@@ -508,7 +525,7 @@ function createStagingEcdsaPresignRuntime(env) {
 			signingWorkerBaseUrl: ROUTER_AB_SIGNING_WORKER_ORIGIN,
 			auth: {
 				kind: "internal_service_auth_secret",
-				secret: requireEnvironmentString(env, "ROUTER_AB_INTERNAL_SERVICE_AUTH_SECRET")
+				secret: presignAuthSecret
 			},
 			fetchImpl: createRouterAbServiceBindingFetch(env)
 		},
@@ -638,7 +655,7 @@ function createStagingYaoRequestScopedRuntime(env, resolveTenantRoot) {
 * This is new composition wiring over the existing authorization classes, not a
 * second authorization implementation: the same adapter the tenant runtime uses
 * is constructed here against request-scoped state instead of runtime-held
-* state, which is the dependency Refactor 93 exists to remove.
+* state, which is the dependency this wiring exists to remove.
 */
 function createStagingRecoveryRequestScopedDependencies(env, tenantRootCustodyLineage, dependencies = {}) {
 	const scope = stagingTenantScope(env);

package/dist/esm/index.js

@@ -6,10 +6,10 @@ import { LocalWorkerVaultProxyGateway, VaultProxyUseService, buildVaultProxyUseO
 import { SessionService, buildCorsOrigins, parseCsvList } from "./core/SessionService.js";
 import { computeEip1559TxHash, encodeEip1559SignedTxFromSignature65, ensureEvmCryptoWasm, secp256k1PrivateKey32ToPublicKey33, secp256k1PublicKey33ToEthereumAddress, signSecp256k1Recoverable } from "./core/ThresholdService/evmCryptoWasm.js";
 import { THRESHOLD_DO_OBJECT_NAME_DEFAULT, THRESHOLD_NODE_ROLE_COORDINATOR, THRESHOLD_NODE_ROLE_DEFAULT, THRESHOLD_PREFIX_DEFAULT } from "./core/defaultConfigsServer.js";
+import { formatSigningSessionSealKeyVersionForWire, parseSigningSessionSealKeyVersion } from "./shared-ts/src/threshold/keyMaterialBrands.js";
 import { buildWalletEd25519SignerId, createWalletStore, resolveWalletStoreNamespace } from "./core/WalletStore.js";
 import { D1WalletStore, WALLET_STORE_D1_SCHEMA_SQL, buildWalletEcdsaSignerRecord, ensureWalletStoreD1Schema } from "./core/d1WalletStore.js";
 import { D1WalletAuthMethodStore, WALLET_AUTH_METHOD_STORE_D1_SCHEMA_SQL, ensureWalletAuthMethodStoreD1Schema, normalizeWalletAuthMethod } from "./core/d1WalletAuthMethodStore.js";
-import { formatSigningSessionSealKeyVersionForWire, parseSigningSessionSealKeyVersion } from "./core/keyMaterialBrands.js";
 import { RouterAbEcdsaPresignRuntime } from "./core/routerAbSigning/RouterAbEcdsaPresignRuntime.js";
 import { registrationPreparationIdFromString } from "./core/types.js";
 import { InMemoryRouterAbNormalSigningAdmissionStore, createInMemoryRouterAbNormalSigningAdmissionAdapter, createInMemoryRouterAbNormalSigningAdmissionStore, createRouterAbNormalSigningAdmissionAdapter } from "./router/domains/signingOperations/routerAbNormalSigningAdmissionCore.js";
@@ -28,6 +28,7 @@ import { createSigningSessionSealService } from "./threshold/session/signingSess
 import { createSigningSessionSealRoutesOptions } from "./threshold/session/signingSessionSeal/routesOptions.js";
 import { createSigningSessionSealOptions, parseSigningSessionSealRootConfig } from "./threshold/session/signingSessionSeal/options.js";
 import { D1IdentityStore, IDENTITY_STORE_D1_SCHEMA_SQL, ensureIdentityStoreD1Schema } from "./core/d1IdentityStore.js";
+import { D1NearPublicKeyStore, NEAR_PUBLIC_KEY_STORE_D1_SCHEMA_SQL, createNearPublicKeyStore, ensureNearPublicKeyStoreD1Schema } from "./core/NearPublicKeyStore.js";
 import { AUTH_SERVICE_CONFIG_DEFAULTS, createAuthServiceConfig, parseBool, requireEnvVar, validateConfigs } from "./core/config.js";
 import { createEcdsaWalletSessionStore, createEd25519WalletSessionStore } from "./core/ThresholdService/stores/WalletSessionStore.js";
 import { createRouterAbSigningRuntimes } from "./core/routerAbSigning/createRouterAbSigningRuntimes.js";
@@ -37,7 +38,6 @@ import { createRedisTcpSigningSessionSealIdempotencyStore, createUpstashSigningS
 import { registerSigningSessionSealRoutes } from "./threshold/session/signingSessionSeal/transport/express.js";
 import "./threshold/session/signingSessionSeal/index.js";
 import { createIdentityStore, resolveIdentityStoreNamespace } from "./core/IdentityStore.js";
-import { D1NearPublicKeyStore, NEAR_PUBLIC_KEY_STORE_D1_SCHEMA_SQL, createNearPublicKeyStore, ensureNearPublicKeyStoreD1Schema } from "./core/NearPublicKeyStore.js";
 import { createWalletAuthMethodStore, resolveWalletAuthMethodStoreNamespace } from "./core/WalletAuthMethodStore.js";
 import { D1WebAuthnAuthenticatorStore, WEBAUTHN_AUTHENTICATOR_STORE_D1_SCHEMA_SQL, createWebAuthnAuthenticatorStore, ensureWebAuthnAuthenticatorStoreD1Schema, resolveWebAuthnAuthenticatorStoreNamespace } from "./core/WebAuthnAuthenticatorStore.js";
 import { D1WebAuthnLoginChallengeStore, WEBAUTHN_LOGIN_CHALLENGE_STORE_D1_SCHEMA_SQL, createWebAuthnLoginChallengeStore, ensureWebAuthnLoginChallengeStoreD1Schema } from "./core/WebAuthnLoginChallengeStore.js";

package/dist/esm/local-hosted-wallet-gateway-worker.js

@@ -1,30 +1,9 @@
-import "./shared-ts/src/utils/routerAbEd25519Yao.js";
 import { runRouterAbPrewarmScheduledV1 } from "./router/cloudflare/runtime/routerAbPrewarm.js";
-import { createStaticWalletConsoleBindingV1, parseStaticWalletConsoleBindingConfigV1 } from "./router/cloudflare/runtime/staticWalletConsoleBinding.js";
 import "./cloud-host.js";
-import { handleSplitGatewayRequest } from "./hosted-wallet-gateway.js";
-import { LOCAL_INTENDED_YAO_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoFaultControllerV1, parseLocalIntendedYaoFaultModeV1, parseLocalIntendedYaoFaultTokenV1, requestWithoutLocalIntendedYaoFaultHeadersV1, responseWithLocalIntendedYaoFaultOutcomeV1 } from "./localIntendedYaoFault.js";
+import { handleLocalHostedWalletGatewayRequestV1 } from "./localHostedWalletGatewayHandler.js";
 //#region src/local-hosted-wallet-gateway-worker.ts
 async function fetch(request, env, ctx) {
-	const config = parseStaticWalletConsoleBindingConfigV1(JSON.parse(env.WALLET_LOCAL_DEPLOYMENT_JSON));
-	const gatewayEnv = {
-		...env,
-		WALLET_CONSOLE: createStaticWalletConsoleBindingV1(config)
-	};
-	const rawMode = request.headers.get(LOCAL_INTENDED_YAO_FAULT_HEADER_V1);
-	const rawToken = request.headers.get(LOCAL_INTENDED_YAO_FAULT_TOKEN_HEADER_V1);
-	const sanitizedRequest = requestWithoutLocalIntendedYaoFaultHeadersV1(request);
-	if (rawMode === null && rawToken === null) return await handleSplitGatewayRequest(sanitizedRequest, gatewayEnv, ctx);
-	const mode = parseLocalIntendedYaoFaultModeV1(rawMode);
-	const token = parseLocalIntendedYaoFaultTokenV1(rawToken);
-	const url = new URL(request.url);
-	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/router-ab/ed25519/yao/registration/execute" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_yao_fault" }, { status: 400 });
-	const controller = new LocalIntendedYaoFaultControllerV1(env.MPC_ROUTER.fetch.bind(env.MPC_ROUTER));
-	controller.arm(mode);
-	return responseWithLocalIntendedYaoFaultOutcomeV1(await handleSplitGatewayRequest(sanitizedRequest, {
-		...gatewayEnv,
-		MPC_ROUTER: controller
-	}, ctx), controller.consumeOutcome(), token);
+	return await handleLocalHostedWalletGatewayRequestV1(request, env, ctx);
 }
 async function scheduled(event, env, _ctx) {
 	await runRouterAbPrewarmScheduledV1(event, env);

package/dist/esm/localHostedWalletGatewayHandler.js

@@ -0,0 +1,312 @@
+import "./shared-ts/src/utils/routerAbEd25519Yao.js";
+import { WALLET_CONSOLE_OP_PATHS_V1 } from "./router/cloudflare/runtime/walletConsoleOps.js";
+import { createStaticWalletConsoleBindingV1, parseStaticWalletConsoleBindingConfigV1 } from "./router/cloudflare/runtime/staticWalletConsoleBinding.js";
+import { handleSplitGatewayRequest } from "./hosted-wallet-gateway.js";
+import { localPresignCancellationProbe } from "./localIntendedPresignCancellation.js";
+import { LOCAL_INTENDED_YAO_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoFaultControllerV1, parseLocalIntendedYaoFaultModeV1, parseLocalIntendedYaoFaultTokenV1, requestWithoutLocalIntendedYaoFaultHeadersV1, responseWithLocalIntendedYaoFaultOutcomeV1 } from "./localIntendedYaoFault.js";
+import { localMaterialAdmissionFault } from "./localIntendedMaterialAdmissionFault.js";
+import { LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_HEADER_V1, LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_TOKEN_HEADER_V1, LocalIntendedEcdsaFinalizeFaultControllerV1, parseLocalIntendedEcdsaFinalizeFaultModeV1, parseLocalIntendedEcdsaFinalizeFaultTokenV1, requestWithoutLocalIntendedEcdsaFinalizeFaultHeadersV1, responseWithLocalIntendedEcdsaFinalizeFaultOutcomeV1 } from "./localIntendedEcdsaFinalizeFault.js";
+import { LOCAL_INTENDED_YAO_FINALIZE_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_FINALIZE_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoFinalizeFaultDatabaseV1, parseLocalIntendedYaoFinalizeFaultModeV1, parseLocalIntendedYaoFinalizeFaultTokenV1, requestWithoutLocalIntendedYaoFinalizeFaultHeadersV1, responseWithLocalIntendedYaoFinalizeFaultOutcomeV1 } from "./localIntendedYaoFinalizeFault.js";
+import { LOCAL_INTENDED_YAO_RECOVERY_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_RECOVERY_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoRecoveryFaultControllerV1, parseLocalIntendedYaoRecoveryFaultModeV1, parseLocalIntendedYaoRecoveryFaultTokenV1, releaseLocalIntendedYaoRecoveryExecuteV1, requestWithoutLocalIntendedYaoRecoveryFaultHeadersV1, responseWithLocalIntendedYaoRecoveryFaultOutcomeV1 } from "./localIntendedYaoRecoveryFault.js";
+import { LOCAL_INTENDED_YAO_EXPORT_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_EXPORT_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoExportFaultDatabaseV1, parseLocalIntendedYaoExportFaultModeV1, parseLocalIntendedYaoExportFaultTokenV1, requestWithoutLocalIntendedYaoExportFaultHeadersV1, responseWithLocalIntendedYaoExportFaultOutcomeV1 } from "./localIntendedYaoExportFault.js";
+import { LOCAL_INTENDED_YAO_SIGNING_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_SIGNING_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoSigningFaultControllerV1, commandLocalIntendedSigningWorkerHoldV1, parseLocalIntendedYaoSigningFaultModeV1, parseLocalIntendedYaoSigningFaultTokenV1, releaseLocalIntendedYaoSigningFinalizeV1, requestWithoutLocalIntendedYaoSigningFaultHeadersV1, responseWithLocalIntendedYaoSigningFaultOutcomeV1 } from "./localIntendedYaoSigningFault.js";
+import { LOCAL_INTENDED_LINK_EXECUTE_FAULT_HEADER_V1, LOCAL_INTENDED_LINK_EXECUTE_FAULT_TOKEN_HEADER_V1, LocalIntendedLinkExecuteFaultControllerV1, parseLocalIntendedLinkExecuteFaultModeV1, parseLocalIntendedLinkExecuteFaultTokenV1, requestWithoutLocalIntendedLinkExecuteFaultHeadersV1, responseWithLocalIntendedLinkExecuteFaultOutcomeV1 } from "./localIntendedLinkExecuteFault.js";
+import { LINKED_DEVICE_REVOKE_PATH_PATTERN_V1, LOCAL_INTENDED_REVOKE_FAULT_HEADER_V1, LOCAL_INTENDED_REVOKE_FAULT_TOKEN_HEADER_V1, LocalIntendedRevokeFaultDatabaseV1, WALLET_REVOKE_AUTH_METHOD_PATH_PATTERN_V1, parseLocalIntendedRevokeFaultModeV1, parseLocalIntendedRevokeFaultTokenV1, requestWithoutLocalIntendedRevokeFaultHeadersV1, responseWithLocalIntendedRevokeFaultOutcomeV1 } from "./localIntendedRevokeFault.js";
+import { LOCAL_INTENDED_SESSION_ADMISSION_FAULT_HEADER_V1, LOCAL_INTENDED_SESSION_ADMISSION_FAULT_TOKEN_HEADER_V1, LocalIntendedSessionAdmissionFaultDatabaseV1, parseLocalIntendedSessionAdmissionFaultModeV1, parseLocalIntendedSessionAdmissionFaultTokenV1, requestWithoutLocalIntendedSessionAdmissionFaultHeadersV1, responseWithLocalIntendedSessionAdmissionFaultOutcomeV1 } from "./localIntendedSessionAdmissionFault.js";
+//#region src/localHostedWalletGatewayHandler.ts
+const ECDSA_RESPOND_FAULT_HEADER = "x-seams-intended-ecdsa-respond-fault-v1";
+const ECDSA_RESPOND_FAULT_PROOF_HEADER = "x-seams-intended-ecdsa-respond-proof-v1";
+const ECDSA_REGISTRATION_PATH = "/router-ab/ecdsa-derivation/register";
+const REGISTRATION_RESPOND_PATH = "/wallets/register/respond";
+const LINK_SOURCE_CONTRIBUTION_EXECUTE_PATH = /^\/wallet\/device-linking\/v1\/sessions\/[^/]+\/source-contribution\/execute$/;
+var DropEcdsaRouterReply = class {
+	constructor(baseFetch) {
+		this.baseFetch = baseFetch;
+		this.observed = false;
+	}
+	async fetch(input, init) {
+		const request = new Request(input, init);
+		const response = await this.baseFetch(request);
+		if (request.method === "POST" && new URL(request.url).pathname === ECDSA_REGISTRATION_PATH) {
+			if (!response.ok) return response;
+			await response.clone().arrayBuffer();
+			this.observed = true;
+			throw new Error("Local ECDSA fault dropped the completed Router registration reply");
+		}
+		return response;
+	}
+};
+var UnavailableTenantRootLineage = class {
+	constructor(base) {
+		this.base = base;
+		this.lookups = 0;
+	}
+	async fetch(input, init) {
+		const request = input instanceof Request ? input : new Request(input, init);
+		if (new URL(request.url).pathname === WALLET_CONSOLE_OP_PATHS_V1.tenantRootActiveLineage) {
+			this.lookups += 1;
+			return Response.json({
+				ok: false,
+				message: "Local lineage lookup unavailable"
+			}, { status: 503 });
+		}
+		return await this.base.fetch(request);
+	}
+};
+function withoutEcdsaRespondFaultHeader(request) {
+	const headers = new Headers(request.headers);
+	headers.delete(ECDSA_RESPOND_FAULT_HEADER);
+	return new Request(request, { headers });
+}
+function withEcdsaRespondFaultProof(response, proof, environmentKey, projectEnvironmentId) {
+	const headers = new Headers(response.headers);
+	headers.set(ECDSA_RESPOND_FAULT_PROOF_HEADER, proof);
+	headers.set("x-seams-intended-ecdsa-environment-key-v1", environmentKey);
+	headers.set("x-seams-intended-ecdsa-environment-id-v1", projectEnvironmentId);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+async function handleEcdsaRespondFault(request, env, ctx, dependencies, fault, environmentKey, projectEnvironmentId) {
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== REGISTRATION_RESPOND_PATH || request.method !== "POST") return Response.json({ code: "invalid_intended_ecdsa_fault" }, { status: 400 });
+	const sanitizedRequest = withoutEcdsaRespondFaultHeader(request);
+	if (fault === "drop_router_reply") {
+		const router = new DropEcdsaRouterReply(env.MPC_ROUTER.fetch.bind(env.MPC_ROUTER));
+		let response;
+		try {
+			response = await handleSplitGatewayRequest(sanitizedRequest, {
+				...env,
+				MPC_ROUTER: router
+			}, ctx, dependencies);
+		} catch {
+			response = Response.json({ code: "router_reply_lost" }, { status: 503 });
+		}
+		return withEcdsaRespondFaultProof(response, router.observed ? "router_reply_dropped" : "router_reply_not_dropped", environmentKey, projectEnvironmentId);
+	}
+	if (fault === "unavailable_lineage") {
+		const console = new UnavailableTenantRootLineage(env.WALLET_CONSOLE);
+		return withEcdsaRespondFaultProof(await handleSplitGatewayRequest(sanitizedRequest, {
+			...env,
+			WALLET_CONSOLE: console
+		}, ctx, dependencies), `lineage_lookups:${console.lookups}`, environmentKey, projectEnvironmentId);
+	}
+	return Response.json({ code: "invalid_intended_ecdsa_fault" }, { status: 400 });
+}
+/**
+* The local Gateway: the hosted Gateway handler plus the intended-suite
+* transport faults, which a request arms with local-only headers. The local
+* Worker and the local Node host both serve through this.
+*/
+async function handleLocalHostedWalletGatewayRequestV1(request, env, ctx, dependencies) {
+	const config = parseStaticWalletConsoleBindingConfigV1(JSON.parse(env.WALLET_LOCAL_DEPLOYMENT_JSON));
+	const gatewayEnv = {
+		...env,
+		WALLET_CONSOLE: createStaticWalletConsoleBindingV1(config)
+	};
+	const canceledPresign = await localPresignCancellationProbe(request, gatewayEnv, ctx, dependencies);
+	if (canceledPresign) return canceledPresign;
+	const ecdsaFault = request.headers.get(ECDSA_RESPOND_FAULT_HEADER);
+	if (ecdsaFault !== null) return await handleEcdsaRespondFault(request, gatewayEnv, ctx, dependencies, ecdsaFault, config.deployment.environmentKey, config.deployment.environmentId);
+	const ecdsaFinalizeMode = request.headers.get(LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_HEADER_V1);
+	const ecdsaFinalizeToken = request.headers.get(LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_TOKEN_HEADER_V1);
+	if (ecdsaFinalizeMode !== null || ecdsaFinalizeToken !== null) return await handleEcdsaFinalizeFault(request, gatewayEnv, ctx, dependencies, ecdsaFinalizeMode, ecdsaFinalizeToken);
+	const yaoRecoveryMode = request.headers.get(LOCAL_INTENDED_YAO_RECOVERY_FAULT_HEADER_V1);
+	const yaoRecoveryToken = request.headers.get(LOCAL_INTENDED_YAO_RECOVERY_FAULT_TOKEN_HEADER_V1);
+	if (yaoRecoveryMode !== null || yaoRecoveryToken !== null) return await handleYaoRecoveryFault(request, gatewayEnv, ctx, dependencies, yaoRecoveryMode, yaoRecoveryToken);
+	const yaoSigningMode = request.headers.get(LOCAL_INTENDED_YAO_SIGNING_FAULT_HEADER_V1);
+	const yaoSigningToken = request.headers.get(LOCAL_INTENDED_YAO_SIGNING_FAULT_TOKEN_HEADER_V1);
+	if (yaoSigningMode !== null || yaoSigningToken !== null) return await handleYaoSigningFault(request, gatewayEnv, ctx, dependencies, yaoSigningMode, yaoSigningToken);
+	const yaoExportMode = request.headers.get(LOCAL_INTENDED_YAO_EXPORT_FAULT_HEADER_V1);
+	const yaoExportToken = request.headers.get(LOCAL_INTENDED_YAO_EXPORT_FAULT_TOKEN_HEADER_V1);
+	if (yaoExportMode !== null || yaoExportToken !== null) return await handleYaoExportFault(request, gatewayEnv, ctx, dependencies, yaoExportMode, yaoExportToken);
+	const yaoFinalizeMode = request.headers.get(LOCAL_INTENDED_YAO_FINALIZE_FAULT_HEADER_V1);
+	const yaoFinalizeToken = request.headers.get(LOCAL_INTENDED_YAO_FINALIZE_FAULT_TOKEN_HEADER_V1);
+	if (yaoFinalizeMode !== null || yaoFinalizeToken !== null) return await handleYaoFinalizeFault(request, gatewayEnv, ctx, dependencies, yaoFinalizeMode, yaoFinalizeToken);
+	const linkExecuteMode = request.headers.get(LOCAL_INTENDED_LINK_EXECUTE_FAULT_HEADER_V1);
+	const linkExecuteToken = request.headers.get(LOCAL_INTENDED_LINK_EXECUTE_FAULT_TOKEN_HEADER_V1);
+	if (linkExecuteMode !== null || linkExecuteToken !== null) return await handleLinkExecuteFault(request, gatewayEnv, ctx, dependencies, linkExecuteMode, linkExecuteToken);
+	const revokeMode = request.headers.get(LOCAL_INTENDED_REVOKE_FAULT_HEADER_V1);
+	const revokeToken = request.headers.get(LOCAL_INTENDED_REVOKE_FAULT_TOKEN_HEADER_V1);
+	if (revokeMode !== null || revokeToken !== null) return await handleRevokeFault(request, gatewayEnv, ctx, dependencies, revokeMode, revokeToken);
+	const materialFault = localMaterialAdmissionFault(request, gatewayEnv.SIGNER_DB);
+	if (materialFault instanceof Response) return materialFault;
+	if (materialFault) {
+		const response = await handleSplitGatewayRequest(materialFault.request, {
+			...gatewayEnv,
+			SIGNER_DB: materialFault.database
+		}, ctx, dependencies);
+		return materialFault.database.response(response, materialFault.token);
+	}
+	const admissionMode = request.headers.get(LOCAL_INTENDED_SESSION_ADMISSION_FAULT_HEADER_V1);
+	const admissionToken = request.headers.get(LOCAL_INTENDED_SESSION_ADMISSION_FAULT_TOKEN_HEADER_V1);
+	if (admissionMode !== null || admissionToken !== null) return await handleSessionAdmissionFault(request, gatewayEnv, ctx, dependencies, admissionMode, admissionToken);
+	const rawMode = request.headers.get(LOCAL_INTENDED_YAO_FAULT_HEADER_V1);
+	const rawToken = request.headers.get(LOCAL_INTENDED_YAO_FAULT_TOKEN_HEADER_V1);
+	const sanitizedRequest = requestWithoutLocalIntendedYaoFaultHeadersV1(request);
+	if (rawMode === null && rawToken === null) return await handleSplitGatewayRequest(sanitizedRequest, gatewayEnv, ctx, dependencies);
+	const mode = parseLocalIntendedYaoFaultModeV1(rawMode);
+	const token = parseLocalIntendedYaoFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/router-ab/ed25519/yao/registration/execute" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_yao_fault" }, { status: 400 });
+	const controller = new LocalIntendedYaoFaultControllerV1(env.MPC_ROUTER.fetch.bind(env.MPC_ROUTER));
+	controller.arm(mode);
+	return responseWithLocalIntendedYaoFaultOutcomeV1(await handleSplitGatewayRequest(sanitizedRequest, {
+		...gatewayEnv,
+		MPC_ROUTER: controller
+	}, ctx, dependencies), controller.consumeOutcome(), token);
+}
+/**
+* Lets the Router run one linked device's source-preserving execution, then
+* loses its answer, so the Gateway's retry must recover the reservation the
+* Router already made. Local only.
+*/
+async function handleLinkExecuteFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedLinkExecuteFaultModeV1(rawMode);
+	const token = parseLocalIntendedLinkExecuteFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || !LINK_SOURCE_CONTRIBUTION_EXECUTE_PATH.test(url.pathname) || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_link_execute_fault" }, { status: 400 });
+	const controller = new LocalIntendedLinkExecuteFaultControllerV1(env.MPC_ROUTER.fetch.bind(env.MPC_ROUTER));
+	return responseWithLocalIntendedLinkExecuteFaultOutcomeV1(await handleSplitGatewayRequest(requestWithoutLocalIntendedLinkExecuteFaultHeadersV1(request), {
+		...env,
+		MPC_ROUTER: controller
+	}, ctx, dependencies), controller.outcome(), token);
+}
+/**
+* Faults one Ed25519 Yao recovery execution on its way to the Router: loses
+* every reply after the Router ran it, or keeps it from the Router, or sends
+* a kept one to the Router now. Local only.
+*/
+async function handleYaoRecoveryFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedYaoRecoveryFaultModeV1(rawMode);
+	const token = parseLocalIntendedYaoRecoveryFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/router-ab/ed25519/yao/recovery/execute" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_yao_recovery_fault" }, { status: 400 });
+	if (mode === "release_router_recovery_execute") return await releaseLocalIntendedYaoRecoveryExecuteV1(env.MPC_ROUTER, token);
+	const controller = new LocalIntendedYaoRecoveryFaultControllerV1(env.MPC_ROUTER.fetch.bind(env.MPC_ROUTER), mode, token);
+	return responseWithLocalIntendedYaoRecoveryFaultOutcomeV1(await handleSplitGatewayRequest(requestWithoutLocalIntendedYaoRecoveryFaultHeadersV1(request), {
+		...env,
+		MPC_ROUTER: controller
+	}, ctx, dependencies), controller.outcome(), token);
+}
+/**
+* Holds one ECDSA signing prepare after its Wallet Session read until another
+* request changes the wallet's authority, and reports whether it did. Local
+* only.
+*/
+async function handleSessionAdmissionFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedSessionAdmissionFaultModeV1(rawMode);
+	const token = parseLocalIntendedSessionAdmissionFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/router-ab/ecdsa-derivation/sign/prepare" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_session_admission_fault" }, { status: 400 });
+	const database = new LocalIntendedSessionAdmissionFaultDatabaseV1(env.SIGNER_DB);
+	return responseWithLocalIntendedSessionAdmissionFaultOutcomeV1(await handleSplitGatewayRequest(requestWithoutLocalIntendedSessionAdmissionFaultHeadersV1(request), {
+		...env,
+		SIGNER_DB: database
+	}, ctx, dependencies), database.outcome(), token);
+}
+/**
+* Refuses the batch that would commit one auth-method revocation, as a failed
+* commit, and reports whether the request's Email OTP code was spent anywhere
+* but in that batch. Local only.
+*/
+async function handleRevokeFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedRevokeFaultModeV1(rawMode);
+	const token = parseLocalIntendedRevokeFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || !(WALLET_REVOKE_AUTH_METHOD_PATH_PATTERN_V1.test(url.pathname) || LINKED_DEVICE_REVOKE_PATH_PATTERN_V1.test(url.pathname)) || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_revoke_fault" }, { status: 400 });
+	const database = new LocalIntendedRevokeFaultDatabaseV1(env.SIGNER_DB);
+	return responseWithLocalIntendedRevokeFaultOutcomeV1(await handleSplitGatewayRequest(requestWithoutLocalIntendedRevokeFaultHeadersV1(request), {
+		...env,
+		SIGNER_DB: database
+	}, ctx, dependencies), database.outcome(), token);
+}
+/**
+* Loses the Gateway's storage once during one Ed25519 Yao NEAR finalize,
+* right after the batch that made the registration visible committed its
+* decision. Local only.
+*/
+async function handleYaoFinalizeFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedYaoFinalizeFaultModeV1(rawMode);
+	const token = parseLocalIntendedYaoFinalizeFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/wallets/register/near-provisioning" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_yao_finalize_fault" }, { status: 400 });
+	const database = new LocalIntendedYaoFinalizeFaultDatabaseV1(env.SIGNER_DB);
+	return responseWithLocalIntendedYaoFinalizeFaultOutcomeV1(await handleSplitGatewayRequest(requestWithoutLocalIntendedYaoFinalizeFaultHeadersV1(request), {
+		...env,
+		SIGNER_DB: database
+	}, ctx, dependencies), database.outcome(), token);
+}
+/**
+* Keeps one NEAR finalize the Gateway sends the Router after authorizing it,
+* run or withheld, or sends a kept one to the Router again: a request
+* authorized before a recovery, arriving after it. Local only.
+*/
+async function handleYaoSigningFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedYaoSigningFaultModeV1(rawMode);
+	const token = parseLocalIntendedYaoSigningFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/router-ab/ed25519/sign" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_yao_signing_fault" }, { status: 400 });
+	if (mode === "release_signing_finalize") return await releaseLocalIntendedYaoSigningFinalizeV1(env.MPC_ROUTER, token);
+	if (mode === "arm_signing_worker_hold" || mode === "read_signing_worker_hold") return await commandLocalIntendedSigningWorkerHoldV1(env.SIGNING_WORKER, env.ROUTER_AB_GATEWAY_TO_SIGNING_WORKER_PRESIGN_AUTH_SECRET, mode, await request.json().catch(() => null));
+	const controller = new LocalIntendedYaoSigningFaultControllerV1(env.MPC_ROUTER.fetch.bind(env.MPC_ROUTER), mode, token);
+	return responseWithLocalIntendedYaoSigningFaultOutcomeV1(await handleSplitGatewayRequest(requestWithoutLocalIntendedYaoSigningFaultHeadersV1(request), {
+		...env,
+		MPC_ROUTER: controller
+	}, ctx, dependencies), controller.outcome());
+}
+/**
+* Loses the Gateway's storage once during one Ed25519 Yao export admission,
+* right after the batch that authorized the export committed, then sends the
+* identical request again inside this Gateway request. The client sees only
+* the second answer. Local only.
+*/
+async function handleYaoExportFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedYaoExportFaultModeV1(rawMode);
+	const token = parseLocalIntendedYaoExportFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/router-ab/ed25519/yao/export/admit" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_yao_export_fault" }, { status: 400 });
+	const sanitized = requestWithoutLocalIntendedYaoExportFaultHeadersV1(request);
+	const body = await sanitized.arrayBuffer();
+	const database = new LocalIntendedYaoExportFaultDatabaseV1(env.SIGNER_DB);
+	const interrupted = await handleSplitGatewayRequest(new Request(sanitized.url, {
+		method: "POST",
+		headers: sanitized.headers,
+		body
+	}), {
+		...env,
+		SIGNER_DB: database
+	}, ctx, dependencies);
+	await interrupted.arrayBuffer();
+	const retried = await handleSplitGatewayRequest(new Request(sanitized.url, {
+		method: "POST",
+		headers: sanitized.headers,
+		body
+	}), env, ctx, dependencies);
+	return responseWithLocalIntendedYaoExportFaultOutcomeV1(retried, database.outcome({
+		interruptedOk: interrupted.ok,
+		retriedOk: retried.ok
+	}), token);
+}
+/**
+* Loses the Router's response to one admitted ECDSA finalize and sends the
+* identical request again, inside this Gateway request and before the Gateway
+* records any outcome. Local only.
+*/
+async function handleEcdsaFinalizeFault(request, env, ctx, dependencies, rawMode, rawToken) {
+	const mode = parseLocalIntendedEcdsaFinalizeFaultModeV1(rawMode);
+	const token = parseLocalIntendedEcdsaFinalizeFaultTokenV1(rawToken);
+	const url = new URL(request.url);
+	if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/router-ab/ecdsa-derivation/sign" || request.method !== "POST" || !mode || !token) return Response.json({ code: "invalid_intended_ecdsa_finalize_fault" }, { status: 400 });
+	const controller = new LocalIntendedEcdsaFinalizeFaultControllerV1(env.MPC_ROUTER.fetch.bind(env.MPC_ROUTER));
+	return responseWithLocalIntendedEcdsaFinalizeFaultOutcomeV1(await handleSplitGatewayRequest(requestWithoutLocalIntendedEcdsaFinalizeFaultHeadersV1(request), {
+		...env,
+		MPC_ROUTER: controller
+	}, ctx, dependencies), controller.consumeOutcome(), token);
+}
+//#endregion
+export { handleLocalHostedWalletGatewayRequestV1 };
+
+//# sourceMappingURL=localHostedWalletGatewayHandler.js.map

package/dist/esm/localIntendedEcdsaFinalizeFault.js

@@ -0,0 +1,85 @@
+import { isLocalIntendedYaoFaultTokenV1 } from "./localIntendedYaoFault.js";
+//#region src/localIntendedEcdsaFinalizeFault.ts
+const LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_HEADER_V1 = "x-seams-intended-ecdsa-finalize-fault-v1";
+const LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_TOKEN_HEADER_V1 = "x-seams-intended-ecdsa-finalize-fault-token-v1";
+const LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_PROOF_HEADER_V1 = "x-seams-intended-ecdsa-finalize-fault-proof-v1";
+const ROUTER_AB_ECDSA_FINALIZE_PATH_V1 = "/router-ab/ecdsa-derivation/sign";
+function parseLocalIntendedEcdsaFinalizeFaultModeV1(value) {
+	return value === "drop_router_response_once" ? value : null;
+}
+function parseLocalIntendedEcdsaFinalizeFaultTokenV1(value) {
+	return isLocalIntendedYaoFaultTokenV1(value) ? value : null;
+}
+var LocalIntendedEcdsaFinalizeFaultControllerV1 = class {
+	constructor(baseFetch) {
+		this.baseFetch = baseFetch;
+		this.state = { kind: "armed" };
+	}
+	async fetch(input, init) {
+		const request = new Request(input, init);
+		if (request.method !== "POST" || new URL(request.url).pathname !== "/router-ab/ecdsa-derivation/sign") return await this.baseFetch.call(globalThis, request);
+		if (this.state.kind !== "armed") {
+			this.state = {
+				kind: "violated",
+				violation: "unexpected_additional_finalize"
+			};
+			throw new Error("Local intended ECDSA fault observed an additional Router finalize");
+		}
+		const body = await request.clone().arrayBuffer();
+		const first = await this.baseFetch.call(globalThis, request.clone());
+		const firstBody = await first.text();
+		if (!first.ok) {
+			this.state = {
+				kind: "violated",
+				violation: "router_first_response_failed"
+			};
+			return new Response(firstBody, first);
+		}
+		const retry = await this.baseFetch.call(globalThis, new Request(request.url, {
+			method: "POST",
+			headers: request.headers,
+			body
+		}));
+		const retryBody = await retry.text();
+		if (!retry.ok) this.state = {
+			kind: "violated",
+			violation: "router_retry_response_failed"
+		};
+		else if (JSON.stringify(JSON.parse(retryBody)) !== JSON.stringify(JSON.parse(firstBody))) this.state = {
+			kind: "violated",
+			violation: "router_retry_changed_response"
+		};
+		else this.state = {
+			kind: "proved",
+			proof: "stored_signature_replayed"
+		};
+		return new Response(retryBody, retry);
+	}
+	consumeOutcome() {
+		const current = this.state;
+		return current.kind === "armed" ? {
+			kind: "violated",
+			violation: "router_finalize_not_observed"
+		} : current;
+	}
+};
+function requestWithoutLocalIntendedEcdsaFinalizeFaultHeadersV1(request) {
+	const headers = new Headers(request.headers);
+	headers.delete(LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_HEADER_V1);
+	headers.delete(LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_TOKEN_HEADER_V1);
+	return new Request(request, { headers });
+}
+function responseWithLocalIntendedEcdsaFinalizeFaultOutcomeV1(response, outcome, token) {
+	const headers = new Headers(response.headers);
+	const proof = outcome.kind === "proved" ? outcome.proof : `violation:${outcome.violation}`;
+	headers.set(LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_PROOF_HEADER_V1, `${token}:${proof}`);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_HEADER_V1, LOCAL_INTENDED_ECDSA_FINALIZE_FAULT_TOKEN_HEADER_V1, LocalIntendedEcdsaFinalizeFaultControllerV1, ROUTER_AB_ECDSA_FINALIZE_PATH_V1, parseLocalIntendedEcdsaFinalizeFaultModeV1, parseLocalIntendedEcdsaFinalizeFaultTokenV1, requestWithoutLocalIntendedEcdsaFinalizeFaultHeadersV1, responseWithLocalIntendedEcdsaFinalizeFaultOutcomeV1 };
+
+//# sourceMappingURL=localIntendedEcdsaFinalizeFault.js.map