update to latest version of the SDK

Author: Yakuhito

Cargo.lock

@@ -30,7 +30,7 @@ futures-util = "0.3.31"
 axum = { version = "0.8.3", features = ["macros"]}
 tower-http = { version = "0.6.2", features = ["cors"] }
 futures = "0.3.31"
-chia-wallet-sdk = { git = "https://github.com/xch-dev/chia-wallet-sdk.git", branch="the_merge", features=["offer-compression", "action-layer"] }
+chia-wallet-sdk = { git = "https://github.com/xch-dev/chia-wallet-sdk.git", rev="1199e568df1d8a77a824e166d674a1e913bef211", features=["offer-compression", "action-layer"] }
 sage-api = { version = "0.10.3", git = "https://github.com/xch-dev/sage.git" }
 chia-puzzles = "0.20.1"
 

Cargo.toml

@@ -1,7 +1,10 @@
 use chia::clvm_utils::ToTreeHash;
 use chia::protocol::Bytes32;
 use chia_wallet_sdk::{
-    driver::{CatalogRegistryConstants, CatalogRegistryState, DelegatedStateAction, MedievalVault},
+    driver::{
+        CatalogRegistryConstants, CatalogRegistryState, DelegatedStateAction, MedievalVault,
+        SingletonInfo,
+    },
     types::{
         puzzles::{DefaultCatMakerArgs, StateSchedulerLayerSolution},
         Mod,

src/cli/catalog/broadcast_catalog_state_update.rs

@@ -1,9 +1,10 @@
 use chia::protocol::Bytes32;
+use chia_puzzle_types::LineageProof;
 use reqwest::Client;
 use std::time::Duration;
 
 use crate::{hex_string_to_bytes32, CliError};
-use chia_wallet_sdk::driver::{Slot, SlotProof};
+use chia_wallet_sdk::driver::Slot;
 use chia_wallet_sdk::types::puzzles::{CatalogSlotValue, SlotInfo};
 
 use super::CatalogNeighborResponse;
@@ -88,18 +89,20 @@ impl CatalogApiClient {
             hex_string_to_bytes32(&neighbors_resp.left_parent_parent_info)?;
         let left_parent_inner_puzzle_hash =
             hex_string_to_bytes32(&neighbors_resp.left_parent_inner_puzzle_hash)?;
-        let left_proof = SlotProof {
-            parent_parent_info: left_parent_parent_info,
+        let left_proof = LineageProof {
+            parent_parent_coin_info: left_parent_parent_info,
             parent_inner_puzzle_hash: left_parent_inner_puzzle_hash,
+            parent_amount: neighbors_resp.left_parent_amount,
         };
 
         let right_parent_parent_info =
             hex_string_to_bytes32(&neighbors_resp.right_parent_parent_info)?;
         let right_parent_inner_puzzle_hash =
             hex_string_to_bytes32(&neighbors_resp.right_parent_inner_puzzle_hash)?;
-        let right_proof = SlotProof {
-            parent_parent_info: right_parent_parent_info,
+        let right_proof = LineageProof {
+            parent_parent_coin_info: right_parent_parent_info,
             parent_inner_puzzle_hash: right_parent_inner_puzzle_hash,
+            parent_amount: neighbors_resp.right_parent_amount,
         };
 
         let left_info = SlotInfo::<CatalogSlotValue>::from_value(launcher_id, 0, left_value);

src/cli/catalog/catalog_api_client.rs

@@ -18,8 +18,8 @@ use chia_wallet_sdk::{
     coinset::ChiaRpcClient,
     driver::{
         decode_offer, launch_catalog_registry, Cat, CatalogRegistryConstants, CatalogRegistryState,
-        DriverError, Launcher, MedievalVaultHint, MedievalVaultInfo, Offer, SpendContext,
-        StateSchedulerInfo,
+        DriverError, Launcher, MedievalVaultHint, MedievalVaultInfo, Offer, SingletonInfo,
+        SpendContext, StateSchedulerInfo,
     },
     types::{
         puzzles::DefaultCatMakerArgs, Conditions, Mod, MAINNET_CONSTANTS, TESTNET11_CONSTANTS,

src/cli/catalog/initiate_launch.rs

@@ -40,8 +40,10 @@ pub struct CatalogNeighborResponse {
 
     pub left_parent_parent_info: String,
     pub left_parent_inner_puzzle_hash: String,
+    pub left_parent_amount: u64,
     pub right_parent_parent_info: String,
     pub right_parent_inner_puzzle_hash: String,
+    pub right_parent_amount: u64,
 }
 
 #[derive(Clone)]
@@ -148,12 +150,14 @@ async fn get_neighbors(
         left_left_asset_id: hex::encode(left.info.value.neighbors.left_value.to_bytes()),
         right_right_asset_id: hex::encode(right.info.value.neighbors.right_value.to_bytes()),
 
-        left_parent_parent_info: hex::encode(left.proof.parent_parent_info.to_bytes()),
+        left_parent_parent_info: hex::encode(left.proof.parent_parent_coin_info.to_bytes()),
         left_parent_inner_puzzle_hash: hex::encode(left.proof.parent_inner_puzzle_hash.to_bytes()),
-        right_parent_parent_info: hex::encode(right.proof.parent_parent_info.to_bytes()),
+        left_parent_amount: left.proof.parent_amount,
+        right_parent_parent_info: hex::encode(right.proof.parent_parent_coin_info.to_bytes()),
         right_parent_inner_puzzle_hash: hex::encode(
             right.proof.parent_inner_puzzle_hash.to_bytes(),
         ),
+        right_parent_amount: right.proof.parent_amount,
     };
 
     Ok(Json(response))

src/cli/catalog/listen.rs

@@ -10,7 +10,7 @@ use chia_wallet_sdk::{
     coinset::{ChiaRpcClient, CoinsetClient},
     driver::{
         CatalogRegistry, CatalogRegistryConstants, CatalogRegistryInfo, CatalogRegistryState,
-        DriverError, Layer, Puzzle, SingletonLayer, Slot, SlotProof, SpendContext,
+        DriverError, Layer, Puzzle, SingletonLayer, Slot, SpendContext,
     },
     types::{
         puzzles::{CatalogSlotValue, SlotInfo},
@@ -135,9 +135,10 @@ pub async fn sync_catalog(
                 CatalogRegistryInfo::new(initial_state, constants),
             );
 
-            let slot_proof = SlotProof {
-                parent_parent_info: lineage_proof.parent_parent_coin_info,
+            let slot_proof = LineageProof {
+                parent_parent_coin_info: lineage_proof.parent_parent_coin_info,
                 parent_inner_puzzle_hash: lineage_proof.parent_inner_puzzle_hash,
+                parent_amount: lineage_proof.parent_amount,
             };
             let left_slot_value = CatalogSlotValue::initial_left_end();
             let right_slot_value = CatalogSlotValue::initial_right_end();

src/cli/catalog/sync.rs

@@ -1,7 +1,8 @@
 use chia::{clvm_utils::ToTreeHash, protocol::Bytes32};
+use chia_puzzle_types::LineageProof;
 use chia_wallet_sdk::{
     coinset::CoinRecord,
-    driver::{DriverError, RewardDistributorConstants, Slot, SlotProof, XchandlesConstants},
+    driver::{DriverError, RewardDistributorConstants, Slot, XchandlesConstants},
     types::puzzles::SlotInfo,
 };
 use clvm_traits::{FromClvm, ToClvm};
@@ -37,9 +38,10 @@ impl Db {
                     slot_value_hash BLOB NOT NULL,
                     spent_block_height INTEGER NOT NULL,
                     slot_value BLOB NOT NULL,
-                    parent_parent_info BLOB NOT NULL,
+                    parent_parent_coin_info BLOB NOT NULL,
                     parent_inner_puzzle_hash BLOB NOT NULL,
-                    PRIMARY KEY (singleton_launcher_id, nonce, slot_value_hash, parent_parent_info)
+                    parent_amount INTEGER NOT NULL,
+                    PRIMARY KEY (singleton_launcher_id, nonce, slot_value_hash, parent_parent_coin_info, parent_amount)
                 )
                 ",
             )
@@ -147,19 +149,20 @@ impl Db {
             "
             INSERT INTO slots (
                 singleton_launcher_id, nonce, slot_value_hash, spent_block_height,
-                slot_value, parent_parent_info, parent_inner_puzzle_hash
+                slot_value, parent_parent_coin_info, parent_inner_puzzle_hash, parent_amount
             )
-            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
-            ON CONFLICT(singleton_launcher_id, nonce, slot_value_hash, parent_parent_info) DO UPDATE SET spent_block_height = excluded.spent_block_height
+            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)
+            ON CONFLICT(singleton_launcher_id, nonce, slot_value_hash, parent_parent_coin_info, parent_amount) DO UPDATE SET spent_block_height = excluded.spent_block_height
             ",
         )
         .bind(slot.info.launcher_id.to_vec())
         .bind(slot.info.nonce as i64)
         .bind(slot.info.value_hash.to_vec())
         .bind(spent_block_height)
         .bind(slot_value_bytes)
-        .bind(slot.proof.parent_parent_info.to_vec())
+        .bind(slot.proof.parent_parent_coin_info.to_vec())
         .bind(slot.proof.parent_inner_puzzle_hash.to_vec())
+        .bind(slot.proof.parent_amount as i64)
         .execute(&self.pool)
         .await
         .map_err(CliError::Sqlx)?;
@@ -173,18 +176,21 @@ impl Db {
     {
         let launcher_id = column_to_bytes32(row.get::<&[u8], _>("singleton_launcher_id"))?;
         let nonce = row.get::<i64, _>("nonce") as u64;
-        let parent_parent_info = column_to_bytes32(row.get::<&[u8], _>("parent_parent_info"))?;
+        let parent_parent_coin_info =
+            column_to_bytes32(row.get::<&[u8], _>("parent_parent_coin_info"))?;
         let parent_inner_puzzle_hash =
             column_to_bytes32(row.get::<&[u8], _>("parent_inner_puzzle_hash"))?;
+        let parent_amount = row.get::<i64, _>("parent_amount") as u64;
 
         let value = node_from_bytes(allocator, row.get::<&[u8], _>("slot_value"))?;
         let value = SV::from_clvm(allocator, value)
             .map_err(|err| CliError::Driver(DriverError::FromClvm(err)))?;
 
         Ok(Slot::new(
-            SlotProof {
-                parent_parent_info,
+            LineageProof {
+                parent_parent_coin_info,
                 parent_inner_puzzle_hash,
+                parent_amount,
             },
             SlotInfo::<SV>::from_value(launcher_id, nonce, value),
         ))

src/cli/database.rs

@@ -8,7 +8,7 @@ use chia::{
     },
 };
 use chia_wallet_sdk::driver::{
-    MedievalVaultHint, MedievalVaultInfo, SpendContext, StateSchedulerInfo,
+    MedievalVaultHint, MedievalVaultInfo, SingletonInfo, SpendContext, StateSchedulerInfo,
 };
 use chia_wallet_sdk::{
     coinset::{ChiaRpcClient, CoinsetClient},

src/cli/multisig/sync.rs

@@ -2,7 +2,7 @@ use chia::protocol::Bytes32;
 use chia::{clvm_utils::ToTreeHash, protocol::Bytes};
 use chia_wallet_sdk::driver::{
     MedievalVault, RewardDistributorAddEntryAction, RewardDistributorRemoveEntryAction,
-    RewardDistributorSyncAction,
+    RewardDistributorSyncAction, SingletonInfo,
 };
 use chia_wallet_sdk::types::puzzles::StateSchedulerLayerSolution;
 use clvmr::{Allocator, NodePtr};