@plasius/economy 0.9.0 → 0.11.0

package/dist/index.js

@@ -1903,6 +1903,7 @@ var COMMAND_SOURCES = /* @__PURE__ */ new Set([
   "shopify",
   "ayet",
   "bitlabs",
+  "google-ad-manager",
   "operator",
   "system"
 ]);
@@ -1915,7 +1916,8 @@ var PRINCIPAL_TYPES = /* @__PURE__ */ new Set([
 var PROVIDER_SOURCES = /* @__PURE__ */ new Set([
   "shopify",
   "ayet",
-  "bitlabs"
+  "bitlabs",
+  "google-ad-manager"
 ]);
 var CAUSATION_KINDS = /* @__PURE__ */ new Set([
   "provider-event",
@@ -1927,10 +1929,12 @@ var CAUSATION_KINDS = /* @__PURE__ */ new Set([
 var PROVIDERS = /* @__PURE__ */ new Set([
   "shopify",
   "ayet",
-  "bitlabs"
+  "bitlabs",
+  "google-ad-manager"
 ]);
 var FINGERPRINT_DOMAINS = /* @__PURE__ */ new Set([
   "economy.idempotency-key.v1",
+  "economy.google-reporting-key.v1",
   "economy.provider-event-key.v1",
   "economy.provider-object-key.v1",
   "economy.provider-payload.v1",
@@ -1956,6 +1960,12 @@ var SOURCE_COMMAND_TYPES = {
   ]),
   ayet: /* @__PURE__ */ new Set(["credit-reward", "hold", "release-hold", "reverse"]),
   bitlabs: /* @__PURE__ */ new Set(["credit-reward", "hold", "release-hold", "reverse"]),
+  "google-ad-manager": /* @__PURE__ */ new Set([
+    "credit-reward",
+    "hold",
+    "release-hold",
+    "reverse"
+  ]),
   operator: /* @__PURE__ */ new Set(["adjust", "reverse", "hold", "release-hold"]),
   system: /* @__PURE__ */ new Set([
     "credit-event",
@@ -2229,6 +2239,9 @@ function assertEconomyProviderEvidenceHash(evidence) {
       "reconciliationEvidenceFingerprint",
       "signatureScheme",
       "signatureVerifiedAt",
+      "verificationMode",
+      "authenticatedRetrievalScheme",
+      "authenticatedRetrievedAt",
       "providerOccurredAt",
       "receivedAt",
       "operationalHandleBindingId"
@@ -2263,9 +2276,27 @@ function assertEconomyProviderEvidenceHash(evidence) {
     );
   }
   assertSafeClassifier(evidence.eventType, "Provider event type");
-  assertSafeClassifier(evidence.signatureScheme, "Provider signature scheme");
-  const signatureVerifiedAt = parseIsoTimestamp(evidence.signatureVerifiedAt);
   const receivedAt = parseIsoTimestamp(evidence.receivedAt);
+  const signatureFieldsPresent = evidence.signatureScheme !== void 0 && evidence.signatureVerifiedAt !== void 0;
+  const retrievalFieldsPresent = evidence.authenticatedRetrievalScheme !== void 0 && evidence.authenticatedRetrievedAt !== void 0;
+  const verificationMode = evidence.verificationMode ?? "provider-signature";
+  economyAssert(
+    verificationMode === "provider-signature" && evidence.provider !== "google-ad-manager" && signatureFieldsPresent && !retrievalFieldsPresent && evidence.authenticatedRetrievalScheme === void 0 && evidence.authenticatedRetrievedAt === void 0 || verificationMode === "authenticated-retrieval" && evidence.provider === "google-ad-manager" && retrievalFieldsPresent && evidence.signatureScheme === void 0 && evidence.signatureVerifiedAt === void 0,
+    "INVALID_CONTRACT",
+    "Provider evidence must use exactly one permitted verification method"
+  );
+  const verifiedAt = verificationMode === "provider-signature" ? evidence.signatureVerifiedAt : evidence.authenticatedRetrievedAt;
+  if (verificationMode === "provider-signature") {
+    assertSafeClassifier(
+      evidence.signatureScheme,
+      "Provider signature scheme"
+    );
+  } else {
+    assertSafeClassifier(
+      evidence.authenticatedRetrievalScheme,
+      "Provider authenticated-retrieval scheme"
+    );
+  }
   if (evidence.providerOccurredAt !== void 0) {
     economyAssert(
       parseIsoTimestamp(evidence.providerOccurredAt) <= receivedAt,
@@ -2274,9 +2305,9 @@ function assertEconomyProviderEvidenceHash(evidence) {
     );
   }
   economyAssert(
-    receivedAt >= signatureVerifiedAt,
+    receivedAt >= parseIsoTimestamp(verifiedAt),
     "INVALID_TIME_WINDOW",
-    "Provider evidence cannot be received before signature verification"
+    "Provider evidence cannot be received before verification"
   );
   if (evidence.operationalHandleBindingId !== void 0) {
     assertEconomyIdentifier(
@@ -2626,8 +2657,13 @@ function canonicalEconomyProviderEvidenceHashPayload(evidence) {
         evidence.reconciliationEvidenceFingerprint
       )
     },
-    signatureScheme: evidence.signatureScheme,
-    signatureVerifiedAt: evidence.signatureVerifiedAt,
+    ...evidence.verificationMode === void 0 ? {} : { verificationMode: evidence.verificationMode },
+    ...evidence.signatureScheme === void 0 ? {} : { signatureScheme: evidence.signatureScheme },
+    ...evidence.signatureVerifiedAt === void 0 ? {} : { signatureVerifiedAt: evidence.signatureVerifiedAt },
+    ...evidence.authenticatedRetrievalScheme === void 0 ? {} : {
+      authenticatedRetrievalScheme: evidence.authenticatedRetrievalScheme
+    },
+    ...evidence.authenticatedRetrievedAt === void 0 ? {} : { authenticatedRetrievedAt: evidence.authenticatedRetrievedAt },
     ...evidence.providerOccurredAt === void 0 ? {} : { providerOccurredAt: evidence.providerOccurredAt },
     receivedAt: evidence.receivedAt,
     ...evidence.operationalHandleBindingId === void 0 ? {} : {
@@ -3441,6 +3477,7 @@ var ACTIVITY_SOURCES2 = /* @__PURE__ */ new Set([
   "shopify",
   "ayet",
   "bitlabs",
+  "google-ad-manager",
   "subscription",
   "event",
   "competition",
@@ -3680,6 +3717,15 @@ function assertReversalAvailable(originalTransactionId, existingTransactions) {
 }
 
 // src/audit-graph.ts
+var PROVIDER_COMMAND_SOURCES = /* @__PURE__ */ new Set([
+  "shopify",
+  "ayet",
+  "bitlabs",
+  "google-ad-manager"
+]);
+function isProviderCommandSource(source) {
+  return PROVIDER_COMMAND_SOURCES.has(source);
+}
 function assertCanonicalHash4(value, label) {
   economyAssert(
     typeof value === "string" && /^sha256:[a-f0-9]{64}$/u.test(value),
@@ -3707,7 +3753,7 @@ function assertCreatedReference(manifest, kind, id, contentHash) {
 }
 function assertProviderGraph(graph, hash, acceptanceCommit) {
   const envelope = graph.commandEnvelope;
-  const providerSource = envelope.commandSource === "shopify" || envelope.commandSource === "ayet" || envelope.commandSource === "bitlabs";
+  const providerSource = isProviderCommandSource(envelope.commandSource);
   if (!providerSource) {
     economyAssert(
       graph.providerEvidenceManifest === void 0 && graph.providerEvidence.length === 0 && graph.operationalHandleBindings.length === 0,
@@ -3854,7 +3900,7 @@ function expectedTransactionActivityTypes(envelope) {
   }
   if (envelope.commandType === "credit-reward") {
     return /* @__PURE__ */ new Set([
-      envelope.commandSource === "ayet" ? "rewarded-ad" : "offerwall"
+      envelope.commandSource === "ayet" || envelope.commandSource === "google-ad-manager" ? "rewarded-ad" : "offerwall"
     ]);
   }
   if (envelope.commandType === "credit-event") {
@@ -3909,7 +3955,7 @@ function assertReceiptGraph(graph, commandEnvelopeHash, hash, acceptanceCommit,
     accepted.receiptId,
     acceptedHash
   );
-  const providerSource = envelope.commandSource === "shopify" || envelope.commandSource === "ayet" || envelope.commandSource === "bitlabs";
+  const providerSource = isProviderCommandSource(envelope.commandSource);
   if (graph.resultReceipt === void 0) {
     economyAssert(
       providerSource && graph.transaction === void 0 && resultCommit === void 0,
@@ -4029,7 +4075,9 @@ function assertAuthorityCommits(graph, hash) {
     "INVALID_CONTRACT",
     "Authority commits do not reconstruct the expected authority head"
   );
-  const providerSource = graph.commandEnvelope.commandSource === "shopify" || graph.commandEnvelope.commandSource === "ayet" || graph.commandEnvelope.commandSource === "bitlabs";
+  const providerSource = isProviderCommandSource(
+    graph.commandEnvelope.commandSource
+  );
   const acceptanceKind = providerSource ? "provider-acceptance" : "first-party-command";
   const acceptanceCommit = graph.commits.find(
     (commit) => commit.manifest.commitKind === acceptanceKind
@@ -4234,6 +4282,324 @@ function evaluateEarlyBackerBySettlementV2(payerAccountId, receivingHouseholdId,
   };
 }
 
+// src/google-rewarded-web.ts
+var GOOGLE_REWARDED_WEB_PROVIDER = "google-ad-manager";
+var GOOGLE_REWARDED_WEB_NOMINAL_MICROS_PER_TOKEN = 100000n;
+var GOOGLE_REWARDED_WEB_MINIMUM_NET_MICROS_PER_TOKEN = 125000n;
+var SIGNED_BIGINT_MAX = 2n ** 63n - 1n;
+var CANONICAL_UNSIGNED_INTEGER = /^(?:0|[1-9][0-9]*)$/u;
+var SHA256 = /^sha256:[a-f0-9]{64}$/u;
+function assertExactKeys4(value, allowed, label) {
+  economyAssert(
+    Object.keys(value).every((key) => allowed.has(key)) && [...allowed].every(
+      (key) => key === "effectiveUntil" || Object.prototype.hasOwnProperty.call(value, key)
+    ),
+    "INVALID_CONTRACT",
+    `${label} contains missing or unsupported fields`
+  );
+}
+function parseGbpMicros(value, label) {
+  economyAssert(
+    typeof value === "string" && CANONICAL_UNSIGNED_INTEGER.test(value),
+    "INVALID_CONTRACT",
+    `${label} must be canonical non-negative GBP micros`
+  );
+  const parsed = BigInt(value);
+  economyAssert(
+    parsed <= SIGNED_BIGINT_MAX,
+    "AMOUNT_OUT_OF_RANGE",
+    `${label} is outside the signed 64-bit range`
+  );
+  return parsed;
+}
+function assertRewardPayload(payload) {
+  assertExactKeys4(payload, /* @__PURE__ */ new Set(["type", "amount"]), "Reward payload");
+  economyAssert(
+    payload.type === "plasius-token-progress" && payload.amount === 1,
+    "INVALID_CONTRACT",
+    "Reward payload must disclose exactly one Token of bundle progress"
+  );
+}
+function assertBoundedCount(value, label) {
+  economyAssert(
+    Number.isSafeInteger(value) && value >= 0,
+    "INVALID_CONTRACT",
+    `${label} must be a non-negative safe integer`
+  );
+}
+function createGoogleRewardedWebQuote(input) {
+  const gross = parseGbpMicros(
+    input.grossRevenueFloorMicros,
+    "grossRevenueFloorMicros"
+  );
+  const providerFee = parseGbpMicros(
+    input.providerFeeMicros,
+    "providerFeeMicros"
+  );
+  const invalidTrafficHaircut = parseGbpMicros(
+    input.invalidTrafficHaircutMicros,
+    "invalidTrafficHaircutMicros"
+  );
+  const otherCost = parseGbpMicros(input.otherCostMicros, "otherCostMicros");
+  const deductions = providerFee + invalidTrafficHaircut + otherCost;
+  economyAssert(
+    deductions <= gross,
+    "INVALID_CONTRACT",
+    "Rewarded-web costs cannot exceed the gross revenue floor"
+  );
+  const eligibleNet = gross - deductions;
+  const retainedMargin = eligibleNet - GOOGLE_REWARDED_WEB_NOMINAL_MICROS_PER_TOKEN;
+  const quote = {
+    schemaVersion: ECONOMY_CONTRACT_VERSION,
+    quoteVersion: input.quoteVersion,
+    provider: GOOGLE_REWARDED_WEB_PROVIDER,
+    currency: "GBP",
+    bundleCompletions: input.bundleCompletions,
+    rewardPayload: input.rewardPayload,
+    grossRevenueFloorMicros: gross.toString(10),
+    providerFeeMicros: providerFee.toString(10),
+    invalidTrafficHaircutMicros: invalidTrafficHaircut.toString(10),
+    otherCostMicros: otherCost.toString(10),
+    eligibleNetRevenueMicros: eligibleNet.toString(10),
+    tokenAmount: serializeTokenSubunits(TOKEN_SUBUNITS_PER_TOKEN),
+    nominalLiabilityMicros: GOOGLE_REWARDED_WEB_NOMINAL_MICROS_PER_TOKEN.toString(10),
+    retainedMarginMicros: retainedMargin.toString(10),
+    effectiveFrom: input.effectiveFrom,
+    ...input.effectiveUntil === void 0 ? {} : { effectiveUntil: input.effectiveUntil }
+  };
+  assertGoogleRewardedWebQuote(quote);
+  return Object.freeze(quote);
+}
+function assertGoogleRewardedWebQuote(quote) {
+  assertExactKeys4(
+    quote,
+    /* @__PURE__ */ new Set([
+      "schemaVersion",
+      "quoteVersion",
+      "provider",
+      "currency",
+      "bundleCompletions",
+      "rewardPayload",
+      "grossRevenueFloorMicros",
+      "providerFeeMicros",
+      "invalidTrafficHaircutMicros",
+      "otherCostMicros",
+      "eligibleNetRevenueMicros",
+      "tokenAmount",
+      "nominalLiabilityMicros",
+      "retainedMarginMicros",
+      "effectiveFrom",
+      "effectiveUntil"
+    ]),
+    "Google rewarded-web quote"
+  );
+  economyAssert(
+    quote.schemaVersion === ECONOMY_CONTRACT_VERSION && quote.provider === GOOGLE_REWARDED_WEB_PROVIDER && quote.currency === "GBP",
+    "INVALID_CONTRACT",
+    "Unsupported Google rewarded-web quote contract"
+  );
+  assertEconomyIdentifier(quote.quoteVersion, "quoteVersion");
+  economyAssert(
+    Number.isSafeInteger(quote.bundleCompletions) && quote.bundleCompletions >= 1 && quote.bundleCompletions <= 1e3,
+    "INVALID_CONTRACT",
+    "Bundle completions must be between 1 and 1,000"
+  );
+  assertRewardPayload(quote.rewardPayload);
+  const gross = parseGbpMicros(
+    quote.grossRevenueFloorMicros,
+    "grossRevenueFloorMicros"
+  );
+  const providerFee = parseGbpMicros(
+    quote.providerFeeMicros,
+    "providerFeeMicros"
+  );
+  const invalidTrafficHaircut = parseGbpMicros(
+    quote.invalidTrafficHaircutMicros,
+    "invalidTrafficHaircutMicros"
+  );
+  const otherCost = parseGbpMicros(quote.otherCostMicros, "otherCostMicros");
+  const eligibleNet = parseGbpMicros(
+    quote.eligibleNetRevenueMicros,
+    "eligibleNetRevenueMicros"
+  );
+  const nominalLiability = parseGbpMicros(
+    quote.nominalLiabilityMicros,
+    "nominalLiabilityMicros"
+  );
+  const retainedMargin = parseGbpMicros(
+    quote.retainedMarginMicros,
+    "retainedMarginMicros"
+  );
+  economyAssert(
+    gross === providerFee + invalidTrafficHaircut + otherCost + eligibleNet,
+    "INVALID_CONTRACT",
+    "Rewarded-web quote revenue arithmetic is inconsistent"
+  );
+  economyAssert(
+    parseTokenSubunits(quote.tokenAmount) === TOKEN_SUBUNITS_PER_TOKEN && nominalLiability === GOOGLE_REWARDED_WEB_NOMINAL_MICROS_PER_TOKEN,
+    "INVALID_CONTRACT",
+    "Rewarded-web quote must issue exactly one whole Token"
+  );
+  economyAssert(
+    eligibleNet >= GOOGLE_REWARDED_WEB_MINIMUM_NET_MICROS_PER_TOKEN && retainedMargin === eligibleNet - nominalLiability && retainedMargin * 5n >= eligibleNet,
+    "INVALID_CONTRACT",
+    "Rewarded-web quote does not preserve the 20% contribution margin"
+  );
+  const effectiveFrom = parseIsoTimestamp(quote.effectiveFrom);
+  if (quote.effectiveUntil !== void 0) {
+    economyAssert(
+      parseIsoTimestamp(quote.effectiveUntil) > effectiveFrom,
+      "INVALID_TIME_WINDOW",
+      "Rewarded-web quote expiry must follow its effective time"
+    );
+  }
+}
+function assertGoogleRewardedWebGrantClaim(claim) {
+  assertExactKeys4(
+    claim,
+    /* @__PURE__ */ new Set([
+      "schemaVersion",
+      "provider",
+      "evidenceTrust",
+      "claimId",
+      "sessionId",
+      "beneficiaryAccountId",
+      "quoteVersion",
+      "reportingKeyFingerprint",
+      "rewardPayload",
+      "claimedAt"
+    ]),
+    "Google rewarded-web grant claim"
+  );
+  economyAssert(
+    claim.schemaVersion === ECONOMY_CONTRACT_VERSION && claim.provider === GOOGLE_REWARDED_WEB_PROVIDER && claim.evidenceTrust === "client-claimed",
+    "INVALID_CONTRACT",
+    "Rewarded-web grant evidence must remain client-claimed"
+  );
+  assertEconomyIdentifier(claim.claimId, "claimId");
+  assertEconomyIdentifier(claim.sessionId, "sessionId");
+  assertEconomyIdentifier(claim.beneficiaryAccountId, "beneficiaryAccountId");
+  assertEconomyIdentifier(claim.quoteVersion, "quoteVersion");
+  assertEconomyHmacFingerprint(
+    claim.reportingKeyFingerprint,
+    "economy.google-reporting-key.v1"
+  );
+  assertRewardPayload(claim.rewardPayload);
+  parseIsoTimestamp(claim.claimedAt);
+}
+function assertGoogleRewardedWebReconciliation(reconciliation, quote) {
+  assertGoogleRewardedWebQuote(quote);
+  assertExactKeys4(
+    reconciliation,
+    /* @__PURE__ */ new Set([
+      "schemaVersion",
+      "provider",
+      "batchId",
+      "quoteVersion",
+      "state",
+      "reportFinality",
+      "reportFingerprint",
+      "adUnitFingerprint",
+      "periodStartedAt",
+      "periodEndedAt",
+      "acceptedClaimCount",
+      "matchedPaidImpressionCount",
+      "creditedBundleCount",
+      "grossRevenueMicros",
+      "eligibleNetRevenueMicros",
+      "nominalLiabilityMicros",
+      "reserveHeldMicros",
+      "reconciledAt"
+    ]),
+    "Google rewarded-web reconciliation"
+  );
+  economyAssert(
+    reconciliation.schemaVersion === ECONOMY_CONTRACT_VERSION && reconciliation.provider === GOOGLE_REWARDED_WEB_PROVIDER && reconciliation.quoteVersion === quote.quoteVersion && ["report-matched", "financially-reconciled", "mismatch"].includes(
+      reconciliation.state
+    ) && ["estimated", "final"].includes(reconciliation.reportFinality),
+    "INVALID_CONTRACT",
+    "Unsupported Google rewarded-web reconciliation contract"
+  );
+  assertEconomyIdentifier(reconciliation.batchId, "batchId");
+  assertEconomyHmacFingerprint(
+    reconciliation.reportFingerprint,
+    "economy.provider-reconciliation.v1"
+  );
+  economyAssert(
+    SHA256.test(reconciliation.adUnitFingerprint),
+    "INVALID_CONTRACT",
+    "Ad-unit fingerprint must be a canonical SHA-256 reference"
+  );
+  const periodStartedAt = parseIsoTimestamp(reconciliation.periodStartedAt);
+  const periodEndedAt = parseIsoTimestamp(reconciliation.periodEndedAt);
+  const reconciledAt = parseIsoTimestamp(reconciliation.reconciledAt);
+  economyAssert(
+    periodEndedAt > periodStartedAt && reconciledAt >= periodEndedAt,
+    "INVALID_TIME_WINDOW",
+    "Reconciliation period and completion times are inconsistent"
+  );
+  assertBoundedCount(reconciliation.acceptedClaimCount, "acceptedClaimCount");
+  assertBoundedCount(
+    reconciliation.matchedPaidImpressionCount,
+    "matchedPaidImpressionCount"
+  );
+  assertBoundedCount(
+    reconciliation.creditedBundleCount,
+    "creditedBundleCount"
+  );
+  const gross = parseGbpMicros(
+    reconciliation.grossRevenueMicros,
+    "grossRevenueMicros"
+  );
+  const eligibleNet = parseGbpMicros(
+    reconciliation.eligibleNetRevenueMicros,
+    "eligibleNetRevenueMicros"
+  );
+  const nominalLiability = parseGbpMicros(
+    reconciliation.nominalLiabilityMicros,
+    "nominalLiabilityMicros"
+  );
+  const reserveHeld = parseGbpMicros(
+    reconciliation.reserveHeldMicros,
+    "reserveHeldMicros"
+  );
+  const expectedCompletions = BigInt(reconciliation.creditedBundleCount) * BigInt(quote.bundleCompletions);
+  const expectedEligibleNet = BigInt(reconciliation.creditedBundleCount) * BigInt(quote.eligibleNetRevenueMicros);
+  const expectedLiability = BigInt(reconciliation.creditedBundleCount) * BigInt(quote.nominalLiabilityMicros);
+  economyAssert(
+    gross >= eligibleNet && nominalLiability === expectedLiability && reserveHeld >= nominalLiability,
+    "INVALID_CONTRACT",
+    "Reconciliation liability or reserve arithmetic is inconsistent"
+  );
+  if (reconciliation.state === "financially-reconciled") {
+    economyAssert(
+      reconciliation.reportFinality === "final" && BigInt(reconciliation.acceptedClaimCount) >= expectedCompletions && BigInt(reconciliation.matchedPaidImpressionCount) >= expectedCompletions && eligibleNet >= expectedEligibleNet,
+      "INVALID_CONTRACT",
+      "Financial reconciliation requires final paid impressions and revenue coverage"
+    );
+  }
+}
+var STATE_TRANSITIONS = {
+  created: /* @__PURE__ */ new Set(["bootstrapped", "suspended", "expired"]),
+  bootstrapped: /* @__PURE__ */ new Set(["client-claimed", "suspended", "expired"]),
+  "client-claimed": /* @__PURE__ */ new Set(["report-matched", "suspended", "expired"]),
+  "report-matched": /* @__PURE__ */ new Set([
+    "financially-reconciled",
+    "suspended",
+    "expired"
+  ]),
+  "financially-reconciled": /* @__PURE__ */ new Set(),
+  suspended: /* @__PURE__ */ new Set(),
+  expired: /* @__PURE__ */ new Set()
+};
+function assertGoogleRewardedWebStateTransition(from, to) {
+  economyAssert(
+    STATE_TRANSITIONS[from]?.has(to) === true,
+    "INVALID_CONTRACT",
+    "Rewarded-web session transition is not forward-safe"
+  );
+}
+
 // src/integrity.ts
 function assertCanonicalHash5(value, label) {
   economyAssert(
@@ -4428,6 +4794,7 @@ function assertSourceLot(lot) {
       "shopify",
       "ayet",
       "bitlabs",
+      "google-ad-manager",
       "subscription",
       "event",
       "competition",
@@ -4450,7 +4817,7 @@ function assertSourceLot(lot) {
     "INVALID_CONTRACT",
     "Source lot has an unsupported refund state"
   );
-  if (lot.source === "ayet" || lot.source === "bitlabs") {
+  if (lot.source === "ayet" || lot.source === "bitlabs" || lot.source === "google-ad-manager") {
     economyAssert(
       lot.transferPolicy === "same-user-only" && lot.providerEventId !== void 0,
       "SOURCE_LOT_RESTRICTED",
@@ -5544,7 +5911,7 @@ var DECISIONS = /* @__PURE__ */ new Set([
   "approve",
   "reject"
 ]);
-function assertExactKeys4(value, allowed, label) {
+function assertExactKeys5(value, allowed, label) {
   economyAssert(
     value !== null && typeof value === "object" && !Array.isArray(value),
     "INVALID_CONTRACT",
@@ -5571,7 +5938,7 @@ function assertReasonCode(reasonCode) {
   );
 }
 function assertOperatorAdjustmentPreview(preview) {
-  assertExactKeys4(preview, PREVIEW_KEYS, "Operator adjustment preview");
+  assertExactKeys5(preview, PREVIEW_KEYS, "Operator adjustment preview");
   economyAssert(
     preview.schemaVersion === ECONOMY_CONTRACT_VERSION && OPERATIONS.has(preview.operation) && TARGET_COMPONENTS.has(preview.targetComponent) && TRANSFER_POLICIES.has(preview.transferPolicy) && preview.refundPolicy === "not-refundable",
     "INVALID_CONTRACT",
@@ -5650,7 +6017,7 @@ function canonicalOperatorAdjustmentPreviewPayload(preview) {
 function assertOperatorAdjustmentProposal(proposal, preview, expectedPreviewHash) {
   assertOperatorAdjustmentPreview(preview);
   assertCanonicalHash6(expectedPreviewHash, "expectedPreviewHash");
-  assertExactKeys4(proposal, PROPOSAL_KEYS, "Operator adjustment proposal");
+  assertExactKeys5(proposal, PROPOSAL_KEYS, "Operator adjustment proposal");
   economyAssert(
     proposal.schemaVersion === ECONOMY_CONTRACT_VERSION && proposal.status === "pending-approval",
     "INVALID_CONTRACT",
@@ -5677,7 +6044,7 @@ function assertOperatorAdjustmentProposal(proposal, preview, expectedPreviewHash
   );
 }
 function canonicalOperatorAdjustmentProposalPayload(proposal) {
-  assertExactKeys4(proposal, PROPOSAL_KEYS, "Operator adjustment proposal");
+  assertExactKeys5(proposal, PROPOSAL_KEYS, "Operator adjustment proposal");
   return JSON.stringify({
     schemaVersion: proposal.schemaVersion,
     proposalId: proposal.proposalId,
@@ -5692,7 +6059,7 @@ function canonicalOperatorAdjustmentProposalPayload(proposal) {
 function assertOperatorAdjustmentDecision(decision, proposal, preview, expectedPreviewHash, expectedProposalHash) {
   assertOperatorAdjustmentProposal(proposal, preview, expectedPreviewHash);
   assertCanonicalHash6(expectedProposalHash, "expectedProposalHash");
-  assertExactKeys4(decision, DECISION_KEYS, "Operator adjustment decision");
+  assertExactKeys5(decision, DECISION_KEYS, "Operator adjustment decision");
   economyAssert(
     decision.schemaVersion === ECONOMY_CONTRACT_VERSION && DECISIONS.has(decision.decision),
     "INVALID_CONTRACT",
@@ -5735,7 +6102,7 @@ function assertOperatorAdjustmentDecision(decision, proposal, preview, expectedP
   );
 }
 function canonicalOperatorAdjustmentDecisionPayload(decision) {
-  assertExactKeys4(decision, DECISION_KEYS, "Operator adjustment decision");
+  assertExactKeys5(decision, DECISION_KEYS, "Operator adjustment decision");
   return JSON.stringify({
     schemaVersion: decision.schemaVersion,
     decisionId: decision.decisionId,
@@ -5759,7 +6126,7 @@ function assertOperatorAdjustmentExecution(execution, preview, proposal, decisio
     expectedProposalHash
   );
   assertCanonicalHash6(expectedDecisionHash, "expectedDecisionHash");
-  assertExactKeys4(execution, EXECUTION_KEYS, "Operator adjustment execution");
+  assertExactKeys5(execution, EXECUTION_KEYS, "Operator adjustment execution");
   economyAssert(
     execution.schemaVersion === ECONOMY_CONTRACT_VERSION,
     "INVALID_CONTRACT",
@@ -5790,7 +6157,7 @@ function assertOperatorAdjustmentExecution(execution, preview, proposal, decisio
   );
 }
 function canonicalOperatorAdjustmentExecutionPayload(execution) {
-  assertExactKeys4(execution, EXECUTION_KEYS, "Operator adjustment execution");
+  assertExactKeys5(execution, EXECUTION_KEYS, "Operator adjustment execution");
   return JSON.stringify({
     schemaVersion: execution.schemaVersion,
     executionId: execution.executionId,
@@ -6863,6 +7230,7 @@ var ACTIVITY_SOURCES3 = /* @__PURE__ */ new Set([
   "shopify",
   "ayet",
   "bitlabs",
+  "google-ad-manager",
   "subscription",
   "event",
   "competition",
@@ -8345,7 +8713,7 @@ var PORTABLE_KEYS = /* @__PURE__ */ new Set([
   "signature",
   ...PORTABLE_BODY_KEYS
 ]);
-function assertExactKeys5(value, allowedKeys, label) {
+function assertExactKeys6(value, allowedKeys, label) {
   economyAssert(
     value !== null && typeof value === "object" && !Array.isArray(value),
     "INVALID_CONTRACT",
@@ -8434,7 +8802,7 @@ function canonicalSignatureMetadata(signature) {
   };
 }
 function assertEconomySealedRecoveryPayload(payload) {
-  assertExactKeys5(
+  assertExactKeys6(
     payload,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -8474,7 +8842,7 @@ function assertEconomySealedRecoveryPayload(payload) {
   );
 }
 function assertAcceptanceBody(body) {
-  assertExactKeys5(
+  assertExactKeys6(
     body,
     "acceptanceEnvelopeId" in body ? ACCEPTANCE_KEYS : ACCEPTANCE_BODY_KEYS,
     "Recovery acceptance body"
@@ -8543,7 +8911,7 @@ function createEconomyRecoveryAcceptanceEnvelope(body, hashCanonicalPayload2) {
   };
 }
 function assertEconomyRecoveryAcceptanceEnvelope(envelope, hashCanonicalPayload2) {
-  assertExactKeys5(envelope, ACCEPTANCE_KEYS, "Recovery acceptance envelope");
+  assertExactKeys6(envelope, ACCEPTANCE_KEYS, "Recovery acceptance envelope");
   assertAcceptanceBody(envelope);
   assertEconomyIdentifier(
     envelope.acceptanceEnvelopeId,
@@ -8584,7 +8952,7 @@ function canonicalEconomyRecoveryAcceptanceEnvelopePayload(envelope, hashCanonic
   });
 }
 function assertCommittedResultBody(body) {
-  assertExactKeys5(
+  assertExactKeys6(
     body,
     "committedResultId" in body ? COMMITTED_RESULT_KEYS : COMMITTED_RESULT_BODY_KEYS,
     "Recovery committed-result body"
@@ -8678,7 +9046,7 @@ function createEconomyRecoveryCommittedResult(body, hashCanonicalPayload2) {
   };
 }
 function assertEconomyRecoveryCommittedResult(result, hashCanonicalPayload2) {
-  assertExactKeys5(
+  assertExactKeys6(
     result,
     COMMITTED_RESULT_KEYS,
     "Recovery committed result"
@@ -8737,7 +9105,7 @@ function assertEconomyRecoveryResultLink(acceptance, result, hashCanonicalPayloa
   );
 }
 function assertEconomyEvidenceSignatureMetadata(signature) {
-  assertExactKeys5(
+  assertExactKeys6(
     signature,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -8757,7 +9125,7 @@ function assertEconomyEvidenceSignatureMetadata(signature) {
   parseIsoTimestamp(signature.signedAt);
 }
 function assertEconomyEvidenceSignature(signature) {
-  assertExactKeys5(
+  assertExactKeys6(
     signature,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -8779,7 +9147,7 @@ function assertEconomyEvidenceSignature(signature) {
   assertBase64url(signature.value, "Evidence signature value", 32, 2048);
 }
 function assertRegionalEvidenceBody(body) {
-  assertExactKeys5(
+  assertExactKeys6(
     body,
     "evidenceReceiptId" in body ? REGIONAL_KEYS : REGIONAL_BODY_KEYS,
     "Regional evidence-receipt body"
@@ -8871,7 +9239,7 @@ function createEconomyRegionalEvidenceReceipt(body, signature, hashCanonicalPayl
   };
 }
 function assertEconomyRegionalEvidenceReceipt(receipt, hashCanonicalPayload2) {
-  assertExactKeys5(receipt, REGIONAL_KEYS, "Regional evidence receipt");
+  assertExactKeys6(receipt, REGIONAL_KEYS, "Regional evidence receipt");
   assertRegionalEvidenceBody(receipt);
   assertEconomyIdentifier(receipt.evidenceReceiptId, "evidenceReceiptId");
   assertEconomyEvidenceSignature(receipt.signature);
@@ -9073,7 +9441,7 @@ function assertEconomyRegionalEvidenceEquality(receipts, expectedRegions, hashCa
   );
 }
 function assertEconomyMerkleInclusionProof(proof) {
-  assertExactKeys5(
+  assertExactKeys6(
     proof,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -9104,7 +9472,7 @@ function assertEconomyMerkleInclusionProof(proof) {
     "Merkle leaf position is outside its bounded tree"
   );
   for (const step of proof.siblings) {
-    assertExactKeys5(
+    assertExactKeys6(
       step,
       /* @__PURE__ */ new Set(["schemaVersion", "side", "hash"]),
       "Merkle proof step"
@@ -9193,7 +9561,7 @@ function assertEconomyMerkleInclusion(proof, anchor, hashCanonicalPayload2) {
   );
 }
 function assertPortableEvidenceReference(reference) {
-  assertExactKeys5(
+  assertExactKeys6(
     reference,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -9230,7 +9598,7 @@ function canonicalPortableEvidenceReference(reference) {
   };
 }
 function assertPortableBody(body) {
-  assertExactKeys5(
+  assertExactKeys6(
     body,
     "portableReceiptId" in body ? PORTABLE_KEYS : PORTABLE_BODY_KEYS,
     "Portable customer-receipt body"
@@ -9354,7 +9722,7 @@ function createEconomyPortableCustomerReceipt(body, signature, hashCanonicalPayl
   };
 }
 function assertEconomyPortableCustomerReceipt(receipt, hashCanonicalPayload2) {
-  assertExactKeys5(receipt, PORTABLE_KEYS, "Portable customer receipt");
+  assertExactKeys6(receipt, PORTABLE_KEYS, "Portable customer receipt");
   assertPortableBody(receipt);
   assertEconomyIdentifier(receipt.portableReceiptId, "portableReceiptId");
   assertEconomyEvidenceSignature(receipt.signature);
@@ -9654,7 +10022,7 @@ var DOCUMENT_ID_KEYS = /* @__PURE__ */ new Set([
   "lifetimeProjectionId",
   "outboxEventId"
 ]);
-function assertExactKeys6(value, allowed, label) {
+function assertExactKeys7(value, allowed, label) {
   economyAssert(
     value !== null && typeof value === "object" && !Array.isArray(value),
     "INVALID_CONTRACT",
@@ -9694,7 +10062,7 @@ function createPersonalWalletInitializationDocumentIds(subjectAccountId, hash) {
   };
 }
 function assertPersonalWalletInitializationCommand(command) {
-  assertExactKeys6(command, COMMAND_KEYS, "Wallet initialization command");
+  assertExactKeys7(command, COMMAND_KEYS, "Wallet initialization command");
   economyAssert(
     command.schemaVersion === ECONOMY_CONTRACT_VERSION && command.commandType === "initialize-wallet" && command.walletKind === "personal",
     "INVALID_CONTRACT",
@@ -9718,7 +10086,7 @@ function canonicalPersonalWalletInitializationCommandPayload(command) {
   });
 }
 function assertPersonalWalletInitializationOutboxIntent(intent) {
-  assertExactKeys6(intent, OUTBOX_KEYS, "Wallet initialization outbox intent");
+  assertExactKeys7(intent, OUTBOX_KEYS, "Wallet initialization outbox intent");
   economyAssert(
     intent.schemaVersion === ECONOMY_CONTRACT_VERSION && intent.eventType === "wallet.initialized.v1",
     "INVALID_CONTRACT",
@@ -9818,8 +10186,8 @@ function createPersonalWalletInitializationState(input, hash) {
   return state;
 }
 function assertPersonalWalletInitializationState(state) {
-  assertExactKeys6(state, STATE_KEYS, "Wallet initialization state");
-  assertExactKeys6(
+  assertExactKeys7(state, STATE_KEYS, "Wallet initialization state");
+  assertExactKeys7(
     state.documentIds,
     DOCUMENT_ID_KEYS,
     "Wallet initialization document IDs"
@@ -9870,6 +10238,9 @@ export {
   ECONOMY_CONTRACT_VERSION,
   ECONOMY_RECOVERY_PROTOCOL_VERSION,
   EconomyError,
+  GOOGLE_REWARDED_WEB_MINIMUM_NET_MICROS_PER_TOKEN,
+  GOOGLE_REWARDED_WEB_NOMINAL_MICROS_PER_TOKEN,
+  GOOGLE_REWARDED_WEB_PROVIDER,
   MODULE_ALLOWANCE_PURPOSE,
   PRE_UTILITY_BACKER_COHORT,
   TOKEN_SUBUNITS_MAX,
@@ -9942,6 +10313,10 @@ export {
   assertFlatTokenCatalog,
   assertFxSnapshot,
   assertGameplayAllocation,
+  assertGoogleRewardedWebGrantClaim,
+  assertGoogleRewardedWebQuote,
+  assertGoogleRewardedWebReconciliation,
+  assertGoogleRewardedWebStateTransition,
   assertJournalChainHead,
   assertModuleAllowance,
   assertModulePurchaseReceipt,
@@ -10035,6 +10410,7 @@ export {
   createEconomyRecoveryCommittedResult,
   createEconomyRegionalEvidenceReceipt,
   createGameplayAllocation,
+  createGoogleRewardedWebQuote,
   createInitialSourceLotSnapshot,
   createModuleAllowance,
   createModulePurchaseReceipt,