sdk

Radroots SDK and bindings
git clone https://radroots.dev/git/sdk.git
Log | Files | Refs | README

sdk_v1_local_enqueue_and_mock_sync.rs (4414B)

      1 use radroots_authority::RadrootsActorContext;
      2 use radroots_core::{
      3     RadrootsCoreCurrency, RadrootsCoreDecimal, RadrootsCoreMoney, RadrootsCoreQuantity,
      4     RadrootsCoreQuantityPrice, RadrootsCoreUnit,
      5 };
      6 use radroots_events::contract::RadrootsActorRole;
      7 use radroots_events::ids::{RadrootsDTag, RadrootsInventoryBinId};
      8 use radroots_nostr::prelude::RadrootsNostrKeys;
      9 use radroots_relay_transport::RadrootsMockRelayPublishAdapter;
     10 use radroots_sdk::protocol::farm::RadrootsFarmRef;
     11 use radroots_sdk::protocol::listing::{
     12     RadrootsListing, RadrootsListingBin, RadrootsListingProduct,
     13 };
     14 use radroots_sdk::{
     15     ListingPreparePublishRequest, OrderStatusRequest, PushOutboxRequest, RadrootsSdk,
     16     RadrootsSdkLocalKeySigner, RadrootsSdkSignerProvider, RadrootsSdkTimestamp, SdkIdempotencyKey,
     17     SdkRelayTargetPolicy, SdkRelayTargetSet, SdkRelayUrlPolicy,
     18 };
     19 
     20 const LOCAL_RELAY: &str = "ws://localhost:7777";
     21 
     22 #[tokio::main]
     23 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     24     let keys = RadrootsNostrKeys::generate();
     25     let seller = keys.public_key().to_hex();
     26     let signer = RadrootsSdkLocalKeySigner::new(keys)?;
     27     let sdk = RadrootsSdk::builder()
     28         .fixed_clock(RadrootsSdkTimestamp::from_unix_seconds(1_700_000_000))
     29         .signer_provider(RadrootsSdkSignerProvider::LocalKey(signer))
     30         .build()
     31         .await?;
     32     let actor = RadrootsActorContext::test(seller.as_str(), [RadrootsActorRole::Seller])?;
     33     let targets = SdkRelayTargetSet::new([LOCAL_RELAY], SdkRelayUrlPolicy::Localhost)?;
     34     let target_policy = SdkRelayTargetPolicy::explicit(targets);
     35 
     36     let prepared = sdk
     37         .listings()
     38         .prepare_publish(ListingPreparePublishRequest::new(
     39             actor.clone(),
     40             sample_listing(seller.as_str()),
     41         ))?;
     42     let enqueue = sdk
     43         .listings()
     44         .enqueue_prepared_publish(
     45             &actor,
     46             prepared,
     47             target_policy,
     48             Some(SdkIdempotencyKey::new("sdk-v1-local-example")?),
     49         )
     50         .await?;
     51     let adapter = RadrootsMockRelayPublishAdapter::new();
     52     let push = sdk
     53         .sync()
     54         .push_outbox_with_adapter(&adapter, PushOutboxRequest::new().with_limit(1))
     55         .await?;
     56     let order_status = sdk
     57         .orders()
     58         .status(OrderStatusRequest::parse("example-order-1")?)
     59         .await?;
     60 
     61     println!("queued listing event: {}", enqueue.signed_event_id.as_str());
     62     println!("published events: {}", push.published_events);
     63     println!("order found: {}", order_status.found);
     64     Ok(())
     65 }
     66 
     67 fn sample_listing(seller: &str) -> RadrootsListing {
     68     RadrootsListing {
     69         d_tag: RadrootsDTag::parse("AAAAAAAAAAAAAAAAAAAAAQ").expect("d tag"),
     70         published_at: None,
     71         farm: RadrootsFarmRef {
     72             pubkey: seller.to_owned(),
     73             d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_owned(),
     74         },
     75         product: RadrootsListingProduct {
     76             key: "coffee".to_owned(),
     77             title: "Coffee".to_owned(),
     78             category: "coffee".to_owned(),
     79             summary: Some("Single origin coffee".to_owned()),
     80             process: None,
     81             lot: None,
     82             location: None,
     83             profile: None,
     84             year: None,
     85         },
     86         primary_bin_id: RadrootsInventoryBinId::parse("bin-1").expect("bin id"),
     87         bins: vec![RadrootsListingBin {
     88             bin_id: RadrootsInventoryBinId::parse("bin-1").expect("bin id"),
     89             quantity: RadrootsCoreQuantity::new(
     90                 RadrootsCoreDecimal::from(1000u32),
     91                 RadrootsCoreUnit::MassG,
     92             ),
     93             price_per_canonical_unit: RadrootsCoreQuantityPrice {
     94                 amount: RadrootsCoreMoney::new(
     95                     RadrootsCoreDecimal::from(20u32),
     96                     RadrootsCoreCurrency::USD,
     97                 ),
     98                 quantity: RadrootsCoreQuantity::new(
     99                     RadrootsCoreDecimal::from(1u32),
    100                     RadrootsCoreUnit::MassG,
    101                 ),
    102             },
    103             display_amount: None,
    104             display_unit: None,
    105             display_label: None,
    106             display_price: None,
    107             display_price_unit: None,
    108         }],
    109         resource_area: None,
    110         plot: None,
    111         discounts: None,
    112         inventory_available: None,
    113         availability: None,
    114         delivery_method: None,
    115         location: None,
    116         images: None,
    117     }
    118 }