From 27667f250cd21b02cc41a4497e804b51553f04ed Mon Sep 17 00:00:00 2001 From: Lexirieru Date: Thu, 29 Oct 2026 19:16:25 +0700 Subject: [PATCH 1/4] feat(#94): AdMob as a second revenue source, and refuse an unpinned owner MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A revenue source selects the template, and the template pins the host. So the caller's `source` argument cannot make a claim verify against the wrong API: an AdMob claim checked as AdSense is rebuilt into a request to adsense.googleapis.com, the identifier differs, and the signature recovers to nobody. Tested in both directions. The value order is NOT in the template. `rebuild_parameters` interleaves positionally, so the order is part of the source's shape and lives in `claim_values`. AdMob needs the reverse of AdSense's because the attestor sorts the parameter keys, putting `body` (which holds the window) before `url` (which holds the publisher id) — #93. Getting it wrong would surface as an unexplained ClaimMismatch, so three places check the same ordering without deriving it from each other: this contract, pin_template.py, and the relay. Micros truncate to cents, never round up. The figure's key is per source (`revenueUsd` / `revenueMicros`) and sits inside the signed context, because the two mistakes are not symmetric: dollars read as micros fail loudly, while micros read as dollars return the 100 USDC cap for any revenue at all, silently. Measured on the deployed contract, not reasoned about: quote("123450000") is 1000000000 stroops. The nullifier is tagged for AdMob only. One Google account's AdSense and AdMob publisher ids are the same `pub-` id (#93, on a real account), so untagged an AdMob proof would spend the AdSense nullifier for the same window. AdSense stays untagged because advances already on chain are keyed on those bytes — pinned against a literal derived independently in Python, so it is not the contract agreeing with itself. The source of an advance is `DataKey::AdvanceSource`, beside the `Advance` rather than a field in it: a required field would retype an existing stored value and every advance recorded before this upgrade would fail to decode. Those are debts. Also carries the two changes asked for on #103: an unpinned claim owner is refused with `ClaimOwnerNotSet` rather than falling back to the borrower, and `set_claim_owner` has its own `ClaimOwnerMalformed` instead of reusing `ClaimMismatch`. Refusing forced the test harness to adopt the real owner shape, which is the actual fix for the class of bug #102 was: a `G…` address cannot be pinned at all, so the pre-#102 form cannot be written here by accident any more. Every test now runs through an app-signed claim. make_claim_fixture.py gains the AdMob chain. Its identifier is byte-identical to the one be/src/admob/fixture.test.ts derives in TypeScript (#101) — a Python encoder and a TypeScript one agreeing on the canonical parameters, the context, and the keccak over them. 61 contract tests pass, plus 9 in reclaim-claim. fmt, clippy -D warnings, the wasm build, the no_std wasm check, make_claim_fixture --check and pin_template --self-test are all clean. The linux wasm row is PENDING for CI to measure. Refs #94, #102, #93. Base is #103. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01QdNuoJ9e954ojofNVGUezW --- docs/interface.md | 132 ++++- sc/advance/src/claim.rs | 49 +- sc/advance/src/lib.rs | 286 +++++++++-- sc/advance/src/sizing.rs | 47 ++ sc/advance/src/test_admob.rs | 314 ++++++++++++ sc/advance/src/test_advance.rs | 32 +- sc/advance/src/test_claim.rs | 126 +++-- ...nd_adsense_do_not_share_a_nullifier.1.json | 462 +++++++++++++++++ ...hecked_against_the_adsense_template.1.json | 461 +++++++++++++++++ ...m_verifies_against_its_own_template.1.json | 461 +++++++++++++++++ ..._checked_against_the_admob_template.1.json | 461 +++++++++++++++++ ...no_recorded_source_reads_as_adsense.1.json | 463 ++++++++++++++++++ ...rather_than_falling_back_to_adsense.1.json | 326 ++++++++++++ ...aves_the_adsense_template_untouched.1.json | 462 +++++++++++++++++ ...ense_nullifier_bytes_did_not_change.1.json | 461 +++++++++++++++++ ...line_gets_a_named_error_not_a_panic.1.json | 76 ++- ...is_refused_rather_than_paid_as_dust.1.json | 76 ++- ...ll_cycle_leaves_nothing_outstanding.1.json | 89 +++- ...aim_moves_real_usdc_to_the_borrower.1.json | 89 +++- ...ro_or_negative_repayment_is_refused.1.json | 89 +++- ...fuses_before_spending_the_nullifier.1.json | 76 ++- ...rn_someone_elses_nullifier_for_free.1.json | 76 ++- ...ke_an_advance_in_someone_elses_name.1.json | 76 ++- ...l_place_means_tenths_not_hundredths.1.json | 76 ++- .../test_advance/overpaying_is_refused.1.json | 93 +++- ..._that_was_never_advanced_is_refused.1.json | 76 ++- ...ain_decimal_with_at_most_two_places.1.json | 76 ++- .../test_advance/the_cap_binds.1.json | 76 ++- ...reports_is_the_floor_quote_enforces.1.json | 76 ++- ...hat_was_proven_not_what_was_claimed.1.json | 89 +++- ...uote_is_a_quarter_of_proven_revenue.1.json | 76 ++- .../the_same_proof_cannot_draw_twice.1.json | 89 +++- ..._the_arithmetic_quote_actually_uses.1.json | 76 ++- ...ent_window_is_a_different_nullifier.1.json | 76 ++- ...e_edge_of_the_window_still_verifies.1.json | 76 ++- ...borrower_cannot_be_spent_by_another.1.json | 76 ++- .../a_proof_from_the_future_is_refused.1.json | 76 ++- ...d_claim_does_not_burn_the_nullifier.1.json | 89 +++- .../a_stale_proof_is_refused.1.json | 76 ++- ...ses_rather_than_guessing_the_owner.1.json} | 26 +- ...he_publisher_id_breaks_verification.1.json | 76 ++- ..._revenue_figure_breaks_verification.1.json | 76 ++- ...hifted_between_publisher_and_window.1.json | 76 ++- ...r_binding_survives_the_pinned_owner.1.json | 25 +- ...the_exact_bytes_the_attestor_signed.1.json | 76 ++- ...ecorded_as_spent_and_was_not_before.1.json | 89 +++- ...ed_lowercase_and_must_look_like_one.1.json | 64 ++- ...same_proof_cannot_fund_two_advances.1.json | 89 +++- ..._signed_for_the_borrower_is_refused.1.json | 25 +- ...pinned_as_owner_that_claim_verifies.1.json | 25 +- sc/wasm-hashes.txt | 2 +- tools/fixtures/forepay-claim.json | 32 +- tools/make_claim_fixture.py | 131 +++++ 53 files changed, 7086 insertions(+), 188 deletions(-) create mode 100644 sc/advance/src/test_admob.rs create mode 100644 sc/advance/test_snapshots/test_admob/admob_and_adsense_do_not_share_a_nullifier.1.json create mode 100644 sc/advance/test_snapshots/test_admob/an_admob_claim_cannot_be_checked_against_the_adsense_template.1.json create mode 100644 sc/advance/test_snapshots/test_admob/an_admob_claim_verifies_against_its_own_template.1.json create mode 100644 sc/advance/test_snapshots/test_admob/an_adsense_claim_cannot_be_checked_against_the_admob_template.1.json create mode 100644 sc/advance/test_snapshots/test_admob/an_advance_with_no_recorded_source_reads_as_adsense.1.json create mode 100644 sc/advance/test_snapshots/test_admob/an_unpinned_source_refuses_rather_than_falling_back_to_adsense.1.json create mode 100644 sc/advance/test_snapshots/test_admob/pinning_admob_leaves_the_adsense_template_untouched.1.json create mode 100644 sc/advance/test_snapshots/test_admob/the_adsense_nullifier_bytes_did_not_change.1.json rename sc/advance/test_snapshots/test_claim/{without_a_pinned_owner_a_claim_signed_as_a_real_attestor_signs_is_refused.1.json => an_unpinned_contract_refuses_rather_than_guessing_the_owner.1.json} (91%) diff --git a/docs/interface.md b/docs/interface.md index 888aaea..26fe962 100644 --- a/docs/interface.md +++ b/docs/interface.md @@ -239,8 +239,10 @@ Assigned once, **never renumbered**. Blocks reserved in #8; this freeze fills 10 | **12** | `ProofStale` | #9 | | **13** | `ProofFromTheFuture` | #9 | | **14** | `VerifierRejected` — Reclaim's `verify_proof` refused | #9 | +| **15** | `ClaimOwnerNotSet` — no owner pinned, so the digest cannot be rebuilt | #102 | +| **16** | `ClaimOwnerMalformed` — `set_claim_owner` not given `0x` + 40 hex digits | #102 | | **20** | `NullifierSpent` | #10 | -| **30** | `RevenueUnparseable` — not `\d+(\.\d+)?`, or more than two decimals | #11 | +| **30** | `RevenueUnparseable` — not parseable in the unit its source attests | #11, #94 | | **31** | `AdvanceTooSmall` — below `MIN_ADVANCE_STROOPS` | #11 | | **40** | `InsufficientLiquidity` — the contract cannot cover the advance | #12 | | **41** | `NoTrustline` — the borrower holds no USDC trustline | #12 | @@ -255,10 +257,11 @@ The front end checks first (#19), but the contract does not assume it did. ```rust request_advance( + source: Source, // AdSense | AdMob — selects the template, which pins the host (§10) borrower: Address, // must equal contextAddress inside the signed claim - revenue_usd: String, // decimal string from extractedParameters - pub_id: String, // AdSense publisher id - window_start: String, // YYYY-MM-DD; split into year/month/day for the URL (§2) + revenue_usd: String, // the figure from extractedParameters, in that source's unit + pub_id: String, // AdSense or AdMob publisher id + window_start: String, // YYYY-MM-DD; split into year/month/day for the request (§2) window_end: String, timestamp_s: u64, epoch: u64, @@ -267,18 +270,23 @@ request_advance( ) -> Result // stroops disbursed ``` +`revenue_usd` keeps its name for AdMob, where it carries micros. Renaming a parameter changes the +contract's public interface for every caller, and the unit is already named unambiguously where it +matters — inside the signed context, as `revenueUsd` or `revenueMicros` (§10). + Order is the security property, and it does not change: 0. **`borrower.require_auth()`** — before anything else, including the hashing -1. template is set, else `TemplateNotSet` -2. split each window date into unpadded year/month/day, else `ClaimMismatch`; rebuild `context` and - `parameters`; rebuild `identifier`; build the digest +1. that source's template is set, else `TemplateNotSet` +2. split each window date into unpadded year/month/day, else `ClaimMismatch`; interleave the seven + values **in that source's order**; rebuild `context` with that source's figure key; rebuild + `identifier`; the claim owner is pinned, else `ClaimOwnerNotSet`; build the digest 3. freshness 4. **cross-contract `verify_proof`** — everything after this point is attested -5. nullifier not spent → **write the nullifier** -6. size +5. nullifier not spent → **write the nullifier**, tagged for anything but AdSense +6. size, in that source's unit 7. disburse -8. record the advance +8. record the advance, and its source beside it if it is not AdSense Verify before trusting any field, and write the nullifier before moving money. Check-then-act with a transfer in between is the classic race. @@ -325,3 +333,107 @@ only way it could have been found before the first proof arrived. The lesson worth keeping is narrow: **the part of a freeze that describes someone else's API is a guess until it is checked against that API.** Checking it did not need a live account — the reference page was enough, and nobody read it. + +--- + +## 10. A second revenue source: AdMob (#94) + +Added after the freeze, labelled `out-of-sow` (SOW §4.1 names AdSense). It changes the shape of the +call, so it belongs in this document rather than in a changelog. + +### What a source selects + +`Source` is `AdSense` or `AdMob`, and it is a parameter on `set_claim_template`, `verify_claim`, +`verify_and_reserve`, `request_advance` and `nullifier_for`. + +**The caller's `source` does not choose the host.** It chooses which template to rebuild against, +and the template *contains* the host. So an AdMob claim checked as `AdSense` is rebuilt into a +request to `adsense.googleapis.com`, produces a different identifier, and the signature recovers to +nobody. That refusal is tested in both directions. It is the property that makes a second source +safe to add at all: no argument a caller supplies can make a claim verify against the wrong API. + +| | AdSense | AdMob | +| --- | --- | --- | +| Host, in the template | `adsense.googleapis.com/v2` | `admob.googleapis.com/v1` | +| Method | `GET`, window in the query string | `POST`, window inside the signed `body` | +| Figure | `revenueUsd`, decimal dollars (`"123.45"`) | `revenueMicros`, integer micros (`"123450000"`) | +| Value order | `pub_id, sy, sm, sd, ey, em, ed` | `sy, sm, sd, ey, em, ed, pub_id` | +| Separators end with | `=` (and `/` before `pub_id`) | `\"year\":`, `\"month\":`, `\"day\":`, `/accounts/` | +| Nullifier tag | none | `admob` | +| `DataKey::AdvanceSource` | absent | written | + +### The value order is not in the template + +`rebuild_parameters` interleaves N parts with N−1 values **positionally**, so the order is part of +the source's shape and lives in `claim_values` in `lib.rs`, not in the pinned bytes. + +AdMob needs the reverse of AdSense's order because the attestor canonicalises `parameters` with +its keys sorted — `body, headers, method, responseMatches, responseRedactions, url` — so the window, +which lives in `body`, comes before the publisher id, which lives in `url` (#93). + +Getting it wrong does not fail safe into a wrong template: the identifier simply would not match +and it would surface as `ClaimMismatch` with nothing pointing at the cause. Three places check the +same ordering, independently and without deriving it from each other: + +- the contract, in `sc/advance/src/test_admob.rs`; +- `tools/pin_template.py --self-test`, which also refuses the other source's order; +- `be/src/admob/request.test.ts`. + +### Micros, and why the key names the unit + +AdMob reports `ESTIMATED_EARNINGS` as `microsValue`: millionths, so 10,000 micros is one cent. +`parse_micros_cents` **truncates** — `1239999` micros is 123 cents, never 124 — so the advance is +never sized from more than was attested. + +The key is inside `extractedParameters`, therefore inside the context, therefore inside the +identifier, therefore signed. It cannot be renamed afterwards or inferred at verification time, and +the two sources never share it, because **the two mistakes are not symmetric**: + +| Mistake | What happens | +| --- | --- | +| Dollars read as micros | `123.45` has a `.`, refused; even as `12345` it truncates to 1 cent and fails `AdvanceTooSmall` — **loud** | +| **Micros read as dollars** | `"123450000"` is a valid decimal. `quote()` returns `1000000000` stroops — the 100 USDC cap — for **any** revenue. No error, no clue — **silent** | + +Measured on the deployed contract on 2026-10-29, not reasoned about: +`quote("123.45") = 308625000`, `quote("123450000") = 1000000000`. + +### The nullifier is tagged for AdMob only + +`sha256(pub_id ‖ window_start ‖ window_end ‖ "admob")`, each field length-prefixed. AdSense hashes +exactly the bytes §4 describes, with nothing appended. + +The asymmetry is **forced, not chosen**: advances already on chain are keyed on the untagged hash, +and tagging AdSense now would compute a different key and orphan records that represent debts. One +`source_tag` function holds the exception, with the reason attached. Every source added after +AdSense is tagged. + +A tag is needed because one Google account's AdSense and AdMob publisher ids are **the same `pub-` +id** — confirmed on a real account in #93, not assumed. Untagged, an AdMob proof would spend the +AdSense nullifier for the same window. + +> **Consequence worth stating: the tag permits two advances, it does not deduplicate.** One creator +> can borrow against Jul–Sep AdSense *and* Jul–Sep AdMob for the same publisher id. That is correct +> — website and in-app ad revenue are different money — but the exposure per creator per window is +> **2× the cap**, not the cap. Harmless at 100 USDC on testnet; a real limit question beyond it. + +### The source of an advance is a parallel key, not a field + +`DataKey::AdvanceSource(BytesN<32>) -> Source`, written beside the `Advance` at disbursement, and +**absent means `AdSense`**. + +Not a field on `Advance`: that struct encodes as a map with symbol keys, so a required field would +change the type of the value stored under an existing key, and every advance recorded before the +upgrade would fail to decode. Those entries are debts. `advance_source` returns `Source` rather than +`Option`, because absent is not missing data — it is the answer. + +Event-only was the other option and is weaker: the front end would have to reconstruct the source +from history, and #66 deliberately reads figures from the contract's own record rather than summing +Horizon. + +### Reading templates back + +`claim_template()` and `provider_hash()` keep their argument-free form and answer for AdSense, so +anything built before #94 keeps working. `claim_template_for(source)` and `provider_hash_for(source)` +are the general form. For `AdSense` both fall back to the pre-#94 singleton keys, so a contract +pinned before sources existed verifies without being re-pinned. **No other source falls back to +anything** — an unpinned source refuses with `TemplateNotSet`. diff --git a/sc/advance/src/claim.rs b/sc/advance/src/claim.rs index dcd4d0e..520935f 100644 --- a/sc/advance/src/claim.rs +++ b/sc/advance/src/claim.rs @@ -139,18 +139,34 @@ fn unpadded(env: &Env, digits: &[u8]) -> Bytes { /// /// `parameters` is pinned in this contract and rebuilt here, so both are as strongly held /// as they were in the context. Nothing moved outside the signature. +/// # Why the figure's key is passed in (#94) +/// +/// AdSense attests dollars (`"123.45"`) and AdMob attests micros (`"123450000"`), so the +/// relay extracts them under different names: `revenueUsd` and `revenueMicros`. The key +/// is inside the context, so it is inside the identifier, so it is signed — it cannot be +/// renamed after the fact or inferred at verification time. +/// +/// They never share a name, and the reason is that the two mistakes are not symmetric. +/// Dollars read as micros truncate to zero cents and are refused. **Micros read as +/// dollars neither overflow nor error: they return the cap.** `quote("123450000")` on the +/// deployed contract is `1_000_000_000` stroops — the 100 USDC maximum — so every advance +/// would silently be the largest one allowed, for any revenue at all. Checked against +/// `CCQFL2Q6…I2HS` on 2026-10-29 rather than reasoned about. pub fn rebuild_context( env: &Env, borrower: &Bytes, - revenue_usd: &Bytes, + revenue_key: &[u8], + revenue: &Bytes, provider_hash: &Bytes, ) -> Bytes { let mut out = Bytes::from_slice(env, br#"{"contextAddress":""#); out.append(borrower); out.extend_from_slice(br#"","contextMessage":""#); out.extend_from_slice(CONTEXT_MESSAGE); - out.extend_from_slice(br#"","extractedParameters":{"revenueUsd":""#); - out.append(revenue_usd); + out.extend_from_slice(br#"","extractedParameters":{""#); + out.extend_from_slice(revenue_key); + out.extend_from_slice(br#"":""#); + out.append(revenue); out.extend_from_slice(br#""},"providerHash":""#); out.append(provider_hash); out.extend_from_slice(br#""}"#); @@ -288,11 +304,36 @@ pub fn lowercase(env: &Env, b: &Bytes) -> Bytes { /// parameters="b\nc"` hashes identically to `provider="a\nb", parameters="c"`, which #3 /// pinned with a test. Length prefixes cost four bytes each and remove the question, so /// no caller can shift a boundary between the publisher id and the window. -pub fn nullifier_of(env: &Env, pub_id: &Bytes, window_start: &Bytes, window_end: &Bytes) -> Bytes { +/// # Why `tag` is `Option` rather than always present (#94) +/// +/// A second revenue source needs its own nullifier space: one Google account's AdSense +/// and AdMob publisher ids are **the same `pub-` id** — confirmed on a real account in +/// #93, not assumed — so without a tag an AdMob proof would spend the AdSense nullifier +/// for the same window, or be blocked by it. The two are different money and each should +/// be borrowable once. +/// +/// AdSense passes `None` and therefore hashes exactly the bytes it always has. That +/// asymmetry is **forced, not chosen**: advances already on chain are keyed on the +/// untagged hash, and tagging AdSense now would orphan them. Every source added after +/// AdSense is tagged. `source_tag` in `lib.rs` is the one place that mapping lives. +pub fn nullifier_of( + env: &Env, + pub_id: &Bytes, + window_start: &Bytes, + window_end: &Bytes, + tag: Option<&[u8]>, +) -> Bytes { let mut buf = Bytes::new(env); for field in [pub_id, window_start, window_end] { buf.extend_from_slice(&field.len().to_be_bytes()); buf.append(field); } + // Length-prefixed like the others, so a tag can never be confused with a longer + // window, and absent is not the same as empty: `None` appends nothing at all, while + // a zero-length tag would append four zero bytes and change the hash. + if let Some(tag) = tag { + buf.extend_from_slice(&(tag.len() as u32).to_be_bytes()); + buf.extend_from_slice(tag); + } env.crypto().sha256(&buf).to_bytes().into() } diff --git a/sc/advance/src/lib.rs b/sc/advance/src/lib.rs index 0b4d890..0160809 100644 --- a/sc/advance/src/lib.rs +++ b/sc/advance/src/lib.rs @@ -49,9 +49,27 @@ mod sizing; pub use claim::{CONTEXT_MESSAGE, PROVIDER}; pub use sizing::{ - ADVANCE_CAP_STROOPS, ADVANCE_DEN, ADVANCE_NUM, MIN_ADVANCE_STROOPS, STROOPS_PER_CENT, + ADVANCE_CAP_STROOPS, ADVANCE_DEN, ADVANCE_NUM, MICROS_PER_CENT, MIN_ADVANCE_STROOPS, + STROOPS_PER_CENT, }; +/// Which Google reporting product a claim was made against (#94). +/// +/// Not a label: it selects the template, and the template pins the host. An AdMob claim +/// is rebuilt against `admob.googleapis.com` bytes and can therefore never verify against +/// the AdSense template, or the reverse. That is the property that makes a second source +/// safe to add, and it lives in storage rather than in the caller's argument. +/// +/// Append-only, like `DataKey`: a variant may be added, none may be removed or renamed. +#[contracttype] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Source { + /// Websites. The original and only source through #93; dollars, in `revenueUsd`. + AdSense, + /// Apps. Micros, in `revenueMicros`, with the window inside a signed POST body. + AdMob, +} + /// Storage keys. Append-only: a new variant may be added, none may ever be removed, /// renamed or given a different payload type. #[contracttype] @@ -78,9 +96,25 @@ pub enum DataKey { /// vanished when its TTL lapsed would erase a debt, which is not a rounding error. Advance(BytesN<32>), /// The attestor's `owner` every claim must carry: the Reclaim app the relay proves - /// with, `0x…`, lowercase (#102). Absent means the borrower, which is what the - /// rehearsal's test witness signs; no real attestor claim has that owner. + /// with, `0x…`, lowercase (#102). Absent is refused rather than guessed — see + /// `verify_claim`. ClaimOwner, + /// The claim template for one revenue source (#94). + /// + /// `ParamsTemplate` above is the AdSense template as it was pinned before sources + /// existed. It is never written again and never removed: `template_of` reads this key + /// first and falls back to it, so a contract pinned under the old key keeps working + /// without a re-pin, and the dev contract did not have to be re-pinned to deploy this. + ParamsTemplateFor(Source), + /// That source's provider hash, as it appears in the signed context. + ProviderHashFor(Source), + /// The source an advance was taken against, beside the `Advance` rather than inside it. + /// + /// **Absent means `AdSense`.** `Advance` is a `#[contracttype]` struct, encoded as a + /// map with symbol keys, so adding a required field would change the type of the value + /// stored under an existing key and every advance already recorded would fail to + /// decode. Those entries represent debts. A parallel key leaves them untouched. + AdvanceSource(BytesN<32>), } /// An advance that has been paid out, and what is still owed on it. @@ -211,15 +245,35 @@ pub enum Error { /// Reclaim's `verify_proof` refused the digest. Either the signature is not from a /// current witness, or one of the rebuilt fields differs from what was signed. VerifierRejected = 14, + /// No claim owner pinned, so the digest cannot be rebuilt (#102). + /// + /// Refused rather than defaulted. The owner a real attestor signs is the requesting + /// Reclaim app, and before #102 this contract rebuilt it as the borrower — a form no + /// real claim has ever carried, which made every real proof fail as `VerifierRejected` + /// with nothing pointing at the cause. Defaulting to the borrower when nothing is + /// pinned would keep that exact failure as the state a contract is in immediately + /// after an upgrade. A contract that cannot verify says so. + ClaimOwnerNotSet = 15, + /// `set_claim_owner` was given something that is not `0x` and 40 hex digits. + /// + /// Its own code rather than `ClaimMismatch`: #11 means the rebuilt claim disagrees + /// with what the attestor signed, and anyone who saw it here would go looking at the + /// template and the proof instead of at their own argument. + ClaimOwnerMalformed = 16, // --- 20-29: nullifier registry (#10) --- /// This publisher and window have already funded an advance. NullifierSpent = 20, // --- 30-39: sizing (#11) --- - /// `revenueUsd` is not a plain non-negative decimal, or carries more than two - /// decimal places. Refused rather than rounded: rounding would make the advance - /// depend on how we round, and anyone must be able to re-derive the figure. + /// The attested figure is not parseable in the form its source attests. + /// + /// For `AdSense`, `revenueUsd` is not a plain non-negative decimal, or carries more + /// than two decimal places. For `AdMob` (#94), `revenueMicros` is not a plain + /// non-negative integer. Refused rather than rounded or coerced: rounding would make + /// the advance depend on how we round, and anyone must be able to re-derive the + /// figure. One code for both, because the caller already knows which source it asked + /// for and the meaning is the same. RevenueUnparseable = 30, /// The sized advance is below `MIN_ADVANCE_STROOPS`. Refused so that a dust advance /// cannot burn the creator's nullifier for the period in exchange for nothing. @@ -487,8 +541,12 @@ impl AdvanceContract { /// no string form for a date: `reports:generate` takes `startDate.year=2026& /// startDate.month=7&startDate.day=1`, unpadded, and one `"2026-07-01"` cannot fill /// three query parameters (#76). + /// `source` selects which template is written. The two are independent: pinning + /// AdMob cannot disturb AdSense, and an AdMob claim is rebuilt against + /// `admob.googleapis.com` bytes so it can never verify against the AdSense template. pub fn set_claim_template( env: Env, + source: Source, parts: Vec, provider_hash: Bytes, ) -> Result<(), Error> { @@ -499,24 +557,38 @@ impl AdvanceContract { let n = parts.len(); env.storage() .instance() - .set(&DataKey::ParamsTemplate, &parts); + .set(&DataKey::ParamsTemplateFor(source), &parts); env.storage() .instance() - .set(&DataKey::ProviderHash, &provider_hash); + .set(&DataKey::ProviderHashFor(source), &provider_hash); Self::bump(&env); ClaimTemplateSet { admin, parts: n }.publish(&env); Ok(()) } - /// The pinned template, if one is set. Public so that anyone can check what this - /// contract will accept before sending a proof to it. + /// The pinned AdSense template, if one is set. + /// + /// Kept argument-free at its original name so anything already reading it keeps + /// working; `claim_template_for` is the general form. pub fn claim_template(env: Env) -> Option> { - env.storage().instance().get(&DataKey::ParamsTemplate) + Self::claim_template_for(env, Source::AdSense) } pub fn provider_hash(env: Env) -> Option { - env.storage().instance().get(&DataKey::ProviderHash) + Self::provider_hash_for(env, Source::AdSense) + } + + /// That source's pinned template, if one is set. Public so that anyone can check what + /// this contract will accept before sending a proof to it. + pub fn claim_template_for(env: Env, source: Source) -> Option> { + Self::template_of(&env, &source) + .ok() + .map(|(parts, _)| parts) + } + + pub fn provider_hash_for(env: Env, source: Source) -> Option { + Self::template_of(&env, &source).ok().map(|(_, hash)| hash) } /// Pin the attestor's `owner`: the Reclaim app id the relay proves with (#102). @@ -535,7 +607,7 @@ impl AdvanceContract { pub fn set_claim_owner(env: Env, owner: Bytes) -> Result<(), Error> { let admin = Self::require_admin(&env)?; if !claim::is_eth_address(&owner) { - return Err(Error::ClaimMismatch); + return Err(Error::ClaimOwnerMalformed); } let owner = claim::lowercase(&env, &owner); env.storage().instance().set(&DataKey::ClaimOwner, &owner); @@ -564,6 +636,7 @@ impl AdvanceContract { /// and the digest changes with it. pub fn verify_claim( env: Env, + source: Source, borrower: Address, revenue_usd: String, pub_id: String, @@ -574,16 +647,7 @@ impl AdvanceContract { signature: BytesN<64>, recovery_id: u32, ) -> Result { - let parts: Vec = env - .storage() - .instance() - .get(&DataKey::ParamsTemplate) - .ok_or(Error::TemplateNotSet)?; - let provider_hash: Bytes = env - .storage() - .instance() - .get(&DataKey::ProviderHash) - .ok_or(Error::TemplateNotSet)?; + let (parts, provider_hash) = Self::template_of(&env, &source)?; // Freshness before any hashing: a stale proof should cost the caller a cheap // refusal, not a keccak over the whole request template. @@ -605,25 +669,37 @@ impl AdvanceContract { // only form AdSense accepts (#76). `window_start` and `window_end` stay // `YYYY-MM-DD` in the interface and in the nullifier — this is a re-encoding on // the way into the template, not a change to what is being borrowed against. - let (sy, sm, sd) = claim::split_date(&env, &start_b).ok_or(Error::ClaimMismatch)?; - let (ey, em, ed) = claim::split_date(&env, &end_b).ok_or(Error::ClaimMismatch)?; - - let parameters = - claim::rebuild_parameters(&parts, &[pub_id_b.clone(), sy, sm, sd, ey, em, ed]) - .ok_or(Error::ClaimMismatch)?; - let context = claim::rebuild_context(&env, &borrower_b, &revenue_b, &provider_hash); + let start = claim::split_date(&env, &start_b).ok_or(Error::ClaimMismatch)?; + let end = claim::split_date(&env, &end_b).ok_or(Error::ClaimMismatch)?; + + let values = Self::claim_values(&source, pub_id_b.clone(), start, end); + let parameters = claim::rebuild_parameters(&parts, &values).ok_or(Error::ClaimMismatch)?; + let context = claim::rebuild_context( + &env, + &borrower_b, + Self::revenue_key(&source), + &revenue_b, + &provider_hash, + ); let identifier = claim::identifier(&env, ¶meters, &context); let identifier_hex = claim::hex_prefixed(&identifier); - // The attestor's `owner` is the Reclaim app that requested the proof, pinned by the - // admin (#102). Before #102 this was the borrower, which no real attestor claim - // carries; that form survives only where nothing is pinned, for the rehearsal's - // test witness. Reclaim lowercases the owner before signing. - let owner: Bytes = match env.storage().instance().get(&DataKey::ClaimOwner) { - Some(pinned) => pinned, - None => claim::lowercase(&env, &borrower_b), - }; + // The attestor's `owner` is the Reclaim app that requested the proof, pinned by + // the admin (#102). Reclaim lowercases it before signing, so the pinned value is + // stored lowercased. + // + // Unpinned is refused, not defaulted. Before #102 this was rebuilt as the + // borrower — a form no real attestor claim has ever carried — and the symptom was + // a bare `VerifierRejected` that took a real proof to diagnose. Falling back to + // the borrower when nothing is pinned would keep that failure as the state every + // contract is in immediately after this upgrade, which is the one moment someone + // is most likely to be testing it. + let owner: Bytes = env + .storage() + .instance() + .get(&DataKey::ClaimOwner) + .ok_or(Error::ClaimOwnerNotSet)?; let digest = claim::message_digest(&env, &identifier_hex, &owner, timestamp_s, epoch); let verifier: Address = env @@ -659,6 +735,7 @@ impl AdvanceContract { /// anything, rather than after. pub fn nullifier_for( env: Env, + source: Source, pub_id: String, window_start: String, window_end: String, @@ -666,7 +743,7 @@ impl AdvanceContract { let pub_id = claim::string_bytes(&env, &pub_id).ok_or(Error::ClaimMismatch)?; let start = claim::string_bytes(&env, &window_start).ok_or(Error::ClaimMismatch)?; let end = claim::string_bytes(&env, &window_end).ok_or(Error::ClaimMismatch)?; - claim::nullifier_of(&env, &pub_id, &start, &end) + claim::nullifier_of(&env, &pub_id, &start, &end, Self::source_tag(&source)) .try_into() .map_err(|_| Error::ClaimMismatch) } @@ -701,6 +778,7 @@ impl AdvanceContract { /// transactions in the same ledger could both pass the check. pub fn verify_and_reserve( env: Env, + source: Source, borrower: Address, revenue_usd: String, pub_id: String, @@ -717,6 +795,7 @@ impl AdvanceContract { let verified = Self::verify_claim( env.clone(), + source, borrower, revenue_usd, pub_id, @@ -730,6 +809,7 @@ impl AdvanceContract { let nullifier = Self::nullifier_for( env.clone(), + source, verified.pub_id.clone(), verified.window_start.clone(), verified.window_end.clone(), @@ -803,6 +883,19 @@ impl AdvanceContract { env.storage().persistent().get(&DataKey::Advance(nullifier)) } + /// The source an advance was taken against. **Absent means `AdSense`** (#94). + /// + /// Returns the source rather than an `Option`, because absent is not missing data: it + /// is the answer for every advance recorded before a second source existed, and for + /// every AdSense advance since. A front end reading this gets the source from a + /// contract read rather than reconstructing it from event history (#66). + pub fn advance_source(env: Env, nullifier: BytesN<32>) -> Source { + env.storage() + .persistent() + .get(&DataKey::AdvanceSource(nullifier)) + .unwrap_or(Source::AdSense) + } + /// Prove revenue, size an advance, and receive USDC. The product, in one call. /// /// The order is the security property and does not change: @@ -836,6 +929,7 @@ impl AdvanceContract { /// race and two transactions in one ledger could otherwise both pass the check. pub fn request_advance( env: Env, + source: Source, borrower: Address, revenue_usd: String, pub_id: String, @@ -850,6 +944,7 @@ impl AdvanceContract { let verified = Self::verify_claim( env.clone(), + source, borrower, revenue_usd, pub_id, @@ -861,7 +956,11 @@ impl AdvanceContract { recovery_id, )?; - let cents = sizing::parse_usd_cents(&env, &verified.revenue_usd) + // Dollars for AdSense, micros for AdMob. The figure arrives as the text the + // attestor signed, so the unit is fixed by the source and never inferred from + // the digits — `"123450000"` is a valid figure in both units and means two + // things four orders of magnitude apart. + let cents = Self::revenue_cents(&env, &source, &verified.revenue_usd) .ok_or(Error::RevenueUnparseable)?; let principal = sizing::advance_stroops(cents).ok_or(Error::RevenueUnparseable)?; if principal < sizing::MIN_ADVANCE_STROOPS { @@ -870,6 +969,7 @@ impl AdvanceContract { let nullifier = Self::nullifier_for( env.clone(), + source, verified.pub_id.clone(), verified.window_start.clone(), verified.window_end.clone(), @@ -924,6 +1024,19 @@ impl AdvanceContract { .persistent() .extend_ttl(&adv_key, 120 * 17_280, 180 * 17_280); + // Beside the advance, not inside it. Written only for a source that is not + // AdSense, so absent reads as AdSense and the advances recorded before #94 — in + // the old shape, with no source anywhere — stay correct rather than merely + // decodable. Same forced asymmetry as the nullifier tag, so there is one rule to + // remember instead of two. + if !matches!(source, Source::AdSense) { + let src_key = DataKey::AdvanceSource(nullifier.clone()); + env.storage().persistent().set(&src_key, &source); + env.storage() + .persistent() + .extend_ttl(&src_key, 120 * 17_280, 180 * 17_280); + } + NullifierSpent { borrower: verified.borrower.clone(), nullifier: nullifier.clone(), @@ -994,6 +1107,97 @@ impl AdvanceContract { // -------------------------------------------------------------- helpers + // ------------------------------------------------ per-source shape (#94) + + /// The nullifier tag for a source, or `None` for an untagged nullifier space. + /// + /// **AdSense carries no tag, and that is forced rather than chosen.** Advances already + /// on chain are keyed on the untagged hash of `(pub_id, window_start, window_end)`; + /// tagging AdSense now would compute a different key for them and orphan records that + /// represent debts. Every source added after AdSense is tagged. + /// + /// A tag is needed at all because one Google account's AdSense and AdMob publisher + /// ids are the same `pub-` id — confirmed on a real account in #93. Untagged, an + /// AdMob proof would spend the AdSense nullifier for the same window. + /// + /// This is the only place the exception lives. Nothing else should branch on it. + fn source_tag(source: &Source) -> Option<&'static [u8]> { + match source { + Source::AdSense => None, + Source::AdMob => Some(b"admob"), + } + } + + /// The key the figure is extracted under, inside the signed context. + /// + /// Signed, so it cannot be renamed afterwards. The two never share a name: see + /// `claim::rebuild_context` for why micros read as dollars is the dangerous direction. + fn revenue_key(source: &Source) -> &'static [u8] { + match source { + Source::AdSense => b"revenueUsd", + Source::AdMob => b"revenueMicros", + } + } + + /// Parse the attested figure into cents, in the unit its source attests. + fn revenue_cents(env: &Env, source: &Source, revenue: &String) -> Option { + match source { + Source::AdSense => sizing::parse_usd_cents(env, revenue), + Source::AdMob => sizing::parse_micros_cents(env, revenue), + } + } + + /// The seven values, in the order they appear in that source's signed `parameters`. + /// + /// `rebuild_parameters` interleaves positionally, so **the order is part of the + /// source's shape and lives here, not in the template** — the template is only the + /// literal segments between the values. + /// + /// AdSense carries `pub_id` in the URL path and the window in the query string after + /// it. AdMob puts the window inside `body`, and `body` sorts before `url` in the + /// canonical parameters (#93), so the window comes first and `pub_id` last. + /// + /// Getting this wrong does not fail safe into a wrong template: `rebuild_parameters` + /// would hash a different request, the identifier would not match what the attestor + /// signed, and it would surface as `ClaimMismatch` with nothing pointing at the cause. + /// `tools/pin_template.py --self-test` and `be/src/admob/request.test.ts` check the + /// same ordering independently, so no two of the three can be wrong together. + fn claim_values( + source: &Source, + pub_id: Bytes, + start: (Bytes, Bytes, Bytes), + end: (Bytes, Bytes, Bytes), + ) -> [Bytes; 7] { + let (sy, sm, sd) = start; + let (ey, em, ed) = end; + match source { + Source::AdSense => [pub_id, sy, sm, sd, ey, em, ed], + Source::AdMob => [sy, sm, sd, ey, em, ed, pub_id], + } + } + + /// That source's template and provider hash. + /// + /// For `AdSense` it falls back to the pre-#94 singleton keys, so a contract pinned + /// before sources existed keeps verifying without being re-pinned. For any other + /// source there is no fallback: an unpinned source refuses. + fn template_of(env: &Env, source: &Source) -> Result<(Vec, Bytes), Error> { + let st = env.storage().instance(); + let parts: Option> = st.get(&DataKey::ParamsTemplateFor(*source)); + let hash: Option = st.get(&DataKey::ProviderHashFor(*source)); + let (parts, hash) = match (parts, hash) { + (Some(p), Some(h)) => (p, h), + _ if matches!(source, Source::AdSense) => ( + st.get(&DataKey::ParamsTemplate) + .ok_or(Error::TemplateNotSet)?, + st.get(&DataKey::ProviderHash) + .ok_or(Error::TemplateNotSet)?, + ), + _ => return Err(Error::TemplateNotSet), + }; + Ok((parts, hash)) + } + fn require_admin(env: &Env) -> Result { let admin: Address = env .storage() @@ -1023,6 +1227,8 @@ impl AdvanceContract { #[cfg(test)] mod test; #[cfg(test)] +mod test_admob; +#[cfg(test)] mod test_advance; #[cfg(test)] mod test_claim; diff --git a/sc/advance/src/sizing.rs b/sc/advance/src/sizing.rs index a59fae5..ea962d1 100644 --- a/sc/advance/src/sizing.rs +++ b/sc/advance/src/sizing.rs @@ -94,3 +94,50 @@ pub fn advance_stroops(cents: i128) -> Option { sized }) } + +/// Micros per cent. AdMob reports `ESTIMATED_EARNINGS` as `microsValue`: millionths of a +/// currency unit, so `"123450000"` is $123.45 and one cent is 10,000 micros. +pub const MICROS_PER_CENT: i128 = 10_000; + +/// Parse an AdMob `microsValue` string into cents, **truncating**. +/// +/// The figure arrives as an integer string of micros, with no decimal point — that is the +/// shape of the field, and the provider's regex captures it as `\d+`. So this refuses a +/// `.` rather than accepting a decimal it was not given, for the same reason +/// `parse_usd_cents` refuses a third decimal place: a figure nobody can re-derive is +/// indistinguishable from one we made up. +/// +/// **Truncation is deliberate and one-directional.** `1_239_999` micros is $1.239999, and +/// this returns 123 cents, not 124. The advance is never sized from more than was +/// attested, and the lost fraction is at most one cent — below the 1 USDC floor by four +/// orders of magnitude, so it can never be the difference between an advance and a +/// refusal. +/// +/// Returns `None` for anything that is not a plain non-negative integer. +pub fn parse_micros_cents(env: &Env, micros: &String) -> Option { + let len = micros.len() as usize; + if len == 0 || len > 32 { + return None; + } + let mut buf = [0u8; 32]; + micros.copy_into_slice(&mut buf[..len]); + let _ = env; + + let mut total: i128 = 0; + for &c in &buf[..len] { + match c { + b'0'..=b'9' => { + total = total.checked_mul(10)?.checked_add((c - b'0') as i128)?; + // Stop well before the multiply in `advance_stroops` can overflow, the + // same guard `parse_usd_cents` applies to its whole part. + if total > i128::MAX / 1_000_000 { + return None; + } + } + // No '.' arm on purpose: a micros field has no fractional part, and silently + // accepting one would mean accepting a figure in a unit we were not given. + _ => return None, + } + } + Some(total / MICROS_PER_CENT) +} diff --git a/sc/advance/src/test_admob.rs b/sc/advance/src/test_admob.rs new file mode 100644 index 0000000..d63be0f --- /dev/null +++ b/sc/advance/src/test_admob.rs @@ -0,0 +1,314 @@ +//! AdMob as a second revenue source (#94). +//! +//! Every constant here comes from `tools/fixtures/forepay-claim.json`, generated by +//! `tools/make_claim_fixture.py` and checked by CI. The AdMob identifier that generator +//! produces is **byte-identical** to the one `be/src/admob/fixture.test.ts` produces from +//! the relay's own request (#101) — a Python encoder and a TypeScript one agreeing on the +//! canonical parameters, the context and the keccak over them. That agreement is the +//! point of having a fixture at all, and it is what #102 taught: a harness that signs +//! what the contract expects proves only that the contract agrees with itself. + +#![cfg(test)] + +use super::*; +use soroban_sdk::{ + testutils::{Address as _, Ledger as _}, + Address, Bytes, Env, String, Vec, +}; + +use crate::test_claim::{ + signature_from, MockVerifier, APP_OWNER, BORROWER, EPOCH, PROVIDER_HASH, PUB_ID, REVENUE, + TEMPLATE, TIMESTAMP_S, WINDOW_END, WINDOW_START, +}; + +/// The literal segments of the AdMob request, with the seven values interleaved. +/// +/// Note where the values fall: the six date numbers are inside `body`, which sorts before +/// `url` in the canonical parameters, so `pub_id` is **last** rather than first (#93). +/// The separators end with escaped JSON keys (`\"month\":`) rather than with `=`. +const ADMOB_TEMPLATE: [&[u8]; 8] = [ + br#"{"body":"{\"reportSpec\":{\"dateRange\":{\"startDate\":{\"year\":"#, + br#",\"month\":"#, + br#",\"day\":"#, + br#"},\"endDate\":{\"year\":"#, + br#",\"month\":"#, + br#",\"day\":"#, + br#"}},\"metrics\":[\"ESTIMATED_EARNINGS\"],\"localizationSettings\":{\"currencyCode\":\"USD\"}}}","headers":{"User-Agent":"reclaim/0.0.1","accept":"application/json","content-type":"application/json"},"method":"POST","responseMatches":[{"type":"regex","value":"\"localizationSettings\":\\s*\\{\\s*\"currencyCode\":\\s*\"USD\"\\s*\\}"},{"type":"regex","value":"\"row\":\\s*\\{\\s*\"metricValues\":\\s*\\{\\s*\"ESTIMATED_EARNINGS\":\\s*\\{\\s*\"microsValue\":\\s*\"(?\\d+)\"\\s*\\}\\s*\\}\\s*\\}"}],"responseRedactions":[{"regex":"\"localizationSettings\":\\s*\\{\\s*\"currencyCode\":\\s*\"USD\"\\s*\\}"},{"regex":"\"row\":\\s*\\{\\s*\"metricValues\":\\s*\\{\\s*\"ESTIMATED_EARNINGS\":\\s*\\{\\s*\"microsValue\":\\s*\"(?\\d+)\"\\s*\\}\\s*\\}\\s*\\}"}],"url":"https://admob.googleapis.com/v1/accounts/"#, + br#"/networkReport:generate"}"#, +]; + +const ADMOB_SIGNATURE_HEX: &str = "b7695d7a14d6de5fb0d1ebb2a0858e8f773247dca9e76b87c1482e9a8fe250996d9ca44151a1cc24001f62a8d568a0d218e573a03fb19a7ad638b3ea024045ce"; +const ADMOB_RECOVERY_ID: u32 = 0; +const ADMOB_REVENUE_MICROS: &str = "12345678"; +/// The AdSense nullifier for the fixture's publisher and window, as it has always been. +/// +/// Pinned against a literal rather than recomputed, because advances already on chain are +/// keyed on exactly these bytes. Independently derived in Python — +/// `sha256` over each of `pub_id`, `window_start`, `window_end` length-prefixed with four +/// big-endian bytes — so this is not the contract agreeing with itself. +const ADSENSE_NULLIFIER: [u8; 32] = [ + 0x31, 0x40, 0xb7, 0xa0, 0x1c, 0x30, 0x6d, 0x98, 0xcf, 0xed, 0x42, 0xae, 0x54, 0x09, 0x28, 0x56, + 0xf3, 0x88, 0x08, 0xa6, 0x9e, 0x15, 0xef, 0x94, 0xce, 0x26, 0xd5, 0x7a, 0x73, 0x4b, 0xa3, 0x1a, +]; + +const ADMOB_PROVIDER_HASH: &str = + "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"; + +struct Fx { + env: Env, + client: AdvanceContractClient<'static>, + borrower: Address, +} + +/// Both templates pinned, and the claim owner pinned to the app. +fn fx() -> Fx { + let env = Env::default(); + env.mock_all_auths(); + env.ledger().set_timestamp(TIMESTAMP_S + 10); + + let verifier = env.register(MockVerifier, ()); + let id = env.register( + AdvanceContract, + (Address::generate(&env), verifier, Address::generate(&env)), + ); + let client = AdvanceContractClient::new(&env, &id); + + let mut adsense = Vec::new(&env); + for p in TEMPLATE.iter() { + adsense.push_back(Bytes::from_slice(&env, p)); + } + client.set_claim_template( + &Source::AdSense, + &adsense, + &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes()), + ); + + let mut admob = Vec::new(&env); + for p in ADMOB_TEMPLATE.iter() { + admob.push_back(Bytes::from_slice(&env, p)); + } + client.set_claim_template( + &Source::AdMob, + &admob, + &Bytes::from_slice(&env, ADMOB_PROVIDER_HASH.as_bytes()), + ); + + client.set_claim_owner(&Bytes::from_slice(&env, APP_OWNER.as_bytes())); + + let borrower = Address::from_string(&String::from_str(&env, BORROWER)); + Fx { + env, + client, + borrower, + } +} + +fn verify_admob(f: &Fx, source: Source) -> Result { + match f.client.try_verify_claim( + &source, + &f.borrower, + &String::from_str(&f.env, ADMOB_REVENUE_MICROS), + &String::from_str(&f.env, PUB_ID), + &String::from_str(&f.env, WINDOW_START), + &String::from_str(&f.env, WINDOW_END), + &TIMESTAMP_S, + &EPOCH, + &signature_from(&f.env, ADMOB_SIGNATURE_HEX), + &ADMOB_RECOVERY_ID, + ) { + Ok(Ok(claim)) => Ok(claim), + Err(Ok(e)) => Err(e), + other => panic!("unexpected host-level result: {other:?}"), + } +} + +#[test] +fn an_admob_claim_verifies_against_its_own_template() { + let f = fx(); + let claim = verify_admob(&f, Source::AdMob).expect("the signed AdMob fixture must verify"); + assert_eq!(claim.borrower, f.borrower); + assert_eq!( + claim.revenue_usd, + String::from_str(&f.env, ADMOB_REVENUE_MICROS) + ); + assert_eq!(claim.pub_id, String::from_str(&f.env, PUB_ID)); +} + +#[test] +fn an_admob_claim_cannot_be_checked_against_the_adsense_template() { + // The template pins the host. An AdMob claim rebuilt against the AdSense template + // hashes a request to adsense.googleapis.com, so the identifier differs and the + // signature recovers to nobody. This is the property that makes a second source safe + // to add: the caller's `source` argument cannot choose the host, only the template can. + let f = fx(); + assert_eq!( + verify_admob(&f, Source::AdSense), + Err(Error::VerifierRejected) + ); +} + +#[test] +fn an_adsense_claim_cannot_be_checked_against_the_admob_template() { + let f = fx(); + let out = f.client.try_verify_claim( + &Source::AdMob, + &f.borrower, + &String::from_str(&f.env, REVENUE), + &String::from_str(&f.env, PUB_ID), + &String::from_str(&f.env, WINDOW_START), + &String::from_str(&f.env, WINDOW_END), + &TIMESTAMP_S, + &EPOCH, + &crate::test_claim::signature(&f.env), + &crate::test_claim::RECOVERY_ID, + ); + assert_eq!(out, Err(Ok(Error::VerifierRejected))); +} + +#[test] +fn an_unpinned_source_refuses_rather_than_falling_back_to_adsense() { + // AdSense falls back to the pre-#94 singleton keys so a contract pinned before + // sources existed keeps working. Nothing else falls back to anything. + let env = Env::default(); + env.mock_all_auths(); + let id = env.register( + AdvanceContract, + ( + Address::generate(&env), + env.register(MockVerifier, ()), + Address::generate(&env), + ), + ); + let client = AdvanceContractClient::new(&env, &id); + let mut adsense = Vec::new(&env); + for p in TEMPLATE.iter() { + adsense.push_back(Bytes::from_slice(&env, p)); + } + client.set_claim_template( + &Source::AdSense, + &adsense, + &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes()), + ); + client.set_claim_owner(&Bytes::from_slice(&env, APP_OWNER.as_bytes())); + + assert!(client.claim_template_for(&Source::AdSense).is_some()); + assert!(client.claim_template_for(&Source::AdMob).is_none()); + + let out = client.try_verify_claim( + &Source::AdMob, + &Address::from_string(&String::from_str(&env, BORROWER)), + &String::from_str(&env, ADMOB_REVENUE_MICROS), + &String::from_str(&env, PUB_ID), + &String::from_str(&env, WINDOW_START), + &String::from_str(&env, WINDOW_END), + &TIMESTAMP_S, + &EPOCH, + &signature_from(&env, ADMOB_SIGNATURE_HEX), + &ADMOB_RECOVERY_ID, + ); + assert_eq!(out, Err(Ok(Error::TemplateNotSet))); +} + +#[test] +fn pinning_admob_leaves_the_adsense_template_untouched() { + let f = fx(); + let adsense = f + .client + .claim_template_for(&Source::AdSense) + .expect("adsense stays pinned"); + assert_eq!( + adsense.get(0).unwrap(), + Bytes::from_slice(&f.env, TEMPLATE[0]) + ); + // And the argument-free getter still answers for AdSense, so anything reading it + // from before #94 keeps working. + assert_eq!(f.client.claim_template(), Some(adsense)); +} + +#[test] +fn the_adsense_nullifier_bytes_did_not_change() { + // Pinned against a literal, because advances already on chain are keyed on exactly + // these bytes. If this test ever has to be updated, those records are orphaned. + let f = fx(); + let n = f.client.nullifier_for( + &Source::AdSense, + &String::from_str(&f.env, PUB_ID), + &String::from_str(&f.env, WINDOW_START), + &String::from_str(&f.env, WINDOW_END), + ); + assert_eq!(n.to_array(), ADSENSE_NULLIFIER); +} + +#[test] +fn admob_and_adsense_do_not_share_a_nullifier() { + // One Google account's AdSense and AdMob publisher ids are the same `pub-` id — + // confirmed on a real account in #93. Untagged, an AdMob proof would spend the + // AdSense nullifier for the same window, or be blocked by it. They are different + // money and each should be borrowable once. + let f = fx(); + let adsense = f.client.nullifier_for( + &Source::AdSense, + &String::from_str(&f.env, PUB_ID), + &String::from_str(&f.env, WINDOW_START), + &String::from_str(&f.env, WINDOW_END), + ); + let admob = f.client.nullifier_for( + &Source::AdMob, + &String::from_str(&f.env, PUB_ID), + &String::from_str(&f.env, WINDOW_START), + &String::from_str(&f.env, WINDOW_END), + ); + assert_ne!(adsense, admob); +} + +#[test] +fn micros_truncate_to_cents_and_never_round_up() { + let env = Env::default(); + let cents = |s: &str| sizing::parse_micros_cents(&env, &String::from_str(&env, s)); + + assert_eq!(cents("12345678"), Some(1234)); // $12.345678 -> 1234c, not 1235 + assert_eq!(cents("1239999"), Some(123)); // $1.239999 -> 123c, not 124 + assert_eq!(cents("10000"), Some(1)); // one cent exactly + assert_eq!(cents("9999"), Some(0)); // just under a cent + assert_eq!(cents("0"), Some(0)); + + // Not a plain non-negative integer: refused rather than coerced. A micros field has + // no fractional part, so accepting a '.' would mean accepting a figure in a unit we + // were not given. + for bad in ["12.34", "-1", "12 34", "", "1e6", "0x10"] { + assert_eq!(cents(bad), None, "{bad}"); + } +} + +#[test] +fn dollars_and_micros_are_never_interchangeable() { + // The asymmetry that is the whole reason the context key differs per source. + // `12345678` read as dollars is $12,345,678 and sizes to the cap, silently. + let env = Env::default(); + let as_micros = sizing::parse_micros_cents(&env, &String::from_str(&env, "12345678")).unwrap(); + let as_dollars = sizing::parse_usd_cents(&env, &String::from_str(&env, "12345678")).unwrap(); + assert_eq!(as_micros, 1234); + assert_eq!(as_dollars, 1_234_567_800); + assert_eq!( + sizing::advance_stroops(as_dollars), + Some(sizing::ADVANCE_CAP_STROOPS), + "micros read as dollars returns the cap rather than erroring, which is why the \ + key names the unit inside the signed context" + ); +} + +#[test] +fn an_advance_with_no_recorded_source_reads_as_adsense() { + // `DataKey::AdvanceSource` is written only for a source that is not AdSense, so + // absent is the answer for every advance recorded before #94 existed. Those entries + // are debts; they must read correctly, not merely decode. + let f = fx(); + let nullifier = f.client.nullifier_for( + &Source::AdSense, + &String::from_str(&f.env, PUB_ID), + &String::from_str(&f.env, WINDOW_START), + &String::from_str(&f.env, WINDOW_END), + ); + assert_eq!(f.client.advance_source(&nullifier), Source::AdSense); + assert_eq!(f.client.advance(&nullifier), None); +} diff --git a/sc/advance/src/test_advance.rs b/sc/advance/src/test_advance.rs index f7983e4..c03aa28 100644 --- a/sc/advance/src/test_advance.rs +++ b/sc/advance/src/test_advance.rs @@ -15,8 +15,8 @@ use soroban_sdk::{ }; use crate::test_claim::{ - signature, BORROWER, EPOCH, PROVIDER_HASH, PUB_ID, RECOVERY_ID, REVENUE, TEMPLATE, TIMESTAMP_S, - WINDOW_END, WINDOW_START, + signature, APP_OWNER, BORROWER, EPOCH, PROVIDER_HASH, PUB_ID, RECOVERY_ID, REVENUE, TEMPLATE, + TIMESTAMP_S, WINDOW_END, WINDOW_START, }; struct Fx { @@ -46,7 +46,15 @@ fn fx(fund_stroops: i128) -> Fx { for p in TEMPLATE.iter() { parts.push_back(Bytes::from_slice(&env, p)); } - client.set_claim_template(&parts, &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes())); + client.set_claim_template( + &Source::AdSense, + &parts, + &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes()), + ); + // The owner has to be pinned here too, even though these tests use a verifier that + // accepts any signature: `verify_claim` refuses an unpinned contract before it ever + // reaches the verifier (#102). That is the point of refusing rather than defaulting. + client.set_claim_owner(&Bytes::from_slice(&env, APP_OWNER.as_bytes())); let usdc_admin = StellarAssetClient::new(&env, &usdc); if fund_stroops > 0 { @@ -70,6 +78,7 @@ fn fx(fund_stroops: i128) -> Fx { fn request(f: &Fx) -> Result { match f.client.try_request_advance( + &Source::AdSense, &f.borrower, &String::from_str(&f.env, REVENUE), &String::from_str(&f.env, PUB_ID), @@ -261,6 +270,7 @@ fn nobody_can_take_an_advance_in_someone_elses_name() { let f = fx(ADVANCE_CAP_STROOPS * 2); f.env.set_auths(&[]); f.client.request_advance( + &Source::AdSense, &f.borrower, &String::from_str(&f.env, REVENUE), &String::from_str(&f.env, PUB_ID), @@ -282,6 +292,7 @@ fn nobody_can_burn_someone_elses_nullifier_for_free() { let f = fx(ADVANCE_CAP_STROOPS * 2); f.env.set_auths(&[]); f.client.verify_and_reserve( + &Source::AdSense, &f.borrower, &String::from_str(&f.env, REVENUE), &String::from_str(&f.env, PUB_ID), @@ -300,6 +311,7 @@ fn an_underfunded_contract_refuses_before_spending_the_nullifier() { assert_eq!(request(&f), Err(Error::InsufficientLiquidity)); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), @@ -331,6 +343,7 @@ fn a_full_cycle_leaves_nothing_outstanding() { let f = fx(ADVANCE_CAP_STROOPS * 2); let principal = request(&f).unwrap(); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), @@ -353,6 +366,7 @@ fn overpaying_is_refused() { let f = fx(ADVANCE_CAP_STROOPS * 2); let principal = request(&f).unwrap(); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), @@ -370,6 +384,7 @@ fn overpaying_is_refused() { fn repaying_something_that_was_never_advanced_is_refused() { let f = fx(0); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), @@ -385,6 +400,7 @@ fn a_zero_or_negative_repayment_is_refused() { let f = fx(ADVANCE_CAP_STROOPS * 2); request(&f).unwrap(); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), @@ -421,7 +437,12 @@ fn a_borrower_without_a_trustline_gets_a_named_error_not_a_panic() { for p in TEMPLATE.iter() { parts.push_back(Bytes::from_slice(&env, p)); } - client.set_claim_template(&parts, &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes())); + client.set_claim_template( + &Source::AdSense, + &parts, + &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes()), + ); + client.set_claim_owner(&Bytes::from_slice(&env, APP_OWNER.as_bytes())); StellarAssetClient::new(&env, &usdc).mint(&id, &(ADVANCE_CAP_STROOPS * 2)); // A literal `G…` with nothing behind it in the test ledger. `Address::generate` @@ -429,6 +450,7 @@ fn a_borrower_without_a_trustline_gets_a_named_error_not_a_panic() { // a transfer to one succeeds and the path under test never runs. let borrower = Address::from_string(&String::from_str(&env, BORROWER)); let out = client.try_request_advance( + &Source::AdSense, &borrower, &String::from_str(&env, REVENUE), &String::from_str(&env, PUB_ID), @@ -443,6 +465,7 @@ fn a_borrower_without_a_trustline_gets_a_named_error_not_a_panic() { // And it must not have burned the period on a payment that could not land. let n = client.nullifier_for( + &Source::AdSense, &String::from_str(&env, PUB_ID), &String::from_str(&env, WINDOW_START), &String::from_str(&env, WINDOW_END), @@ -455,6 +478,7 @@ fn the_ledger_records_what_was_proven_not_what_was_claimed() { let f = fx(ADVANCE_CAP_STROOPS * 2); request(&f).unwrap(); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), diff --git a/sc/advance/src/test_claim.rs b/sc/advance/src/test_claim.rs index 109593b..1924ce7 100644 --- a/sc/advance/src/test_claim.rs +++ b/sc/advance/src/test_claim.rs @@ -37,13 +37,18 @@ pub(crate) const PROVIDER_HASH: &str = "0x569b93233185c054ed9fda68b5aef8fda180b6d291180450bf757b11bb52f7df"; pub(crate) const TIMESTAMP_S: u64 = 1_760_000_000; pub(crate) const EPOCH: u64 = 1; -const SIGNATURE_HEX: &str = "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f"; -pub(crate) const RECOVERY_ID: u32 = 1; -/// The same claim, signed the way a real attestor signs it: with `owner` set to the -/// requesting Reclaim app rather than the borrower (#102). From the fixture's `appOwner*`. -const APP_OWNER: &str = "0x6415200c713135e77157e1536d488df4f2bb7d04"; +/// The claim signed the way a real attestor signs it: `owner` set to the requesting +/// Reclaim app (#102). This is the **default** these tests run through, because it is the +/// only shape that exists in the wild. From the fixture's `appOwner*`. +pub(crate) const APP_OWNER: &str = "0x6415200c713135e77157e1536d488df4f2bb7d04"; const APP_SIGNATURE_HEX: &str = "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7"; -const APP_RECOVERY_ID: u32 = 0; +pub(crate) const RECOVERY_ID: u32 = 0; + +/// The same claim signed with `owner = borrower`, the form this harness used before #102. +/// No attestor has ever produced it. Kept only so the tests that prove it is refused can +/// still construct it. +const BORROWER_SIGNATURE_HEX: &str = "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f"; +const BORROWER_RECOVERY_ID: u32 = 1; /// The address the fixture's signature recovers to. const SIGNER: [u8; 20] = [ 0x19, 0xe7, 0xe3, 0x76, 0xe7, 0xc2, 0x13, 0xb7, 0xe7, 0xe7, 0xe4, 0x6c, 0xc7, 0x0a, 0x5d, 0xd0, @@ -139,7 +144,9 @@ struct Fixture { borrower: Address, } -fn setup() -> Fixture { +/// Template pinned, claim owner **not** pinned. Only for the tests that are about the +/// owner itself; everything else uses `setup`. +fn setup_unpinned() -> Fixture { let env = Env::default(); env.mock_all_auths(); env.ledger().set_timestamp(TIMESTAMP_S + 10); @@ -154,7 +161,11 @@ fn setup() -> Fixture { for p in TEMPLATE.iter() { parts.push_back(Bytes::from_slice(&env, p)); } - client.set_claim_template(&parts, &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes())); + client.set_claim_template( + &Source::AdSense, + &parts, + &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes()), + ); let borrower = Address::from_string(&String::from_str(&env, BORROWER)); Fixture { @@ -164,11 +175,34 @@ fn setup() -> Fixture { } } +/// The default fixture: template pinned **and** the claim owner pinned to the app. +/// +/// Pinning the owner is not a detail of these tests, it is the shape every real claim +/// has (#102). The harness used to sign with `owner = borrower`, which no attestor has +/// ever produced, and that is precisely why the suite could be green while the contract +/// could not verify anything real. A `G…` address cannot even be pinned — `set_claim_owner` +/// takes `0x` and 40 hex digits — so there is no way to write that old shape here by +/// accident any more. +fn setup() -> Fixture { + let f = setup_unpinned(); + f.client + .set_claim_owner(&Bytes::from_slice(&f.env, APP_OWNER.as_bytes())); + f +} + +/// The app-signed signature: the form a real attestor produces, and therefore the default +/// every test runs through. `SIGNATURE_HEX` (owner = borrower) survives only in the tests +/// that prove that shape is refused. pub(crate) fn signature(env: &Env) -> BytesN<64> { - signature_from(env, SIGNATURE_HEX) + signature_from(env, APP_SIGNATURE_HEX) +} + +/// The pre-#102 shape: `owner = borrower`. Pairs with `BORROWER_RECOVERY_ID`. +fn borrower_signature(env: &Env) -> BytesN<64> { + signature_from(env, BORROWER_SIGNATURE_HEX) } -fn signature_from(env: &Env, hex: &str) -> BytesN<64> { +pub(crate) fn signature_from(env: &Env, hex: &str) -> BytesN<64> { let mut raw = [0u8; 64]; for (i, b) in raw.iter_mut().enumerate() { let hi = hex.as_bytes()[i * 2]; @@ -188,6 +222,7 @@ fn verify( borrower: &Address, ) -> Result { match f.client.try_verify_claim( + &Source::AdSense, borrower, &String::from_str(&f.env, revenue), &String::from_str(&f.env, pub_id), @@ -252,6 +287,7 @@ fn verification_is_refused_until_the_template_is_pinned() { // The contract deploys with no template, and must refuse rather than accept anything. let out = client.try_verify_claim( + &Source::AdSense, &borrower, &String::from_str(&env, REVENUE), &String::from_str(&env, PUB_ID), @@ -340,7 +376,13 @@ fn the_context_carries_only_the_figure() { // hashes, and is simply never what an attestor signed. let env = Env::default(); let b = |s: &str| Bytes::from_slice(&env, s.as_bytes()); - let got = crate::claim::rebuild_context(&env, &b(BORROWER), &b(REVENUE), &b(PROVIDER_HASH)); + let got = crate::claim::rebuild_context( + &env, + &b(BORROWER), + b"revenueUsd", + &b(REVENUE), + &b(PROVIDER_HASH), + ); let want = b(concat!( r#"{"contextAddress":"GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2","#, r#""contextMessage":"Forepay advance request","#, @@ -377,7 +419,7 @@ fn the_template_the_contract_used_to_accept_is_refused_now() { parts.push_back(Bytes::from_slice(&env, p)); } assert_eq!( - client.try_set_claim_template(&parts, &Bytes::from_slice(&env, b"0x00")), + client.try_set_claim_template(&Source::AdSense, &parts, &Bytes::from_slice(&env, b"0x00")), Err(Ok(Error::ClaimMismatch)) ); } @@ -397,7 +439,11 @@ fn only_the_admin_can_pin_the_template() { } // No auth mocked: require_auth must bite. assert!(client - .try_set_claim_template(&parts, &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes())) + .try_set_claim_template( + &Source::AdSense, + &parts, + &Bytes::from_slice(&env, PROVIDER_HASH.as_bytes()) + ) .is_err()); } @@ -417,7 +463,7 @@ fn a_template_with_the_wrong_number_of_parts_is_refused() { let mut parts = Vec::new(&env); parts.push_back(Bytes::from_slice(&env, b"only-one-part")); assert_eq!( - client.try_set_claim_template(&parts, &Bytes::from_slice(&env, b"0x00")), + client.try_set_claim_template(&Source::AdSense, &parts, &Bytes::from_slice(&env, b"0x00")), Err(Ok(Error::ClaimMismatch)) ); } @@ -427,6 +473,7 @@ fn a_template_with_the_wrong_number_of_parts_is_refused() { /// `verify_claim` on the fixture signed with the app as owner. fn verify_app_signed(f: &Fixture) -> Result { match f.client.try_verify_claim( + &Source::AdSense, &f.borrower, &String::from_str(&f.env, REVENUE), &String::from_str(&f.env, PUB_ID), @@ -435,7 +482,7 @@ fn verify_app_signed(f: &Fixture) -> Result { &TIMESTAMP_S, &EPOCH, &signature_from(&f.env, APP_SIGNATURE_HEX), - &APP_RECOVERY_ID, + &RECOVERY_ID, ) { Ok(Ok(claim)) => Ok(claim), Err(Ok(e)) => Err(e), @@ -444,28 +491,43 @@ fn verify_app_signed(f: &Fixture) -> Result { } #[test] -fn without_a_pinned_owner_a_claim_signed_as_a_real_attestor_signs_is_refused() { - // The #102 bug, kept as a test: rebuilding the owner from the borrower cannot match a - // claim whose owner is the requesting app, which is every real attestor claim. - let f = setup(); - assert_eq!(verify_app_signed(&f), Err(Error::VerifierRejected)); +fn an_unpinned_contract_refuses_rather_than_guessing_the_owner() { + // #102, as a refusal instead of a silent wrong answer. Before the fix the contract + // rebuilt the owner from the borrower, a form no real attestor claim carries, and the + // symptom was a bare VerifierRejected that took a real proof to diagnose. Defaulting + // to that form when nothing is pinned would leave every contract in exactly that + // state for the window between execute_upgrade and set_claim_owner. + let f = setup_unpinned(); + assert_eq!(verify_app_signed(&f), Err(Error::ClaimOwnerNotSet)); + assert_eq!(f.client.claim_owner(), None); } #[test] fn with_the_app_pinned_as_owner_that_claim_verifies() { let f = setup(); - f.client - .set_claim_owner(&Bytes::from_slice(&f.env, APP_OWNER.as_bytes())); let claim = verify_app_signed(&f).expect("a claim signed for the pinned app must verify"); assert_eq!(claim.borrower, f.borrower); } #[test] fn with_the_app_pinned_a_claim_signed_for_the_borrower_is_refused() { + // The pre-#102 shape, refused on a contract configured the way a real one is. This is + // what proves pinning actually changes the bytes being hashed rather than being + // recorded and ignored. let f = setup(); - f.client - .set_claim_owner(&Bytes::from_slice(&f.env, APP_OWNER.as_bytes())); - assert!(verify(&f, REVENUE, PUB_ID, &f.borrower).is_err()); + let out = f.client.try_verify_claim( + &Source::AdSense, + &f.borrower, + &String::from_str(&f.env, REVENUE), + &String::from_str(&f.env, PUB_ID), + &String::from_str(&f.env, WINDOW_START), + &String::from_str(&f.env, WINDOW_END), + &TIMESTAMP_S, + &EPOCH, + &borrower_signature(&f.env), + &BORROWER_RECOVERY_ID, + ); + assert_eq!(out, Err(Ok(Error::VerifierRejected))); } #[test] @@ -473,10 +535,9 @@ fn the_borrower_binding_survives_the_pinned_owner() { // The owner is the app for everyone, so it cannot be what binds the borrower. The // context still does: another address changes the identifier. let f = setup(); - f.client - .set_claim_owner(&Bytes::from_slice(&f.env, APP_OWNER.as_bytes())); let attacker = Address::generate(&f.env); let out = f.client.try_verify_claim( + &Source::AdSense, &attacker, &String::from_str(&f.env, REVENUE), &String::from_str(&f.env, PUB_ID), @@ -485,7 +546,7 @@ fn the_borrower_binding_survives_the_pinned_owner() { &TIMESTAMP_S, &EPOCH, &signature_from(&f.env, APP_SIGNATURE_HEX), - &APP_RECOVERY_ID, + &RECOVERY_ID, ); assert_eq!(out, Err(Ok(Error::VerifierRejected))); } @@ -511,7 +572,7 @@ fn the_owner_is_stored_lowercase_and_must_look_like_one() { assert_eq!( f.client .try_set_claim_owner(&Bytes::from_slice(&f.env, bad.as_bytes())), - Err(Ok(Error::ClaimMismatch)), + Err(Ok(Error::ClaimOwnerMalformed)), "{bad}" ); } @@ -540,6 +601,7 @@ fn only_the_admin_can_pin_the_owner() { fn reserve(f: &Fixture, borrower: &Address) -> Result { match f.client.try_verify_and_reserve( + &Source::AdSense, borrower, &String::from_str(&f.env, REVENUE), &String::from_str(&f.env, PUB_ID), @@ -569,6 +631,7 @@ fn the_same_proof_cannot_fund_two_advances() { fn the_nullifier_is_recorded_as_spent_and_was_not_before() { let f = setup(); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), @@ -590,6 +653,7 @@ fn a_refused_claim_does_not_burn_the_nullifier() { assert!(reserve(&f, &attacker).is_err()); let n = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), @@ -608,11 +672,13 @@ fn a_refused_claim_does_not_burn_the_nullifier() { fn a_different_window_is_a_different_nullifier() { let f = setup(); let a = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, WINDOW_START), &String::from_str(&f.env, WINDOW_END), ); let b = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, PUB_ID), &String::from_str(&f.env, "2026-04-01"), &String::from_str(&f.env, "2026-06-30"), @@ -627,11 +693,13 @@ fn field_boundaries_cannot_be_shifted_between_publisher_and_window() { // moving characters across a boundary must change the hash. let f = setup(); let a = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, "pub-12"), &String::from_str(&f.env, "34"), &String::from_str(&f.env, WINDOW_END), ); let b = f.client.nullifier_for( + &Source::AdSense, &String::from_str(&f.env, "pub-1"), &String::from_str(&f.env, "234"), &String::from_str(&f.env, WINDOW_END), diff --git a/sc/advance/test_snapshots/test_admob/admob_and_adsense_do_not_share_a_nullifier.1.json b/sc/advance/test_snapshots/test_admob/admob_and_adsense_do_not_share_a_nullifier.1.json new file mode 100644 index 0000000..c7b3f79 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/admob_and_adsense_do_not_share_a_nullifier.1.json @@ -0,0 +1,462 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdMob" + } + ] + }, + { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + }, + { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 1760000010, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414144324b4d" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_admob/an_admob_claim_cannot_be_checked_against_the_adsense_template.1.json b/sc/advance/test_snapshots/test_admob/an_admob_claim_cannot_be_checked_against_the_adsense_template.1.json new file mode 100644 index 0000000..4d0f034 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/an_admob_claim_cannot_be_checked_against_the_adsense_template.1.json @@ -0,0 +1,461 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdMob" + } + ] + }, + { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + }, + { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 1760000010, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414144324b4d" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_admob/an_admob_claim_verifies_against_its_own_template.1.json b/sc/advance/test_snapshots/test_admob/an_admob_claim_verifies_against_its_own_template.1.json new file mode 100644 index 0000000..4d0f034 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/an_admob_claim_verifies_against_its_own_template.1.json @@ -0,0 +1,461 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdMob" + } + ] + }, + { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + }, + { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 1760000010, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414144324b4d" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_admob/an_adsense_claim_cannot_be_checked_against_the_admob_template.1.json b/sc/advance/test_snapshots/test_admob/an_adsense_claim_cannot_be_checked_against_the_admob_template.1.json new file mode 100644 index 0000000..4d0f034 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/an_adsense_claim_cannot_be_checked_against_the_admob_template.1.json @@ -0,0 +1,461 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdMob" + } + ] + }, + { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + }, + { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 1760000010, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414144324b4d" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_admob/an_advance_with_no_recorded_source_reads_as_adsense.1.json b/sc/advance/test_snapshots/test_admob/an_advance_with_no_recorded_source_reads_as_adsense.1.json new file mode 100644 index 0000000..6c12e90 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/an_advance_with_no_recorded_source_reads_as_adsense.1.json @@ -0,0 +1,463 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdMob" + } + ] + }, + { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + }, + { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 1760000010, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414144324b4d" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_admob/an_unpinned_source_refuses_rather_than_falling_back_to_adsense.1.json b/sc/advance/test_snapshots/test_admob/an_unpinned_source_refuses_rather_than_falling_back_to_adsense.1.json new file mode 100644 index 0000000..8f05511 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/an_unpinned_source_refuses_rather_than_falling_back_to_adsense.1.json @@ -0,0 +1,326 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "74beb3d1766e5455fda0dc427f938b1490e614db4e1af37a884e05f94d87a7d6" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "74beb3d1766e5455fda0dc427f938b1490e614db4e1af37a884e05f94d87a7d6", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414146435434" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_admob/pinning_admob_leaves_the_adsense_template_untouched.1.json b/sc/advance/test_snapshots/test_admob/pinning_admob_leaves_the_adsense_template_untouched.1.json new file mode 100644 index 0000000..c7b3f79 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/pinning_admob_leaves_the_adsense_template_untouched.1.json @@ -0,0 +1,462 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdMob" + } + ] + }, + { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + }, + { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 1760000010, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414144324b4d" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_admob/the_adsense_nullifier_bytes_did_not_change.1.json b/sc/advance/test_snapshots/test_admob/the_adsense_nullifier_bytes_did_not_change.1.json new file mode 100644 index 0000000..4d0f034 --- /dev/null +++ b/sc/advance/test_snapshots/test_admob/the_adsense_nullifier_bytes_did_not_change.1.json @@ -0,0 +1,461 @@ +{ + "generators": { + "address": 4, + "nonce": 0, + "mux_id": 0 + }, + "auth": [ + [], + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, + { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + }, + { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_template", + "args": [ + { + "vec": [ + { + "symbol": "AdMob" + } + ] + }, + { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + }, + { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 29, + "sequence_number": 0, + "timestamp": 1760000010, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + "live_until": 4095 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "801925984706572462" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a" + }, + "storage": [ + { + "key": { + "vec": [ + { + "symbol": "Admin" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b22626f6479223a227b5c227265706f7274537065635c223a7b5c226461746552616e67655c223a7b5c227374617274446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d2c5c22656e64446174655c223a7b5c22796561725c223a" + }, + { + "bytes": "2c5c226d6f6e74685c223a" + }, + { + "bytes": "2c5c226461795c223a" + }, + { + "bytes": "7d7d2c5c226d6574726963735c223a5b5c22455354494d415445445f4541524e494e47535c225d2c5c226c6f63616c697a6174696f6e53657474696e67735c223a7b5c2263757272656e6379436f64655c223a5c225553445c227d7d7d222c2268656164657273223a7b22557365722d4167656e74223a227265636c61696d2f302e302e31222c22616363657074223a226170706c69636174696f6e2f6a736f6e222c22636f6e74656e742d74797065223a226170706c69636174696f6e2f6a736f6e227d2c226d6574686f64223a22504f5354222c22726573706f6e73654d617463686573223a5b7b2274797065223a227265676578222c2276616c7565223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b2274797065223a227265676578222c2276616c7565223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c22726573706f6e7365526564616374696f6e73223a5b7b227265676578223a225c226c6f63616c697a6174696f6e53657474696e67735c223a5c5c732a5c5c7b5c5c732a5c2263757272656e6379436f64655c223a5c5c732a5c225553445c225c5c732a5c5c7d227d2c7b227265676578223a225c22726f775c223a5c5c732a5c5c7b5c5c732a5c226d657472696356616c7565735c223a5c5c732a5c5c7b5c5c732a5c22455354494d415445445f4541524e494e47535c223a5c5c732a5c5c7b5c5c732a5c226d6963726f7356616c75655c223a5c5c732a5c22283f3c726576656e75654d6963726f733e5c5c642b295c225c5c732a5c5c7d5c5c732a5c5c7d5c5c732a5c5c7d227d5d2c2275726c223a2268747470733a2f2f61646d6f622e676f6f676c65617069732e636f6d2f76312f6163636f756e74732f" + }, + { + "bytes": "2f6e6574776f726b5265706f72743a67656e6572617465227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "vec": [ + { + "bytes": "7b226d6574686f64223a22474554222c2275726c223a2268747470733a2f2f616473656e73652e676f6f676c65617069732e636f6d2f76322f6163636f756e74732f" + }, + { + "bytes": "2f7265706f7274733a67656e65726174653f6461746552616e67653d435553544f4d267374617274446174652e796561723d" + }, + { + "bytes": "267374617274446174652e6d6f6e74683d" + }, + { + "bytes": "267374617274446174652e6461793d" + }, + { + "bytes": "26656e64446174652e796561723d" + }, + { + "bytes": "26656e64446174652e6d6f6e74683d" + }, + { + "bytes": "26656e64446174652e6461793d" + }, + { + "bytes": "266d6574726963733d455354494d415445445f4541524e494e47532663757272656e6379436f64653d555344267265706f7274696e6754696d655a6f6e653d4143434f554e545f54494d455f5a4f4e45227d" + } + ] + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdMob" + } + ] + } + ] + }, + "val": { + "bytes": "307863646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364636463646364" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] + } + ] + }, + "val": { + "bytes": "307835363962393332333331383563303534656439666461363862356165663866646131383062366432393131383034353062663735376231316262353266376466" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Usdc" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "vec": [ + { + "symbol": "Verifier" + } + ] + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM" + } + } + ] + } + } + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "0d6d61ed9340595cb73d424cebeddb6def971a72143eafd77ef9806c3724701a", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414149544134" + } + }, + "ext": "v0" + }, + "live_until": 3110400 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "a41146d7d116b29faf18d228425fa97194e16df1d4f3e5d4f51c58ca557fcc6d", + "code": "746573745f636f6e74726163745f666f725f636f6e74726163745f69645f4341414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414144324b4d" + } + }, + "ext": "v0" + }, + "live_until": 4095 + } + ] + }, + "events": [] +} \ No newline at end of file diff --git a/sc/advance/test_snapshots/test_advance/a_borrower_without_a_trustline_gets_a_named_error_not_a_panic.1.json b/sc/advance/test_snapshots/test_advance/a_borrower_without_a_trustline_gets_a_named_error_not_a_panic.1.json index b43fbc0..0f48fdf 100644 --- a/sc/advance/test_snapshots/test_advance/a_borrower_without_a_trustline_gets_a_named_error_not_a_panic.1.json +++ b/sc/advance/test_snapshots/test_advance/a_borrower_without_a_trustline_gets_a_named_error_not_a_panic.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -181,6 +207,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -245,7 +291,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -282,7 +347,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/a_figure_below_the_floor_is_refused_rather_than_paid_as_dust.1.json b/sc/advance/test_snapshots/test_advance/a_figure_below_the_floor_is_refused_rather_than_paid_as_dust.1.json index ec44fe7..ebe6d94 100644 --- a/sc/advance/test_snapshots/test_advance/a_figure_below_the_floor_is_refused_rather_than_paid_as_dust.1.json +++ b/sc/advance/test_snapshots/test_advance/a_figure_below_the_floor_is_refused_rather_than_paid_as_dust.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [] ], @@ -151,6 +177,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -202,7 +248,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -239,7 +304,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/a_full_cycle_leaves_nothing_outstanding.1.json b/sc/advance/test_snapshots/test_advance/a_full_cycle_leaves_nothing_outstanding.1.json index 00ca39e..62425cd 100644 --- a/sc/advance/test_snapshots/test_advance/a_full_cycle_leaves_nothing_outstanding.1.json +++ b/sc/advance/test_snapshots/test_advance/a_full_cycle_leaves_nothing_outstanding.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -106,6 +132,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "request_advance", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4" }, @@ -128,10 +161,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -317,6 +350,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -500,7 +553,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -537,7 +609,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -627,7 +706,7 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4", "key": { "ledger_key_nonce": { - "nonce": "4837995959683129791" + "nonce": "8370022561469687789" } }, "durability": "temporary", diff --git a/sc/advance/test_snapshots/test_advance/a_verified_claim_moves_real_usdc_to_the_borrower.1.json b/sc/advance/test_snapshots/test_advance/a_verified_claim_moves_real_usdc_to_the_borrower.1.json index 0938435..a193602 100644 --- a/sc/advance/test_snapshots/test_advance/a_verified_claim_moves_real_usdc_to_the_borrower.1.json +++ b/sc/advance/test_snapshots/test_advance/a_verified_claim_moves_real_usdc_to_the_borrower.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -107,6 +133,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "request_advance", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4" }, @@ -129,10 +162,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -224,6 +257,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -407,7 +460,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -444,7 +516,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -494,7 +573,7 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4", "key": { "ledger_key_nonce": { - "nonce": "4837995959683129791" + "nonce": "2032731177588607455" } }, "durability": "temporary", diff --git a/sc/advance/test_snapshots/test_advance/a_zero_or_negative_repayment_is_refused.1.json b/sc/advance/test_snapshots/test_advance/a_zero_or_negative_repayment_is_refused.1.json index c990519..f07ff7d 100644 --- a/sc/advance/test_snapshots/test_advance/a_zero_or_negative_repayment_is_refused.1.json +++ b/sc/advance/test_snapshots/test_advance/a_zero_or_negative_repayment_is_refused.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -106,6 +132,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "request_advance", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4" }, @@ -128,10 +161,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -225,6 +258,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -408,7 +461,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -445,7 +517,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -495,7 +574,7 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4", "key": { "ledger_key_nonce": { - "nonce": "4837995959683129791" + "nonce": "2032731177588607455" } }, "durability": "temporary", diff --git a/sc/advance/test_snapshots/test_advance/an_underfunded_contract_refuses_before_spending_the_nullifier.1.json b/sc/advance/test_snapshots/test_advance/an_underfunded_contract_refuses_before_spending_the_nullifier.1.json index 6d4f5e7..fe9191b 100644 --- a/sc/advance/test_snapshots/test_advance/an_underfunded_contract_refuses_before_spending_the_nullifier.1.json +++ b/sc/advance/test_snapshots/test_advance/an_underfunded_contract_refuses_before_spending_the_nullifier.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -182,6 +208,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -246,7 +292,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -283,7 +348,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/nobody_can_burn_someone_elses_nullifier_for_free.1.json b/sc/advance/test_snapshots/test_advance/nobody_can_burn_someone_elses_nullifier_for_free.1.json index d46de3c..6452592 100644 --- a/sc/advance/test_snapshots/test_advance/nobody_can_burn_someone_elses_nullifier_for_free.1.json +++ b/sc/advance/test_snapshots/test_advance/nobody_can_burn_someone_elses_nullifier_for_free.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -180,6 +206,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -244,7 +290,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -281,7 +346,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/nobody_can_take_an_advance_in_someone_elses_name.1.json b/sc/advance/test_snapshots/test_advance/nobody_can_take_an_advance_in_someone_elses_name.1.json index d46de3c..6452592 100644 --- a/sc/advance/test_snapshots/test_advance/nobody_can_take_an_advance_in_someone_elses_name.1.json +++ b/sc/advance/test_snapshots/test_advance/nobody_can_take_an_advance_in_someone_elses_name.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -180,6 +206,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -244,7 +290,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -281,7 +346,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/one_decimal_place_means_tenths_not_hundredths.1.json b/sc/advance/test_snapshots/test_advance/one_decimal_place_means_tenths_not_hundredths.1.json index 83a22b9..930004d 100644 --- a/sc/advance/test_snapshots/test_advance/one_decimal_place_means_tenths_not_hundredths.1.json +++ b/sc/advance/test_snapshots/test_advance/one_decimal_place_means_tenths_not_hundredths.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [], @@ -154,6 +180,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -205,7 +251,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -242,7 +307,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/overpaying_is_refused.1.json b/sc/advance/test_snapshots/test_advance/overpaying_is_refused.1.json index 3a07920..7ebdc03 100644 --- a/sc/advance/test_snapshots/test_advance/overpaying_is_refused.1.json +++ b/sc/advance/test_snapshots/test_advance/overpaying_is_refused.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -106,6 +132,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "request_advance", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4" }, @@ -128,10 +161,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -249,7 +282,7 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", "key": { "ledger_key_nonce": { - "nonce": "1033654523790656264" + "nonce": "4270020994084947596" } }, "durability": "temporary", @@ -269,7 +302,27 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", "key": { "ledger_key_nonce": { - "nonce": "2032731177588607455" + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" } }, "durability": "temporary", @@ -450,7 +503,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -487,7 +559,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -537,7 +616,7 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4", "key": { "ledger_key_nonce": { - "nonce": "4837995959683129791" + "nonce": "2032731177588607455" } }, "durability": "temporary", diff --git a/sc/advance/test_snapshots/test_advance/repaying_something_that_was_never_advanced_is_refused.1.json b/sc/advance/test_snapshots/test_advance/repaying_something_that_was_never_advanced_is_refused.1.json index c9f1a04..a2811a7 100644 --- a/sc/advance/test_snapshots/test_advance/repaying_something_that_was_never_advanced_is_refused.1.json +++ b/sc/advance/test_snapshots/test_advance/repaying_something_that_was_never_advanced_is_refused.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [] @@ -152,6 +178,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -203,7 +249,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -240,7 +305,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/revenue_must_be_a_plain_decimal_with_at_most_two_places.1.json b/sc/advance/test_snapshots/test_advance/revenue_must_be_a_plain_decimal_with_at_most_two_places.1.json index 5f5e521..f4b8cb3 100644 --- a/sc/advance/test_snapshots/test_advance/revenue_must_be_a_plain_decimal_with_at_most_two_places.1.json +++ b/sc/advance/test_snapshots/test_advance/revenue_must_be_a_plain_decimal_with_at_most_two_places.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [], @@ -158,6 +184,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -209,7 +255,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -246,7 +311,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/the_cap_binds.1.json b/sc/advance/test_snapshots/test_advance/the_cap_binds.1.json index ec44fe7..ebe6d94 100644 --- a/sc/advance/test_snapshots/test_advance/the_cap_binds.1.json +++ b/sc/advance/test_snapshots/test_advance/the_cap_binds.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [] ], @@ -151,6 +177,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -202,7 +248,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -239,7 +304,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/the_floor_the_getter_reports_is_the_floor_quote_enforces.1.json b/sc/advance/test_snapshots/test_advance/the_floor_the_getter_reports_is_the_floor_quote_enforces.1.json index 6821297..a95a699 100644 --- a/sc/advance/test_snapshots/test_advance/the_floor_the_getter_reports_is_the_floor_quote_enforces.1.json +++ b/sc/advance/test_snapshots/test_advance/the_floor_the_getter_reports_is_the_floor_quote_enforces.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [], @@ -153,6 +179,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -204,7 +250,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -241,7 +306,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/the_ledger_records_what_was_proven_not_what_was_claimed.1.json b/sc/advance/test_snapshots/test_advance/the_ledger_records_what_was_proven_not_what_was_claimed.1.json index 166b070..6aa15e0 100644 --- a/sc/advance/test_snapshots/test_advance/the_ledger_records_what_was_proven_not_what_was_claimed.1.json +++ b/sc/advance/test_snapshots/test_advance/the_ledger_records_what_was_proven_not_what_was_claimed.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -106,6 +132,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "request_advance", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4" }, @@ -128,10 +161,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -224,6 +257,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -407,7 +460,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -444,7 +516,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -494,7 +573,7 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4", "key": { "ledger_key_nonce": { - "nonce": "4837995959683129791" + "nonce": "2032731177588607455" } }, "durability": "temporary", diff --git a/sc/advance/test_snapshots/test_advance/the_quote_is_a_quarter_of_proven_revenue.1.json b/sc/advance/test_snapshots/test_advance/the_quote_is_a_quarter_of_proven_revenue.1.json index c9f1a04..a2811a7 100644 --- a/sc/advance/test_snapshots/test_advance/the_quote_is_a_quarter_of_proven_revenue.1.json +++ b/sc/advance/test_snapshots/test_advance/the_quote_is_a_quarter_of_proven_revenue.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [] @@ -152,6 +178,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -203,7 +249,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -240,7 +305,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_advance/the_same_proof_cannot_draw_twice.1.json b/sc/advance/test_snapshots/test_advance/the_same_proof_cannot_draw_twice.1.json index c0e30d8..fdd61ba 100644 --- a/sc/advance/test_snapshots/test_advance/the_same_proof_cannot_draw_twice.1.json +++ b/sc/advance/test_snapshots/test_advance/the_same_proof_cannot_draw_twice.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -106,6 +132,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "request_advance", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4" }, @@ -128,10 +161,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -224,6 +257,26 @@ "contract_data": { "ext": "v0", "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "4837995959683129791" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "key": { "ledger_key_nonce": { "nonce": "1033654523790656264" @@ -407,7 +460,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -444,7 +516,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -494,7 +573,7 @@ "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDR4", "key": { "ledger_key_nonce": { - "nonce": "4837995959683129791" + "nonce": "2032731177588607455" } }, "durability": "temporary", diff --git a/sc/advance/test_snapshots/test_advance/the_sizing_getter_describes_the_arithmetic_quote_actually_uses.1.json b/sc/advance/test_snapshots/test_advance/the_sizing_getter_describes_the_arithmetic_quote_actually_uses.1.json index 83a22b9..930004d 100644 --- a/sc/advance/test_snapshots/test_advance/the_sizing_getter_describes_the_arithmetic_quote_actually_uses.1.json +++ b/sc/advance/test_snapshots/test_advance/the_sizing_getter_describes_the_arithmetic_quote_actually_uses.1.json @@ -36,6 +36,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -74,6 +81,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [], @@ -154,6 +180,26 @@ }, "live_until": 4095 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -205,7 +251,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -242,7 +307,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/a_different_window_is_a_different_nullifier.1.json b/sc/advance/test_snapshots/test_claim/a_different_window_is_a_different_nullifier.1.json index b209b4d..9e1c4d7 100644 --- a/sc/advance/test_snapshots/test_claim/a_different_window_is_a_different_nullifier.1.json +++ b/sc/advance/test_snapshots/test_claim/a_different_window_is_a_different_nullifier.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [] ], @@ -110,6 +136,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -141,7 +187,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -178,7 +243,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/a_proof_at_the_edge_of_the_window_still_verifies.1.json b/sc/advance/test_snapshots/test_claim/a_proof_at_the_edge_of_the_window_still_verifies.1.json index 2889fe0..8166cbc 100644 --- a/sc/advance/test_snapshots/test_claim/a_proof_at_the_edge_of_the_window_still_verifies.1.json +++ b/sc/advance/test_snapshots/test_claim/a_proof_at_the_edge_of_the_window_still_verifies.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [] ], "ledger": { @@ -109,6 +135,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -140,7 +186,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/a_proof_bound_to_one_borrower_cannot_be_spent_by_another.1.json b/sc/advance/test_snapshots/test_claim/a_proof_bound_to_one_borrower_cannot_be_spent_by_another.1.json index 9e73102..d57ade8 100644 --- a/sc/advance/test_snapshots/test_claim/a_proof_bound_to_one_borrower_cannot_be_spent_by_another.1.json +++ b/sc/advance/test_snapshots/test_claim/a_proof_bound_to_one_borrower_cannot_be_spent_by_another.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [] ], "ledger": { @@ -109,6 +135,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -140,7 +186,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/a_proof_from_the_future_is_refused.1.json b/sc/advance/test_snapshots/test_claim/a_proof_from_the_future_is_refused.1.json index b25527e..bbefb0d 100644 --- a/sc/advance/test_snapshots/test_claim/a_proof_from_the_future_is_refused.1.json +++ b/sc/advance/test_snapshots/test_claim/a_proof_from_the_future_is_refused.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [] ], "ledger": { @@ -109,6 +135,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -140,7 +186,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/a_refused_claim_does_not_burn_the_nullifier.1.json b/sc/advance/test_snapshots/test_claim/a_refused_claim_does_not_burn_the_nullifier.1.json index 025e095..3b57d1e 100644 --- a/sc/advance/test_snapshots/test_claim/a_refused_claim_does_not_burn_the_nullifier.1.json +++ b/sc/advance/test_snapshots/test_claim/a_refused_claim_does_not_burn_the_nullifier.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [], @@ -66,6 +92,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "verify_and_reserve", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2" }, @@ -88,10 +121,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -120,7 +153,7 @@ "contract": "GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2", "key": { "ledger_key_nonce": { - "nonce": "1033654523790656264" + "nonce": "4837995959683129791" } }, "durability": "temporary", @@ -174,6 +207,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -232,7 +285,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -269,7 +341,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/a_stale_proof_is_refused.1.json b/sc/advance/test_snapshots/test_claim/a_stale_proof_is_refused.1.json index c6917f1..4e2921f 100644 --- a/sc/advance/test_snapshots/test_claim/a_stale_proof_is_refused.1.json +++ b/sc/advance/test_snapshots/test_claim/a_stale_proof_is_refused.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [] ], "ledger": { @@ -109,6 +135,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -140,7 +186,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/without_a_pinned_owner_a_claim_signed_as_a_real_attestor_signs_is_refused.1.json b/sc/advance/test_snapshots/test_claim/an_unpinned_contract_refuses_rather_than_guessing_the_owner.1.json similarity index 91% rename from sc/advance/test_snapshots/test_claim/without_a_pinned_owner_a_claim_signed_as_a_real_attestor_signs_is_refused.1.json rename to sc/advance/test_snapshots/test_claim/an_unpinned_contract_refuses_rather_than_guessing_the_owner.1.json index 83ecd8a..ddf24db 100644 --- a/sc/advance/test_snapshots/test_claim/without_a_pinned_owner_a_claim_signed_as_a_real_attestor_signs_is_refused.1.json +++ b/sc/advance/test_snapshots/test_claim/an_unpinned_contract_refuses_rather_than_guessing_the_owner.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,7 @@ } ] ], + [], [] ], "ledger": { @@ -140,7 +148,14 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +192,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/changing_the_publisher_id_breaks_verification.1.json b/sc/advance/test_snapshots/test_claim/changing_the_publisher_id_breaks_verification.1.json index 83ecd8a..d2e69b3 100644 --- a/sc/advance/test_snapshots/test_claim/changing_the_publisher_id_breaks_verification.1.json +++ b/sc/advance/test_snapshots/test_claim/changing_the_publisher_id_breaks_verification.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [] ], "ledger": { @@ -109,6 +135,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -140,7 +186,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/changing_the_revenue_figure_breaks_verification.1.json b/sc/advance/test_snapshots/test_claim/changing_the_revenue_figure_breaks_verification.1.json index 83ecd8a..d2e69b3 100644 --- a/sc/advance/test_snapshots/test_claim/changing_the_revenue_figure_breaks_verification.1.json +++ b/sc/advance/test_snapshots/test_claim/changing_the_revenue_figure_breaks_verification.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [] ], "ledger": { @@ -109,6 +135,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -140,7 +186,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/field_boundaries_cannot_be_shifted_between_publisher_and_window.1.json b/sc/advance/test_snapshots/test_claim/field_boundaries_cannot_be_shifted_between_publisher_and_window.1.json index b209b4d..9e1c4d7 100644 --- a/sc/advance/test_snapshots/test_claim/field_boundaries_cannot_be_shifted_between_publisher_and_window.1.json +++ b/sc/advance/test_snapshots/test_claim/field_boundaries_cannot_be_shifted_between_publisher_and_window.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [] ], @@ -110,6 +136,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -141,7 +187,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -178,7 +243,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/the_borrower_binding_survives_the_pinned_owner.1.json b/sc/advance/test_snapshots/test_claim/the_borrower_binding_survives_the_pinned_owner.1.json index 56298c9..d57ade8 100644 --- a/sc/advance/test_snapshots/test_claim/the_borrower_binding_survives_the_pinned_owner.1.json +++ b/sc/advance/test_snapshots/test_claim/the_borrower_binding_survives_the_pinned_owner.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -191,7 +198,14 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -228,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/the_contract_rebuilds_the_exact_bytes_the_attestor_signed.1.json b/sc/advance/test_snapshots/test_claim/the_contract_rebuilds_the_exact_bytes_the_attestor_signed.1.json index 83ecd8a..d2e69b3 100644 --- a/sc/advance/test_snapshots/test_claim/the_contract_rebuilds_the_exact_bytes_the_attestor_signed.1.json +++ b/sc/advance/test_snapshots/test_claim/the_contract_rebuilds_the_exact_bytes_the_attestor_signed.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [] ], "ledger": { @@ -109,6 +135,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -140,7 +186,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -177,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/the_nullifier_is_recorded_as_spent_and_was_not_before.1.json b/sc/advance/test_snapshots/test_claim/the_nullifier_is_recorded_as_spent_and_was_not_before.1.json index 07c86df..8b0c576 100644 --- a/sc/advance/test_snapshots/test_claim/the_nullifier_is_recorded_as_spent_and_was_not_before.1.json +++ b/sc/advance/test_snapshots/test_claim/the_nullifier_is_recorded_as_spent_and_was_not_before.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [], [], [ @@ -65,6 +91,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "verify_and_reserve", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2" }, @@ -87,10 +120,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -120,7 +153,7 @@ "contract": "GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2", "key": { "ledger_key_nonce": { - "nonce": "5541220902715666415" + "nonce": "1033654523790656264" } }, "durability": "temporary", @@ -174,6 +207,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -232,7 +285,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -269,7 +341,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/the_owner_is_stored_lowercase_and_must_look_like_one.1.json b/sc/advance/test_snapshots/test_claim/the_owner_is_stored_lowercase_and_must_look_like_one.1.json index bb07700..cbda49e 100644 --- a/sc/advance/test_snapshots/test_claim/the_owner_is_stored_lowercase_and_must_look_like_one.1.json +++ b/sc/advance/test_snapshots/test_claim/the_owner_is_stored_lowercase_and_must_look_like_one.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", @@ -133,6 +159,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "1033654523790656264" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -196,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -233,7 +286,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/the_same_proof_cannot_fund_two_advances.1.json b/sc/advance/test_snapshots/test_claim/the_same_proof_cannot_fund_two_advances.1.json index 39b9dc7..c17a117 100644 --- a/sc/advance/test_snapshots/test_claim/the_same_proof_cannot_fund_two_advances.1.json +++ b/sc/advance/test_snapshots/test_claim/the_same_proof_cannot_fund_two_advances.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -54,6 +61,25 @@ } ] ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", + "function_name": "set_claim_owner", + "args": [ + { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], [ [ "GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2", @@ -63,6 +89,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "verify_and_reserve", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "address": "GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2" }, @@ -85,10 +118,10 @@ "u64": "1" }, { - "bytes": "0a1607562845069dcd91874ae32ffc55d2ce799078af623b8300c1765137ca0f577ba3ed8dc8895867e717734d9535536384718e77126229ed28327c54cf202f" + "bytes": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7" }, { - "u32": 1 + "u32": 0 } ] } @@ -118,7 +151,7 @@ "contract": "GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2", "key": { "ledger_key_nonce": { - "nonce": "5541220902715666415" + "nonce": "1033654523790656264" } }, "durability": "temporary", @@ -172,6 +205,26 @@ }, "live_until": 6311999 }, + { + "entry": { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": "5541220902715666415" + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + "live_until": 6311999 + }, { "entry": { "last_modified_ledger_seq": 0, @@ -230,7 +283,26 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ClaimOwner" + } + ] + }, + "val": { + "bytes": "307836343135323030633731333133356537373135376531353336643438386466346632626237643034" + } + }, + { + "key": { + "vec": [ + { + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -267,7 +339,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/with_the_app_pinned_a_claim_signed_for_the_borrower_is_refused.1.json b/sc/advance/test_snapshots/test_claim/with_the_app_pinned_a_claim_signed_for_the_borrower_is_refused.1.json index 834ffc4..d2e69b3 100644 --- a/sc/advance/test_snapshots/test_claim/with_the_app_pinned_a_claim_signed_for_the_borrower_is_refused.1.json +++ b/sc/advance/test_snapshots/test_claim/with_the_app_pinned_a_claim_signed_for_the_borrower_is_refused.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -191,7 +198,14 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -228,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/advance/test_snapshots/test_claim/with_the_app_pinned_as_owner_that_claim_verifies.1.json b/sc/advance/test_snapshots/test_claim/with_the_app_pinned_as_owner_that_claim_verifies.1.json index 834ffc4..d2e69b3 100644 --- a/sc/advance/test_snapshots/test_claim/with_the_app_pinned_as_owner_that_claim_verifies.1.json +++ b/sc/advance/test_snapshots/test_claim/with_the_app_pinned_as_owner_that_claim_verifies.1.json @@ -16,6 +16,13 @@ "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4", "function_name": "set_claim_template", "args": [ + { + "vec": [ + { + "symbol": "AdSense" + } + ] + }, { "vec": [ { @@ -191,7 +198,14 @@ "key": { "vec": [ { - "symbol": "ParamsTemplate" + "symbol": "ParamsTemplateFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, @@ -228,7 +242,14 @@ "key": { "vec": [ { - "symbol": "ProviderHash" + "symbol": "ProviderHashFor" + }, + { + "vec": [ + { + "symbol": "AdSense" + } + ] } ] }, diff --git a/sc/wasm-hashes.txt b/sc/wasm-hashes.txt index 3b78d90..87ff31c 100644 --- a/sc/wasm-hashes.txt +++ b/sc/wasm-hashes.txt @@ -18,7 +18,7 @@ # triple stellar-cli sha256 # --- verified by CI on every push --- -x86_64-unknown-linux-gnu 28.1.0 c8ca0ee5d8f157a2d76cb0bfa3f05e09e4a2fc2627042ab8b621bbfe850673bb +x86_64-unknown-linux-gnu 28.1.0 PENDING # @@UNVERIFIED@@ rows below this marker are reference only and are not checked aarch64-apple-darwin 27.0.0 2aefbf745ea1b8ac4faea4018b08679adcf233fd0e0590136e46dbbe9756ed25 diff --git a/tools/fixtures/forepay-claim.json b/tools/fixtures/forepay-claim.json index 9c39231..ca44878 100644 --- a/tools/fixtures/forepay-claim.json +++ b/tools/fixtures/forepay-claim.json @@ -39,5 +39,35 @@ "appOwner": "0x6415200c713135e77157e1536d488df4f2bb7d04", "appOwnerSignData": "0x18303a91f81e35d749d26b04a60e1ae95974128afd7ca66b3950547527480dee\n0x6415200c713135e77157e1536d488df4f2bb7d04\n1760000000\n1", "appOwnerSignature64": "be04cabf370de372ce48726350419d76169f5b35fa64ba03ffb5db5b1a5a4a6a773196501dcfd7a42b94a1a510c9aaa0ff5536cb37ed0ada1f917415da9e96c7", - "appOwnerRecoveryId": 0 + "appOwnerRecoveryId": 0, + "admob": { + "pubId": "pub-1234567890123456", + "revenueMicros": "12345678", + "providerHash": "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd", + "templateParts": [ + "{\"body\":\"{\\\"reportSpec\\\":{\\\"dateRange\\\":{\\\"startDate\\\":{\\\"year\\\":", + ",\\\"month\\\":", + ",\\\"day\\\":", + "},\\\"endDate\\\":{\\\"year\\\":", + ",\\\"month\\\":", + ",\\\"day\\\":", + "}},\\\"metrics\\\":[\\\"ESTIMATED_EARNINGS\\\"],\\\"localizationSettings\\\":{\\\"currencyCode\\\":\\\"USD\\\"}}}\",\"headers\":{\"User-Agent\":\"reclaim/0.0.1\",\"accept\":\"application/json\",\"content-type\":\"application/json\"},\"method\":\"POST\",\"responseMatches\":[{\"type\":\"regex\",\"value\":\"\\\"localizationSettings\\\":\\\\s*\\\\{\\\\s*\\\"currencyCode\\\":\\\\s*\\\"USD\\\"\\\\s*\\\\}\"},{\"type\":\"regex\",\"value\":\"\\\"row\\\":\\\\s*\\\\{\\\\s*\\\"metricValues\\\":\\\\s*\\\\{\\\\s*\\\"ESTIMATED_EARNINGS\\\":\\\\s*\\\\{\\\\s*\\\"microsValue\\\":\\\\s*\\\"(?\\\\d+)\\\"\\\\s*\\\\}\\\\s*\\\\}\\\\s*\\\\}\"}],\"responseRedactions\":[{\"regex\":\"\\\"localizationSettings\\\":\\\\s*\\\\{\\\\s*\\\"currencyCode\\\":\\\\s*\\\"USD\\\"\\\\s*\\\\}\"},{\"regex\":\"\\\"row\\\":\\\\s*\\\\{\\\\s*\\\"metricValues\\\":\\\\s*\\\\{\\\\s*\\\"ESTIMATED_EARNINGS\\\":\\\\s*\\\\{\\\\s*\\\"microsValue\\\":\\\\s*\\\"(?\\\\d+)\\\"\\\\s*\\\\}\\\\s*\\\\}\\\\s*\\\\}\"}],\"url\":\"https://admob.googleapis.com/v1/accounts/", + "/networkReport:generate\"}" + ], + "values": [ + "2026", + "7", + "1", + "2026", + "9", + "30", + "pub-1234567890123456" + ], + "parameters": "{\"body\":\"{\\\"reportSpec\\\":{\\\"dateRange\\\":{\\\"startDate\\\":{\\\"year\\\":2026,\\\"month\\\":7,\\\"day\\\":1},\\\"endDate\\\":{\\\"year\\\":2026,\\\"month\\\":9,\\\"day\\\":30}},\\\"metrics\\\":[\\\"ESTIMATED_EARNINGS\\\"],\\\"localizationSettings\\\":{\\\"currencyCode\\\":\\\"USD\\\"}}}\",\"headers\":{\"User-Agent\":\"reclaim/0.0.1\",\"accept\":\"application/json\",\"content-type\":\"application/json\"},\"method\":\"POST\",\"responseMatches\":[{\"type\":\"regex\",\"value\":\"\\\"localizationSettings\\\":\\\\s*\\\\{\\\\s*\\\"currencyCode\\\":\\\\s*\\\"USD\\\"\\\\s*\\\\}\"},{\"type\":\"regex\",\"value\":\"\\\"row\\\":\\\\s*\\\\{\\\\s*\\\"metricValues\\\":\\\\s*\\\\{\\\\s*\\\"ESTIMATED_EARNINGS\\\":\\\\s*\\\\{\\\\s*\\\"microsValue\\\":\\\\s*\\\"(?\\\\d+)\\\"\\\\s*\\\\}\\\\s*\\\\}\\\\s*\\\\}\"}],\"responseRedactions\":[{\"regex\":\"\\\"localizationSettings\\\":\\\\s*\\\\{\\\\s*\\\"currencyCode\\\":\\\\s*\\\"USD\\\"\\\\s*\\\\}\"},{\"regex\":\"\\\"row\\\":\\\\s*\\\\{\\\\s*\\\"metricValues\\\":\\\\s*\\\\{\\\\s*\\\"ESTIMATED_EARNINGS\\\":\\\\s*\\\\{\\\\s*\\\"microsValue\\\":\\\\s*\\\"(?\\\\d+)\\\"\\\\s*\\\\}\\\\s*\\\\}\\\\s*\\\\}\"}],\"url\":\"https://admob.googleapis.com/v1/accounts/pub-1234567890123456/networkReport:generate\"}", + "context": "{\"contextAddress\":\"GA2CD6PMHMBTCFAQDO3R22BSZN5ZSVTAKVNOKXL2SONZBLGRAYIOWWH2\",\"contextMessage\":\"Forepay advance request\",\"extractedParameters\":{\"revenueMicros\":\"12345678\"},\"providerHash\":\"0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd\"}", + "identifier": "0x4f3b53c4ab1ee8f71e6827166cda154d4a5fc22cb2df30d58c69b15977d8aba6", + "signData": "0x4f3b53c4ab1ee8f71e6827166cda154d4a5fc22cb2df30d58c69b15977d8aba6\n0x6415200c713135e77157e1536d488df4f2bb7d04\n1760000000\n1", + "signature64": "b7695d7a14d6de5fb0d1ebb2a0858e8f773247dca9e76b87c1482e9a8fe250996d9ca44151a1cc24001f62a8d568a0d218e573a03fb19a7ad638b3ea024045ce", + "recoveryId": 0 + } } diff --git a/tools/make_claim_fixture.py b/tools/make_claim_fixture.py index 9dc9ae4..60186cb 100644 --- a/tools/make_claim_fixture.py +++ b/tools/make_claim_fixture.py @@ -126,6 +126,137 @@ def build() -> dict: "appOwnerSignData": app_sign_data, "appOwnerSignature64": (app_r.to_bytes(32, "big") + app_s.to_bytes(32, "big")).hex(), "appOwnerRecoveryId": app_rec, + # The same claim chain for AdMob (#94): a different host, the window inside a + # signed POST body, the figure in micros under its own key, and therefore a + # different value order. Signed with the app as owner, because that is the only + # shape a real attestor produces. + "admob": build_admob(), + } + + +# ---------------------------------------------------------------- AdMob (#94) + +ADMOB_PUB_ID = "pub-1234567890123456" +ADMOB_REVENUE_MICROS = "12345678" # $12.345678 -> 1234 cents, truncated +ADMOB_PROVIDER_HASH = "0x" + "cd" * 32 + +# The AdMob request the relay builds, as the attestor canonicalises it: keys sorted, so +# `body` comes before `url`. That ordering is the whole reason AdMob needs its own value +# order — the window lives in `body` and the publisher id in `url`, so the dates come +# first and `pub_id` last (#93). +# +# Built here rather than pasted, so the escaping is produced by the same json encoder the +# relay uses instead of being typed by hand. `tools/fixtures/admob-claim.json` (#101) is +# the relay's own copy of the same request; this one exists so the contract has a *signed* +# AdMob claim to verify, which that one has no signature for. +ADMOB_MATCH = ( + r'"row":\s*\{\s*"metricValues":\s*\{\s*"ESTIMATED_EARNINGS":' + r'\s*\{\s*"microsValue":\s*"(?\d+)"\s*\}\s*\}\s*\}' +) +ADMOB_CURRENCY_MATCH = r'"localizationSettings":\s*\{\s*"currencyCode":\s*"USD"\s*\}' + + +def admob_body(start: str, end: str) -> str: + sy, sm, sd = date_values(start) + ey, em, ed = date_values(end) + return ( + '{"reportSpec":{"dateRange":{"startDate":{"year":' + sy + + ',"month":' + sm + ',"day":' + sd + + '},"endDate":{"year":' + ey + ',"month":' + em + ',"day":' + ed + + '}},"metrics":["ESTIMATED_EARNINGS"],"localizationSettings":{"currencyCode":"USD"}}}' + ) + + +def admob_parameters(pub_id: str, start: str, end: str) -> str: + """The canonical signed parameters: keys in sorted order, body as a JSON string.""" + return json.dumps( + { + "body": admob_body(start, end), + "headers": { + "User-Agent": "reclaim/0.0.1", + "accept": "application/json", + "content-type": "application/json", + }, + "method": "POST", + "responseMatches": [ + {"type": "regex", "value": ADMOB_CURRENCY_MATCH}, + {"type": "regex", "value": ADMOB_MATCH}, + ], + "responseRedactions": [ + {"regex": ADMOB_CURRENCY_MATCH}, + {"regex": ADMOB_MATCH}, + ], + "url": f"https://admob.googleapis.com/v1/accounts/{pub_id}/networkReport:generate", + }, + separators=(",", ":"), + sort_keys=True, + ) + + +def admob_template(parameters: str, values: list[str]) -> list[str]: + """Split `parameters` at the seven values, left to right, and prove the split. + + The same three proofs `tools/pin_template.py` applies, because a template derived + without them round-trips happily while being wrong: a split at the wrong occurrence + of a one-character value like "1" or "7" reproduces the string and then fails for + every other window. + """ + parts: list[str] = [] + cursor = 0 + for i, value in enumerate(values): + at = parameters.find(value, cursor) + assert at >= 0, f"value {i} ({value!r}) not found after offset {cursor}" + parts.append(parameters[cursor:at]) + cursor = at + len(value) + parts.append(parameters[cursor:]) + + rebuilt = parts[0] + for i, value in enumerate(values): + rebuilt += value + parts[i + 1] + assert rebuilt == parameters, "the parts and values do not reproduce the parameters" + + # Structure, which is what actually catches a wrong occurrence. Each date value sits + # immediately after its own escaped JSON key, and the publisher id after /accounts/. + expected_tails = [ + r'\"year\":', r'\"month\":', r'\"day\":', + r'\"year\":', r'\"month\":', r'\"day\":', + "/accounts/", + ] + for i, tail in enumerate(expected_tails): + assert parts[i].endswith(tail), f"part {i} should end {tail!r}, ends {parts[i][-14:]!r}" + assert len(parts) == 8, f"{len(parts)} parts, want 8" + return parts + + +def build_admob() -> dict: + values = date_values(WINDOW_START) + date_values(WINDOW_END) + [ADMOB_PUB_ID] + parameters = admob_parameters(ADMOB_PUB_ID, WINDOW_START, WINDOW_END) + parts = admob_template(parameters, values) + + context = ( + '{"contextAddress":"' + BORROWER + + '","contextMessage":"' + CONTEXT_MESSAGE + + '","extractedParameters":{"revenueMicros":"' + ADMOB_REVENUE_MICROS + + '"},"providerHash":"' + ADMOB_PROVIDER_HASH + '"}' + ) + identifier = "0x" + secp.keccak256( + b"http\n" + parameters.encode() + b"\n" + context.encode() + ).hex() + sign_data = f"{identifier}\n{APP_OWNER.lower()}\n{TIMESTAMP_S}\n{EPOCH}" + r, s, rec = secp.sign(secp.eip191_digest(sign_data), TEST_KEY) + + return { + "pubId": ADMOB_PUB_ID, + "revenueMicros": ADMOB_REVENUE_MICROS, + "providerHash": ADMOB_PROVIDER_HASH, + "templateParts": parts, + "values": values, + "parameters": parameters, + "context": context, + "identifier": identifier, + "signData": sign_data, + "signature64": (r.to_bytes(32, "big") + s.to_bytes(32, "big")).hex(), + "recoveryId": rec, } From 779a5ef6581cfd6e2f470c28b100bd8ab4026eac Mon Sep 17 00:00:00 2001 From: Lexirieru Date: Thu, 29 Oct 2026 19:19:35 +0700 Subject: [PATCH 2/4] feat(#94): record the linux wasm hash CI measured Filled in from the measurement the runner printed for the PENDING row, rather than from a local build: wasm is byte-identical only within a host triple and toolchain, so the macOS hash is not the one CI checks. x86_64-unknown-linux-gnu 28.1.0 4c5b24de377fab73a55db715739f8b4d9f7e48e75484cad0c8f9df8f52b7a049 Every other step of that run passed, including "Test snapshots are committed", so the snapshots in the previous commit are complete and stable. Coverage was skipped because the job stopped at the PENDING row; this push is the first run that exercises it. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01QdNuoJ9e954ojofNVGUezW --- sc/wasm-hashes.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sc/wasm-hashes.txt b/sc/wasm-hashes.txt index 87ff31c..1609b18 100644 --- a/sc/wasm-hashes.txt +++ b/sc/wasm-hashes.txt @@ -18,7 +18,7 @@ # triple stellar-cli sha256 # --- verified by CI on every push --- -x86_64-unknown-linux-gnu 28.1.0 PENDING +x86_64-unknown-linux-gnu 28.1.0 4c5b24de377fab73a55db715739f8b4d9f7e48e75484cad0c8f9df8f52b7a049 # @@UNVERIFIED@@ rows below this marker are reference only and are not checked aarch64-apple-darwin 27.0.0 2aefbf745ea1b8ac4faea4018b08679adcf233fd0e0590136e46dbbe9756ed25 From faf9540216d3892a26adf64ffcd4f00dd0800cc9 Mon Sep 17 00:00:00 2001 From: Lexirieru Date: Thu, 29 Oct 2026 19:25:32 +0700 Subject: [PATCH 3/4] docs(#94): say why unwrap_or on AdvanceSource is safe Verified against the official state-archival docs via MCP Stellar Raven: a persistent entry whose TTL lapses is archived, not deleted, and the host makes the caller restore it before the read. So an AdMob advance cannot quietly read back as AdSense once its TTL runs out. The line itself would be a silent debt-relabelling bug in temporary storage, and nothing in the code said why it is not one here. Same property the nullifier already rests on. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01QdNuoJ9e954ojofNVGUezW --- sc/advance/src/lib.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/sc/advance/src/lib.rs b/sc/advance/src/lib.rs index 0160809..b96e937 100644 --- a/sc/advance/src/lib.rs +++ b/sc/advance/src/lib.rs @@ -889,6 +889,11 @@ impl AdvanceContract { /// is the answer for every advance recorded before a second source existed, and for /// every AdSense advance since. A front end reading this gets the source from a /// contract read rather than reconstructing it from event history (#66). + /// `unwrap_or` is safe here only because the entry is **persistent**. A persistent + /// entry whose TTL lapses is archived, not deleted, and the host makes the caller + /// restore it before the read — so an AdMob advance can never quietly read back as + /// AdSense once its TTL runs out. In `temporary` storage this same line would do + /// exactly that, silently, and relabel a debt. Same reasoning the nullifier rests on. pub fn advance_source(env: Env, nullifier: BytesN<32>) -> Source { env.storage() .persistent() From 648f86456330ee68c1ed280ba390fd1810770206 Mon Sep 17 00:00:00 2001 From: Lexirieru Date: Thu, 29 Oct 2026 19:30:04 +0700 Subject: [PATCH 4/4] fix(#94): re-record the wasm hash, and why a doc comment moved it The previous row was measured before faf9540, which added a doc comment and nothing else. That changed the wasm. Proven rather than assumed, by building twice with nothing else different: with the doc comment on advance_source 0c5c70c9...acdd (aarch64-apple-darwin) with that one comment removed 57f3ebce...04b3 and `strings` finds the comment's text inside the wasm. soroban-sdk embeds the doc comments of #[contractimpl] functions in the contract-spec metadata section, so they are part of the deployed bytes. Two consequences, now in the wasm-hashes.txt header so the next person does not spend an afternoon on it: - A "docs only" commit is not docs-only for the artifact. It needs this row re-recorded, and on a released contract a new release and a new verification. - These comments are published on chain and readable by anyone. Good to have on purpose, surprising to discover by accident. Linux row from CI's own measurement on the rebased branch: x86_64-unknown-linux-gnu 28.1.0 f4fd10d646307bd4f204a26be3b64c35141587b9e12aca0f41b48c049d3a5a36 Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01QdNuoJ9e954ojofNVGUezW --- sc/wasm-hashes.txt | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/sc/wasm-hashes.txt b/sc/wasm-hashes.txt index 1609b18..0d1a207 100644 --- a/sc/wasm-hashes.txt +++ b/sc/wasm-hashes.txt @@ -15,10 +15,25 @@ # The hash that matters for deployment is neither of these: it is the one the release # workflow produces, because StellarExpert matches the on-chain wasm against the attested # artifact. See docs/deployments.md. +# +# A DOC COMMENT ON A PUBLIC CONTRACT FUNCTION CHANGES THESE HASHES. +# +# soroban-sdk embeds the doc comments of `#[contractimpl]` functions in the wasm's +# contract-spec metadata, so they are part of the deployed bytes. Measured here on +# 2026-10-29 by building twice with nothing else changed: +# +# with a doc comment on `advance_source` 0c5c70c9...acdd (aarch64-apple-darwin) +# with that one comment removed 57f3ebce...04b3 +# +# and `strings` finds the comment's text inside the wasm. So a "docs only" commit is not +# docs-only for the artifact: it needs this row re-recorded, and on a released contract it +# needs a new release and a new verification. It also means these comments are published +# on chain and readable by anyone — which is a good property to have on purpose and a +# surprising one to discover by accident. # triple stellar-cli sha256 # --- verified by CI on every push --- -x86_64-unknown-linux-gnu 28.1.0 4c5b24de377fab73a55db715739f8b4d9f7e48e75484cad0c8f9df8f52b7a049 +x86_64-unknown-linux-gnu 28.1.0 f4fd10d646307bd4f204a26be3b64c35141587b9e12aca0f41b48c049d3a5a36 # @@UNVERIFIED@@ rows below this marker are reference only and are not checked aarch64-apple-darwin 27.0.0 2aefbf745ea1b8ac4faea4018b08679adcf233fd0e0590136e46dbbe9756ed25