@plasius/economy 0.8.0 → 0.10.0

package/dist/index.js

@@ -1895,7 +1895,8 @@ var COMMAND_TYPES = /* @__PURE__ */ new Set([
   "chargeback",
   "reverse",
   "adjust",
-  "initialize-wallet"
+  "initialize-wallet",
+  "initialize-admin-reporting"
 ]);
 var COMMAND_SOURCES = /* @__PURE__ */ new Set([
   "browser",
@@ -1930,6 +1931,7 @@ var PROVIDERS = /* @__PURE__ */ new Set([
 ]);
 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",
@@ -1959,6 +1961,7 @@ var SOURCE_COMMAND_TYPES = {
   system: /* @__PURE__ */ new Set([
     "credit-event",
     "credit-competition",
+    "initialize-admin-reporting",
     "hold",
     "release-hold",
     "reverse"
@@ -3439,6 +3442,7 @@ var ACTIVITY_SOURCES2 = /* @__PURE__ */ new Set([
   "shopify",
   "ayet",
   "bitlabs",
+  "google-ad-manager",
   "subscription",
   "event",
   "competition",
@@ -4232,6 +4236,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(
@@ -4426,6 +4748,7 @@ function assertSourceLot(lot) {
       "shopify",
       "ayet",
       "bitlabs",
+      "google-ad-manager",
       "subscription",
       "event",
       "competition",
@@ -4448,7 +4771,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",
@@ -5542,7 +5865,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",
@@ -5569,7 +5892,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",
@@ -5648,7 +5971,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",
@@ -5675,7 +5998,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,
@@ -5690,7 +6013,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",
@@ -5733,7 +6056,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,
@@ -5757,7 +6080,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",
@@ -5788,7 +6111,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,
@@ -6861,6 +7184,7 @@ var ACTIVITY_SOURCES3 = /* @__PURE__ */ new Set([
   "shopify",
   "ayet",
   "bitlabs",
+  "google-ad-manager",
   "subscription",
   "event",
   "competition",
@@ -8343,7 +8667,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",
@@ -8432,7 +8756,7 @@ function canonicalSignatureMetadata(signature) {
   };
 }
 function assertEconomySealedRecoveryPayload(payload) {
-  assertExactKeys5(
+  assertExactKeys6(
     payload,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -8472,7 +8796,7 @@ function assertEconomySealedRecoveryPayload(payload) {
   );
 }
 function assertAcceptanceBody(body) {
-  assertExactKeys5(
+  assertExactKeys6(
     body,
     "acceptanceEnvelopeId" in body ? ACCEPTANCE_KEYS : ACCEPTANCE_BODY_KEYS,
     "Recovery acceptance body"
@@ -8541,7 +8865,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,
@@ -8582,7 +8906,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"
@@ -8676,7 +9000,7 @@ function createEconomyRecoveryCommittedResult(body, hashCanonicalPayload2) {
   };
 }
 function assertEconomyRecoveryCommittedResult(result, hashCanonicalPayload2) {
-  assertExactKeys5(
+  assertExactKeys6(
     result,
     COMMITTED_RESULT_KEYS,
     "Recovery committed result"
@@ -8735,7 +9059,7 @@ function assertEconomyRecoveryResultLink(acceptance, result, hashCanonicalPayloa
   );
 }
 function assertEconomyEvidenceSignatureMetadata(signature) {
-  assertExactKeys5(
+  assertExactKeys6(
     signature,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -8755,7 +9079,7 @@ function assertEconomyEvidenceSignatureMetadata(signature) {
   parseIsoTimestamp(signature.signedAt);
 }
 function assertEconomyEvidenceSignature(signature) {
-  assertExactKeys5(
+  assertExactKeys6(
     signature,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -8777,7 +9101,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"
@@ -8869,7 +9193,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);
@@ -9071,7 +9395,7 @@ function assertEconomyRegionalEvidenceEquality(receipts, expectedRegions, hashCa
   );
 }
 function assertEconomyMerkleInclusionProof(proof) {
-  assertExactKeys5(
+  assertExactKeys6(
     proof,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -9102,7 +9426,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"
@@ -9191,7 +9515,7 @@ function assertEconomyMerkleInclusion(proof, anchor, hashCanonicalPayload2) {
   );
 }
 function assertPortableEvidenceReference(reference) {
-  assertExactKeys5(
+  assertExactKeys6(
     reference,
     /* @__PURE__ */ new Set([
       "schemaVersion",
@@ -9228,7 +9552,7 @@ function canonicalPortableEvidenceReference(reference) {
   };
 }
 function assertPortableBody(body) {
-  assertExactKeys5(
+  assertExactKeys6(
     body,
     "portableReceiptId" in body ? PORTABLE_KEYS : PORTABLE_BODY_KEYS,
     "Portable customer-receipt body"
@@ -9352,7 +9676,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);
@@ -9652,7 +9976,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",
@@ -9692,7 +10016,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",
@@ -9716,7 +10040,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",
@@ -9816,8 +10140,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"
@@ -9868,6 +10192,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,
@@ -9940,6 +10267,10 @@ export {
   assertFlatTokenCatalog,
   assertFxSnapshot,
   assertGameplayAllocation,
+  assertGoogleRewardedWebGrantClaim,
+  assertGoogleRewardedWebQuote,
+  assertGoogleRewardedWebReconciliation,
+  assertGoogleRewardedWebStateTransition,
   assertJournalChainHead,
   assertModuleAllowance,
   assertModulePurchaseReceipt,
@@ -10033,6 +10364,7 @@ export {
   createEconomyRecoveryCommittedResult,
   createEconomyRegionalEvidenceReceipt,
   createGameplayAllocation,
+  createGoogleRewardedWebQuote,
   createInitialSourceLotSnapshot,
   createModuleAllowance,
   createModulePurchaseReceipt,