commit dd493e1502e17a5725c03736d9d826456e6d0c79 parent 22c816a10f815cc1b5b9d6b16d02986418e997b0 Author: triesap <tyson@radroots.org> Date: Sun, 25 Oct 2026 03:03:59 +0000 storage: retain authenticated seller source evidence - Preserve exact original carriers and deduplicated logical records. - Bind owner access and independently acknowledged source progress. - Commit bounded protected evidence on the existing native worker. - Verify retained catalogs, atomic failures, replay and provider races. Diffstat:
28 files changed, 2675 insertions(+), 56 deletions(-)
diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -2450,6 +2450,15 @@ impl serde_core::ser::Serialize for radroots_storage::workspace::seller_stock::S pub fn radroots_storage::workspace::seller_stock::StockResources::serialize<S: serde_core::ser::Serializer>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> impl<'de> serde_core::de::Deserialize<'de> for radroots_storage::workspace::seller_stock::StockResources pub fn radroots_storage::workspace::seller_stock::StockResources::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> +pub struct radroots_storage::workspace::seller_stock::StockSourceCheckpointRef +impl radroots_storage::workspace::seller_stock::StockSourceCheckpointRef +pub const fn radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::authority(self) -> radroots_domain::context::AuthorityRef +pub const fn radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::authorization(self) -> core::option::Option<radroots_storage::workspace::seller_stock::StockAuthorizationRef> +pub fn radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::from_host_metadata(radroots_domain::context::AuthorityRef, radroots_domain::context::Sequence, core::option::Option<radroots_domain::identifier::CheckpointDigest>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError> +pub const fn radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::head(self) -> core::option::Option<radroots_domain::identifier::CheckpointDigest> +pub const fn radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::revision(self) -> radroots_domain::context::Sequence +pub const fn radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::with_authorization(self, radroots_storage::workspace::seller_stock::StockAuthorizationRef) -> Self +pub const fn radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::with_optional_authorization(self, core::option::Option<radroots_storage::workspace::seller_stock::StockAuthorizationRef>) -> Self #[non_exhaustive] pub enum radroots_storage::workspace::WorkspaceError pub radroots_storage::workspace::WorkspaceError::Capacity pub radroots_storage::workspace::WorkspaceError::Closed diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -371,6 +371,15 @@ pub use radroots_storage_sqlite::workspace::WorkspaceScope pub enum radroots_storage_sqlite::workspace::StockGrantOutcome pub radroots_storage_sqlite::workspace::StockGrantOutcome::Committed(radroots_storage_sqlite::workspace::StockGrantReceipt) pub radroots_storage_sqlite::workspace::StockGrantOutcome::Unknown(radroots_domain::identifier::TransactionId) +pub enum radroots_storage_sqlite::workspace::StockSourceOutcome +pub radroots_storage_sqlite::workspace::StockSourceOutcome::Committed(radroots_storage_sqlite::workspace::StockSourceReceipt) +pub radroots_storage_sqlite::workspace::StockSourceOutcome::Unknown +pub radroots_storage_sqlite::workspace::StockSourceOutcome::Unknown::envelope: radroots_domain::identifier::EnvelopeEventId +pub radroots_storage_sqlite::workspace::StockSourceOutcome::Unknown::transaction: radroots_domain::identifier::TransactionId +pub enum radroots_storage_sqlite::workspace::StockSourceProfile +pub radroots_storage_sqlite::workspace::StockSourceProfile::Known +pub radroots_storage_sqlite::workspace::StockSourceProfile::Rejected +pub radroots_storage_sqlite::workspace::StockSourceProfile::Unsupported pub struct radroots_storage_sqlite::workspace::NativeWorkspace impl radroots_storage_sqlite::workspace::NativeWorkspace pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::authenticate(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError> @@ -385,6 +394,9 @@ impl radroots_storage_sqlite::workspace::NativeWorkspace pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::initialize_seller_stock(&std::path::Path, &radroots_storage_sqlite::workspace::StockEnrollment, radroots_storage_sqlite::workspace::WorkspaceCrypto, alloc::sync::Arc<dyn radroots_storage::workspace::WorkspaceClock>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::open_seller_stock(&std::path::Path, radroots_storage::workspace::AttachmentInput, radroots_storage_sqlite::workspace::WorkspaceCrypto, alloc::sync::Arc<dyn radroots_storage::workspace::WorkspaceClock>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_authority(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockAuthorityReceipt, radroots_storage::workspace::WorkspaceError> +impl radroots_storage_sqlite::workspace::NativeWorkspace +pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::retain_stock_source(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, &radroots_storage_sqlite::workspace::StockSourceCapture, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockSourceOutcome, radroots_storage::command::OperationError> +pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_source(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_domain::identifier::EnvelopeEventId, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage_sqlite::workspace::StockSourceSnapshot>, radroots_storage::command::OperationError> impl core::fmt::Debug for radroots_storage_sqlite::workspace::NativeWorkspace pub fn radroots_storage_sqlite::workspace::NativeWorkspace::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl radroots_storage::command::OperationJournal for radroots_storage_sqlite::workspace::NativeWorkspace @@ -416,6 +428,7 @@ impl radroots_storage_sqlite::workspace::StockAuthorityReceipt pub fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::input(&self) -> &radroots_storage::workspace::AttachmentInput pub const fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::inventory_checkpoint(&self) -> core::option::Option<radroots_storage::inventory::InventoryCheckpointRef> pub const fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::revocation_generation(&self) -> radroots_domain::context::Sequence +pub const fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::source_checkpoint(&self) -> core::option::Option<radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef> pub const fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::transaction_id(&self) -> radroots_domain::identifier::TransactionId pub struct radroots_storage_sqlite::workspace::StockEnrollment impl radroots_storage_sqlite::workspace::StockEnrollment @@ -438,6 +451,31 @@ impl radroots_storage_sqlite::workspace::StockGrantReceipt pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::authorization(&self) -> radroots_storage::workspace::seller_stock::authorization::StockAuthorizationRef pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::grant_id(&self) -> radroots_domain::identifier::GrantId pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::transaction_id(&self) -> radroots_domain::identifier::TransactionId +pub struct radroots_storage_sqlite::workspace::StockSourceCapture +impl radroots_storage_sqlite::workspace::StockSourceCapture +pub const fn radroots_storage_sqlite::workspace::StockSourceCapture::envelope_id(&self) -> radroots_domain::identifier::EnvelopeEventId +pub fn radroots_storage_sqlite::workspace::StockSourceCapture::prepare(radroots_storage::workspace::seller_stock::selection::SellerAuthoritySelection, &radroots_nostr::commerce::RecordOpening) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError> +pub const fn radroots_storage_sqlite::workspace::StockSourceCapture::profile(&self) -> radroots_storage_sqlite::workspace::StockSourceProfile +pub fn radroots_storage_sqlite::workspace::StockSourceCapture::record_id(&self) -> core::option::Option<radroots_domain::identifier::RecordId> +pub const fn radroots_storage_sqlite::workspace::StockSourceCapture::transaction_id(&self) -> radroots_domain::identifier::TransactionId +impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockSourceCapture +pub fn radroots_storage_sqlite::workspace::StockSourceCapture::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage_sqlite::workspace::StockSourceReceipt +impl radroots_storage_sqlite::workspace::StockSourceReceipt +pub const fn radroots_storage_sqlite::workspace::StockSourceReceipt::checkpoint(&self) -> radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef +pub const fn radroots_storage_sqlite::workspace::StockSourceReceipt::envelope_id(&self) -> radroots_domain::identifier::EnvelopeEventId +pub const fn radroots_storage_sqlite::workspace::StockSourceReceipt::profile(&self) -> radroots_storage_sqlite::workspace::StockSourceProfile +pub const fn radroots_storage_sqlite::workspace::StockSourceReceipt::record_id(&self) -> core::option::Option<radroots_domain::identifier::RecordId> +pub const fn radroots_storage_sqlite::workspace::StockSourceReceipt::transaction_id(&self) -> radroots_domain::identifier::TransactionId +pub struct radroots_storage_sqlite::workspace::StockSourceSnapshot +impl radroots_storage_sqlite::workspace::StockSourceSnapshot +pub fn radroots_storage_sqlite::workspace::StockSourceSnapshot::protected_canonical_record(&self) -> core::option::Option<&[u8]> +pub fn radroots_storage_sqlite::workspace::StockSourceSnapshot::protected_outer(&self) -> &[u8] +pub fn radroots_storage_sqlite::workspace::StockSourceSnapshot::protected_rumor(&self) -> &[u8] +pub fn radroots_storage_sqlite::workspace::StockSourceSnapshot::protected_seal(&self) -> &[u8] +pub const fn radroots_storage_sqlite::workspace::StockSourceSnapshot::receipt(&self) -> &radroots_storage_sqlite::workspace::StockSourceReceipt +impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockSourceSnapshot +pub fn radroots_storage_sqlite::workspace::StockSourceSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage_sqlite::workspace::WorkspaceCrypto impl radroots_storage_sqlite::workspace::WorkspaceCrypto pub fn radroots_storage_sqlite::workspace::WorkspaceCrypto::new(alloc::sync::Arc<dyn radroots_secrets::provider::SecretProvider>, radroots_secrets::id::SecretRef, radroots_secrets::wrapping::SecretMaterial, radroots_secrets::provider::AccessPolicy) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError> diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -75,16 +75,17 @@ "scope": "seller_stock_owner", "database": "stock_execution_v1.sqlite", "lock": ".stock_execution_v1.lock", - "schema_version": 5, + "schema_version": 6, "retained_enrollment_versions": [ 1 ], "retained_inventory_versions": [ 2, 3, - 4 + 4, + 5 ], - "authority_payload_schema": "radroots.seller_stock.authority.v5", + "authority_payload_schema": "radroots.seller_stock.authority.v6", "inventory_operation_payload_schema": "radroots.seller_stock.operation.v4", "mapping_payload_schema": "radroots.seller_stock.mapping.v1", "mapping_owner_administration_required": true, @@ -128,7 +129,23 @@ "capability_contract": { "id": "radroots.seller_stock.native_inventory", "version": "1" - } + }, + "source_payload_schemas": [ + "radroots.seller_stock.source_record.v1", + "radroots.seller_stock.source_evidence.v1", + "radroots.seller_stock.source_part.v1" + ], + "source_profile_dispositions": [ + "known", + "unsupported", + "rejected" + ], + "source_owner_administration_required": true, + "inventory_scope_grants_source_access": false, + "source_checkpoint_independent": true, + "source_profile_implies_actionability": false, + "source_carrier_max_bytes": 65536, + "source_chunk_max_bytes": 16384 }, "provenance": { "app_behavior_implementation": "independent_reimplementation", diff --git a/crates/storage/src/workspace/seller_stock.rs b/crates/storage/src/workspace/seller_stock.rs @@ -14,6 +14,8 @@ mod selection; pub use selection::{SellerAuthoritySelection, StockCapabilityContract}; mod permissions; pub use permissions::{StockAction, StockGrantScope, StockResources}; +mod source; +pub use source::StockSourceCheckpointRef; /// Explicit local enrollment inputs, supplied by a trusted host interaction. /// Only a qualified stock host may persist the resulting authority. pub struct SellerStockConfig { diff --git a/crates/storage/src/workspace/seller_stock/source.rs b/crates/storage/src/workspace/seller_stock/source.rs @@ -0,0 +1,52 @@ +//! Source progress metadata, independent of physical inventory progress. +use super::{StockAuthorizationRef, WorkspaceError}; +use radroots_domain::{AuthorityRef, CheckpointDigest, Sequence}; +/// A caller-retained acknowledged source minimum. It establishes neither +/// protected provenance nor source completeness, actionability or authority. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct StockSourceCheckpointRef { + authority: AuthorityRef, + revision: Sequence, + head: Option<CheckpointDigest>, + authorization: Option<StockAuthorizationRef>, +} +impl StockSourceCheckpointRef { + pub fn from_host_metadata( + authority: AuthorityRef, + revision: Sequence, + head: Option<CheckpointDigest>, + ) -> Result<Self, WorkspaceError> { + if (revision.get() == 0) != head.is_none() { + return Err(WorkspaceError::InvalidInput); + } + Ok(Self { + authority, + revision, + head, + authorization: None, + }) + } + pub const fn authority(self) -> AuthorityRef { + self.authority + } + pub const fn revision(self) -> Sequence { + self.revision + } + pub const fn head(self) -> Option<CheckpointDigest> { + self.head + } + pub const fn authorization(self) -> Option<StockAuthorizationRef> { + self.authorization + } + pub const fn with_authorization(mut self, state: StockAuthorizationRef) -> Self { + self.authorization = Some(state); + self + } + pub const fn with_optional_authorization( + mut self, + state: Option<StockAuthorizationRef>, + ) -> Self { + self.authorization = state; + self + } +} diff --git a/crates/storage_sqlite/Cargo.toml b/crates/storage_sqlite/Cargo.toml @@ -42,6 +42,8 @@ radroots_event_codec = { workspace = true, default-features = false, features = "json", "std", ] } +radroots_nostr = { workspace = true, default-features = false, features = ["commerce"] } +radroots_protocol = { workspace = true, default-features = false, features = ["commerce"] } radroots_secrets = { workspace = true, default-features = false } radroots_storage = { workspace = true, default-features = false, features = [ "serde", @@ -63,7 +65,7 @@ sqlx = { workspace = true, features = ["runtime-tokio", "sqlite-bundled"] } [dev-dependencies] radroots_signing = { workspace = true, features = ["chat", "artifacts"] } -radroots_nostr = { workspace = true, default-features = false, features = ["signing", "nip17"] } +radroots_nostr = { workspace = true, default-features = false, features = ["nip17"] } radroots_protocol = { workspace = true, default-features = false, features = ["chat"] } nostr = { workspace = true, default-features = false, features = ["std", "nip44"] } futures = { workspace = true } diff --git a/crates/storage_sqlite/src/workspace/crypto.rs b/crates/storage_sqlite/src/workspace/crypto.rs @@ -709,7 +709,7 @@ fn stock_root_context( input: &super::AttachmentInput, version: i64, ) -> Result<EnvelopeContext, WorkspaceError> { - if matches!(version, 4 | 5) { + if matches!(version, 4..=6) { use sha2::{Digest, Sha256}; let namespace = radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment( @@ -724,8 +724,10 @@ fn stock_root_context( let mut hash = Sha256::new(); hash.update(if version == 4 { b"radroots.seller_stock.authority_context.v4\0" - } else { + } else if version == 5 { b"radroots.seller_stock.authority_context.v5\0" + } else { + b"radroots.seller_stock.authority_context.v6\0" }); hash.update(wire.as_slice()); let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into()); @@ -736,8 +738,10 @@ fn stock_root_context( .map_err(|_| WorkspaceError::InvalidInput)?, PayloadSchemaId::parse(if version == 4 { "radroots.seller_stock.authority.v4" - } else { + } else if version == 5 { "radroots.seller_stock.authority.v5" + } else { + "radroots.seller_stock.authority.v6" }) .map_err(|_| WorkspaceError::InvalidInput)?, )); @@ -770,6 +774,18 @@ fn stock_record_context( "radroots.seller_stock.mapping", "radroots.seller_stock.mapping.v1", ), + "source_record" => ( + "radroots.seller_stock.source_record", + "radroots.seller_stock.source_record.v1", + ), + "source_evidence" => ( + "radroots.seller_stock.source_evidence", + "radroots.seller_stock.source_evidence.v1", + ), + "source_part" => ( + "radroots.seller_stock.source_part", + "radroots.seller_stock.source_part.v1", + ), "grant" => ( "radroots.seller_stock.grant", "radroots.seller_stock.grant.v2", @@ -811,11 +827,11 @@ fn stock_record_context_for_catalog( ) -> Result<EnvelopeContext, WorkspaceError> { let original = stock_record_context(input, kind, id)?; let schema = match (catalog, kind) { - (2, _) | (3..=5, "pool") => return Ok(original), + (2, _) | (3..=6, "pool") => return Ok(original), (3, "operation") => "radroots.seller_stock.operation.v2", (4, "operation") => "radroots.seller_stock.operation.v3", - (5, "operation") => "radroots.seller_stock.operation.v4", - (3..=5, "movement") => "radroots.seller_stock.movement.v2", + (5 | 6, "operation") => "radroots.seller_stock.operation.v4", + (3..=6, "movement") => "radroots.seller_stock.movement.v2", _ => return Err(WorkspaceError::RecoveryRequired), }; Ok(EnvelopeContext::new( diff --git a/crates/storage_sqlite/src/workspace/mod.rs b/crates/storage_sqlite/src/workspace/mod.rs @@ -24,7 +24,8 @@ mod snapshot; mod stock; pub use stock::{ SellerStockConfig, StockAuthorityReceipt, StockEnrollment, StockGrantEnrollment, - StockGrantOutcome, StockGrantReceipt, + StockGrantOutcome, StockGrantReceipt, StockSourceCapture, StockSourceOutcome, + StockSourceProfile, StockSourceReceipt, StockSourceSnapshot, }; mod worker; diff --git a/crates/storage_sqlite/src/workspace/stock.rs b/crates/storage_sqlite/src/workspace/stock.rs @@ -9,9 +9,14 @@ use radroots_storage::workspace::seller_stock::{ SellerAuthoritySelection, StockAction, StockAuthorizationRef, StockGrantRecord, StockGrantScope, }; pub(in crate::workspace) mod grants; +pub(in crate::workspace) mod source; use grants::StockRecord; pub use grants::{StockGrantEnrollment, StockGrantOutcome, StockGrantReceipt}; use serde::{Deserialize, Serialize}; +pub use source::{ + StockSourceCapture, StockSourceOutcome, StockSourceProfile, StockSourceReceipt, + StockSourceSnapshot, +}; use sqlx::{Connection, SqliteConnection}; use std::{ path::Path, @@ -72,8 +77,16 @@ pub struct StockAuthorityReceipt { pub(super) transaction: TransactionId, pub(super) revocation: Sequence, pub(super) inventory: Option<radroots_storage::inventory::InventoryCheckpointRef>, + pub(super) sources: Option<radroots_storage::workspace::seller_stock::StockSourceCheckpointRef>, } impl StockAuthorityReceipt { + /// Separately retained source progress; profile recognition proves no order + /// actionability. Absent for retained catalogs without source retention. + pub const fn source_checkpoint( + &self, + ) -> Option<radroots_storage::workspace::seller_stock::StockSourceCheckpointRef> { + self.sources + } pub fn input(&self) -> &AttachmentInput { &self.input } @@ -143,6 +156,7 @@ impl NativeWorkspace { self.worker.stock_authority(input, proof).await } } +#[derive(Clone)] struct Authority { catalog: i64, input: AttachmentInput, @@ -150,6 +164,16 @@ struct Authority { revocation: Sequence, inventory: Option<InventoryCheckpoint>, authorization: Option<StockAuthorizationRef>, + sources: Option<SourceCheckpoint>, +} +#[derive(Clone, Copy, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct SourceCheckpoint { + revision: Sequence, + records: Sequence, + parts: Sequence, + #[serde(deserialize_with = "required_nullable")] + head: Option<radroots_domain::CheckpointDigest>, } #[derive(Clone, Copy, Serialize, Deserialize)] #[serde(deny_unknown_fields)] @@ -267,8 +291,42 @@ struct AuthorityV5 { inventory: InventoryCheckpointCurrent, authorization: StockAuthorizationRef, } +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct AuthorityV6 { + version: u8, + namespace: SellerAuthoritySelection, + administrator: GrantId, + transaction: TransactionId, + revocation: Sequence, + #[serde(deserialize_with = "object")] + inventory: InventoryCheckpointCurrent, + #[serde(deserialize_with = "object")] + sources: SourceCheckpoint, + authorization: StockAuthorizationRef, +} impl Authority { fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> { + if self.catalog == 6 { + let bytes = serde_json::to_vec(&AuthorityV6 { + version: 6, + namespace: SellerAuthoritySelection::from_attachment(&self.input), + administrator: self.input.grant_id(), + transaction: self.transaction, + revocation: self.revocation, + inventory: self + .inventory + .ok_or(WorkspaceError::RecoveryRequired)? + .current()?, + sources: self.sources.ok_or(WorkspaceError::RecoveryRequired)?, + authorization: self.authorization.ok_or(WorkspaceError::RecoveryRequired)?, + }) + .map_err(|_| WorkspaceError::StorageFailure)?; + if bytes.len() > 16 * 1024 { + return Err(WorkspaceError::Capacity); + } + return Ok(zeroize::Zeroizing::new(bytes)); + } if self.catalog == 5 { let bytes = serde_json::to_vec(&AuthorityV5 { version: 5, @@ -339,6 +397,7 @@ impl Authority { revocation: v.revocation, inventory: None, authorization: None, + sources: None, } } 2 | 3 => { @@ -355,6 +414,7 @@ impl Authority { revocation: v.revocation, inventory: Some(v.inventory.into()), authorization: None, + sources: None, } } 4 => { @@ -372,6 +432,7 @@ impl Authority { revocation: v.revocation, inventory: Some(v.inventory.into()), authorization: Some(v.authorization), + sources: None, } } 5 => { @@ -389,6 +450,30 @@ impl Authority { revocation: v.revocation, inventory: Some(v.inventory.into()), authorization: Some(v.authorization), + sources: None, + } + } + 6 => { + let value: AuthorityV6 = closed_record(bytes)?; + if value.version != 6 + || value.authorization.generation() != value.revocation + || (value.inventory.revision.get() == 0) != value.inventory.head.is_none() + || (value.sources.revision.get() == 0) != value.sources.head.is_none() + || (value.sources.revision.get() == 0) != (value.sources.parts.get() == 0) + || value.sources.records.get() > value.sources.revision.get() + || value.sources.parts.get() / 3 < value.sources.revision.get() + || value.sources.parts.get() > value.sources.revision.get().saturating_mul(12) + { + return Err(WorkspaceError::RecoveryRequired); + } + Self { + catalog, + input: value.namespace.attachment(value.administrator)?, + transaction: value.transaction, + revocation: value.revocation, + inventory: Some(value.inventory.into()), + authorization: Some(value.authorization), + sources: Some(value.sources), } } _ => return Err(WorkspaceError::RecoveryRequired), @@ -420,6 +505,12 @@ pub(super) async fn initialize( namespace.validate()?; if let Some(initial) = initial { let mut authority = Authority { + sources: Some(SourceCheckpoint { + revision: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, + records: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, + parts: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, + head: None, + }), catalog: schema::CURRENT, authorization: None, input: input.clone(), @@ -473,7 +564,7 @@ pub(super) async fn initialize( .await .map_err(|_| WorkspaceError::StorageFailure)?; } - sqlx::query("PRAGMA user_version=5") + sqlx::query("PRAGMA user_version=6") .execute(&mut *tx) .await .map_err(|_| WorkspaceError::StorageFailure)?; @@ -557,6 +648,9 @@ async fn read( if let Some(checkpoint) = authority.inventory { inventory::check_head(connection, checkpoint).await?; } + if let Some(checkpoint) = authority.sources { + check_source_counts(connection, checkpoint).await?; + } Ok((authority, record, root, grant)) } pub(super) async fn authenticate( @@ -602,6 +696,7 @@ pub(super) async fn authenticate( namespace.validate()?; Ok(( StockAuthorityReceipt { + sources:authority.sources.map(|value|radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::from_host_metadata(expected.authority(),value.revision,value.head).map(|state|state.with_optional_authorization(authority.authorization))).transpose()?, input: authority.input, transaction: authority.transaction, revocation: authority.revocation, @@ -811,6 +906,39 @@ fn closed_record<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> Result<T, Worksp } serde_json::from_slice(bytes).map_err(|_| WorkspaceError::RecoveryRequired) } +async fn check_source_counts( + connection: &mut SqliteConnection, + checkpoint: SourceCheckpoint, +) -> Result<(), WorkspaceError> { + use sqlx::Row; + let row=sqlx::query("SELECT count(*),coalesce(max(revision),0),coalesce(sum(CASE WHEN revision=? AND chain_head=? THEN 1 ELSE 0 END),0) FROM stock_source_evidence").bind(checkpoint.revision.get() as i64).bind(checkpoint.head.map(|id|id.as_bytes().to_vec())).fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; + let count: i64 = row + .try_get(0) + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let maximum: i64 = row + .try_get(1) + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let matched: i64 = row + .try_get(2) + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let records: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_source_records") + .fetch_one(&mut *connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let parts: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_source_parts") + .fetch_one(connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; + if count != checkpoint.revision.get() as i64 + || maximum != count + || matched != i64::from(checkpoint.head.is_some()) + || records != checkpoint.records.get() as i64 + || parts != checkpoint.parts.get() as i64 + { + return Err(WorkspaceError::RecoveryRequired); + } + Ok(()) +} fn object<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>( deserializer: D, ) -> Result<T, D::Error> { diff --git a/crates/storage_sqlite/src/workspace/stock/grants.rs b/crates/storage_sqlite/src/workspace/stock/grants.rs @@ -324,7 +324,7 @@ pub(in crate::workspace) async fn change( } let (mut authority, record, old_root, old_grant) = super::read(turn.connection, change.caller.input(), turn.crypto).await?; - if !(4..=5).contains(&authority.catalog) { + if !(4..=6).contains(&authority.catalog) { return Err(WorkspaceError::Unauthorized); } let catalog = authority.catalog; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs @@ -120,7 +120,7 @@ pub(super) fn encode_operation( String::from_utf8(clear.to_vec()).map_err(|_| OperationError::StorageFailure)?, ) .map_err(|_| OperationError::StorageFailure)?; - if catalog == 5 { + if matches!(catalog, 5 | 6) { return super::encode(&OperationV4 { version: 4, authorization: authorization.ok_or(OperationError::RecoveryRequired)?, @@ -158,7 +158,7 @@ fn decode_inner( catalog: i64, allow_mapping: bool, ) -> Result<(InventoryRequest, OperationData), OperationError> { - if catalog == 5 { + if matches!(catalog, 5 | 6) { let decoded: OperationV4<'_> = super::closed_record(bytes).map_err(|_| OperationError::RecoveryRequired)?; if decoded.version != 4 { diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/mapping.rs b/crates/storage_sqlite/src/workspace/stock/inventory/mapping.rs @@ -58,7 +58,7 @@ impl MappingRead { } } pub(super) fn require(access: &Access, key: OptionMappingKey) -> Result<(), OperationError> { - if access.authority.catalog != 5 { + if !(5..=6).contains(&access.authority.catalog) { return Err(OperationError::UnsupportedOperation); } if !access.record.administrator() diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs b/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs @@ -3,7 +3,7 @@ use super::*; pub(super) fn record_version(catalog: i64) -> Result<u8, OperationError> { match catalog { 2 => Ok(1), - 3..=5 => Ok(2), + 3..=6 => Ok(2), _ => Err(OperationError::RecoveryRequired), } } diff --git a/crates/storage_sqlite/src/workspace/stock/schema.rs b/crates/storage_sqlite/src/workspace/stock/schema.rs @@ -1,7 +1,7 @@ //! Exact stock catalogs. Enrollment-only version1 is retained without upgrade. use super::WorkspaceError; use sqlx::SqliteConnection; -pub(super) const CURRENT: i64 = 5; +pub(super) const CURRENT: i64 = 6; const AUTHORITY: &str = "CREATE TABLE stock_authority (singleton INTEGER PRIMARY KEY CHECK(singleton=1), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT"; const GRANTS: &str = "CREATE TABLE stock_grants (grant_id BLOB PRIMARY KEY CHECK(length(grant_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID"; const POOLS: &str = "CREATE TABLE stock_pools (pool_id BLOB PRIMARY KEY CHECK(length(pool_id)=32), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID"; @@ -22,7 +22,7 @@ pub(super) fn objects( ]; match version { 1 => {} - 2..=5 => objects.extend([ + 2..=6 => objects.extend([ ("table", "stock_pools", "stock_pools", POOLS), ("table", "stock_operations", "stock_operations", OPERATIONS), ( @@ -57,9 +57,27 @@ pub(super) fn objects( )); objects.push(("index", "stock_actor_operation_identity", "stock_operations", "CREATE UNIQUE INDEX stock_actor_operation_identity ON stock_operations(actor,operation_id)")); } - if version == 5 { + if version >= 5 { objects.push(("table","stock_mappings","stock_mappings","CREATE TABLE stock_mappings (listing_author BLOB NOT NULL CHECK(length(listing_author)=32), listing_d BLOB NOT NULL CHECK(length(listing_d)=16), option_id BLOB NOT NULL CHECK(length(option_id)=32), pool_id BLOB NOT NULL REFERENCES stock_pools(pool_id), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(listing_author,listing_d,option_id)) STRICT, WITHOUT ROWID")); } + if version == 6 { + objects.push(("table","stock_source_records","stock_source_records","CREATE TABLE stock_source_records (record_id BLOB PRIMARY KEY CHECK(length(record_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); + objects.push(("table","stock_source_evidence","stock_source_evidence","CREATE TABLE stock_source_evidence (envelope_id BLOB PRIMARY KEY CHECK(length(envelope_id)=32), record_id BLOB REFERENCES stock_source_records(record_id), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); + objects.push(("index","stock_source_transaction_identity","stock_source_evidence","CREATE UNIQUE INDEX stock_source_transaction_identity ON stock_source_evidence(transaction_id)")); + objects.push(( + "index", + "stock_source_revision_identity", + "stock_source_evidence", + "CREATE UNIQUE INDEX stock_source_revision_identity ON stock_source_evidence(revision)", + )); + objects.push(( + "index", + "stock_source_head_identity", + "stock_source_evidence", + "CREATE UNIQUE INDEX stock_source_head_identity ON stock_source_evidence(chain_head)", + )); + objects.push(("table","stock_source_parts","stock_source_parts","CREATE TABLE stock_source_parts (envelope_id BLOB NOT NULL REFERENCES stock_source_evidence(envelope_id), role INTEGER NOT NULL CHECK(role BETWEEN 0 AND 2), part INTEGER NOT NULL CHECK(part BETWEEN 0 AND 3), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(envelope_id,role,part)) STRICT, WITHOUT ROWID")); + } Ok(objects) } pub(super) async fn admit(connection: &mut SqliteConnection) -> Result<i64, WorkspaceError> { diff --git a/crates/storage_sqlite/src/workspace/stock/source.rs b/crates/storage_sqlite/src/workspace/stock/source.rs @@ -0,0 +1,276 @@ +//! Protected original-source retention on the existing stock connection owner. +//! Recognized profiles remain claims until causal and business admission. +use super::*; +use radroots_domain::{CheckpointDigest, EnvelopeEventId, RecordId, RumorEventId}; +use radroots_nostr::{commerce::RecordOpening, private_ingress::AuthenticatedCarrier}; +use radroots_storage::{ + command::OperationError, workspace::seller_stock::StockSourceCheckpointRef, +}; +use sha2::{Digest, Sha256}; +use zeroize::Zeroizing; +mod checkpoint; +mod record; +mod transaction; +pub(in crate::workspace) use transaction::{query, retain}; + +/// Authenticated carrier/profile disposition, without causal actionability. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum StockSourceProfile { + Known, + Unsupported, + Rejected, +} +/// Original immutable source prepared before store IO. Only the Nostr layer's +/// authenticated opening types supply its evidence; metadata cannot mint it. +pub struct StockSourceCapture { + namespace: SellerAuthoritySelection, + transaction: TransactionId, + envelope: EnvelopeEventId, + seal: EnvelopeEventId, + rumor: RumorEventId, + profile: StockSourceProfile, + canonical: Option<(RecordId, Zeroizing<Vec<u8>>)>, + pieces: [Zeroizing<Vec<u8>>; 3], + manifest: Manifest, +} +#[derive(Clone, Copy, Eq, PartialEq, Serialize)] +struct Piece { + bytes: u32, + digest: [u8; 32], + parts: u8, +} +impl<'de> Deserialize<'de> for Piece { + fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct Wire { + bytes: u32, + digest: [u8; 32], + parts: u8, + } + let wire: Wire = super::object(deserializer)?; + Ok(Self { + bytes: wire.bytes, + digest: wire.digest, + parts: wire.parts, + }) + } +} +#[derive(Clone, Copy, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Manifest { + envelope: EnvelopeEventId, + seal: EnvelopeEventId, + rumor: RumorEventId, + profile: StockSourceProfile, + #[serde(deserialize_with = "super::required_nullable")] + record: Option<RecordId>, + #[serde(deserialize_with = "super::required_nullable")] + canonical_digest: Option<[u8; 32]>, + pieces: [Piece; 3], +} +impl StockSourceCapture { + pub fn prepare( + namespace: SellerAuthoritySelection, + opening: &RecordOpening, + ) -> Result<Self, WorkspaceError> { + let (carrier, profile, canonical) = match opening { + RecordOpening::Known(value) => { + let encoded = + radroots_protocol::commerce::EncodedRecord::capture(value.record().content()) + .map_err(|_| WorkspaceError::InvalidInput)?; + ( + value.carrier(), + StockSourceProfile::Known, + Some(( + encoded.record_id(), + Zeroizing::new(encoded.protected_wire().to_vec()), + )), + ) + } + RecordOpening::Unsupported(value) => { + (value.carrier(), StockSourceProfile::Unsupported, None) + } + RecordOpening::Rejected(value) => (value.carrier(), StockSourceProfile::Rejected, None), + }; + if carrier.recipient() != namespace.participant() { + return Err(WorkspaceError::WrongNamespace); + } + let pieces = source_pieces(carrier)?; + let envelope = EnvelopeEventId::from_bytes(*carrier.envelope_id().as_bytes()); + let seal = EnvelopeEventId::from_bytes(*carrier.seal_id().as_bytes()); + let rumor = carrier.rumor().event_id(); + let descriptors = pieces.each_ref().map(|bytes| Piece { + bytes: bytes.len() as u32, + digest: Sha256::digest(bytes.as_slice()).into(), + parts: bytes.len().div_ceil(16 * 1024) as u8, + }); + let manifest = Manifest { + envelope, + seal, + rumor, + profile, + record: canonical.as_ref().map(|value| value.0), + canonical_digest: canonical + .as_ref() + .map(|value| Sha256::digest(value.1.as_slice()).into()), + pieces: descriptors, + }; + Ok(Self { + namespace, + transaction: TransactionId::from_bytes(super::super::random()?), + envelope, + seal, + rumor, + profile, + canonical, + pieces, + manifest, + }) + } + pub const fn transaction_id(&self) -> TransactionId { + self.transaction + } + pub const fn envelope_id(&self) -> EnvelopeEventId { + self.envelope + } + pub const fn profile(&self) -> StockSourceProfile { + self.profile + } + pub fn record_id(&self) -> Option<RecordId> { + self.canonical.as_ref().map(|value| value.0) + } + pub(super) fn retained_copy(&self) -> Self { + Self { + namespace: self.namespace.clone(), + transaction: self.transaction, + envelope: self.envelope, + seal: self.seal, + rumor: self.rumor, + profile: self.profile, + canonical: self + .canonical + .as_ref() + .map(|(id, bytes)| (*id, Zeroizing::new(bytes.to_vec()))), + pieces: self + .pieces + .each_ref() + .map(|value| Zeroizing::new(value.to_vec())), + manifest: self.manifest, + } + } +} +fn source_pieces( + carrier: &AuthenticatedCarrier, +) -> Result<[Zeroizing<Vec<u8>>; 3], WorkspaceError> { + let texts = [ + carrier.protected_outer(), + carrier.protected_seal(), + carrier.protected_rumor(), + ]; + if texts + .iter() + .any(|text| text.is_empty() || text.len() > 64 * 1024) + { + return Err(WorkspaceError::InvalidInput); + } + Ok(texts.map(|text| Zeroizing::new(text.as_bytes().to_vec()))) +} +impl std::fmt::Debug for StockSourceCapture { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("StockSourceCapture(<redacted>)") + } +} +/// Confirmed original storage identity. Profile recognition is not an order +/// decision, source-completeness result or physical fact. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct StockSourceReceipt { + transaction: TransactionId, + envelope: EnvelopeEventId, + record: Option<RecordId>, + profile: StockSourceProfile, + checkpoint: StockSourceCheckpointRef, +} +impl StockSourceReceipt { + pub const fn transaction_id(&self) -> TransactionId { + self.transaction + } + pub const fn envelope_id(&self) -> EnvelopeEventId { + self.envelope + } + pub const fn record_id(&self) -> Option<RecordId> { + self.record + } + pub const fn profile(&self) -> StockSourceProfile { + self.profile + } + pub const fn checkpoint(&self) -> StockSourceCheckpointRef { + self.checkpoint + } +} +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum StockSourceOutcome { + Committed(StockSourceReceipt), + Unknown { + transaction: TransactionId, + envelope: EnvelopeEventId, + }, +} +/// Explicit private original bytes, returned only under current source access. +/// This never reconstructs an authenticated-opening token or business status. +pub struct StockSourceSnapshot { + receipt: StockSourceReceipt, + pieces: [Zeroizing<Vec<u8>>; 3], + canonical: Option<Zeroizing<Vec<u8>>>, +} +impl StockSourceSnapshot { + pub const fn receipt(&self) -> &StockSourceReceipt { + &self.receipt + } + pub fn protected_outer(&self) -> &[u8] { + &self.pieces[0] + } + pub fn protected_seal(&self) -> &[u8] { + &self.pieces[1] + } + pub fn protected_rumor(&self) -> &[u8] { + &self.pieces[2] + } + pub fn protected_canonical_record(&self) -> Option<&[u8]> { + self.canonical.as_ref().map(|value| value.as_slice()) + } +} +impl std::fmt::Debug for StockSourceSnapshot { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("StockSourceSnapshot(<redacted>)") + } +} +impl NativeWorkspace { + /// Retains original authenticated evidence on the selected owner worker. + /// Borrowed capture/proof remain available after error or observer loss. + pub async fn retain_stock_source( + &self, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + capture: &StockSourceCapture, + proof: &AttachmentProof, + ) -> Result<StockSourceOutcome, OperationError> { + let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; + self.worker + .retain_stock_source(binding, minimum, capture.retained_copy(), proof) + .await + } + pub async fn stock_source( + &self, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + envelope: EnvelopeEventId, + proof: &AttachmentProof, + ) -> Result<Option<StockSourceSnapshot>, OperationError> { + let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; + self.worker + .stock_source(binding, minimum, envelope, proof) + .await + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/source/checkpoint.rs b/crates/storage_sqlite/src/workspace/stock/source/checkpoint.rs @@ -0,0 +1,171 @@ +use super::*; +use sqlx::Row; +pub(super) enum Target { + Minimum(StockSourceCheckpointRef), + Envelope( + EnvelopeEventId, + Option<(Sequence, CheckpointDigest, [u8; 32])>, + ), + Record(RecordId, Option<[u8; 32]>), +} +pub(super) struct Proof { + lower: u64, + upper: u64, + digest: [u8; 32], +} +fn hash() -> Sha256 { + let mut value = Sha256::new(); + value.update(b"radroots.seller_stock.source_ancestry_snapshot.v1\0"); + value +} +fn hash_row( + hash: &mut Sha256, + revision: u64, + envelope: &[u8], + record: Option<&[u8]>, + transaction: &[u8], + head: &[u8], + protected: &[u8], +) { + hash.update(revision.to_be_bytes()); + hash.update(envelope); + hash.update([u8::from(record.is_some())]); + if let Some(record) = record { + hash.update(record); + } + hash.update(transaction); + hash.update(head); + hash.update((protected.len() as u64).to_be_bytes()); + hash.update(protected); +} +impl Proof { + pub async fn confirm(&self, connection: &mut SqliteConnection) -> Result<(), OperationError> { + let mut hash = hash(); + for revision in (self.lower..=self.upper).rev() { + let row=sqlx::query("SELECT envelope_id,record_id,transaction_id,chain_head,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_source_evidence WHERE revision=?").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + let envelope: Vec<u8> = row + .try_get(0) + .map_err(|_| OperationError::RecoveryRequired)?; + let record: Option<Vec<u8>> = row + .try_get(1) + .map_err(|_| OperationError::RecoveryRequired)?; + let tx: Vec<u8> = row + .try_get(2) + .map_err(|_| OperationError::RecoveryRequired)?; + let head: Vec<u8> = row + .try_get(3) + .map_err(|_| OperationError::RecoveryRequired)?; + let protected: Vec<u8> = row + .try_get::<Option<Vec<u8>>, _>(4) + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + if envelope.len() != 32 + || tx.len() != 32 + || head.len() != 32 + || record.as_ref().is_some_and(|value| value.len() != 32) + { + return Err(OperationError::RecoveryRequired); + } + hash_row( + &mut hash, + revision, + &envelope, + record.as_deref(), + &tx, + &head, + &protected, + ); + } + let actual: [u8; 32] = hash.finalize().into(); + if actual != self.digest { + return Err(OperationError::RecoveryRequired); + } + Ok(()) + } +} +pub(super) async fn authenticate( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + current: SourceCheckpoint, + target: Target, +) -> Result<Proof, OperationError> { + let upper = current.revision.get(); + if let Target::Minimum(minimum) = target + && (minimum.authority() != input.authority() || minimum.revision().get() > upper) + { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + let mut expected = current.head; + let mut hash = hash(); + for revision in (1..=upper).rev() { + let id:Vec<u8>=sqlx::query_scalar("SELECT envelope_id FROM stock_source_evidence WHERE revision=? AND length(envelope_id)=32").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + let envelope = EnvelopeEventId::from_bytes( + id.try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let retained = record::read(connection, input, crypto, envelope) + .await? + .ok_or(OperationError::RecoveryRequired)?; + let header = &retained.header; + if header.revision.get() != revision || Some(header.head) != expected { + return Err(OperationError::RecoveryRequired); + } + hash_row( + &mut hash, + revision, + envelope.as_bytes(), + header + .manifest + .record + .as_ref() + .map(|id| id.as_bytes().as_slice()), + header.transaction.as_bytes(), + header.head.as_bytes(), + &retained.protected, + ); + let matched = match &target { + Target::Minimum(minimum) if minimum.revision().get() == revision => { + if minimum.head() != Some(header.head) { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + true + } + Target::Envelope(id, observed) if *id == envelope => { + let digest: [u8; 32] = Sha256::digest(&retained.protected).into(); + if *observed != Some((header.revision, header.head, digest)) { + return Err(OperationError::RecoveryRequired); + } + true + } + Target::Record(id, observed) if header.manifest.record == Some(*id) => { + if *observed != header.manifest.canonical_digest { + return Err(OperationError::RecoveryRequired); + } + true + } + _ => false, + }; + if matched { + return Ok(Proof { + lower: revision, + upper, + digest: hash.finalize().into(), + }); + } + expected = header.previous; + } + let absent = match target { + Target::Minimum(value) => value.revision().get() == 0 && value.head().is_none(), + Target::Envelope(_, value) => value.is_none(), + Target::Record(_, value) => value.is_none(), + }; + if expected.is_some() || !absent { + return Err(OperationError::RecoveryRequired); + } + Ok(Proof { + lower: 1, + upper, + digest: hash.finalize().into(), + }) +} diff --git a/crates/storage_sqlite/src/workspace/stock/source/record.rs b/crates/storage_sqlite/src/workspace/stock/source/record.rs @@ -0,0 +1,269 @@ +use super::*; +use sqlx::Row; +#[derive(Clone, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub(super) struct Header { + pub version: u8, + #[serde(deserialize_with = "super::super::object")] + pub manifest: Manifest, + pub transaction: TransactionId, + pub revision: Sequence, + #[serde(deserialize_with = "super::super::required_nullable")] + pub previous: Option<CheckpointDigest>, + pub head: CheckpointDigest, + pub grant: GrantId, + pub principal: String, + pub authorization: StockAuthorizationRef, +} +pub(super) struct RetainedHeader { + pub header: Header, + pub protected: Vec<u8>, +} +pub(super) fn encode(value: &impl Serialize) -> Result<Zeroizing<Vec<u8>>, OperationError> { + let bytes = + Zeroizing::new(serde_json::to_vec(value).map_err(|_| OperationError::StorageFailure)?); + if bytes.len() > 16 * 1024 { + return Err(OperationError::InvalidCommand); + } + Ok(bytes) +} +pub(super) fn head( + input: &AttachmentInput, + value: &Header, +) -> Result<CheckpointDigest, OperationError> { + #[derive(Serialize)] + struct Fields<'a> { + version: u8, + manifest: &'a Manifest, + transaction: TransactionId, + revision: Sequence, + previous: Option<CheckpointDigest>, + grant: GrantId, + principal: &'a str, + authorization: StockAuthorizationRef, + } + let fields = Fields { + version: value.version, + manifest: &value.manifest, + transaction: value.transaction, + revision: value.revision, + previous: value.previous, + grant: value.grant, + principal: &value.principal, + authorization: value.authorization, + }; + let mut hash = Sha256::new(); + hash.update(b"radroots.seller_stock.source_chain.v1\0"); + hash.update(input.workspace_id().as_bytes()); + hash.update(input.authority().executor_id().as_bytes()); + hash.update(input.authority().generation().get().to_be_bytes()); + hash.update(input.route_digest().as_bytes()); + hash.update(encode(&fields)?.as_slice()); + Ok(CheckpointDigest::from_bytes(hash.finalize().into())) +} +impl Header { + pub fn validate(&self, input: &AttachmentInput) -> Result<(), OperationError> { + let known = self.manifest.profile == StockSourceProfile::Known; + if self.version != 1 + || self.revision.get() == 0 + || (self.revision.get() == 1) != self.previous.is_none() + || self.principal.is_empty() + || self.principal.len() > 128 + || self.principal.chars().any(char::is_control) + || known != self.manifest.record.is_some() + || known != self.manifest.canonical_digest.is_some() + || self.head != head(input, self)? + { + return Err(OperationError::RecoveryRequired); + } + for piece in self.manifest.pieces { + if piece.bytes == 0 + || piece.bytes > 64 * 1024 + || u32::from(piece.parts) != piece.bytes.div_ceil(16 * 1024) + { + return Err(OperationError::RecoveryRequired); + } + } + Ok(()) + } + pub fn receipt(&self, input: &AttachmentInput) -> Result<StockSourceReceipt, OperationError> { + Ok(StockSourceReceipt { + transaction: self.transaction, + envelope: self.manifest.envelope, + record: self.manifest.record, + profile: self.manifest.profile, + checkpoint: StockSourceCheckpointRef::from_host_metadata( + input.authority(), + self.revision, + Some(self.head), + )? + .with_authorization(self.authorization), + }) + } +} +pub(super) async fn read( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + envelope: EnvelopeEventId, +) -> Result<Option<RetainedHeader>, OperationError> { + let row=sqlx::query("SELECT record_id,transaction_id,revision,chain_head,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_source_evidence WHERE envelope_id=?").bind(envelope.as_bytes().as_slice()).fetch_optional(connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let Some(row) = row else { return Ok(None) }; + let protected: Vec<u8> = row + .try_get::<Option<Vec<u8>>, _>(4) + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + let clear = crypto + .open_stock_record(input, "source_evidence", envelope.as_bytes(), &protected) + .await?; + let header: Header = clear + .expose_secret(|bytes| super::super::closed_record(bytes)) + .map_err(|_| OperationError::RecoveryRequired)?; + header.validate(input)?; + let logical: Option<Vec<u8>> = row + .try_get(0) + .map_err(|_| OperationError::RecoveryRequired)?; + let tx: Vec<u8> = row + .try_get(1) + .map_err(|_| OperationError::RecoveryRequired)?; + let revision: i64 = row + .try_get(2) + .map_err(|_| OperationError::RecoveryRequired)?; + let head: Vec<u8> = row + .try_get(3) + .map_err(|_| OperationError::RecoveryRequired)?; + if header.manifest.envelope != envelope + || logical != header.manifest.record.map(|id| id.as_bytes().to_vec()) + || tx != header.transaction.as_bytes() + || revision <= 0 + || revision as u64 != header.revision.get() + || head != header.head.as_bytes() + { + return Err(OperationError::RecoveryRequired); + } + Ok(Some(RetainedHeader { header, protected })) +} +pub(super) fn part_id(envelope: EnvelopeEventId, role: u8, part: u8) -> [u8; 32] { + let mut hash = Sha256::new(); + hash.update(b"radroots.seller_stock.source_part_key.v1\0"); + hash.update(envelope.as_bytes()); + hash.update([role, part]); + hash.finalize().into() +} +pub(super) async fn canonical( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + id: RecordId, +) -> Result<Option<(Zeroizing<Vec<u8>>, Vec<u8>)>, OperationError> { + let row: Option<Option<Vec<u8>>> = sqlx::query_scalar("SELECT CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_source_records WHERE record_id=?") + .bind(id.as_bytes().as_slice()) + .fetch_optional(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + let Some(protected) = row else { + return Ok(None); + }; + let protected = protected.ok_or(OperationError::RecoveryRequired)?; + let clear = crypto + .open_stock_record(input, "source_record", id.as_bytes(), &protected) + .await?; + let canonical = clear.expose_secret(|bytes| { + let decoded = radroots_protocol::commerce::decode(bytes) + .map_err(|_| OperationError::RecoveryRequired)?; + if decoded.record_id() != id { + return Err(OperationError::RecoveryRequired); + } + let encoded = radroots_protocol::commerce::EncodedRecord::capture(decoded.content()) + .map_err(|_| OperationError::RecoveryRequired)?; + if encoded.protected_wire() != bytes { + return Err(OperationError::RecoveryRequired); + } + Ok(Zeroizing::new(bytes.to_vec())) + })?; + Ok(Some((canonical, protected))) +} +pub(super) async fn pieces( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + header: &Header, +) -> Result<([Zeroizing<Vec<u8>>; 3], [u8; 32]), OperationError> { + let mut pieces: [Zeroizing<Vec<u8>>; 3] = std::array::from_fn(|_| Zeroizing::new(Vec::new())); + let mut witness = Sha256::new(); + witness.update(b"radroots.seller_stock.source_parts_snapshot.v1\0"); + let mut count = 0; + for (role, piece) in header.manifest.pieces.iter().enumerate() { + for part in 0..piece.parts { + let protected:Vec<u8>=sqlx::query_scalar("SELECT protected FROM stock_source_parts WHERE envelope_id=? AND role=? AND part=? AND length(protected) BETWEEN 1 AND 262144").bind(header.manifest.envelope.as_bytes().as_slice()).bind(role as i64).bind(i64::from(part)).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + hash_part(&mut witness, role as u8, part, &protected); + let clear = crypto + .open_stock_record( + input, + "source_part", + &part_id(header.manifest.envelope, role as u8, part), + &protected, + ) + .await?; + clear.expose_secret(|bytes| { + let expected = if part + 1 == piece.parts { + piece.bytes as usize - (usize::from(piece.parts) - 1) * 16 * 1024 + } else { + 16 * 1024 + }; + if bytes.len() != expected { + return Err(OperationError::RecoveryRequired); + } + pieces[role].extend_from_slice(bytes); + Ok(()) + })?; + count += 1; + } + let actual: [u8; 32] = Sha256::digest(pieces[role].as_slice()).into(); + if pieces[role].len() != piece.bytes as usize || actual != piece.digest { + return Err(OperationError::RecoveryRequired); + } + } + let actual: i64 = + sqlx::query_scalar("SELECT count(*) FROM stock_source_parts WHERE envelope_id=?") + .bind(header.manifest.envelope.as_bytes().as_slice()) + .fetch_one(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if actual != count { + return Err(OperationError::RecoveryRequired); + } + Ok((pieces, witness.finalize().into())) +} +fn hash_part(hash: &mut Sha256, role: u8, part: u8, protected: &[u8]) { + hash.update([role, part]); + hash.update((protected.len() as u64).to_be_bytes()); + hash.update(protected); +} +pub(super) async fn confirm_parts( + connection: &mut SqliteConnection, + header: &Header, + expected: [u8; 32], +) -> Result<(), OperationError> { + let mut hash = Sha256::new(); + hash.update(b"radroots.seller_stock.source_parts_snapshot.v1\0"); + let mut count = 0; + for (role, piece) in header.manifest.pieces.iter().enumerate() { + for part in 0..piece.parts { + let protected:Vec<u8>=sqlx::query_scalar("SELECT protected FROM stock_source_parts WHERE envelope_id=? AND role=? AND part=? AND length(protected) BETWEEN 1 AND 262144").bind(header.manifest.envelope.as_bytes().as_slice()).bind(role as i64).bind(i64::from(part)).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + hash_part(&mut hash, role as u8, part, &protected); + count += 1; + } + } + let actual: i64 = + sqlx::query_scalar("SELECT count(*) FROM stock_source_parts WHERE envelope_id=?") + .bind(header.manifest.envelope.as_bytes().as_slice()) + .fetch_one(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + let digest: [u8; 32] = hash.finalize().into(); + if digest != expected || actual != count { + return Err(OperationError::RecoveryRequired); + } + Ok(()) +} diff --git a/crates/storage_sqlite/src/workspace/stock/source/transaction.rs b/crates/storage_sqlite/src/workspace/stock/source/transaction.rs @@ -0,0 +1,473 @@ +use super::super::inventory::Turn; +use super::*; +use checkpoint::{Proof, Target}; +use radroots_storage::command::protected::same_binding; +use record::{Header, RetainedHeader}; + +struct Access { + authority: Authority, + record: StockRecord, + root: Vec<u8>, + grant: Vec<u8>, + current: WorkspaceBinding, + minimum: Proof, +} +async fn access( + turn: &mut Turn<'_>, + binding: &WorkspaceBinding, + minimum: StockSourceCheckpointRef, + proof: &AttachmentProof, +) -> Result<Access, OperationError> { + if *turn.uncertain { + return Err(OperationError::RecoveryRequired); + } + turn.namespace.validate()?; + if !SellerAuthoritySelection::from_attachment(turn.selected).matches_attachment(binding.input()) + { + return Err(OperationError::Unauthorized); + } + let (authority, record, root, grant) = + super::super::read(turn.connection, binding.input(), turn.crypto).await?; + if authority.catalog != 6 { + return Err(OperationError::UnsupportedOperation); + } + let current = record.authenticate(binding.input(), proof, turn.clock.now()?)?; + same_binding(binding, ¤t)?; + if current.observed_at() < binding.observed_at() { + return Err(WorkspaceError::Unavailable.into()); + } + if current.scope() != WorkspaceScope::SellerStockOwner || !record.administrator() { + return Err(OperationError::Unauthorized); + } + if authority.authorization != minimum.authorization() { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + let witness = checkpoint::authenticate( + turn.connection, + turn.selected, + turn.crypto, + authority.sources.ok_or(OperationError::RecoveryRequired)?, + Target::Minimum(minimum), + ) + .await?; + Ok(Access { + authority, + record, + root, + grant, + current, + minimum: witness, + }) +} +impl Access { + async fn confirm( + &self, + connection: &mut SqliteConnection, + namespace: &Namespace, + clock: &dyn WorkspaceClock, + proof: &AttachmentProof, + ) -> Result<(), OperationError> { + namespace.validate()?; + super::super::unchanged( + connection, + self.current.input(), + self.authority.catalog, + &self.root, + &self.grant, + ) + .await?; + grants::check_state( + connection, + self.authority + .authorization + .ok_or(OperationError::RecoveryRequired)?, + ) + .await?; + super::super::check_source_counts( + connection, + self.authority + .sources + .ok_or(OperationError::RecoveryRequired)?, + ) + .await?; + self.minimum.confirm(connection).await?; + let current = self + .record + .authenticate(self.current.input(), proof, clock.now()?)?; + same_binding(&self.current, ¤t)?; + if current.observed_at() < self.current.observed_at() { + return Err(WorkspaceError::Unavailable.into()); + } + if !self.record.administrator() { + return Err(OperationError::Unauthorized); + } + Ok(()) + } +} +struct Observation { + ancestry: Proof, + header: Option<RetainedHeader>, + canonical: Option<(RecordId, Option<Vec<u8>>)>, + parts: Option<[u8; 32]>, + record_ancestry: Option<Proof>, +} +impl Observation { + async fn confirm( + &self, + connection: &mut SqliteConnection, + envelope: EnvelopeEventId, + ) -> Result<(), OperationError> { + self.ancestry.confirm(connection).await?; + if let Some(proof) = &self.record_ancestry { + proof.confirm(connection).await?; + } + let count: i64 = if let Some(header) = &self.header { + sqlx::query_scalar( + "SELECT count(*) FROM stock_source_evidence WHERE envelope_id=? AND protected=?", + ) + .bind(envelope.as_bytes().as_slice()) + .bind(&header.protected) + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)? + } else { + sqlx::query_scalar("SELECT count(*) FROM stock_source_evidence WHERE envelope_id=?") + .bind(envelope.as_bytes().as_slice()) + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)? + }; + if count != i64::from(self.header.is_some()) { + return Err(OperationError::RecoveryRequired); + } + if let Some((id, protected)) = &self.canonical { + let count: i64 = if let Some(protected) = protected { + sqlx::query_scalar( + "SELECT count(*) FROM stock_source_records WHERE record_id=? AND protected=?", + ) + .bind(id.as_bytes().as_slice()) + .bind(protected) + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)? + } else { + sqlx::query_scalar("SELECT count(*) FROM stock_source_records WHERE record_id=?") + .bind(id.as_bytes().as_slice()) + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)? + }; + if count != i64::from(protected.is_some()) { + return Err(OperationError::RecoveryRequired); + } + } + if let (Some(header), Some(expected)) = (&self.header, self.parts) { + record::confirm_parts(connection, &header.header, expected).await?; + } + Ok(()) + } +} +async fn observed( + turn: &mut Turn<'_>, + authority: &Authority, + envelope: EnvelopeEventId, +) -> Result<Observation, OperationError> { + let retained = record::read(turn.connection, turn.selected, turn.crypto, envelope).await?; + let expected = retained.as_ref().map(|value| { + ( + value.header.revision, + value.header.head, + Sha256::digest(&value.protected).into(), + ) + }); + let ancestry = checkpoint::authenticate( + turn.connection, + turn.selected, + turn.crypto, + authority.sources.ok_or(OperationError::RecoveryRequired)?, + Target::Envelope(envelope, expected), + ) + .await?; + Ok(Observation { + ancestry, + header: retained, + canonical: None, + parts: None, + record_ancestry: None, + }) +} +async fn load( + turn: &mut Turn<'_>, + observation: &mut Observation, +) -> Result<StockSourceSnapshot, OperationError> { + let retained = observation + .header + .as_ref() + .ok_or(OperationError::RecoveryRequired)?; + let (pieces, witness) = record::pieces( + turn.connection, + turn.selected, + turn.crypto, + &retained.header, + ) + .await?; + observation.parts = Some(witness); + let canonical = if let Some(id) = retained.header.manifest.record { + let (clear, protected) = record::canonical(turn.connection, turn.selected, turn.crypto, id) + .await? + .ok_or(OperationError::RecoveryRequired)?; + let digest: [u8; 32] = Sha256::digest(clear.as_slice()).into(); + if Some(digest) != retained.header.manifest.canonical_digest { + return Err(OperationError::RecoveryRequired); + } + observation.canonical = Some((id, Some(protected))); + Some(clear) + } else { + None + }; + Ok(StockSourceSnapshot { + receipt: retained.header.receipt(turn.selected)?, + pieces, + canonical, + }) +} +async fn confirm_read( + turn: &mut Turn<'_>, + access: &Access, + proof: &AttachmentProof, + envelope: EnvelopeEventId, + observed: &Observation, +) -> Result<(), OperationError> { + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked: Result<(), OperationError> = async { + access + .confirm(&mut tx, turn.namespace, turn.clock, proof) + .await?; + observed.confirm(&mut tx, envelope).await?; + turn.namespace.validate()?; + Ok(()) + } + .await; + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Err(OperationError::RecoveryRequired); + } + checked +} +pub(in crate::workspace) async fn query( + turn: &mut Turn<'_>, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + envelope: EnvelopeEventId, + proof: AttachmentProof, +) -> Result<Option<StockSourceSnapshot>, OperationError> { + let access = access(turn, &binding, minimum, &proof).await?; + let mut observation = observed(turn, &access.authority, envelope).await?; + let result = if observation.header.is_some() { + Some(load(turn, &mut observation).await?) + } else { + None + }; + confirm_read(turn, &access, &proof, envelope, &observation).await?; + Ok(result) +} +pub(in crate::workspace) async fn retain( + turn: &mut Turn<'_>, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + capture: StockSourceCapture, + proof: AttachmentProof, +) -> Result<StockSourceOutcome, OperationError> { + let access = access(turn, &binding, minimum, &proof).await?; + if capture.namespace != SellerAuthoritySelection::from_attachment(turn.selected) { + return Err(OperationError::Unauthorized); + } + let mut observation = observed(turn, &access.authority, capture.envelope).await?; + if let Some(prior) = &observation.header { + if prior.header.manifest != capture.manifest { + return Err(OperationError::IdempotencyConflict); + } + let snapshot = load(turn, &mut observation).await?; + confirm_read(turn, &access, &proof, capture.envelope, &observation).await?; + return Ok(StockSourceOutcome::Committed(snapshot.receipt)); + } + let before = access + .authority + .sources + .ok_or(OperationError::RecoveryRequired)?; + let mut protected_record = None; + let mut new_record = false; + if let Some((id, canonical)) = &capture.canonical { + let prior = record::canonical(turn.connection, turn.selected, turn.crypto, *id).await?; + let digest = prior + .as_ref() + .map(|value| Sha256::digest(value.0.as_slice()).into()); + observation.record_ancestry = Some( + checkpoint::authenticate( + turn.connection, + turn.selected, + turn.crypto, + before, + Target::Record(*id, digest), + ) + .await?, + ); + if let Some((clear, _)) = &prior + && clear.as_slice() != canonical.as_slice() + { + return Err(OperationError::InvalidEvidence); + } + new_record = prior.is_none(); + if new_record { + protected_record = Some(( + *id, + turn.crypto + .seal_stock_record(turn.selected, "source_record", id.as_bytes(), canonical) + .await?, + )); + } + observation.canonical = Some((*id, prior.map(|value| value.1))); + } + let revision = Sequence::new( + before + .revision + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?; + let mut header = Header { + version: 1, + manifest: capture.manifest, + transaction: capture.transaction, + revision, + previous: before.head, + head: CheckpointDigest::from_bytes([0; 32]), + grant: access.current.input().grant_id(), + principal: access.current.principal_id().into(), + authorization: access + .authority + .authorization + .ok_or(OperationError::RecoveryRequired)?, + }; + header.head = record::head(turn.selected, &header)?; + let mut parts = Vec::new(); + for (role, clear) in capture.pieces.iter().enumerate() { + for (part, clear) in clear.chunks(16 * 1024).enumerate() { + let protected = turn + .crypto + .seal_stock_record( + turn.selected, + "source_part", + &record::part_id(capture.envelope, role as u8, part as u8), + clear, + ) + .await?; + parts.push((role as u8, part as u8, protected)); + } + } + let protected_header = turn + .crypto + .seal_stock_record( + turn.selected, + "source_evidence", + capture.envelope.as_bytes(), + &record::encode(&header)?, + ) + .await?; + let mut next = access.authority.clone(); + next.sources = Some(SourceCheckpoint { + revision, + head: Some(header.head), + records: Sequence::new( + before + .records + .get() + .checked_add(u64::from(new_record)) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?, + parts: Sequence::new( + before + .parts + .get() + .checked_add(parts.len() as u64) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?, + }); + let root = turn + .crypto + .seal_stock_root(turn.selected, next.catalog, &next.encode()?) + .await?; + let receipt = header.receipt(turn.selected)?; + turn.namespace.validate()?; + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let changed: Result<(), OperationError> = async { + access.confirm(&mut tx, turn.namespace, turn.clock, &proof).await?; + observation.confirm(&mut tx, capture.envelope).await?; + if let Some((id, protected)) = protected_record { + sqlx::query("INSERT INTO stock_source_records(record_id,protected) VALUES(?,?)") + .bind(id.as_bytes().as_slice()) + .bind(protected) + .execute(&mut *tx) + .await + .map_err(|_| OperationError::StorageFailure)?; + } + sqlx::query("INSERT INTO stock_source_evidence(envelope_id,record_id,transaction_id,revision,chain_head,protected) VALUES(?,?,?,?,?,?)") + .bind(capture.envelope.as_bytes().as_slice()) + .bind(header.manifest.record.map(|id| id.as_bytes().to_vec())) + .bind(capture.transaction.as_bytes().as_slice()) + .bind(revision.get() as i64) + .bind(header.head.as_bytes().as_slice()) + .bind(protected_header) + .execute(&mut *tx) + .await + .map_err(|_| OperationError::StorageFailure)?; + for (role, part, protected) in parts { + sqlx::query("INSERT INTO stock_source_parts(envelope_id,role,part,protected) VALUES(?,?,?,?)") + .bind(capture.envelope.as_bytes().as_slice()) + .bind(i64::from(role)) + .bind(i64::from(part)) + .bind(protected) + .execute(&mut *tx) + .await + .map_err(|_| OperationError::StorageFailure)?; + } + let changed = sqlx::query("UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?") + .bind(root) + .bind(&access.root) + .execute(&mut *tx) + .await + .map_err(|_| OperationError::StorageFailure)?; + if changed.rows_affected() != 1 { + return Err(OperationError::RecoveryRequired); + } + turn.namespace.validate()?; + Ok(()) + }.await; + let unknown = || StockSourceOutcome::Unknown { + transaction: capture.transaction, + envelope: capture.envelope, + }; + if let Err(error) = changed { + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Ok(unknown()); + } + return Err(error); + } + if tx.commit().await.is_err() { + *turn.uncertain = true; + return Ok(unknown()); + } + Ok(StockSourceOutcome::Committed(receipt)) +} diff --git a/crates/storage_sqlite/src/workspace/stock/tests.rs b/crates/storage_sqlite/src/workspace/stock/tests.rs @@ -109,7 +109,7 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang ) .await .unwrap(); - assert_eq!(schema::admit(&mut connection).await, Ok(5)); + assert_eq!(schema::admit(&mut connection).await, Ok(6)); assert_eq!(schema::integrity(&mut connection).await, Ok(())); let root: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_authority") .fetch_one(&mut connection) @@ -117,18 +117,29 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang .unwrap(); let clear = fixture .crypto() - .open_stock_root(enrollment.input(), 5, &root) + .open_stock_root(enrollment.input(), 6, &root) .await .unwrap(); let authority = clear - .expose_secret(|bytes| Authority::decode(bytes, 5)) + .expose_secret(|bytes| Authority::decode(bytes, 6)) .unwrap(); clear.expose_secret(|bytes| { let original:serde_json::Value=serde_json::from_slice(bytes).unwrap(); assert_eq!(original["inventory"]["mappings"],"0"); for bad in [serde_json::json!([]),serde_json::json!({"revision":"1","pools":"1","movements":"1","head":original["inventory"]["head"]})] { let mut value=original.clone();value["inventory"]=bad; - assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),5).is_err()); + assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),6).is_err()); + } + for bad in [ + serde_json::json!([]), + serde_json::json!({"revision":"0","records":"0","parts":"0"}), + serde_json::json!({"revision":"0","records":"0","parts":"0","head":null,"extra":true}), + serde_json::json!({"revision":"1","records":"0","parts":"2","head":"01".repeat(32)}), + serde_json::json!({"revision":"1","records":"0","parts":"13","head":"01".repeat(32)}), + serde_json::json!({"revision":"1","records":"2","parts":"3","head":"01".repeat(32)}), + ] { + let mut value=original.clone();value["sources"]=bad; + assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),6).is_err()); } }); assert_eq!(authority.input, *enrollment.input()); @@ -178,7 +189,7 @@ async fn current_and_retained_roots_bind_the_complete_namespace_with_distinct_ca let caller = namespace.attachment(GrantId::from_bytes([9; 32])).unwrap(); let crypto = fixture.crypto(); let clear = b"synthetic context payload"; - for version in [4, 5] { + for version in [4, 5, 6] { let current = crypto .seal_stock_root(&owner, version, clear) .await @@ -240,6 +251,10 @@ async fn retained_inventory_v4_preserves_scoped_grants_and_original_effects_with { retained_inventory_catalog(4).await; } +#[tokio::test] +async fn retained_inventory_v5_preserves_mappings_and_never_adds_source_tables() { + retained_inventory_catalog(5).await; +} async fn retained_inventory_catalog(catalog: i64) { use radroots_storage::inventory::{InventoryCommandKind, InventoryOutcome}; let fixture = CryptoFixture::new(); @@ -261,7 +276,7 @@ async fn retained_inventory_catalog(catalog: i64) { .unwrap(); // Literal retained catalog/root shapes from published creation/correction source; not predecessor-binary evidence. let crypto = fixture.crypto(); - let grant_clear = if catalog == 4 { + let grant_clear = if catalog >= 4 { StockGrantRecord::from_enrollment(record) .unwrap() .encode() @@ -269,7 +284,7 @@ async fn retained_inventory_catalog(catalog: i64) { } else { record.encode().unwrap() }; - let grant = if catalog == 4 { + let grant = if catalog >= 4 { crypto .seal_stock_record(&input, "grant", input.grant_id().as_bytes(), &grant_clear) .await @@ -281,11 +296,15 @@ async fn retained_inventory_catalog(catalog: i64) { .unwrap() }; // The v4 namespace, grant2 and operation3 envelopes remain frozen literals. - let value = if catalog == 4 { + let mut value = if catalog >= 4 { serde_json::json!({"version":4,"namespace":SellerAuthoritySelection::from_attachment(&input),"administrator":input.grant_id(),"transaction":TransactionId::from_bytes([9;32]),"revocation":"1","inventory":{"revision":"0","pools":"0","movements":"0","head":null},"authorization":grants::single_state(input.grant_id(),&grant).unwrap()}) } else { serde_json::json!({"version":catalog,"input":input,"transaction":TransactionId::from_bytes([9;32]),"revocation":"1","inventory":{"revision":"0","pools":"0","movements":"0","head":null}}) }; + if catalog == 5 { + value["version"] = serde_json::json!(5); + value["inventory"]["mappings"] = serde_json::json!("0"); + } let clear = zeroize::Zeroizing::new(serde_json::to_vec(&value).unwrap()); let root = crypto .seal_stock_root(&input, catalog, &clear) @@ -319,6 +338,7 @@ async fn retained_inventory_catalog(catalog: i64) { 2 => "PRAGMA user_version=2", 3 => "PRAGMA user_version=3", 4 => "PRAGMA user_version=4", + 5 => "PRAGMA user_version=5", _ => unreachable!(), }) .execute(&mut *tx) @@ -332,12 +352,9 @@ async fn retained_inventory_catalog(catalog: i64) { .await .unwrap(); let binding = store.authenticate(input.clone(), &proof).await.unwrap(); - let minimum = store - .stock_authority(input.clone(), &proof) - .await - .unwrap() - .inventory_checkpoint() - .unwrap(); + let authority = store.stock_authority(input.clone(), &proof).await.unwrap(); + assert!(authority.source_checkpoint().is_none()); + let minimum = authority.inventory_checkpoint().unwrap(); let context = CommandContextData::new( OperationId::from_bytes([7; 32]), binding.actor(), @@ -394,20 +411,26 @@ async fn retained_inventory_catalog(catalog: i64) { ); let mut mapping = serde_json::json!({"type":"stock.map_option","context":context,"input":{"listing":{"kind":30402,"author":participant(),"d":"0a".repeat(16)},"option_id":"0b".repeat(32),"pool_id":PoolId::from_bytes([8;32]),"expected_mapping_version":"0","per_sale_unit":{"amount":"1","unit":"each"}}}); mapping["context"]["operation_id"] = serde_json::json!(OperationId::from_bytes([11; 32])); - assert_eq!( - store - .execute_inventory( - InventoryRequest::from_protected_wire( - binding.clone(), - created.checkpoint(), - &serde_json::to_vec(&mapping).unwrap() - ) - .unwrap(), - copy() + let mapped = store + .execute_inventory( + InventoryRequest::from_protected_wire( + binding.clone(), + created.checkpoint(), + &serde_json::to_vec(&mapping).unwrap(), ) - .await, - Err(OperationError::UnsupportedOperation) - ); + .unwrap(), + copy(), + ) + .await; + if catalog < 5 { + assert_eq!(mapped, Err(OperationError::UnsupportedOperation)); + } else { + let InventoryOutcome::Committed(mapped) = mapped.unwrap() else { + panic!("retained mapping must confirm") + }; + assert_eq!(mapped.mapping().unwrap().version().get(), 1); + assert_eq!(mapped.pool(), created.pool()); + } let mut corrected = serde_json::json!({"type":"stock.adjust","context":context,"input":{"pool_id":PoolId::from_bytes([8;32]),"expected_version":"1","direction":"add","amount":"1","reason":"new correction profile"}}); corrected["context"]["operation_id"] = serde_json::json!(OperationId::from_bytes([10; 32])); let correction = store @@ -437,7 +460,7 @@ async fn retained_inventory_catalog(catalog: i64) { InventoryOutcome::Unknown(_) => panic!("retained correction must confirm"), } } - if catalog == 4 { + if catalog >= 4 { let child = StockGrantEnrollment::prepare( &SellerAuthoritySelection::from_attachment(&input), "retained-device".into(), @@ -520,9 +543,13 @@ async fn retained_inventory_catalog(catalog: i64) { .unwrap(); old.expose_secret(|bytes| { let value: serde_json::Value = serde_json::from_slice(bytes).unwrap(); - let value = if catalog == 4 { - assert_eq!(value["version"], 3); - assert!(value.get("mapping").is_none()); + let value = if catalog >= 4 { + assert_eq!(value["version"], if catalog == 4 { 3 } else { 4 }); + if catalog == 4 { + assert!(value.get("mapping").is_none()); + } else { + assert_eq!(value["mapping"], serde_json::Value::Null); + } value["operation"].clone() } else { value @@ -538,6 +565,7 @@ async fn retained_inventory_catalog(catalog: i64) { 2 => "PRAGMA user_version=3", 3 => "PRAGMA user_version=4", 4 => "PRAGMA user_version=5", + 5 => "PRAGMA user_version=6", _ => unreachable!(), }) .execute(&mut connection) diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs @@ -38,6 +38,20 @@ const QUEUE_MAX_BYTES: usize = 4 * 1024 * 1024; const QUEUE_CAPACITY: usize = 32; type Reply<T, E = WorkspaceError> = oneshot::Sender<Result<T, E>>; enum Job { + RetainStockSource( + Box<WorkspaceBinding>, + radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + Box<stock::StockSourceCapture>, + AttachmentProof, + Reply<stock::StockSourceOutcome, OperationError>, + ), + StockSource( + Box<WorkspaceBinding>, + radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + radroots_domain::EnvelopeEventId, + AttachmentProof, + Reply<Option<stock::StockSourceSnapshot>, OperationError>, + ), OptionMapping( Box<WorkspaceBinding>, radroots_storage::inventory::InventoryCheckpointRef, @@ -175,6 +189,12 @@ enum Job { impl Job { fn reject_recovery(self) { match self { + Self::RetainStockSource(_, _, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } + Self::StockSource(_, _, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } Self::OptionMapping(_, _, _, _, reply) => { let _ = reply.send(Err(OperationError::RecoveryRequired)); } @@ -388,6 +408,8 @@ impl Handle { | Job::InventoryOperation(..) | Job::Pool(..) | Job::OptionMapping(..) + | Job::RetainStockSource(..) + | Job::StockSource(..) | Job::Revoke(..) | Job::StockAuthority(..) ) @@ -480,6 +502,50 @@ impl Handle { }; let _ = reply.send(result); } + Job::RetainStockSource(binding, minimum, capture, proof, reply) => { + let result = if kind == Kind::SellerStock { + stock::source::retain( + &mut stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + }, + *binding, + minimum, + *capture, + proof, + ) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } + Job::StockSource(binding, minimum, envelope, proof, reply) => { + let result = if kind == Kind::SellerStock { + stock::source::query( + &mut stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + }, + *binding, + minimum, + envelope, + proof, + ) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } Job::OptionMapping(binding, minimum, key, proof, reply) => { let result = if kind == Kind::SellerStock { stock::inventory::Turn { @@ -913,6 +979,44 @@ impl Handle { ))?; result.await.map_err(|_| OperationError::RecoveryRequired)? } + pub(super) async fn retain_stock_source( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + capture: stock::StockSourceCapture, + proof: AttachmentProof, + ) -> Result<stock::StockSourceOutcome, OperationError> { + let anchor = stock::StockSourceOutcome::Unknown { + transaction: capture.transaction_id(), + envelope: capture.envelope_id(), + }; + let (reply, result) = oneshot::channel(); + self.send(Job::RetainStockSource( + Box::new(binding), + minimum, + Box::new(capture), + proof, + reply, + ))?; + result.await.unwrap_or(Ok(anchor)) + } + pub(super) async fn stock_source( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + envelope: radroots_domain::EnvelopeEventId, + proof: AttachmentProof, + ) -> Result<Option<stock::StockSourceSnapshot>, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::StockSource( + Box::new(binding), + minimum, + envelope, + proof, + reply, + ))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } pub(super) async fn option_mapping( &self, binding: WorkspaceBinding, @@ -943,6 +1047,7 @@ impl Handle { } fn send(&self, job: Job) -> Result<(), WorkspaceError> { let bytes = match &job { + Job::RetainStockSource(..) => 256 * 1024, Job::ChangeStockGrant(..) | Job::ExecuteInventory(..) => 64 * 1024, Job::CaptureDeliveryObservation(..) => 96 * 1024, Job::PrepareDelivery(..) => 1024 * 1024, diff --git a/crates/storage_sqlite/tests/fixtures/stock_sources.v1.json b/crates/storage_sqlite/tests/fixtures/stock_sources.v1.json @@ -0,0 +1,65 @@ +[ + { + "name": "quote/peer", + "recipient_scalar": 2, + "raw_wrap": "{\"id\":\"d3197dd91a831135e51824a6aee4afcda60142b14cdc0c9c1cd7745724d2cf72\",\"pubkey\":\"4a5169f673aa632f538aaa128b6348536db2b637fd89073d49b6a23879cdb3ad\",\"created_at\":1699997999,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"]],\"content\":\"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\",\"sig\":\"662b3c9e4c9570bb4a87bb1294cc13abcae9be331fcc55ba70e14b31670a92aa727c7b29d682fb110d2af364c91402f16f1a18f0ccb63af1b636cb511c6b874f\"}", + "raw_seal": "{\"id\":\"3b168c32495bb5985141f9d4aebf6f72bbc1331242c378cdc911736d0beef979\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699999000,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"5f4d30253f21ce60b103f4e62848f81cf5af7f009df869cf7d8031f05d353d2ad01dd0adda61c7de3944763184bf7f1ef31942513682c91ebfe55a888e7ff40e\"}", + "raw_rumor": "{\"id\":\"1c37125db126106b4de9da045358a3a469eecee6751ddbdcd38f78cc7c9d0bf6\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":450,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"450\\\",\\\"order_id\\\":null,\\\"parents\\\":[\\\"0303030303030303030303030303030303030303030303030303030303030303\\\",\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"0707070707070707070707070707070707070707070707070707070707070707\\\",\\\"0808080808080808080808080808080808080808080808080808080808080808\\\",\\\"0909090909090909090909090909090909090909090909090909090909090909\\\",\\\"0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a\\\",\\\"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b\\\",\\\"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"600\\\",\\\"in_reply_to\\\":\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n\ud83e\udd6c\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\\u0000\\\\u0001\\\\u0002\\\\u0003\\\\u0004\\\\u0005\\\\u0006\\\\u0007\\\\b\\\\t\\\\n\\\\u000b\\\\f\\\\r\\\\u000e\\\\u000f\\\\u0010\\\\u0011\\\\u0012\\\\u0013\\\\u0014\\\\u0015\\\\u0016\\\\u0017\\\\u0018\\\\u0019\\\\u001a\\\\u001b\\\\u001c\\\\u001d\\\\u001e\\\\u001f \\\\\\\"\\\\\\\\/ \u00c5 A\u030a \u2028 \u2029 \ud83e\udd6c\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}}],\\\"fulfillment_charge\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"25\\\"},\\\"lines\\\":[{\\\"amount\\\":\\\"3\\\",\\\"fulfillment_group\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"id\\\":\\\"0505050505050505050505050505050505050505050505050505050505050505\\\",\\\"maximum_line_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"439\\\"},\\\"option\\\":{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"Bag\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"200\\\"},\\\"tiers\\\":[{\\\"from\\\":\\\"2\\\",\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"}}],\\\"type\\\":\\\"fixed\\\"},\\\"supply\\\":{\\\"amount\\\":\\\"0\\\",\\\"type\\\":\\\"estimated\\\",\\\"window\\\":{\\\"end\\\":\\\"200\\\",\\\"start\\\":\\\"100\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}},\\\"unit\\\":{\\\"contents\\\":{\\\"quantity\\\":{\\\"amount\\\":\\\"500\\\",\\\"unit\\\":\\\"g\\\"},\\\"type\\\":\\\"estimated\\\"},\\\"label\\\":\\\"bag\\\",\\\"type\\\":\\\"package\\\"}},\\\"option_id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"},\\\"selected_tier_from\\\":\\\"2\\\",\\\"type\\\":\\\"fixed\\\"},\\\"product\\\":{\\\"description\\\":\\\"Public crop\\\",\\\"name\\\":\\\"Carrots \ud83e\udd55\\\",\\\"origin_summary\\\":\\\"Example area\\\",\\\"producer\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\"},\\\"source\\\":{\\\"coordinate\\\":{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"d\\\":\\\"01010101010101010101010101010101\\\",\\\"kind\\\":30402},\\\"event_id\\\":\\\"0303030303030303030303030303030303030303030303030303030303030303\\\"},\\\"source_lot_label\\\":\\\"Private lot A\\\"}],\\\"maximum_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"464\\\"},\\\"rounding\\\":\\\"half_even_net_line_v1\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"supply\\\":{\\\"type\\\":\\\"stock_backed\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"6b938453a4506446c837b7e01bcb650edc8051c14a9eeb0f3c638020dce35498\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"thread_id\\\":\\\"1414141414141414141414141414141414141414141414141414141414141414\\\",\\\"type\\\":\\\"quote\\\",\\\"version\\\":1}\"}" + }, + { + "name": "quote/self", + "recipient_scalar": 1, + "raw_wrap": "{\"id\":\"fcb8aa987a2fb33c68540193d9c13edb126b4b55342d1dce339c76e5fbd94251\",\"pubkey\":\"9d1abaec9f5715a15c7628244170951e0f85e87f68ca5393d3f9fc3fa23a69c8\",\"created_at\":1699997998,\"kind\":1059,\"tags\":[[\"p\",\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\"]],\"content\":\"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\",\"sig\":\"a6a0842d51a1684577f96693811f4ffcf6cc53484b92868d316e6b30e5c7747ffb175fac6b0d9335f2b11f43fc7e0f636e9ee5f5b900507e77d69d2b69dc0b59\"}", + "raw_seal": "{\"id\":\"29f3d844ce8ca15e99a4eeefbb7543ca236ee89883817216b6ef998d88e3d216\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699998999,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"d4173484936e4b30be6abdf5799cfeb4cc2ce0babea2018af8bb4decb2d90990cc16823e3a46d6b498eb8c6755dfe736c50c456c1d72617fe341ed3d9d472e6f\"}", + "raw_rumor": "{\"id\":\"1c37125db126106b4de9da045358a3a469eecee6751ddbdcd38f78cc7c9d0bf6\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":450,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"450\\\",\\\"order_id\\\":null,\\\"parents\\\":[\\\"0303030303030303030303030303030303030303030303030303030303030303\\\",\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"0707070707070707070707070707070707070707070707070707070707070707\\\",\\\"0808080808080808080808080808080808080808080808080808080808080808\\\",\\\"0909090909090909090909090909090909090909090909090909090909090909\\\",\\\"0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a\\\",\\\"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b\\\",\\\"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"600\\\",\\\"in_reply_to\\\":\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n\ud83e\udd6c\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\\u0000\\\\u0001\\\\u0002\\\\u0003\\\\u0004\\\\u0005\\\\u0006\\\\u0007\\\\b\\\\t\\\\n\\\\u000b\\\\f\\\\r\\\\u000e\\\\u000f\\\\u0010\\\\u0011\\\\u0012\\\\u0013\\\\u0014\\\\u0015\\\\u0016\\\\u0017\\\\u0018\\\\u0019\\\\u001a\\\\u001b\\\\u001c\\\\u001d\\\\u001e\\\\u001f \\\\\\\"\\\\\\\\/ \u00c5 A\u030a \u2028 \u2029 \ud83e\udd6c\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}}],\\\"fulfillment_charge\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"25\\\"},\\\"lines\\\":[{\\\"amount\\\":\\\"3\\\",\\\"fulfillment_group\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"id\\\":\\\"0505050505050505050505050505050505050505050505050505050505050505\\\",\\\"maximum_line_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"439\\\"},\\\"option\\\":{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"Bag\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"200\\\"},\\\"tiers\\\":[{\\\"from\\\":\\\"2\\\",\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"}}],\\\"type\\\":\\\"fixed\\\"},\\\"supply\\\":{\\\"amount\\\":\\\"0\\\",\\\"type\\\":\\\"estimated\\\",\\\"window\\\":{\\\"end\\\":\\\"200\\\",\\\"start\\\":\\\"100\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}},\\\"unit\\\":{\\\"contents\\\":{\\\"quantity\\\":{\\\"amount\\\":\\\"500\\\",\\\"unit\\\":\\\"g\\\"},\\\"type\\\":\\\"estimated\\\"},\\\"label\\\":\\\"bag\\\",\\\"type\\\":\\\"package\\\"}},\\\"option_id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"},\\\"selected_tier_from\\\":\\\"2\\\",\\\"type\\\":\\\"fixed\\\"},\\\"product\\\":{\\\"description\\\":\\\"Public crop\\\",\\\"name\\\":\\\"Carrots \ud83e\udd55\\\",\\\"origin_summary\\\":\\\"Example area\\\",\\\"producer\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\"},\\\"source\\\":{\\\"coordinate\\\":{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"d\\\":\\\"01010101010101010101010101010101\\\",\\\"kind\\\":30402},\\\"event_id\\\":\\\"0303030303030303030303030303030303030303030303030303030303030303\\\"},\\\"source_lot_label\\\":\\\"Private lot A\\\"}],\\\"maximum_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"464\\\"},\\\"rounding\\\":\\\"half_even_net_line_v1\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"supply\\\":{\\\"type\\\":\\\"stock_backed\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"6b938453a4506446c837b7e01bcb650edc8051c14a9eeb0f3c638020dce35498\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"thread_id\\\":\\\"1414141414141414141414141414141414141414141414141414141414141414\\\",\\\"type\\\":\\\"quote\\\",\\\"version\\\":1}\"}" + }, + { + "name": "request/peer", + "recipient_scalar": 1, + "raw_wrap": "{\"id\":\"40a7da4a1bdcf84770730f321cd3641fdf446164f2b51bdd4972038e912410b4\",\"pubkey\":\"70b55404702ffa86ecfa4e88e0f354004a0965a5eea5fbbd297436001ae920df\",\"created_at\":1699997997,\"kind\":1059,\"tags\":[[\"p\",\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\"]],\"content\":\"Apj4ywBgWHLPsbc0t/usCJiMMzY65awg6VaJx93fy2QvPmSftKUX2JmvBF1hqDNb9w08f2CE4y2Y4BypSi7BRHmoKc0v8ACHMjbUtWv/5tqDEPNsHiu2FjF+fEureksBNxcaYH9i+yoGegjsDI4jzBXj72lh+JkvB136l/CNBPuPPZtpGlggzHIEEi4w1hL9VjLD7CMd8O0QwIQBTlImWcHaOqX69qdSrihj8vykatWjidc6T1p9tJP/5bHooHhu+4z5WJeWeMchRdnuoO7/6t02am0WMCAlyuOjfsTGzwpv6R84WJKaxHX5eIAwBjhl/ah54T4+EWnGb3M4BfmnJKFIfeIDXmfsIHZRyGqNE+dZQHb9vvPlMAy8S6uJztwEUrMrqodPUrvDu4RAhlNu7axHBc9EjloVf5YcOMfdLYhjDvBkxZGJTZS4zhei3qPq1lz0OSA4SBuesAzGjt9onX/BMyoTU6M8YtXHltwD6z8DkiDjZFgRnzfjb2cMX4xguxIkHYy60PbvzdA5ensVSgqpIaCOzCv/0jxCUFJCsOkgKjRtHu+SDQpaxWOm0ySaXFOkNMQpgRAX4Xohd1716cxmQleOouoh2Js9rn+upPq1PbiTWhdWhRw/3UY7y7LJ6vxBFZKEYG2F0X8mbU+filjoUudnD2wyHuP7koMTM65WT3zM1FfIWQXR6lGUkkY7aCxo1fo1X/iFPuKRHMQa+PG4ZhyhE13kRnF9E5If5FHI6QHHYavOwzMdVODqOJjw54ywIoWJUS5TjmCyfBYErBzTyVNHHx8ehD2JiOcNDJlaoMGXU9mEzfHIxh/JJf/MTB+53hgjNMk/wMWgE3zZKfpf9T4n411KR9jyY3R7AwfWBM4nHBCcp6uJ0GVvzccRpdrNQbAeKed+qXChkEiS/xbPqj/wjZq71CafXsR2Ijw76pDFDtP41Iv/VTPT74UlOcSIq2ZNLAAQj6t+Sp8L3/t5mKmMzkXq+903bK3XhCIbMS9vJ3+Hdf/M0mb2E86kGSN5faTLU2D/V3Hnyqn3x01oosM30DaU27CR+wFcnilHpR/O9L1MINCtsLFkk3Oo+sgaS0JnklZ1c4w1B/Wa8362XM6baXxKiBaqbmOqQWU0S4Qud4ZVo8ehQ8JGgx0JIexOUJYQKUtn33RWopJq213djI7UBAjgAampSxqfrnOPRLRmKG1WYisznZH0TCWP3xwPmilhv6PeY9ANqb+aqEw6t0oTy1kdXt5BmGXxMrHf+yKzvNgsnU8tAX1gfgZQih/jk41fW0V/dk6BRwHn9vqgveiQDKIPmuAuCPGcPaio2WNr6ycmtXGkzVfPfuDd+PUGEVyLFvOIp+2XtzMgsxXuWzidxXKSaQYCja2kKg5qgr6ss5exVGAwSQFgwWge8xkijSPjMcRDqRflGNTT4y0sOuE1Hk2rzWH7kDR4QD6oL8Vactk+csIWvp8xKvixl9+h8MH9YO8sL+aCFZWG2q+dEJUDpLowWE33GAuN30x6RLiANyJ4NtGjnAH6XpyuW/rXsR4NiPwP0pMSfK8xa8d/rWOJbliZufe7qklMkM2lyTxVaKA7Mi5rG0W0JTbyqVrco2AKGAOPFVaEOP3J5V/PBVfFlyXmQ8xHSFyzH2mGP6WH1ek5EcX+/Rm0ajDw47M+Y9jqBAMvcT16laU854ci3y/iKQHftDwwWatvLRWlMBZiCozrvBNP3UEAXZ1ugihtyTXdQHoSntokdzSZnhTIAME/5rq45eqAnXwMb36l7voqa/V1wpSk35YlydzXDQdkzjGFACfmY8/9WoongE+PxzXp7J7/f7S05WEeh1oEqdBychmaa1h+JlvpdblvWdi7SLFncTJ56bUs2f4o8GcLFKOAGmhSHdD6BKW9FEQRx+Chj2iE2j+jfOHEtbg8M6Cx26/FssWCb66Fpzw8l6xXmaRQTnXAkyEc/7/JAgZU9v95G7BCHeF4rFiRo0vgjHpKGcrm6Kis9cWFspZOeHBwHlRfx/rOvU/4k6kE63qZwQN842EWZr4uHNrhw0azMcbjsnruQEI3ESXB2nokihtQg0U41h6GlGTZFcYjHA8ao9qXxtyQXlSgjlhkM6XyGaDqNQsHC5YFGsYHXt14viSm+3Y4g79pNo8BxbPVvdUfizzOmb3cj7FCCMVA+QWyiw47+cJ0lriLgq65SckVj15sueCASBi0Hnomt5K1PyrUVGCW6bmpzzjxyNTB0WJw0fMD8BKWKDj6+fJG+GBumBEDUC4gsroWBK+3zMPoaCIFulGjROSbBWJr4WM+6Cx5tc5xGAwHu28usyem9biwKHlVrjEXIhVz1OqgMBntVmk9kxM3P/088LhdaDs4j50up5zwJfDIj8d3OeIpdTWt7EkA191HpRRma5WTk7vs6xWGnFtnqMZE+IHrDlT9hIhgG2zScUsfVk0Be9l+dI7yl89buoRXlcEvkZqs092ytajliBxWRsMy7AM71VwT4TUJf4EZ/RFXwiQycRW9Z4ciJGz+y3UrwB8knDR1F0Y7uUte3Jn0GFTo7MFstWYgUs15+0YSMIRogLSusZEOUN5Fn1DauwXb8lsZA4na+1Zr4JeDkjE/iQDUynV+pd455s/77VGeJQjH5aq9P5eAARBf2qzF78RjntkAJXtSD9AaNGxHtoGyt/yd5n2gUXnYd/0JRWwJLtcU7aJ8M8arod/WzdxdCyDjMLT6CiebbDx4lPfPe2mIESYADNvf1/w0v5idO50v7Giyt6QhB7qtuCnMaFnDEDGlmdKNJLpb9eW3JTwo7WYKRqWkuyEMjjQudPDYB3E4M2+eXN6ss5J/E0WnLA2M6JCi9FoYdJGkl9FxMC4UbntVjHtkYkquxBIG82HA+QfPtPu5rRdbj6K2xho6e8LQFMThBdCxy9CbetDptRSg4LNwxDSrrKjeaZnty58dacaz+N2Mq3IM7+rAGEdR2kNmfL4tnIE6GiAprkSSwtXH1s/etLiKhEEH6j0svIB5incTeaBKcUHxguiESgorbkLxVRCCGbnUiWHzmB8Usrp4+q9wvGxKVMVtRX9xASsT82OO9GI62YRC5ktwAYZxRjtEpUZRd+4am75CW8mtBd8zELROtMJ6hjcV33xwsJoEXeUDPXF+9vJN5XONGOzARrs0dKtYoR4XvkHYYCn1Kd6kcoGWl/aLGKlBw7vkFasFcaTPzIQUZJSVvxvaVUul+fYMjGpi8UkRS2E8h/wxXfocOJzMeLk6xOkf1TUUN2CV/nttuTEN4C/jWLn88lN7FtHtr63Pywa7FSMS0ivaMt89ReWAj270/crKwDXiL8IFxdfrsGkwb2jrA9kklLadMItjdfVjmCloMgModoQlq9knkwSfnNl7BamI6SAZ54J0cnqvj+kAnOoavqt0u8kxO9qtlJX24/5dzy+iNmJ+BGh+76yXyWJtgq7OlKPxNk0MWEIvEAa7E/ErfGTZiQFXn3ZwqIGEmzxfuSc2QwHWFHXAXgtFPcJChuQ3+jNbs0/nzRM9IBx7frf4vyrweAOu5juqtvWM4ZTGKl9uJ1nyg4z/HfUiKXOpaV+uKEPHPiGnkIufXwm4KEnf6rKzRn9G9UAoLKqPI3oZqK5VgPkym+ymMT6qhgfrjglKvQ3yjnnmKo3PPkY7lS2JqMN27VkYWC1oWXG3DHcMzWCawolSyC1AI/9glxgyAPQDOrQDVqXBSfG56pfhijdZR2OpQ90MwdzO7doJZg62TMx2t+AX5Dh03djZQyr6TqeKztqdMJp7+PzdTaJR7ciYbfj8wcmXzB1Q7gs6hsQjOH1B3zFezpCQRslh9ReEtaNUEp8E3KshcB5/UsIUKELv5SehgC+CFodTs1h6RM7nTy1sOYPazGCl9M6PP1h/GDyGkcf1z1mvrpAO+BVSBjHE/4FAL1wq5fTIJ2Ar+a8RHKfig4QeMZPQ62S9N94nBcCil0LkFWPiwO8ESC3sc+wt1wIaStQv5AMPYiHq4u2U5BooAS1EHj8l3YXiZiGX6YfqgPwEQoYwsMNIKV5N8FmKdGt2BTLD9WhmEkSwSnibU0hRNGrx9AmGUsCPhuyURD/8qIuX7acWPEgsiWU0f2VAffVgBfAkubCbehYrncQ8fnKkf+H51QW/rCoDOYlq9IocP5ponKYFA8BRyvsQp13xWDQW8yGyorrLQ98izijiVHmxVxo2L1K8+sfF3iqd9JjifU1phPs9J4QdzXLh1IBDhG3cipUT4Km5cNbZg/s/LjGJRYyj3Y+7y/syCGJTFtrsYDecY5slFwirFxBEPmca+aoMbjvS3iSdLfCzIiQPu51t0YgHNLeeX+Fvaac5rVOKtyg0ozPrlsh2eMEF5U5jkIxqHbbj6FFz3ZlcqcoYHkwo3Qn9Tru3GuOoGAqj1jw1GIZg/n2jcCXUfU+bwyTo2pzy8//X7DhQq1OC4zq6JtGMGW0mXMR5jJhmgiFIz8xFfAcb3u2PQn1z/rlh7b4aILS/jDLRFvE/amk+BsqjUzbPBM9I1zYkREU8qWwKMEgfI34lOaYL5ogQYaFRsyn2MkNv7ZlE/g6yCAjg68kz8BYKKRujN8/S05ks8fR3uOt7XaWjrhwF+TdpvIh56/eMIcxYTi4RU7kKpd5veSiyrQcnkmQWWJ3DdacQ+q23w3wZCxumyPTM5FJoG4rJDqKiH6xhXFoPwemdYGto5X7X7o5gDf2xa78MtWQT/bAr8RiUTSooTvDtagEW4wp6qN7l3izjp2wCxVhjIAnbZO3NaaIKEOMi3cStCw8/m06A+i+Mvxu8HjwAVPnoV3cdGuFFRjea9kt+yk5D5sh/oTETW1eBv/aMF8P1THCBHmLTz77cab6TW0lbveT/FIb0fb0CSZEGrkANFP6xvIbIXEOvy2g6c7ztmDq6KvwyBrMfaPGKXQfZW0Jm/wxgp9fPTXe7/b2MvDiQnJ1rlZIg0VlChmOZhl7v5KpdtltoXOio4LN4WMpTIP2ChZ/l0kReRuxIhniu6y9IpkOGoOWKwxeLPTOTKUFinHU/5HNCCG/ejzF43bf/zMcTjzMwsCdLiCp3Fix4HSHYbFIWJI4WvbymHPJa2KngBMx1gNyZdC9IpOAnCio3UTqKpe65eAnaOekU8Sli3Q39hNJf1fK09XRxIi+Kj/nH+bCTvHeseXjMtCFOvezfWoWDUP2x06SxolbmfZz7OdrO6koRJa853xJ9Mgxv2ZfDOJIc2AOk74jtKYMviguioVTF6MyzTD1cDMCisM2LODas5zBVBZsnwL1WeRzKovpvZphi1NezTV4O1mfzqzGdvKhksIIAzgBTpfRzi/OSMDJWAKlkURJFsd/hjCHOfm+yK7CnarHcg31JHv0UUl16mj+x2gud2bwd4uh533kB7Remr3arhQ9HGTbLuYw9/XKGjOE2P6Wf/40JR0a6nH3CRth13gnBGNof7Y04sqF78df2qgXBikuVVUPFNq5OxAnMwaN4o6jVH2q+slMUk/pBaionOXhYQr85niM2mCbAYqgjOV3GFpY5R4t2c1nluvoXjM3Xd4Sa4Dd3Lu9lXDNk8ahlP+07fEuhKjOGLfH1b7jJ4rE23ZPfgk14uShT0LdseAuQeL6Iac1PzXXB0fC6K6XdYsxHZofpF/FMAzIE96D3emfdnEJAb1KljIqrV7IV2Ja/WUijtS/DQEcS8Ab38cnurPKlUDzZOR1fBJMHRVQfeWyAJ5r3r8HnqtlR//bQjgu9hJFXEN9hTogZvU2dpGOi9P4MG7JnfpJjZ67Dh9QgkuprODt2vyxmUNYkSmm+Kle/OI38xl5H1YJfEbn4IFsVG7KpCfhzpIYgXtVwPRjeso+do5MGTq77lNFODUIQ7SwEuq/oSYjkTtmkJuuhTmwjQI0JBsePMuLF0LmdsqZ1hQMLA6N/k/IkCvH83F2XafbCgRZGDSmU3rb0Mhq3jG7sPM4gXyzi1IqMtw+Iz8YywYGTRCNP6HSkz9n3cJ3wBVTkIwoNhV66cloGI/+65AByfT4bwISRm8PiPrYGtm0NaIhCi8+mnrS/P9aHzcpzGFK/roD7PdDpn49f3GmZllKfX1M54/HlQGenBLasK7kUI4vLUvPjICQ4pW4qDNjyEJMO/tpFHZoreTBsQ5Gwx0Hyt3BbddDpVZ7nz0sppILvPBlxjdRBor6giAA9K1MwdLyHLGjh6QkisW0DAteFVh0hauK9IKf2IGPBDQNtFpRcNkoMjYXLC8qEt+ccDiZ8aPytjHqR8WFUnwUQcrlOIPdlBFTMRpXH43/Cvis0tsOdkG/P+Qv+r2PxZXA4dWzh+oBPHDNnwajFBiYyq2xAaAcPh5swaGm56+Gi6DRtYCcBcRH0Qw9KvtD20zoRY9EhueiGqrx/8BwY47aqCE+E26SpD/vu0m5RBJL0hYQelnvnJHhLD/VuItZHJzfrFata7hbMoKIIW5vqMAcRZSANHwkPzQ/pVqFY5hNBp+MZwQj63A7PIoi0TGTSUFKRC4z3JJB5VDigFWG4mBFmeJx2Tgn+BCiW2aQqLviW5jDGyYerDiSL2TJ/QHa4NenRSLdvF4yl7ptSYOFr0oJENi3aLtSmX9FHxmcc+lrlTdLxywvgqlZ8tPf7D8w975xxypgIU96n+dAJ5na7i8+7MvnetxSXe8jQMnP51c9CesihXytEB+Zxj+/hoCEzGKIj3SVG3t4+Lh3t7g5nijJxfdtYiWsWSR+GZQ8ie68RMDSMYRwnKHnCdeuC8EgLXuleF1pf55TT38gazPFZ6LkNoarwXjyaXdY4e7ewo7Jn20ogQZSaerN+U3y7JqtmmQFq8t7luBnKRFFQE0F1GpAXUCnOqnD5sA9gKy9iYmt3aV7wp45/kUjVSIuABzvlFFvCPtnId3HdCr4mGlwePACojM41nUs3J4pRVTgPsWDMXnf1U0fMgQd/tDAFpb19+td3/HZvrw0A4u93ddBp9HPDEpZX7yuE8rrMyCpqE9OfmfiuWPvR5OpcePDdoEuqH5yxV7f8NfovfB7FyqE4IHJFF+OeRTnwgFsb7ag6tmNR1A259CbfYGl/6u2WHbGd8GusDZtvXPM9plzxXyCg4998I/v1SwwvVaPX6CmGi07+T5bpv8TJfD5d+GH/L125Dc6Wtfjorwcz0HV1S1f/Yj9bK8JaBJGop4t3QdwT2+QA9VuMGQPvV2A+gYZFn1xJc1ORXTjmpsFUvmyzp/jRlGmSpXJpxo3VNLIEiOv57maeetUYR0//BqqvEyJqfIsMRkMVe+aO1DU7cxrHwKMevOfINA1a7jbAeNzWWVXp7/cltkq8wZqtZZI10k2UlwA13Ca/0nNL5XCBDKjeWcOUorm1liJnxd+0enTGF9OHErzXWDLred1GW7VS/3fA09TcMLVFEUkI/OfkxAvMfTS2Q3OnF+DC8SFPhkQkQHWlcb9fONL1wdYnzgvdfhcxKc/jgUVKkELZNB4VugYHboCHuVzo0Ncw+s2FVek5y9ZdnQMHcYPGgAKcnRuaGTvnUkdoD5/N7/Hw+AWBGjqJI0pCHWrzL45JSmDJ3jU0jA4xww19J9HBF84hj+6CQz88dIom1e8SLN6Ux/2luTDTiH3lTv45wwUJM79bNYVuBidn5hiVgAUf7xhvaHPhrFepUqYr0CHALV8TRFkvXl49VtZMZwPowm/+9u8aWZfMwWJfim0VsNd5WFtzmg0Tk0iNgKr8ef11hz1C7ReG5MfsbModP56KyGCEC8xqs3AfT3t43UaBa06qr/mcEnwhu7THfWG3KsAsK+9YBE9EvDCPuGOl3GzfFhz82a245H7dPgkjFZfZhh6NMpy0ueiZJ42nQj4TBILTZr8Nrzw8Dv0adpby6AbsL3AwgPMIiNjvUI3K8Ns0tItxkMCg2c0STxI5AxkCjsLQOiqIvT0aqcN/W34jIw8WH979SxrvFwxbBK9LiqvFyLwetzj8P15G2jBzYdWAjJCJQ/PlQ0NAjKEaMyyCvY0Tf05V0ecQ0rXoquICcfN/MF7XndSP4D6o18cKEPSysStyC8e/rwpn3p4ZDPYN9EwVBDNR9Br3J1vuIL+gTvq8STXtOBR+inrrXKMSqIv8lesBh6WrMFs0QSkKiv7veC5Th0QDIcVzAYBqFobrC7mwjEYoIhGEHBur+wu5b0hrDPZSy/pmhC+vqwf+KtYLoi80YbslIisAbPH1OOk3IyErHCxGvW3Nrr/0nXYoZB+Z2f+uQxX+0vH0lVBhuQ8ivwcQBfu2iVaYo6wcVIWvpoxqZIFst+ssq0qJYSCOTfEA1kOc+RPmHeFDZOZlMuKx+RnkThl3jUkTS4sYRwTs9G4x/VUDySSkdCtnOofPaCdqaGfdOHPvzYd3npi5nq38QZBbjabfBi3dkbk8pHFE8+W0eBjUhpPwPFESIt0Czbr6qn/UCmpRTfvZFa6C4eDGag4soR3ceE8xr8oQ7+iL/S+YyMz2Wms/x/ogZHFbRlF7geQnkfrloO4TIBiMlXa+2l7D3z2hYVVICIsyjw3zIBz1UBCGVx3YFRjdqw3Gs1lbwVQz/IeatnW0mx1uljCTv5KxybLRTl+kvrepuW/u66tgaWzrvS7RSlQ0Gpjk4p1eyJBb6WU+TwAoMgsGHdROqlo+gTOkFCk9DBqkXh1E46J99ONcWaKhR4G+ILHmWVgrZtwy+8FoLvR8zJxCu7thIHFhrPiBDIlYW8d5AW0dcoWSPPr+QK9Zxbdi5QGVB0+PvybmuU/mfWrut2cStmTq0Ne/vutATFHyeYzNAqClfjYjyJ27l0RtXKzsl8dQOihDrSI0iQThPwVWVUwW0ZYSNOL75O0nbzYnUWBolZtz9tkkxRDdCWOseoknK0/ntNzIcIKcpVaRVHvt5+at/tG9j4+BZ2S9a3HvNNOFgUwM/AvPCAe2Ndmg1pj6n+CYNMxZtn/TXllNX2/uN/qr112FAMc+wbhltD17OVrRYB5NHMBVWIxmCIw0EPZJdet9y9ao+al+udKIMvHeXfOzpwWrGwb2eoxs+vQpeDl5PdqODOqBK0XKk5Y3lWoGZNYqLO7kOmEvjUEp5A5emzULC94ggLpTnw8aoJiamdnAxkHd43yOlICGgNWwN0/CHEAw3SYXbFUpAI6DhV2MQw0uPTVotxiiTfKlcr8JuZHO8J6g/A52Cy7I/ZAWK2X0KTqUG3KLYvp06rqEwjLHXJqI5pWpn0iO3uOOc9obrCO4CXedumSArGBvRElnRa7B4LeA4qOdxUly9jnHJWLX9r1iC9ulop+VXsDgR7z9wm8XJ4/0vX6jnQHnW9/KWtVCCXH/gEie5OgV1ESd7VlfmXjc+2PztMKvrsR1kZGyteDrwR6KYxs6ldTbO2SMDn7Fm9EK/D5WaD7nj3qxQZzwj7T2Clep2hl4A92Fwpr47rBTvv0JBj3yg/lH/t7ZO7Ihj/C4nbdupvhPEdS+ciIfnS3J/4bCGZqX6oLHUMSpTvg6jCfQdYbtZ6oLZqRj4teK44oD6jW/Uaz8NqZyvD8oqOHRzQlb/lFdw/0mdQY5ecC8IOdR7506lrsDA89i99CC/FtBdy2TF7xS2vHRYTIXdcTWmxBk4+ENfTGhCckWWx7dPYQtEhgOfPWXUFk9HIOrPK7P62rXqKs54/Xl3Q1gq2nerSTtjFFVgvD9ruTWIGisxPOfNFjuwvWjMhPntN2IgkZO7gNqoeWN8T3Cvn1Op3YbOUwV3j43W17eKPlCijpaYSDdDNrRb3FEcA0DnylvUHRp5JFkTyC+ZNqzFl+P8KfK/lX53oGK07Arn0au/wSS3ODVJ2HTx+PUbv9NwL26xBLMJJp9DaXEDqPACTcgYDsJXbPvrn3sX1YVYDhZVi6sQJT7yfFJ9UGEO1G6iFPTQSwPO0u7mi4Z/m26z6kF3a+QuzVmpVdddoyGpwNAPWn4ruI1UVgQDmv/PWXA1HfGO9+bXCI4/oD0IXyL3JrN3HksnJd8z2pOHIws8ItjC3AugqJ5M4f86nQuoOIQuITY9vrzU2PoZkEZ9hIuJOsSBeuDOjgyDGNYBw4vx95JML8qjcXj7kT4G0ARFvpvEc6c0dfZx3Gz1+VEzVvDBr20mhBs4JKzHfZq4WwYjWgRVszNE96Hn3T1qgv2Ho3PobPLtPdYzON8X5YAtPHnYJV7ws1XgPTD0bsUBL9O2tVopXv9o7lrR6O1/fPFh4HB+umKiGJ8PP/5yzvSAxIX9rHyB2LWogrVb4fVPWJgbxP9s3dG5jGBY3jJhnCLtljYNm7/QRurGe4n1Mly60Z8yZOyVIVXhqvfOSooMISwVYK5oCsCBDOHJbJdd2QkUUQu69TsaYgWy2dd6Hlwlv9JYK5uVxrA/BnhDeLNoeyXhZ6Zr9yTqiAsMfk4xlWSIRSok5WkeL3pHpEFSTrUcMTgRG8NIuBhcRGacG5plmkX2eogutUopvqSgfH1OOYr8S0a6KwNDqRICvEF4h4/oRICEg2iGyRwfRjF74R4FXmtCfNTbCjFYS87zv4XvFMLRb5CE35ZNnPcyNAJGKxS3LCn2mm1SmJWcOqLqtKuCmoeDMjPcqPpl1Cv/6z+DCSipe3nah8Dbbd0q9MGyC5qLdiJitdStO6mdZDfCrsCT9cdwOhKldAdx/5phuWCAIHfJK+/k+62E9SA1JfST6PccKMX021r9PtEJFk/6xJz68SRm+ZRw3DWhxef8irojeUQl6ObVffP/QoHgMbw13yamRN4x0NEDn5CkuAC402ZQ8g8UqrXUTC78hyie5k4ausWkxP5VBLuC1qM4KJ4k6DP2RAmwBFzBoJEZOd3RdmOChoH/FaOx/4bZVwoEP5tJLDwZeJdpdoicB8+5HgCSCxjwyo9FoSrsAtg8lbzEp1H5m6vrX+wGr5C6a9Hhr2LVsZkJjfqfbiHG9Jz4cC8r4JgKkQXaA0c48O9hXQsY5tZzSsmDk6O4WPWnaOMsnDTgf8xO1jBiF55QTaYPgfUeswUGX4NwJmlbT7W711OH2qj1xyykZ0JGQGd\",\"sig\":\"af6e67123445a1f0743b1a641e2d59fc422497aacadc6eaac708572918b74c43bd0b64cc5fe3dfc61fccfdf9a3ab364e8b171492b647a765b286d6b46672103e\"}", + "raw_seal": "{\"id\":\"a89c86fefa15125c9879e957b5de3f4c707fa9535abcf095b939cb28ea1ec35c\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699998998,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"4e61d134bdb754c76e684cb5dfa044bf6ed5c8fdff9187817c1bf66e563c1fdeeb42ceee4386f5af72e69ce71950bd7021307005603dfad0c556415e14a9dd21\"}", + "raw_rumor": "{\"id\":\"74dcef63bd14b45036d02ed24cc9438b95b7d4fd51ecc69c26158ed339470e59\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":450,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"450\\\",\\\"order_id\\\":\\\"1515151515151515151515151515151515151515151515151515151515151515\\\",\\\"parents\\\":[\\\"0303030303030303030303030303030303030303030303030303030303030303\\\",\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"0707070707070707070707070707070707070707070707070707070707070707\\\",\\\"0808080808080808080808080808080808080808080808080808080808080808\\\",\\\"0909090909090909090909090909090909090909090909090909090909090909\\\",\\\"0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a\\\",\\\"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b\\\",\\\"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"600\\\",\\\"quote\\\":\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n\ud83e\udd6c\\\",\\\"contact\\\":\\\"\\\",\\\"instructions\\\":\\\"Call \\\\\\\"arrival\\\\\\\"\\\\\\\\now\\\\t\\\",\\\"mode\\\":\\\"delivery\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}}],\\\"fulfillment_charge\\\":{\\\"currency\\\":\\\"JPY\\\",\\\"exponent\\\":0,\\\"minor\\\":\\\"25\\\"},\\\"lines\\\":[{\\\"amount\\\":\\\"2\\\",\\\"fulfillment_group\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"id\\\":\\\"0505050505050505050505050505050505050505050505050505050505050505\\\",\\\"maximum_line_total\\\":{\\\"currency\\\":\\\"JPY\\\",\\\"exponent\\\":0,\\\"minor\\\":\\\"170\\\"},\\\"option\\\":{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"Bag\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"100\\\",\\\"maximum_per_sale_unit\\\":\\\"500\\\",\\\"maximum_per_sale_unit_total\\\":{\\\"currency\\\":\\\"JPY\\\",\\\"exponent\\\":0,\\\"minor\\\":\\\"85\\\"},\\\"measurement_unit\\\":\\\"g\\\",\\\"minimum_per_sale_unit\\\":\\\"250\\\",\\\"rate\\\":{\\\"currency\\\":\\\"JPY\\\",\\\"exponent\\\":0,\\\"minor\\\":\\\"17\\\"},\\\"type\\\":\\\"variable_weight\\\"},\\\"supply\\\":{\\\"amount\\\":\\\"0\\\",\\\"type\\\":\\\"estimated\\\",\\\"window\\\":{\\\"end\\\":\\\"200\\\",\\\"start\\\":\\\"100\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}},\\\"unit\\\":{\\\"contents\\\":{\\\"quantity\\\":{\\\"amount\\\":\\\"500\\\",\\\"unit\\\":\\\"g\\\"},\\\"type\\\":\\\"fixed\\\"},\\\"label\\\":\\\"bag\\\",\\\"type\\\":\\\"package\\\"}},\\\"option_id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"price\\\":{\\\"basis\\\":\\\"100\\\",\\\"maximum\\\":\\\"1000\\\",\\\"maximum_total\\\":{\\\"currency\\\":\\\"JPY\\\",\\\"exponent\\\":0,\\\"minor\\\":\\\"170\\\"},\\\"measurement_unit\\\":\\\"g\\\",\\\"minimum\\\":\\\"500\\\",\\\"rate\\\":{\\\"currency\\\":\\\"JPY\\\",\\\"exponent\\\":0,\\\"minor\\\":\\\"17\\\"},\\\"type\\\":\\\"variable_weight\\\"},\\\"product\\\":{\\\"description\\\":\\\"Public crop\\\",\\\"name\\\":\\\"Carrots \ud83e\udd55\\\",\\\"origin_summary\\\":\\\"Example area\\\",\\\"producer\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\"},\\\"source\\\":{\\\"coordinate\\\":{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"d\\\":\\\"01010101010101010101010101010101\\\",\\\"kind\\\":30402},\\\"event_id\\\":\\\"0303030303030303030303030303030303030303030303030303030303030303\\\"},\\\"source_lot_label\\\":null}],\\\"maximum_total\\\":{\\\"currency\\\":\\\"JPY\\\",\\\"exponent\\\":0,\\\"minor\\\":\\\"195\\\"},\\\"rounding\\\":\\\"half_even_net_line_v1\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"supply\\\":{\\\"expected_window\\\":{\\\"end\\\":\\\"200\\\",\\\"start\\\":\\\"100\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"},\\\"risk_disclosure\\\":\\\"Weather change \ud83c\udf27\\\",\\\"type\\\":\\\"future_promise\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"08e8f87c0741efae469e140a5cf4468a9b87830492cb716202a8f826ebea89d4\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"thread_id\\\":\\\"1414141414141414141414141414141414141414141414141414141414141414\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}" + }, + { + "name": "exact_rumor_limit", + "recipient_scalar": 2, + "raw_wrap": "{\"id\":\"ae4f158fb9da203293afa28850524ad5a89c261bf98bd3d0fbd5e225a7aa1c66\",\"pubkey\":\"0aecff9438a87c97f7ae22ab2a6e9b1b726ac25674065f3f72fa84f1f7268744\",\"created_at\":1699997887,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"]],\"content\":\"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\",\"sig\":\"9f5081dad223e7f1a21f467eae400ddab3a245fc7795415308b1393621ea5ec803a893caea5a6537e8ed12bf62dee9d983095fa563fde6c90a2bc957a5fa6f73\"}", + "raw_seal": "{\"id\":\"2e1ddb245d23a37ee5e304b03e627f23f14be1b6cc922c48f120bfbf24280d3b\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699998888,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"1b170de8ac3a88b80b143b7a6dcb486b3cb4a2d4e0513dfb9f3f10839c60c2904a1e5f6aa635d6750ea7af34e3774fee50280a0c2aa17150753cd70a97609aeb\"}", + "raw_rumor": "{\"id\":\"95d9f97a6935b7841f2bfba72b65959b9a0d7b2a046dddde87d7b0b7c5b437b9\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":45,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"45\\\",\\\"order_id\\\":null,\\\"parents\\\":[\\\"0303030303030303030303030303030303030303030303030303030303030303\\\",\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"0707070707070707070707070707070707070707070707070707070707070707\\\",\\\"0808080808080808080808080808080808080808080808080808080808080808\\\",\\\"0909090909090909090909090909090909090909090909090909090909090909\\\",\\\"0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a\\\",\\\"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b\\\",\\\"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"600\\\",\\\"in_reply_to\\\":\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}},{\\\"id\\\":\\\"0505050505050505050505050505050505050505050505050505050505050505\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}},{\\\"id\\\":\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}},{\\\"id\\\":\\\"0707070707070707070707070707070707070707070707070707070707070707\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}},{\\\"id\\\":\\\"0808080808080808080808080808080808080808080808080808080808080808\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}},{\\\"id\\\":\\\"0909090909090909090909090909090909090909090909090909090909090909\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}},{\\\"id\\\":\\\"0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}},{\\\"id\\\":\\\"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b\\\",\\\"terms\\\":{\\\"address\\\":\\\"\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}}],\\\"fulfillment_charge\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"25\\\"},\\\"lines\\\":[{\\\"amount\\\":\\\"3\\\",\\\"fulfillment_group\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"id\\\":\\\"0505050505050505050505050505050505050505050505050505050505050505\\\",\\\"maximum_line_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"439\\\"},\\\"option\\\":{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"Bag\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"200\\\"},\\\"tiers\\\":[{\\\"from\\\":\\\"2\\\",\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"}}],\\\"type\\\":\\\"fixed\\\"},\\\"supply\\\":{\\\"amount\\\":\\\"0\\\",\\\"type\\\":\\\"estimated\\\",\\\"window\\\":{\\\"end\\\":\\\"200\\\",\\\"start\\\":\\\"100\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}},\\\"unit\\\":{\\\"contents\\\":{\\\"quantity\\\":{\\\"amount\\\":\\\"500\\\",\\\"unit\\\":\\\"g\\\"},\\\"type\\\":\\\"estimated\\\"},\\\"label\\\":\\\"bag\\\",\\\"type\\\":\\\"package\\\"}},\\\"option_id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"},\\\"selected_tier_from\\\":\\\"2\\\",\\\"type\\\":\\\"fixed\\\"},\\\"product\\\":{\\\"description\\\":\\\"Public crop\\\",\\\"name\\\":\\\"Carrots \ud83e\udd55\\\",\\\"origin_summary\\\":\\\"Example area\\\",\\\"producer\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\"},\\\"source\\\":{\\\"coordinate\\\":{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"d\\\":\\\"01010101010101010101010101010101\\\",\\\"kind\\\":30402},\\\"event_id\\\":\\\"0303030303030303030303030303030303030303030303030303030303030303\\\"},\\\"source_lot_label\\\":\\\"Private lot A\\\"}],\\\"maximum_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"464\\\"},\\\"rounding\\\":\\\"half_even_net_line_v1\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"supply\\\":{\\\"type\\\":\\\"stock_backed\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"d53aa727486adbe5b980a7186d41b3bf30ca56dfac7175a92a3c955568057f71\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"thread_id\\\":\\\"1414141414141414141414141414141414141414141414141414141414141414\\\",\\\"type\\\":\\\"quote\\\",\\\"version\\\":1}\"}" + }, + { + "name": "exact_outer_limit", + "recipient_scalar": 2, + "raw_wrap": "{\"id\":\"aaf9b60b75ddbee92dffdc7fc6431b1f617088821e4669ab3d92318094613e27\",\"pubkey\":\"b48afcceaaae5d6e95a7cf1d7db0f3cbcb949e8ba2b79411aaf4c04054246f7c\",\"created_at\":1699997885,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"],[\"alt\",\"\"]],\"content\":\"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\",\"sig\":\"1b057e938cb62b84b0f368acf177d5d400967ec9193af17aa9f84b52d0a59f20ec36de497ef5995fcb160999ae702bb48e11818eb226ccd4b9b3d975fd339d5c\"}", + "raw_seal": "{\"id\":\"bd48febf59f822da51955b1b8bfc56e474d8eb61ea668c5ea0b941c7172df493\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699998886,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"b733d4ae4d2a214b51a280243f833c7afb3670aae322f7299aa41cf9257d9d9a992afa1f7d3d55c1c5e8c6480d6ece8d9243d6668a4c9a3ac575e460bfad25bf\"}", + "raw_rumor": "{\"id\":\"ae3cb40f95993f31f86911b28ce6d65fbac77172c5abe4696547ec55b66a1563\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":450,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"450\\\",\\\"order_id\\\":\\\"1515151515151515151515151515151515151515151515151515151515151515\\\",\\\"parents\\\":[\\\"0303030303030303030303030303030303030303030303030303030303030303\\\",\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"0707070707070707070707070707070707070707070707070707070707070707\\\",\\\"0808080808080808080808080808080808080808080808080808080808080808\\\",\\\"0909090909090909090909090909090909090909090909090909090909090909\\\",\\\"0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a\\\",\\\"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b\\\",\\\"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c\\\"],\\\"payload\\\":{\\\"reason\\\":\\\"Private reason \\\\u0000 \ud83e\udd6c \u00c5 A\u030a\\\",\\\"request\\\":\\\"0606060606060606060606060606060606060606060606060606060606060606\\\"},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"1948db6c028f0ad3122f21862146ddd0aa8ef7a5d5824b8f21dbb81b5a689dae\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"thread_id\\\":\\\"1414141414141414141414141414141414141414141414141414141414141414\\\",\\\"type\\\":\\\"decline\\\",\\\"version\\\":1}\"}" + }, + { + "name": "record_missing_field", + "recipient_scalar": 2, + "raw_wrap": "{\"id\":\"5de2aed0c3938680fd69a5955eee7bb67f87335ad7e59c771e501ef2902c8c9c\",\"pubkey\":\"270451056fcc937c9cbffe130f2aaeb08ffd227e0dbbc7cad0b4b01d19b49937\",\"created_at\":1699997896,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"]],\"content\":\"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\",\"sig\":\"50568ecaf83da3a7124bfb397d419223eb85c2a3bdf06888497076b07a22261251771076a0679b3dd94001058380dd923e7afc6bb3a8dc26a92bffe23c2fa617\"}", + "raw_seal": "{\"id\":\"4afb41cc6b73da48289de3f2c343839f65dc0850b8774400915a903f9a3137ba\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699998897,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"e4083b6de2e17789c28dd3a092f6db7cbdf58b6b6b81b92d308e79cf78afd7f3f0611302eaba45e5f3bc9e37e2a0dbb983e0ed3a126bf245e012b8e5eaafd5d8\"}", + "raw_rumor": "{\"id\":\"26563bc7da1e48e53201bb7edc8a5440e336a2b9135c224acbbae91299b7bcbd\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":450,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"created_at\\\":\\\"450\\\",\\\"order_id\\\":\\\"1515151515151515151515151515151515151515151515151515151515151515\\\",\\\"parents\\\":[\\\"0303030303030303030303030303030303030303030303030303030303030303\\\",\\\"0606060606060606060606060606060606060606060606060606060606060606\\\",\\\"0707070707070707070707070707070707070707070707070707070707070707\\\",\\\"0808080808080808080808080808080808080808080808080808080808080808\\\",\\\"0909090909090909090909090909090909090909090909090909090909090909\\\",\\\"0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a\\\",\\\"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b\\\",\\\"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c\\\"],\\\"payload\\\":{\\\"reason\\\":\\\"Private reason \\\\u0000 \ud83e\udd6c \u00c5 A\u030a\\\",\\\"request\\\":\\\"0606060606060606060606060606060606060606060606060606060606060606\\\"},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"1948db6c028f0ad3122f21862146ddd0aa8ef7a5d5824b8f21dbb81b5a689dae\\\",\\\"seller\\\":\\\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\\\",\\\"thread_id\\\":\\\"1414141414141414141414141414141414141414141414141414141414141414\\\",\\\"type\\\":\\\"decline\\\",\\\"version\\\":1}\"}" + }, + { + "name": "future_profile", + "recipient_scalar": 2, + "raw_wrap": "{\"id\":\"6aaad6a40ce961f3f5e09c7c7c87837dd71b5708f440e59a9f14cab8f4f7a6b6\",\"pubkey\":\"04e8df18f90f67e9fed8c6d5b66cfbe6ff0a86bbdb99021448ab57c5c5a7021f\",\"created_at\":1699997892,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"]],\"content\":\"AsuP+qf3O8mA9ONg1crCwz9aSBdOWZdRIH9+s7ssg0TwCStnXWNd58cnOUWw9RmyatfTquS1paw3CB21yCz/laEbhVBSddrSCxFTKTqiJdzMYS5w0ERCmm2VJTvS9cDzdYzWkukNHVMXwpNTGp2kf9GSler3JGEwpzyqzZmCmSHlxQIabJZdji/NSxb2LpcZU0fdYH5U/ZgyDLQM9T2X8jfHje6FnR6os0Dyq9RlA2A+GSBrXLD6OBny59diFq7OnAiJEsjC2pB6imHhkea7cKDPLt6W0UQ2zBgQR+b5nxKc5PS1b2Ge+kcGin95CFNOvMTvIOa5p/lkVhLtU8obx87CGjsKD5e0Fn6RgTYvKsbXeP0q6Mnd2/KysmxcjMJBkUFEyhrdnzjsBauvPx2+F42m96TfpBFkMzt8C5GSQPsDTd3G5ReMJ5GFEEMlrNVCOWacklotSHjzikQ//Al7Z3oe94cmcQbZCSPmY8HxItEtjWGbS2eWEsipQSqmBfyN2ydP2JCT3Q6/AYM4uHZYVbeHvHKiPij2Qdpme3ucifEahJLTn+hezszQ8hwb/mDqlg2TQqDaYbCzhcSjXqZ91t0ounjyM7IK19sLvA5l1nkVa5ZmKHZleTn4QG+eXObwTWmQQuQmeKz7o2gUkMHi23mmSJQ94q56Xa6f03Jd4RFL1H5GPY9Ot0Ytu+D2TsJ06V9d3KtwvQvRYFQfQKH6d0VOYC6gsTm6qyScRf0aE09fPz0Zuu+H1JfhIbtuL2FiKgRhiTpubR8/D25dgMFdMJRpxL/Nhp4yadsA/wfrBpEXJozzt7UlDsHsG7KnQRK1ZvvPFYP4OqelbUKgvxbLt/BY1/Ox2YHmrFkMVdCLto2Sf2/9BMEvalszj4R0yAQgFSdyyKa1Z7vag+yl8wkxdWJCq4/RBaybmC8giNkALXyMUFGgdWVOFQzoMNFxJJSyC/5bN8BXm7LlovM7Am3l7fhhHeBp7Lop3Bzbn61YGMYfL6hej89wiUXU7UV0r3es92VVkKuiNt0y+wAZVKzQYjVD9Ud56H30DfkAJ0hGrUbtdoZYid0UHbnlj3qVwtwW0TmJUKXs7mUbFCntf0vZqpUe5HDr8xLk/3cgsZEUFKqYucIURxBDqnK/erPSekcPcRdIbc31pIZ79dhFdYuqxn4CtWEETlDSPiIi79siGjEYXhVmDoNF9cbbuaAy6rsHAMq8XlgMkkIze9P6oc+4xcvNRa9pylahtoMvOSa9guZtAABSDMXKs8AG8Y8SE+MdVKPU9VXu6MQ59A/KmwNyZutYNKsBVfgc7wbNjEt1j4UiQaw8XcXZQyqGztIcIMfJK6yH35sDGEg1A3dn+S+4nWerBhBcBQSVomoWgoy0f/OfPYpJUzqBlKpN2xWMEhV6osiyUdYa8WYJMJX8+FNPKVVGsLnaB8KPCXYmoFvcLEKDrng=\",\"sig\":\"84306dea2b054b755b139a4974a90f0319575a04e1e6def39929c622ea456dcb3d9be98767d54829aa75f24694bd7f1bee83e66d9b1cc43f90853af19bad8b71\"}", + "raw_seal": "{\"id\":\"6e6507dafc618492f9fb25821441bd6da14be22b896db1de3074aa98e4eee082\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699998893,\"kind\":13,\"tags\":[],\"content\":\"AmMKl27mljOWOqcl537AKpHd0caArZDjlGJ2TIvViaQmdZuIK5dLguIWuisQD9No8vhIiR4FOMH56AYdj32xi/V9k4wrLW1YGKgth2Y0ttd7VQAuNScs/Z1UdKleME3eQWnR1QSrUpT15FVZOVJnarMqP4poJvOxsUK4B/hYVvmptMEmC7lFyqVgECSL9sQxWLgd+h4BLbCZpFFqwLOZ4rP6pccSabA1H3k8gSsfFtsYI33qyRUVsFJ1cdqBs/dAPdwtq4GRzVAev4SAi0CaOm7b2ALuJYWKZZRkinlwOnwZxJEfgEtwEhyV1YPRxfoljBWdaEs0Xh5Q1a7FyO/sz966MalMtFf6vRpicmKDY9+CmHIG8yEb/mXNKbSuzigiTfKXS8xwP+2p38db82q/I6fyPhxY6PxVx+d7ACIzUM64aEWLHWyeA5EfbXPWSjGgCVDSoGqXkam7iLgwNIuSt/gt/8mJVWUMhWSEWPjQZ7JOwf1opJCIZgPn+scuSej0Bc+0xb/zvrVKSqrli4ReD+yXo6c/TFAvfM01UkMLyZn+DrUaOpmi92nObLsib1kHv8R5RQQXzWMQvLXgOXEI8cXLrQ==\",\"sig\":\"909b78e913ecc263dfbf5972d9128ca28616906a9c2ae9f701deb765d82af7aea2189a355970f8cac33abc4c8c5293dceaf1a1a0e34f88be2c48277686a9df7c\"}", + "raw_rumor": "{\"id\":\"a715177281e1d55584a26753088f06473c0064dffea0cbe8cff401adc3356915\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":450,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"profile\\\":\\\"future.commerce\\\",\\\"version\\\":1,\\\"type\\\":\\\"future_record\\\",\\\"private_future\\\":{\\\"value\\\":\\\"Synthetic unknown data\\\"}}\"}" + }, + { + "name": "future_version", + "recipient_scalar": 2, + "raw_wrap": "{\"id\":\"e2cfc78a4937528a1637d78a64e1fd593e5f3ab29ab2c81147f79520ff0d757f\",\"pubkey\":\"c326c98efb05405d87f1e604c4e9fae24a3b1175251e5836c13d4c5d16f78670\",\"created_at\":1699997891,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"]],\"content\":\"ArUeR9KpqusQ5T7IYtFGssceuXMKro3XxnZEcbNJmyJjxW46B5/J/Hin3dTH7JDn9knDDGesu8U/oAUxY2uwaNVbEs6Tzbv0HuRyLgM0FBNb+wZn37kh3/lvmHa6SxR7lNl2jp75IuTDJXDwOYuY+YVg64X0ALjXzYZjHHNcS4P9gWpSqmhexCt4pZuK1E+CsPDbMDzjiG2H+Bk3gsrDD97J4pDNWJq57VgmpccazrGQDa++bKUaJvhGX7SdMiQ0Q8fBBETTxu3DFqIsY9lw5lPc0tGcFJ+rG83MYlZeua4P5t6vAcbJ2SqRcrvK/akpDXguoxDy4kQac9ZLNFNqz1OR9H/cjXP5GlGVjzIJOuJ8sNm11ib7uCqv7DhktNmWpCkAGK8LgtI8kU7BUV0jZb8DGJqTRgYLLWwE51abGGqgBIebm/yvmOEOI/GxYEPJJtFNGiJ19nl0NGc5ylmrUtM7jdk7oPw9XZOUx9epsnrF+Uuiz1Ej7HeAuiKqTde9B51OqR2Vk2jryQDxv4X+VnxEASm4VhKpsz41uHRtUducchJiPsyMzH8S/zAaCvrjhcZ9xxFBznkeixIcYW7H5U9hCpnU9L+X7paDfWpkCpaLOORFKoPIGKi00LrOqS9J9e+REWlmPy2wnGqFs1Rg8Mquj4O2UEGzc/COIrqirOnodJPMrKtvaFycc5/VobLs2S1EAnB17Xyy/ZA83GD/7q1PN1sUYED59YPeWDnkn4yECc6Q/jKm0qesXpuW9ItE+whZO16PUvi+3t3ldorxcL74my99D62X7Vf9MAbSVbLixY6A0MP+aGoDQvct+1lc7ImC7eiuq1d9/yFQlVGo4PDwjZtphjIyBao1hV1W4Z8cwWTOkOsIOW0Mj28ewZR2UgxddKJew6JY79XzcuWFkk5ard+EI/Bg1MAY9pqWpqKq5vp+OVCEmhr2YlHZbHOeEIucvMmK7atekT4xcKvG1rJ0hizMQaIKOCkFndSR2Gxv9/7s6f7qi5rmFfLm7EeOisiBrmzxPwbpYKlC1wt7ZrkDuakcEolGKko01L7fm5PecK1r334hQYSpoUKix4oR3tB8jvFyz6HyrhwRGTzfTr9F9GBnfgdLZfOueRL0Vt2gkrLEuGinflUXXLncK7T2+CC5FHqRjcVoSkQ9SHGLlBx8Ff+S40f6qvghKKMC+h+Df7rygrHpfdQ8/B8HcHkbKKWBUWknBuWbpzFSuhLpTD/R/UIRsquCyvk2/HgnVOL1II51+ngTg0DfCapObu0oTkbnNw9XL8pJU4VBKV/xtpKfjpfxnGXAso5n76cctZwf4mmYsyzETOLwvTPCoSwBNK3AN9dDGsJB0dO2MoOd4ote2uWqDLuH5QkhAek4Rz/YHtOMVb0A4n+oljJWvETX4djAz0XE4E1FYYH/n3drYa5CkAcZzgZc6aIXA8chMOE7VCQ=\",\"sig\":\"ede6d36d16db693a41c25020dc840ae8b71bf1ff183c108a2332f781c6ef292c5d7113fe9f3a6fa5316348802617236e50f92b5fc75f35e0fad8f0de80cdc059\"}", + "raw_seal": "{\"id\":\"78701481ceffe9aa6c933a1c288e397ad931cd24ea901903cf6c1bb1c107df1a\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699998892,\"kind\":13,\"tags\":[],\"content\":\"Avq/rD7eeYx5l46ZJ93S0hd3yXB0M7N1sxB4121H0bc323HQbVma6ldwc9s1baaDPWbBhhZx1EBDeLYImFi9rASoW5PwuOop0Ft4KnR7dVO1yZhv1JT2vpYoXGLRfvv/sCY2H6Z40Ui7AIxQqS1/wnP02guG7kq0fyO9Ux7q/7WWfxeToFlxF7dYtXmeYsAeudMLep23zLlA2DDGTBZM1q9V071GoTxcKRWHNK3gImypRCd46QaSWVz+3PGxQP5VcbrPsYaag14S7xNLPNmb4YdVnZqNB8fZi8czZxVw9xn4Iddtbc6pb8Q6dJL3dtW08/7E03WBwGvVJBiHI2d0XfLfGYICtxhSwHMwOatticpTlheaLUkXJUehnpx2jJsUlfEs4oUHF0U+hHIXzloqbt7CClq7ohLBRvv+8M6GQTSCCFdgKlhrwxficzuYBJsXNv6a3koduokXXBfA37dBi7dPQCX8nWBe89Z8Z6izxZslbGJL75XumaqrQhpWdNjP/82NFnxeFH8MjHAkW6Eu5D2g/2MjzSxjpZm+cRtyrHoejybV3cvDWHXrN1tmM1GBztMEsKW+jJMmnsscPVGUXceByg==\",\"sig\":\"e57134cdb88ea2a96df8b159e061345fd16ec39c461c91854d9a580390d5a7c63a67d4186a94dd93bbd9433d11dab054977d6d08b23f2b3057d66d901c5c3d8a\"}", + "raw_rumor": "{\"id\":\"cf8bdcfbb3e48fdc6d32288f07cf1a2d379984b0bdeceba10ef888e405ffafe2\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":450,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"profile\\\":\\\"radroots.commerce\\\",\\\"version\\\":2,\\\"type\\\":\\\"future_record\\\",\\\"private_future\\\":{\\\"value\\\":\\\"Synthetic unknown data\\\"}}\"}" + }, + { + "name": "other_rumor_kind", + "recipient_scalar": 2, + "raw_wrap": "{\"id\":\"ff2db0c5ef2dea2feebf698991f8bc220de97e92a54b6e73605bb426c3960658\",\"pubkey\":\"754b1a74a5680dc5ef51d97650803e6e310c4791695c28dc7afa4158ce2e7a00\",\"created_at\":1699997889,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"]],\"content\":\"AhsAi/RYH1sk1irBOflBt7n3WtUWWxAI6ZIwiA8wXUqCGfgIMxRDaxmOWZlPfjtQtKLhM8zNy0eukV8OlL4WsrshxIuZwstI7v5nWreuOvUHrX3ftytMSUSY8WHP5+dUAhhUqWbk99i9s5Nb/WgTFSpcANvtagbjak0s+qeya/PpHsNWkg+51K3mK4ahu870xrIHJjsCAas/Jw2lEp6BbnG9LrNe7I+3kocRdCM1ZTH/P/Tsv1gAF6oS2CT1LrZri7V/v6Ea3sC7O5XSu2ovoX+SVADXgc/82T/QRtGlzdVXBkaXL8z5mXmnva+ajplA8VSq+6K1SIJ5xN8DWgQjSLasmM89gHG6zUnFHQMS7+kLci0fg4BH9EedRmXf8+o2KmVpisdq7rmIhRdRAKM44tkUHQZHcft219XQdxEO2/YY6puA7EzH9J9xS00zHAMSvoz86/5rR8kLCSkjkRCDEXhKg1J18Mo55ofNzmqViAoitdSMVGTBTIgTuvESQNiNWTFmujSVW7NNvFfOttDjh3r5Kdtq9ArExev2I86ilNl5VohU+OnTEfI1zIMp3WSyJTcEsWhu1+VQuh+ZFb6GvBSfXxQ0zJ/dGdX68Scp2oh2NJ6kuRBeBIow8SQFi769HfxvUuG8DkgREV9iDeTzoSubJ67AXawpjgsEzs4O0naiRxs0ynLqb01d9BJWBw+iLiy2yS+5Vpg/CFKtjb4Cej+2brGUKNE8pSGDKID0LFz793yJUKxa1raBY1Vv6vkFNX4ThHjSb1954igwOIgDojjZvm7y80qnTjh5HGojpw1fiKkJ/ck20n6z0WEjegWLPuj5RfrOHRBSTPruWH8t+cZHe+4xGZm/QC98rpVtpE2XoQJWfkFgdCzX5YL2i6Oe5s15w/InINdENcpruVOGevDnkD6araWVzErL8cxBcE8bl41EkMcpmpIlzMrsz7N5qTRSxpBSuh7WbAhRgxMMqMgxHqQwTfJo1XQ5K8Q+LsFFMDeBuxhPi3/UFCxhG5XcXBTzGqDpvFx4PKSjF5hL3W72+yWwT27NKLIYhFqX2kxLlogsJpi/oxxhPEcPPcvGoYliyC7KD0kfINx0sQrdL42uKMbDFrd2t+o06MIG7jq3SxK5S/AQAQ7p+jSPV2uQWtmXJ3Z0tAskPsPpTZ41p9mwwuwX1ei/OpsImcVAEUTMoEMJWSa+s93CstXJsB7cxvJvPXZ8r2xrj+qfGwHDqRFcUH3NnagXkdxMLEQkCa1TZ7DnPASNQpY2jsUY3BxVwQcW\",\"sig\":\"23d433692e9afaf088ebffe114ef60f198e0bd8d4c7ce4dc486c27fefb018edd5aa803d89e19c00c6b6d16d17eea09a2636041f719ef2fea3f237fd65ceefdca\"}", + "raw_seal": "{\"id\":\"d6155482fd3024df8491869c467eebdabe38d12a38a54537d522b63c6ce9f6df\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":1699998890,\"kind\":13,\"tags\":[],\"content\":\"AgdDBbtc9IVuM20R0DVQmDxYZUA+JgqZ7N00SoGxkLKDO/fsD0GPP2fulsWM1TxO03lV0EkBhP61AQgQcoSwKN4AKKiwSsVMD9hWwI64+/S2FIQZXflhxrsBNllZKvoKTNZCtsJsMTV687qPpd8QbRHSgPDqYEG6Xpn653kyQvV3dU0IR30RUcHbiVIpbzUG5uaxkVluIHePoJM5fdyWt+RwrHmqvn+nhOqTcdqpROUUEkOFMQfCsmhycAr/1BYn0EBSw2B1rHrwvKhlWKt2Tpi5RoH3eFpXB2oW1IrfX+3MHjFtz549ovWw4HOWiPZepF28HXYQ5LRwXCq+lN54jgeqNWkrkkI0s6L3cs318DXK2ed3tLFayIG+djKkNCWfvKKIDWrpcvuxNVS7r8R0HjlzD84OAIaooTW9Foc+Kek4R5U=\",\"sig\":\"613466b175a57876b5e95783f975c16d58823a4f90666cceb172ee64b12200eee629589c5841855204cc84b45cb8c791f51a56777103076cdf54818483aebb64\"}", + "raw_rumor": "{\"id\":\"bd5da280555d02975572c74b369585519c66738379b8b221deb38da6b9b51115\",\"pubkey\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"created_at\":450,\"kind\":14,\"tags\":[],\"content\":\"Synthetic standard chat text\"}" + } +] diff --git a/crates/storage_sqlite/tests/fixtures/stock_sources.v1.provenance.json b/crates/storage_sqlite/tests/fixtures/stock_sources.v1.provenance.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "source_path": "crates/nostr/tests/fixtures/commerce_envelopes.v1.json", + "source_sha256": "bd59710bedc337b5e4bdcb1c0753de06a74927027b76a0202b251b0e45d02565", + "license": "MIT OR Apache-2.0", + "selection": [ + "exact_outer_limit", + "exact_rumor_limit", + "future_profile", + "future_version", + "other_rumor_kind", + "quote/peer", + "quote/self", + "record_missing_field", + "request/peer" + ], + "transformation": "Exact selected name, recipient scalar and original outer/seal/rumor bytes; no cryptographic or record bytes modified. Original independent nested-envelope vectors remain the source." +} diff --git a/crates/storage_sqlite/tests/package_boundary.rs b/crates/storage_sqlite/tests/package_boundary.rs @@ -29,6 +29,8 @@ fn sqlite_storage_declares_the_final_backend_boundaries() { "radroots_domain", "radroots_event", "radroots_event_codec", + "radroots_nostr", + "radroots_protocol", "radroots_secrets", "radroots_storage", "radroots_transport", diff --git a/crates/storage_sqlite/tests/support/pool_creation.rs b/crates/storage_sqlite/tests/support/pool_creation.rs @@ -1117,3 +1117,6 @@ mod grants; #[path = "option_mapping.rs"] mod mapping; + +#[path = "stock_source.rs"] +mod source; diff --git a/crates/storage_sqlite/tests/support/source_provider.rs b/crates/storage_sqlite/tests/support/source_provider.rs @@ -0,0 +1,122 @@ +use super::*; +use radroots_secrets::{ + Error, + provider::{SecretCapabilities, SecretProvider}, + wrapping::{KeyWrapping, UnwrapRequest, WrapRequest, WrappedSecret}, +}; +use radroots_transport::source::BoxFuture; + +/// Pause after real provider IO, before the worker can confirm the observed +/// rows. The other connection must remain able to write at this boundary. +struct PausedProvider { + inner: Arc<FileProvider>, + gate: PausedClock, + schema: std::sync::Mutex<Option<&'static str>>, +} +impl PausedProvider { + fn arm(&self, schema: &'static str) { + *self.schema.lock().unwrap() = Some(schema); + self.gate.arm(); + } + fn pause(&self, schema: &str) { + let selected = { + let mut armed = self.schema.lock().unwrap(); + if *armed == Some(schema) { + armed.take().is_some() + } else { + false + } + }; + if selected { + self.gate.now().unwrap(); + } + } +} +impl SecretProvider for PausedProvider { + fn backend_kind(&self) -> BackendKind { + self.inner.backend_kind() + } + fn capabilities(&self) -> SecretCapabilities { + self.inner.capabilities() + } +} +impl KeyWrapping for PausedProvider { + fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> { + self.inner.wrap(request) + } + fn unwrap<'a>( + &'a self, + request: UnwrapRequest<'a>, + ) -> BoxFuture<'a, Result<SecretMaterial, Error>> { + Box::pin(async move { + let result = self.inner.unwrap(request).await; + self.pause(request.context().payload_schema().as_str()); + result + }) + } +} + +#[tokio::test] +async fn source_reads_recheck_original_rows_changed_during_actual_provider_io() { + for statement in [ + "UPDATE stock_source_parts SET protected=randomblob(length(protected)) WHERE role=0 AND part=0", + "UPDATE stock_source_records SET protected=randomblob(length(protected))", + "UPDATE stock_source_evidence SET transaction_id=zeroblob(32)", + ] { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let receipt = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + store.close().await.unwrap(); + let provider = Arc::new(PausedProvider { + inner: f.provider.clone(), + gate: PausedClock { + state: std::sync::Mutex::new((false, false, false)), + changed: std::sync::Condvar::new(), + }, + schema: std::sync::Mutex::new(None), + }); + let crypto = WorkspaceCrypto::new( + provider.clone(), + SecretRef::new( + f.reference.id().clone(), + f.reference.backend(), + f.reference.key_version(), + ), + SecretMaterial::from_slice(&[0x41; 32]).unwrap(), + AccessPolicy::standard(), + ) + .unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), crypto, f.clock.clone()) + .await + .unwrap(); + let mut conn = database(&f).await; + provider.arm("radroots.seller_stock.source_record.v1"); + let mut future = Box::pin(store.stock_source( + binding, + receipt.checkpoint(), + original.envelope_id(), + e.proof(), + )); + assert!(futures::poll!(future.as_mut()).is_pending()); + provider.gate.entered(); + // This actual write succeeds while the selected worker is awaiting + // provider IO; no SQLite transaction may span that IO. + sqlx::raw_sql(statement).execute(&mut conn).await.unwrap(); + provider.gate.release(); + assert!(matches!( + future.await, + Err(OperationError::RecoveryRequired) + )); + conn.close().await.unwrap(); + store.close().await.unwrap(); + } +} diff --git a/crates/storage_sqlite/tests/support/stock_authority.rs b/crates/storage_sqlite/tests/support/stock_authority.rs @@ -602,7 +602,7 @@ async fn changed_catalog_after_protected_reads_is_refused_before_authenticated_c clock.release(); assert_eq!(operation.await, Err(WorkspaceError::RecoveryRequired)); store.close().await.unwrap(); - sqlx::query("PRAGMA user_version=5") + sqlx::query("PRAGMA user_version=6") .execute(&mut connection) .await .unwrap(); diff --git a/crates/storage_sqlite/tests/support/stock_source.rs b/crates/storage_sqlite/tests/support/stock_source.rs @@ -0,0 +1,758 @@ +use super::*; +use radroots_nostr::{commerce, key::SecretKey, signing::LocalSigner}; +use radroots_signing::{provider::ProviderCall, request::CancellationSignal}; +use radroots_storage::workspace::seller_stock::{ + SellerAuthoritySelection, StockSourceCheckpointRef, +}; +use radroots_storage_sqlite::workspace::{ + StockGrantEnrollment, StockGrantOutcome, StockSourceCapture, StockSourceOutcome, + StockSourceProfile, StockSourceReceipt, +}; +use serde::Deserialize; +use std::num::NonZeroU64; + +#[path = "source_provider.rs"] +mod provider; + +#[derive(Clone, Deserialize)] +struct Vector { + name: String, + recipient_scalar: u64, + raw_wrap: String, + raw_seal: String, + raw_rumor: String, +} +fn vectors() -> Vec<Vector> { + serde_json::from_str(include_str!("../fixtures/stock_sources.v1.json")).unwrap() +} +fn source_vector(name: &str) -> Vector { + vectors().into_iter().find(|row| row.name == name).unwrap() +} +fn signer(row: &Vector) -> LocalSigner { + LocalSigner::with_clock( + SecretKey::parse(&format!("{:064x}", row.recipient_scalar)).unwrap(), + || Ok(1000), + ) + .unwrap() +} +async fn capture(e: &StockEnrollment, row: &Vector) -> StockSourceCapture { + let signer = signer(row); + let call = ProviderCall::new( + signer.public_key(), + NonZeroU64::new(2000).unwrap(), + CancellationSignal::new(), + ); + let opened = commerce::open(&signer, call, &row.raw_wrap).await.unwrap(); + StockSourceCapture::prepare( + SellerAuthoritySelection::from_attachment(e.input()), + &opened, + ) + .unwrap() +} +async fn create_source( + f: &Fixture, + row: &Vector, + clock: Arc<dyn WorkspaceClock>, +) -> ( + NativeWorkspace, + StockEnrollment, + radroots_storage::workspace::WorkspaceBinding, +) { + let e = StockEnrollment::prepare( + SellerStockConfig::new( + signer(row).public_key(), + key(), + "source-owner", + UnixSeconds::new(200).unwrap(), + ) + .unwrap(), + clock.as_ref(), + ) + .unwrap(); + let store = NativeWorkspace::initialize_seller_stock(&f.path, &e, f.crypto(), clock) + .await + .unwrap(); + let binding = store + .authenticate(e.input().clone(), e.proof()) + .await + .unwrap(); + (store, e, binding) +} +async fn source_minimum(store: &NativeWorkspace, e: &StockEnrollment) -> StockSourceCheckpointRef { + store + .stock_authority(e.input().clone(), e.proof()) + .await + .unwrap() + .source_checkpoint() + .unwrap() +} +fn retained(outcome: StockSourceOutcome) -> StockSourceReceipt { + match outcome { + StockSourceOutcome::Committed(receipt) => receipt, + StockSourceOutcome::Unknown { .. } => panic!("expected a confirmed source transaction"), + } +} + +#[tokio::test] +async fn authenticated_original_profiles_replay_and_reopen_without_changing_inventory() { + for row in vectors() { + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let before = store + .stock_authority(e.input().clone(), e.proof()) + .await + .unwrap(); + let min = before.source_checkpoint().unwrap(); + let original = capture(&e, &row).await; + let expected = match row.name.as_str() { + "future_profile" | "future_version" | "other_rumor_kind" => { + StockSourceProfile::Unsupported + } + "record_missing_field" => StockSourceProfile::Rejected, + _ => StockSourceProfile::Known, + }; + assert_eq!(original.profile(), expected); + let receipt = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + assert_eq!(receipt.transaction_id(), original.transaction_id()); + assert_eq!(receipt.envelope_id(), original.envelope_id()); + assert_eq!(receipt.record_id(), original.record_id()); + assert_eq!(receipt.checkpoint().revision().get(), 1); + let replay = capture(&e, &row).await; + assert_ne!(replay.transaction_id(), original.transaction_id()); + assert_eq!( + retained( + store + .retain_stock_source(binding.clone(), receipt.checkpoint(), &replay, e.proof()) + .await + .unwrap() + ), + receipt + ); + let after = store + .stock_authority(e.input().clone(), e.proof()) + .await + .unwrap(); + assert_eq!(before.inventory_checkpoint(), after.inventory_checkpoint()); + store.close().await.unwrap(); + let store = NativeWorkspace::open_seller_stock( + &f.path, + e.input().clone(), + f.crypto(), + f.clock.clone(), + ) + .await + .unwrap(); + let value = store + .stock_source( + binding, + receipt.checkpoint(), + original.envelope_id(), + e.proof(), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(value.receipt(), &receipt); + assert_eq!(value.protected_outer(), row.raw_wrap.as_bytes()); + assert_eq!(value.protected_seal(), row.raw_seal.as_bytes()); + assert_eq!(value.protected_rumor(), row.raw_rumor.as_bytes()); + assert_eq!( + value.protected_canonical_record().is_some(), + expected == StockSourceProfile::Known + ); + assert_eq!(format!("{value:?}"), "StockSourceSnapshot(<redacted>)"); + let mut conn = database(&f).await; + let protected: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_source_evidence") + .fetch_one(&mut conn) + .await + .unwrap(); + assert!(!String::from_utf8_lossy(&protected).contains("source-owner")); + let max: i64 = sqlx::query_scalar("SELECT max(length(protected)) FROM stock_source_parts") + .fetch_one(&mut conn) + .await + .unwrap(); + assert!(max <= 262144); + conn.close().await.unwrap(); + store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn every_source_write_window_rolls_back_canonical_parts_header_and_progress() { + for trigger in [ + "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_records BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", + "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_evidence BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", + "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_parts WHEN NEW.role=0 AND NEW.part=0 BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", + "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_parts WHEN NEW.role=2 BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", + "CREATE TRIGGER source_fault BEFORE UPDATE ON stock_authority BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", + ] { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let mut conn = database(&f).await; + sqlx::raw_sql(trigger).execute(&mut conn).await.unwrap(); + assert_eq!( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await, + Err(OperationError::StorageFailure) + ); + assert_eq!(source_minimum(&store, &e).await, min); + for (table, statement) in [ + ("records", "SELECT count(*) FROM stock_source_records"), + ("evidence", "SELECT count(*) FROM stock_source_evidence"), + ("parts", "SELECT count(*) FROM stock_source_parts"), + ] { + let count: i64 = sqlx::query_scalar(statement) + .fetch_one(&mut conn) + .await + .unwrap(); + assert_eq!(count, 0, "{table}"); + } + sqlx::raw_sql("DROP TRIGGER source_fault") + .execute(&mut conn) + .await + .unwrap(); + assert!( + store + .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) + .await + .unwrap() + .is_none() + ); + let receipt = retained( + store + .retain_stock_source(binding, min, &original, e.proof()) + .await + .unwrap(), + ); + assert_eq!(receipt.transaction_id(), original.transaction_id()); + conn.close().await.unwrap(); + store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn failed_source_commit_is_unknown_fences_access_and_recovers_original_anchor() { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let mut conn = database(&f).await; + sqlx::raw_sql("CREATE TABLE source_commit_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER source_commit_fault_trigger AFTER INSERT ON stock_source_evidence BEGIN INSERT INTO source_commit_fault VALUES(2); END").execute(&mut conn).await.unwrap(); + assert_eq!( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + StockSourceOutcome::Unknown { + transaction: original.transaction_id(), + envelope: original.envelope_id() + } + ); + assert!(matches!( + store + .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) + .await, + Err(OperationError::RecoveryRequired) + )); + store.close().await.unwrap(); + sqlx::raw_sql("DROP TRIGGER source_commit_fault_trigger; DROP TABLE source_commit_fault") + .execute(&mut conn) + .await + .unwrap(); + conn.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert!( + store + .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) + .await + .unwrap() + .is_none() + ); + let receipt = retained( + store + .retain_stock_source(binding, min, &original, e.proof()) + .await + .unwrap(), + ); + assert_eq!(receipt.transaction_id(), original.transaction_id()); + store.close().await.unwrap(); +} + +#[tokio::test] +async fn current_proof_time_and_administration_gate_source_reads_and_original_replay() { + use radroots_storage::workspace::seller_stock::StockGrantScope; + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let receipt = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + let wrong = AttachmentProof::from_protected_input(&[0xb7; 32]).unwrap(); + assert!(matches!( + store + .stock_source(binding.clone(), min, original.envelope_id(), &wrong) + .await, + Err(OperationError::Workspace(WorkspaceError::Unauthorized)) + )); + for time in [0, 99, 200] { + f.clock.0.store(time, Ordering::SeqCst); + assert!( + store + .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) + .await + .is_err() + ); + assert!( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .is_err() + ); + } + f.clock.0.store(100, Ordering::SeqCst); + let child = StockGrantEnrollment::prepare( + &SellerAuthoritySelection::from_attachment(e.input()), + "physical-only".into(), + UnixSeconds::new(200).unwrap(), + StockGrantScope::full_inventory(), + ) + .unwrap(); + let inventory = store + .stock_authority(e.input().clone(), e.proof()) + .await + .unwrap() + .inventory_checkpoint() + .unwrap(); + let authorization = match store + .enroll_stock_grant(binding.clone(), inventory, e.proof(), &child) + .await + .unwrap() + { + StockGrantOutcome::Committed(receipt) => receipt.authorization(), + _ => panic!("grant must confirm"), + }; + let physical = store + .authenticate(child.input().clone(), child.proof()) + .await + .unwrap(); + let current_min = receipt.checkpoint().with_authorization(authorization); + assert!(matches!( + store + .stock_source( + physical.clone(), + current_min, + original.envelope_id(), + child.proof() + ) + .await, + Err(OperationError::Unauthorized) + )); + assert!(matches!( + store + .retain_stock_source(physical, current_min, &original, child.proof()) + .await, + Err(OperationError::Unauthorized) + )); + assert!(matches!( + store + .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + assert_eq!( + retained( + store + .retain_stock_source(binding, current_min, &original, e.proof()) + .await + .unwrap() + ), + receipt + ); + store.close().await.unwrap(); +} + +#[tokio::test] +async fn source_transaction_rechecks_clock_and_expiry_after_protection_io() { + for next in [0, 99, 200] { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let clock = Arc::new(AdmissionClock { + armed: std::sync::atomic::AtomicBool::new(false), + calls: AtomicU64::new(0), + next, + }); + let (store, e, binding) = create_source(&f, &row, clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + clock.armed.store(true, Ordering::SeqCst); + let result = store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await; + if next == 200 { + assert_eq!( + result, + Err(OperationError::Workspace(WorkspaceError::GrantExpired)) + ); + } else { + assert_eq!( + result, + Err(OperationError::Workspace(WorkspaceError::Unavailable)) + ); + } + clock.armed.store(false, Ordering::SeqCst); + assert_eq!(source_minimum(&store, &e).await, min); + assert!( + store + .stock_source(binding, min, original.envelope_id(), e.proof()) + .await + .unwrap() + .is_none() + ); + store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn admitted_source_retention_survives_observer_loss_and_close_drains_original_identity() { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let clock = Arc::new(PausedClock { + state: std::sync::Mutex::new((false, false, false)), + changed: std::sync::Condvar::new(), + }); + let (store, e, binding) = create_source(&f, &row, clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + clock.arm(); + let mut future = + Box::pin(store.retain_stock_source(binding.clone(), min, &original, e.proof())); + assert!(futures::poll!(future.as_mut()).is_pending()); + clock.entered(); + drop(future); + let mut closing = Box::pin(store.close()); + assert!(futures::poll!(closing.as_mut()).is_pending()); + drop(closing); + assert!(matches!( + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await, + Err(WorkspaceError::WriterActive) + )); + clock.release(); + store.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + let snapshot = store + .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) + .await + .unwrap() + .unwrap(); + assert_eq!( + snapshot.receipt().transaction_id(), + original.transaction_id() + ); + assert_eq!( + &retained( + store + .retain_stock_source(binding, min, &original, e.proof()) + .await + .unwrap() + ), + snapshot.receipt() + ); + store.close().await.unwrap(); +} + +#[tokio::test] +async fn missing_or_substituted_original_source_parts_and_canonical_records_are_never_repaired() { + for statement in [ + "UPDATE stock_source_parts SET protected=randomblob(length(protected)) WHERE role=0 AND part=0", + "UPDATE stock_source_records SET protected=randomblob(length(protected))", + "UPDATE stock_source_evidence SET transaction_id=zeroblob(32)", + "DELETE FROM stock_source_parts WHERE role=2", + ] { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let receipt = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + let mut conn = database(&f).await; + sqlx::raw_sql(statement).execute(&mut conn).await.unwrap(); + assert!( + store + .stock_source( + binding.clone(), + receipt.checkpoint(), + original.envelope_id(), + e.proof() + ) + .await + .is_err() + ); + assert!( + store + .retain_stock_source(binding, receipt.checkpoint(), &original, e.proof()) + .await + .is_err() + ); + conn.close().await.unwrap(); + store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn retained_source_checkpoint_refuses_full_database_restore_and_foreign_or_forked_minima() { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + store.close().await.unwrap(); + let path = f.path.join("stock_execution_v1.sqlite"); + let original_db = std::fs::read(&path).unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + let original = capture(&e, &row).await; + let receipt = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + let fork = StockSourceCheckpointRef::from_host_metadata( + min.authority(), + receipt.checkpoint().revision(), + Some(radroots_domain::CheckpointDigest::from_bytes([0xc9; 32])), + ) + .unwrap() + .with_optional_authorization(min.authorization()); + assert!(matches!( + store + .stock_source(binding.clone(), fork, original.envelope_id(), e.proof()) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + let foreign = StockSourceCheckpointRef::from_host_metadata( + AuthorityRef::new( + ExecutorId::from_bytes([0xc7; 32]), + min.authority().generation(), + ), + min.revision(), + None, + ) + .unwrap() + .with_optional_authorization(min.authorization()); + assert!(matches!( + store + .stock_source(binding.clone(), foreign, original.envelope_id(), e.proof()) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + store.close().await.unwrap(); + std::fs::write(&path, original_db).unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert!(matches!( + store + .stock_source( + binding.clone(), + receipt.checkpoint(), + original.envelope_id(), + e.proof() + ) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + assert!(matches!( + store + .retain_stock_source(binding, receipt.checkpoint(), &original, e.proof()) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + store.close().await.unwrap(); +} + +#[tokio::test] +async fn separate_authenticated_envelopes_keep_both_originals_and_one_logical_record() { + use nostr::{EventBuilder, JsonUtil, Keys, UnsignedEvent}; + let row = source_vector("quote/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let sender = Keys::parse(&format!("{:064x}", 1)).unwrap(); + let recipient = nostr::PublicKey::from_hex(&signer(&row).public_key().to_hex()).unwrap(); + let rumor = UnsignedEvent::from_json(&row.raw_rumor).unwrap(); + let event = EventBuilder::gift_wrap(&sender, &recipient, rumor, []) + .await + .unwrap(); + let mut second = row.clone(); + second.raw_wrap = event.as_json(); + let other = capture(&e, &second).await; + assert_eq!(other.record_id(), original.record_id()); + assert_ne!(other.envelope_id(), original.envelope_id()); + let first = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + let next = retained( + store + .retain_stock_source(binding.clone(), first.checkpoint(), &other, e.proof()) + .await + .unwrap(), + ); + assert_eq!(next.checkpoint().revision().get(), 2); + assert_ne!(first.checkpoint().head(), next.checkpoint().head()); + let mut conn = database(&f).await; + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_source_records") + .fetch_one(&mut conn) + .await + .unwrap(); + assert_eq!(count, 1); + conn.close().await.unwrap(); + store.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + for (capture, raw) in [ + (&original, row.raw_wrap.as_bytes()), + (&other, second.raw_wrap.as_bytes()), + ] { + let value = store + .stock_source( + binding.clone(), + first.checkpoint(), + capture.envelope_id(), + e.proof(), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(value.protected_outer(), raw); + } + assert_eq!( + retained( + store + .retain_stock_source(binding, next.checkpoint(), &original, e.proof()) + .await + .unwrap() + ), + first + ); + store.close().await.unwrap(); +} + +#[tokio::test] +async fn same_envelope_identity_with_different_original_bytes_is_a_conflict() { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let receipt = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + let mut alias = row.clone(); + alias.raw_wrap = serde_json::to_string_pretty( + &serde_json::from_str::<serde_json::Value>(&row.raw_wrap).unwrap(), + ) + .unwrap(); + let alias = capture(&e, &alias).await; + assert_eq!(alias.envelope_id(), original.envelope_id()); + assert_eq!( + store + .retain_stock_source(binding.clone(), receipt.checkpoint(), &alias, e.proof()) + .await, + Err(OperationError::IdempotencyConflict) + ); + assert_eq!(source_minimum(&store, &e).await, receipt.checkpoint()); + let value = store + .stock_source( + binding, + receipt.checkpoint(), + original.envelope_id(), + e.proof(), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(value.protected_outer(), row.raw_wrap.as_bytes()); + store.close().await.unwrap(); +} + +#[tokio::test] +async fn inventory_progress_preserves_source_checkpoint_and_original_evidence() { + let row = source_vector("request/peer"); + let f = Fixture::new(); + let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; + let min = source_minimum(&store, &e).await; + let original = capture(&e, &row).await; + let receipt = retained( + store + .retain_stock_source(binding.clone(), min, &original, e.proof()) + .await + .unwrap(), + ); + let inventory = committed( + store + .execute_inventory(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await + .unwrap(), + ); + assert_eq!(inventory.checkpoint().revision().get(), 1); + assert_eq!(source_minimum(&store, &e).await, receipt.checkpoint()); + store.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert_eq!( + store + .stock_source( + binding, + receipt.checkpoint(), + original.envelope_id(), + e.proof() + ) + .await + .unwrap() + .unwrap() + .receipt(), + &receipt + ); + store.close().await.unwrap(); +} diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -103,6 +103,14 @@ struct StockCapabilityContract { #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct NativeSellerStockAuthority { + source_payload_schemas: Vec<String>, + source_profile_dispositions: Vec<String>, + source_owner_administration_required: bool, + inventory_scope_grants_source_access: bool, + source_checkpoint_independent: bool, + source_profile_implies_actionability: bool, + source_carrier_max_bytes: u32, + source_chunk_max_bytes: u32, mapping_payload_schema: String, mapping_owner_administration_required: bool, mapping_changes_physical_stock: bool, @@ -321,12 +329,25 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.scope == "seller_stock_owner" && stock.database == "stock_execution_v1.sqlite" && stock.lock == ".stock_execution_v1.lock" - && stock.schema_version == 5 + && stock.schema_version == 6 && stock.retained_enrollment_versions == [1] - && stock.retained_inventory_versions == [2, 3, 4] - && stock.authority_payload_schema == "radroots.seller_stock.authority.v5" + && stock.retained_inventory_versions == [2, 3, 4, 5] + && stock.authority_payload_schema == "radroots.seller_stock.authority.v6" && stock.inventory_operation_payload_schema == "radroots.seller_stock.operation.v4" && stock.mapping_payload_schema == "radroots.seller_stock.mapping.v1" + && stock.source_payload_schemas + == [ + "radroots.seller_stock.source_record.v1", + "radroots.seller_stock.source_evidence.v1", + "radroots.seller_stock.source_part.v1", + ] + && stock.source_profile_dispositions == ["known", "unsupported", "rejected"] + && stock.source_owner_administration_required + && !stock.inventory_scope_grants_source_access + && stock.source_checkpoint_independent + && !stock.source_profile_implies_actionability + && stock.source_carrier_max_bytes == 65536 + && stock.source_chunk_max_bytes == 16384 && stock.mapping_owner_administration_required && !stock.mapping_changes_physical_stock && !stock.mapping_changes_pool_version @@ -901,6 +922,31 @@ mod tests { } #[test] + fn source_retention_contract_requires_provenance_bounds_and_separate_authority() { + for (field, bad) in [ + ("schema_version", json!(5)), + ("retained_inventory_versions", json!([2, 3, 4])), + ("source_payload_schemas", json!([])), + ("source_profile_dispositions", json!(["known"])), + ("source_owner_administration_required", json!(false)), + ("inventory_scope_grants_source_access", json!(true)), + ("source_checkpoint_independent", json!(false)), + ("source_profile_implies_actionability", json!(true)), + ("source_carrier_max_bytes", json!(65537)), + ("source_chunk_max_bytes", json!(16385)), + ] { + assert!( + validate_bytes(&changed( + &format!("/native_seller_stock_authority/{field}"), + bad + )) + .is_err(), + "{field}" + ); + } + } + + #[test] fn native_mapping_contract_preserves_catalogs_owner_access_and_physical_non_effects() { for (field, bad) in [ ("schema_version", json!(4)),