Payment

#if UNITY_ANDROID
using Stove.StoveSDK.IAP.Google;
#endif

public void Initialize()
{
    IAP.Initialize((Result result) =>
    {
        if (result.IsSuccessful)
        {
            SetListener(); // call setListener
        }
        else if (result.ErrorCode == Auth.UnauthorizedError)
        {
            //TODO : login
        }
        else
        {
            //InitializeError. Android Only
            // see https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode
        }
    });
}

public void SetListener()
{
    IAP.SetListener((Result result, IAPProduct product, IAPPurchaseDetail purchaseDetail) =>
    {
        if (result.IsSuccessful)
        {
            //purchase success
        }
        else if (result.IsCanceled)
        {
            //purchase cancellation
        }
        else if (result.ErrorCode == IAPError.SuccessButUserMissMatchError)
        {
            //purchase success (account mismatch)
            //can occur when the account changes or the world moves before payment verification completes
        }
        else if (result.ErrorCode == IAPError.PurchasedError)
        {
            //payment verification pending - later auto-processed by the billing server, notified via push
        }
        else if (result.ErrorCode == IAPError.WaitingError)
        {
            //grant pending - later auto-processed, notified via push
        }
        else if (result.ErrorCode == IAPError.MarketError)
        {
            //Android: BillingClient.BillingResponseCode
            //iOS: SKError.Code
        }
    });
}

#if UNITY_ANDROID
using Stove.StoveSDK.IAP.Google;
#endif

public void FetchProducts()
{
    IAP.FetchProducts((Result result, List<IAPProduct> products) =>
    {
        if (result.IsSuccessful)
        {
            foreach (IAPProduct product in products)
            {
                IAPProduct.ProductState state = product.State;
                if (state == IAPProduct.ProductState.Available) { /* purchasable */ }
                else if (state == IAPProduct.ProductState.Waiting) { /* paying */ }
                else if (state == IAPProduct.ProductState.Purchased) { /* flush needed */ }
                string localizedTitle = product.LocalizedTitle;
                string price = product.Price;
            }
        }
        else if (result.IsServerError) { /* billing-server error */ }
        else { /* network error */ }
    });
}

#if UNITY_ANDROID
using Stove.StoveSDK.IAP.Google;
#endif

public void StartPurchase(IAPProduct product)
{
    IAPProduct.ProductState state = product.State;
    if (state == IAPProduct.ProductState.Waiting) { /* paying - disable the button */ }
    else if (state == IAPProduct.ProductState.Available)
    {
        IAP.StartPurchase(product, (Result result) =>
        {
            if (result.IsSuccessful) { /* payment started */ }
            else if (result.IsServerError)
            {
                if (result.ErrorCode == 93106) { /* already-subscribed product */ }
            }
            else if (result.ErrorCode == Auth.UnauthorizedError) { /* AuthUI.login */ }
            else if (result.ErrorCode == IAPError.InvalidProductError) { /* use the fetchProducts result */ }
            else { /* network error */ }
        });
    }
    else if (state == IAPProduct.ProductState.Purchased)
    {
        IAP.Flush(); //re-grant handling
    }
}

public void Flush()
{
    IAP.Flush();
    // the result is delivered via the setListener callback
}

string serviceOrderId = "set your developer payload";
IAP.StartPurchase(product, serviceOrderId, null, (Result result) => { });

#if UNITY_ANDROID
using Stove.StoveSDK.IAP.Google;
#endif

public void HandleVoidedPurchases()
{
    IAP.HandleVoidedPurchases((Result result) =>
    {
        if (result.IsSuccessful)
        {
            /** game entry allowed **/
        }
        else if (result.IsCanceled)
        {
            if (result.UserInfo != null && result.UserInfo.TryGetValue("userAction", out string userAction))
            {
                if (!string.IsNullOrEmpty(userAction) && userAction.Equals("customerSupport"))
                {
                    ViewUI.CustomerSupport((Result result, Dictionary<string, string> dictionary) =>
                    {
                        HandleVoidedPurchases();
                    });
                    return;
                }
            }
            HandleVoidedPurchases();
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) =>
            {
                if (result.ErrorCode == 40303)
                {
                    Auth.Logout();
                }
            });
        }
    });
}

IAP.SetCustomBillingGUID("{STOVE_guid}_{STOVE_character_no}");

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// 1) Initialization — call after Base_Initialize completes.
std::wstring shopKey = L"YOUR_SHOP_KEY";
auto initResult = IAP_Initialize(shopKey.c_str());
// If a parent window is needed: IAP_InitializeWithWndInfo(shopKey.c_str(), mainWindowHandle);
if (!initResult.IsSuccessful())
{
    // Implement the logic for initialization failure.
    return;
}

// 2) Shutdown — clean up in the order IAP_UnInitialize then Base_UnInitialize.
IAP_UnInitialize();
// then call Base_UnInitialize()

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// Look up required-terms agreement (after IAP_Initialize completes)
StovePCTermsOption termsOption;
termsOption.SetOperation(StovePCTermsOperation::WITH_WEBVIEW);
termsOption.SetWebviewMode(Base::WebViewMode::INTERNAL);
termsOption.SetWebviewRect(0, 0, 800, 600);
IAP_FetchTermsAgreement(&termsOption,
    [](CallbackResult callbackResult, bool agreed, const wchar_t* url)
    {
        if (callbackResult.GetResult().IsSuccessful() && !agreed)
        {
            // Show the terms-agreement flow.
        }
    });

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// 1) Category lookup
IAP_FetchShopCategories(
    [](CallbackResult callbackResult, StovePCShopCategory* categories, uint32_t categoriesSize)
    {
        if (callbackResult.GetResult().IsSuccessful())
        {
            // Build shop-tab UI from categories[0..categoriesSize)
        }
    });

// 2) Product-list lookup
StovePCFetchProductParam fetchParams;
fetchParams.SetCategoryId(L"");   // empty value = all categories
fetchParams.SetPageNumber(1);
fetchParams.SetPageSize(20);
IAP_FetchProducts(&fetchParams,
    [](CallbackResult callbackResult, StovePCProduct* products, uint32_t productsSize)
    {
        if (callbackResult.GetResult().IsSuccessful())
        {
            // Build shop UI from products[0..productsSize)
        }
    });

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

void IAP_StartPurchase_WITH_WEBVIEW_AND_CONFIRM_RESULT_Example()
{
    // (1) Build product/parameters (in practice, pass the in-game item info the user selected)
    StovePCOrderProduct product1; product1.SetProductId(123); product1.SetSalePrice(1000);  product1.SetQuantity(3);
    StovePCOrderProduct product2; product2.SetProductId(456); product2.SetSalePrice(5000);  product2.SetQuantity(2);
    StovePCOrderProduct product3; product3.SetProductId(789); product3.SetSalePrice(39800); product3.SetQuantity(1);

    StovePCStartPurchaseParam params;
    params.CreateOrderProduct(3);            // create an internal array sized to the number of ordered products
    params.SetOrderProduct(0, &product1);
    params.SetOrderProduct(1, &product2);
    params.SetOrderProduct(2, &product3);

    // (2) Option: the SDK auto-handles showing the payment window + detecting completion + ConfirmPurchase (server confirmation)
    StovePCPurchaseOption option;
    option.SetOperation(StovePCPurchaseOperation::WITH_WEBVIEW_AND_CONFIRM_RESULT);
    option.SetWebviewMode(Base::WebViewMode::INTERNAL);
    // SetWebviewRect args: (x, y, width, height). Dead center is (-1, -1).
    option.SetWebviewRect(0, 0, 420, 700);
    params.SetPurchaseOption(option);

    Game::ShopUI::SetPurchaseButtonEnabled(false);   // (developer pseudo-function) prevent double-clicks during payment

    // (3) Start payment — the payment window closes, so use the Ex API that receives onDestroy
    //     this path also has the SDK internally handle ConfirmPurchase for the zero-cost item (NOT_NEED_PAYMENT_WINDOW) case
    //     and deliver the result via onFinished. So a GetPurchaseProgress() branch or
    //     a manual IAP_ConfirmPurchase call is unnecessary (calling it directly causes duplicate confirmation).
    IAP_StartPurchaseEx(&params,
        // onFinished: the actual purchase-completion handling point (called once after the SDK finishes ConfirmPurchase)
        [](CallbackResult callbackResult, StovePCPurchaseResult purchaseResult)
        {
            // (3-1) Payment failure/cancellation handling. All cases where the flow didn't end normally come here (purchased is always false).
            //       The cause is distinguished by ResultCode.
            if (!callbackResult.GetResult().IsSuccessful())
            {
                if (callbackResult.GetResult().GetResultCode() == (uint32_t)SDKResultCode::WEBVIEW_CLOSED_BEFORE_PURCHASE)
                {
                    // The user closed the payment window without completing payment (payment cancellation). Handle it as an intentional cancellation, not an error.
                }
                else
                {
                    // Other errors: payment-window entry failure (VIEWUI_NOT_INITIALIZED / WEBVIEW_CREATE_FAIL / WEBVIEW_LOAD_URL_FAIL),
                    //            parameter error, REST network/server error, ConfirmPurchase server-API failure, etc.
                }
                return;   // no item grant in any case
            }

            // (3-2) This is the actual purchase-completion point.
            //       The result after the SDK finished ConfirmPurchase is in purchaseResult,
            //       so if IsPurchased()==true, grant the item right here (and only here).
            //       The zero-cost item (NOT_NEED_PAYMENT_WINDOW) case also comes in as purchased=true and is handled the same way.
            if (purchaseResult.IsPurchased())
            {
                // Purchase-completion grant point. Apply code here to reflect purchasedProducts[0..purchasedProductSize) into inventory/currency.
                //   transactionMasterNumber is unique per transaction. Developers running a game server can
                //   use this value to prevent server-side duplicate grants, and also as a key to prevent
                //   duplicate handling (duplicate-grant display, etc.) in the UI.
                for (uint32_t i = 0; i < purchaseResult.GetPurchasedProductCount(); ++i)
                {
                    const StovePCPurchasedProduct* product = purchaseResult.GetPurchasedProduct(i);
                    int64_t        detailNo   = product->GetTransactionDetailNumber();  // purchase detail number (purchased-product TID)
                    int64_t        productId  = product->GetProductId();                // platform product ID
                    const wchar_t* categoryId = product->GetCategoryId();               // category ID
                    int32_t        totalQty   = product->GetTotalQuantity();            // total quantity sold
                    int32_t        memberQty  = product->GetMemberQuantity();           // member purchase quantity
                    int32_t        guidQty    = product->GetGuidQuantity();             // guid purchase quantity
                    // Implement handling per purchased item
                }

                // Info on the currency/payment method used (StovePCChargeInfo). Used for receipt display, settlement logging, etc.
                for (uint32_t i = 0; i < purchaseResult.GetChargeInfoCount(); ++i)
                {
                    const StovePCChargeInfo* charge = purchaseResult.GetChargeInfo(i);
                    int32_t        type       = charge->GetChargeType();              // 98: STOVE Cash, 99: points, others: PG payment method
                    const wchar_t* typeName   = charge->GetChargeTypeName();          // payment-method name
                    double         deductVal  = charge->GetChargeDeductVal();         // payment price
                    double         displayVal = charge->GetChargeDisplayDeductVal();  // cash-converted price of the payment price
                    // Implement handling per payment method
                }
            }
            else
            {
                // The flow is normal (IsSuccessful()==true) but the server hasn't confirmed payment completion.
                //   (the rare case where ConfirmPurchase returns HTTP 200 but the server response status=false = payment state undetermined)
                // Don't grant the item; hand off to a server-side purchase-state re-lookup or customer support.
                // (user cancellation/payment failure is handled not here but in (3-1) above via IsSuccessful()==false.)
            }
        },
        // onDestroy: called when the payment-window pop-up closes. 
        [](CallbackResult callbackResult)
        {
            // A UI-cleanup-only callback. (completion decision/grant is handled in onFinished above)
            Game::ShopUI::SetPurchaseButtonEnabled(true);   // (developer pseudo-function) re-enable the locked purchase button
            Game::ShopUI::HideLoadingSpinner();             // (developer pseudo-function) clear the loading/overlay
        });
}

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// IAP_ConfirmPurchase result callback (shared by DEFAULT / NOT_NEED_PAYMENT_WINDOW)
//   The point where status == true is the actual purchase-completion point.
static void OnConfirmPurchase(CallbackResult callbackResult, bool status,
                              StovePCPurchasedProduct* purchasedProducts, uint32_t purchasedProductSize,
                              StovePCChargeInfo* chargeInfos, uint32_t chargeInfoSize)
{
    if (callbackResult.GetResult().IsSuccessful() && status)
    {
        // Purchase-completion grant point. Apply code here to reflect purchasedProducts[0..purchasedProductSize) into inventory/currency.
        //   transactionMasterNumber is unique per transaction. Developers running a game server can
        //   use this value to prevent server-side duplicate grants, and also as a key to prevent
        //   duplicate handling (duplicate-grant display, etc.) in the UI.
        for (uint32_t i = 0; i < purchasedProductSize; ++i)
        {
            const StovePCPurchasedProduct* product = &purchasedProducts[i];
            int64_t        detailNo   = product->GetTransactionDetailNumber();  // purchase detail number (purchased-product TID)
            int64_t        productId  = product->GetProductId();                // platform product ID
            const wchar_t* categoryId = product->GetCategoryId();               // category ID
            int32_t        totalQty   = product->GetTotalQuantity();            // total quantity sold
            int32_t        memberQty  = product->GetMemberQuantity();           // member purchase quantity
            int32_t        guidQty    = product->GetGuidQuantity();             // guid purchase quantity
            // Implement handling per purchased item
        }

        // Info on the currency/payment method used (StovePCChargeInfo). Used for receipt display, settlement logging, etc.
        for (uint32_t i = 0; i < chargeInfoSize; ++i)
        {
            const StovePCChargeInfo* charge = &chargeInfos[i];
            int32_t        type       = charge->GetChargeType();              // 98: STOVE Cash, 99: points, others: PG payment method
            const wchar_t* typeName   = charge->GetChargeTypeName();          // payment-method name
            double         deductVal  = charge->GetChargeDeductVal();         // payment price
            double         displayVal = charge->GetChargeDisplayDeductVal();  // cash-converted price of the payment price
            // Implement handling per payment method
        }
    }
    else if (!callbackResult.GetResult().IsSuccessful())
    {
        // The ConfirmPurchase call itself failed (network/server error, parameter error, etc.). No item grant + failure log/retry/inquiry guidance.
    }
    else
    {
        // The call succeeded (IsSuccessful()==true) but the server didn't confirm payment completion (status==false).
        //   This covers a cancellation where the user closed the window without completing payment, or a payment-undetermined state.
        // No item grant. If needed, re-look up the purchase state on the server / guide the user.
    }
}

void IAP_StartPurchase_DEFAULT_Example()
{
    // (1) Build product/parameters (in practice, pass the in-game item info the user selected)
    StovePCOrderProduct product1; product1.SetProductId(123); product1.SetSalePrice(1000);  product1.SetQuantity(3);
    StovePCOrderProduct product2; product2.SetProductId(456); product2.SetSalePrice(5000);  product2.SetQuantity(2);
    StovePCOrderProduct product3; product3.SetProductId(789); product3.SetSalePrice(39800); product3.SetQuantity(1);

    StovePCStartPurchaseParam params;
    params.CreateOrderProduct(3);            // create an internal array sized to the number of ordered products
    params.SetOrderProduct(0, &product1);
    params.SetOrderProduct(1, &product2);
    params.SetOrderProduct(2, &product3);

    // (2) Option: DEFAULT — the SDK doesn't show a payment webview (the game shows the payment URL directly).
    //     Since there's no SDK payment window, SetWebviewMode / SetWebviewRect settings are meaningless (omitted).
    StovePCPurchaseOption option;
    option.SetOperation(StovePCPurchaseOperation::DEFAULT);
    params.SetPurchaseOption(option);

    // (3) Start payment.
    //     DEFAULT has no SDK payment window so the onDestroy callback isn't called (internally POPUP_NOT_CREATED
    //     occurs but the C++ wrapper intercepts it and doesn't call the user onDestroy); for API consistency, use IAP_StartPurchaseEx.
    IAP_StartPurchaseEx(&params,
        // onFinished: the "payment URL issued" point (not purchase completion)
        [](CallbackResult callbackResult, StovePCPurchaseResult purchaseResult)
        {
            // (3-1) Whether payment started. If it failed, the URL wasn't issued either. Notify the user of failure and end.
            if (!callbackResult.GetResult().IsSuccessful())
                return;

            // (3-2) A case needing no payment window (zero-cost payment, etc.). Already payment-complete.
            //       Finalize with ConfirmPurchase to get the confirmed-grant list. (the completion result is OnConfirmPurchase)
            if (purchaseResult.GetPurchaseProgress() == PurchaseProgress::NOT_NEED_PAYMENT_WINDOW)
            {
                IAP_ConfirmPurchase(purchaseResult.GetTransactionMasterNumber(), OnConfirmPurchase);
                return;
            }

            // (3-3) This onFinished is only a signal that "the payment URL was issued", not purchase completion.
            //       The game opens its own payment page with this URL to let the user pay,
            //       and keeps the transaction number (txnNo) until the ConfirmPurchase call.
            const wchar_t* paymentUrl = purchaseResult.GetOneTimePaymentUrl();
            int64_t        txnNo      = purchaseResult.GetTransactionMasterNumber();
            Game::SavePendingTransaction(txnNo);           // (developer pseudo-function) keep the transaction number
            Game::OpenOwnPaymentPage(paymentUrl, txnNo);   // (developer pseudo-function) show the own payment page
        },
        // onDestroy: with DEFAULT there's no SDK payment window, so this callback isn't called.
        [](CallbackResult callbackResult)
        {
        });
}

// (4) Called when the game detects payment completion on its own payment page. The purchase-completion result comes in via OnConfirmPurchase.
//     Note: don't call it at the onFinished (URL-issued) point. At that point the user hasn't paid yet.
void Game_ConfirmOwnPurchase()
{
    int64_t txnNo = Game::TakePendingTransaction();      // (developer pseudo-function) retrieve the kept transaction number
    if (txnNo != 0)
        IAP_ConfirmPurchase(txnNo, OnConfirmPurchase);
}

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// IAP_ConfirmPurchase result callback (shared by WITH_WEBVIEW / NOT_NEED_PAYMENT_WINDOW)
//   The point where status == true is the actual purchase-completion point.
static void OnConfirmPurchase(CallbackResult callbackResult, bool status,
                              StovePCPurchasedProduct* purchasedProducts, uint32_t purchasedProductSize,
                              StovePCChargeInfo* chargeInfos, uint32_t chargeInfoSize)
{
    if (callbackResult.GetResult().IsSuccessful() && status)
    {
        // Purchase-completion grant point. Apply code here to reflect purchasedProducts[0..purchasedProductSize) into inventory/currency.
        //   transactionMasterNumber is unique per transaction. Developers running a game server can
        //   use this value to prevent server-side duplicate grants, and also as a key to prevent
        //   duplicate handling (duplicate-grant display, etc.) in the UI.
        for (uint32_t i = 0; i < purchasedProductSize; ++i)
        {
            const StovePCPurchasedProduct* product = &purchasedProducts[i];
            int64_t        detailNo   = product->GetTransactionDetailNumber();  // purchase detail number (purchased-product TID)
            int64_t        productId  = product->GetProductId();                // platform product ID
            const wchar_t* categoryId = product->GetCategoryId();               // category ID
            int32_t        totalQty   = product->GetTotalQuantity();            // total quantity sold
            int32_t        memberQty  = product->GetMemberQuantity();           // member purchase quantity
            int32_t        guidQty    = product->GetGuidQuantity();             // guid purchase quantity
            // Implement handling per purchased item
        }

        // Info on the currency/payment method used (StovePCChargeInfo). Used for receipt display, settlement logging, etc.
        for (uint32_t i = 0; i < chargeInfoSize; ++i)
        {
            const StovePCChargeInfo* charge = &chargeInfos[i];
            int32_t        type       = charge->GetChargeType();              // 98: STOVE Cash, 99: points, others: PG payment method
            const wchar_t* typeName   = charge->GetChargeTypeName();          // payment-method name
            double         deductVal  = charge->GetChargeDeductVal();         // payment price
            double         displayVal = charge->GetChargeDisplayDeductVal();  // cash-converted price of the payment price
            // Implement handling per payment method
        }
    }
    else if (!callbackResult.GetResult().IsSuccessful())
    {
        // The ConfirmPurchase call itself failed (network/server error, parameter error, etc.). No item grant + failure log/retry/inquiry guidance.
    }
    else
    {
        // The call succeeded (IsSuccessful()==true) but the server didn't confirm payment completion (status==false).
        //   This covers a cancellation where the user closed the window without completing payment, or a payment-undetermined state.
        // No item grant. If needed, re-look up the purchase state on the server / guide the user.
    }
}

void IAP_StartPurchase_WITH_WEBVIEW_Example()
{
    // (1) Build product/parameters (in practice, pass the in-game item info the user selected)
    StovePCOrderProduct product1; product1.SetProductId(123); product1.SetSalePrice(1000);  product1.SetQuantity(3);
    StovePCOrderProduct product2; product2.SetProductId(456); product2.SetSalePrice(5000);  product2.SetQuantity(2);
    StovePCOrderProduct product3; product3.SetProductId(789); product3.SetSalePrice(39800); product3.SetQuantity(1);

    StovePCStartPurchaseParam params;
    params.CreateOrderProduct(3);            // create an internal array sized to the number of ordered products
    params.SetOrderProduct(0, &product1);
    params.SetOrderProduct(1, &product2);
    params.SetOrderProduct(2, &product3);

    // (2) Option: WITH_WEBVIEW — the SDK shows the payment webview but doesn't auto-call ConfirmPurchase.
    StovePCPurchaseOption option;
    option.SetOperation(StovePCPurchaseOperation::WITH_WEBVIEW);
    option.SetWebviewMode(Base::WebViewMode::INTERNAL);          // display inside the game window
    // SetWebviewRect args: (x, y, width, height). Dead center is (-1, -1).
    option.SetWebviewRect(0, 0, 420, 700);
    params.SetPurchaseOption(option);

    // (3) Start payment — the payment window closes, so use the Ex API that receives onDestroy
    Game::ShopUI::SetPurchaseButtonEnabled(false);   // (developer pseudo-function) prevent double-clicks during payment

    IAP_StartPurchaseEx(&params,
        // onFinished: the "payment window shown" signal (not purchase completion)
        [](CallbackResult callbackResult, StovePCPurchaseResult purchaseResult)
        {
            // (3-1) Whether payment-window entry succeeded. If it failed, the webview didn't open (UI recovery happens in onDestroy).
            if (!callbackResult.GetResult().IsSuccessful())
                return;

            // (3-2) A situation like a zero-cost item purchase, so the payment window doesn't open. Receive the confirmed list via ConfirmPurchase.
            if (purchaseResult.GetPurchaseProgress() == PurchaseProgress::NOT_NEED_PAYMENT_WINDOW)
            {
                IAP_ConfirmPurchase(purchaseResult.GetTransactionMasterNumber(), OnConfirmPurchase);
                return;
            }

            // (3-3) This onFinished is only a signal that the webview URL finished loading, not purchase completion.
            //       The SDK doesn't notify payment completion, so to get the completion result the game must directly
            //       call IAP_ConfirmPurchase. Keep the transaction number.
            Game::SavePendingTransaction(purchaseResult.GetTransactionMasterNumber());   // (developer pseudo-function) keep the transaction number
        },
        // onDestroy: when the payment-window pop-up closes. UI-cleanup only
        [](CallbackResult callbackResult)
        {
            // (4) The "webview closed" screen event (unrelated to payment success/failure).
            //     Don't do payment decision, grant, or ConfirmPurchase here.
            //     (window closing isn't payment completion, and if the window isn't closed after payment it isn't even called)
            Game::ShopUI::SetPurchaseButtonEnabled(true);   // (developer pseudo-function) re-enable the locked purchase button
            Game::ShopUI::HideLoadingSpinner();             // (developer pseudo-function) clear the loading/overlay
        });
}

// (5) Called at an explicit moment when the game can be certain payment is complete (e.g., returning to the game after payment / checking purchase history).
//     Note: don't tie it to onDestroy (window close). Window closing isn't a payment-completion signal, so it's risky.
void Game_ConfirmPendingPurchase()
{
    int64_t txnNo = Game::TakePendingTransaction();      // (developer pseudo-function) retrieve the kept transaction number
    if (txnNo != 0)
        IAP_ConfirmPurchase(txnNo, OnConfirmPurchase);   // the purchase-completion result goes to OnConfirmPurchase
}

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// The StartPurchase callback and the Steam overlay display aren't guaranteed to be ordered.
// Keep the transaction master number from the callback and use it at the Steamworks callback moment.
static int64_t g_PendingTxnNo = 0;

// (4) Purchase-confirmation result callback
//     In the Steam flow, status / purchasedProducts / chargeInfos come back as defaults,
//     so judge success by CallbackResult alone.
void OnConfirmPurchase(CallbackResult callbackResult, bool status,
                       StovePCPurchasedProduct* purchasedProducts, uint32_t purchasedProductsSize,
                       StovePCChargeInfo* chargeInfos, uint32_t chargeInfosSize)
{
    if (!callbackResult.GetResult().IsSuccessful())
    {
        // Confirmation failed — don't grant the item. Implement failure guidance or a retry.
        return;
    }

    // Confirmation complete. Check the grant result via inventory lookup.
    IAP_FetchInventory(
        [](CallbackResult cb, StovePCInventoryItem* items, uint32_t itemsSize)
        {
            if (cb.GetResult().IsSuccessful())
            {
                // Refresh the inventory/currency UI from items[0..itemsSize)
            }
        });
}

// (1) Start the purchase — don't set PurchaseOption (it isn't applied in the Steam flow).
void StartSteamPurchase()
{
    StovePCOrderProduct product; product.SetProductId(123); product.SetSalePrice(1000); product.SetQuantity(1);

    StovePCStartPurchaseParam params;
    params.CreateOrderProduct(1);
    params.SetOrderProduct(0, &product);
    // The Steam launcher injects the payment overlay, so leave StovePCPurchaseOption at its default.

    Game::ShopUI::SetPurchaseButtonEnabled(false);   // (developer pseudo-function) prevent double-clicks

    IAP_StartPurchase(&params,
        [](CallbackResult callbackResult, StovePCPurchaseResult purchaseResult)
        {
            // In the Steam flow, judge success/failure by CallbackResult alone.
            if (!callbackResult.GetResult().IsSuccessful())
            {
                Game::ShopUI::SetPurchaseButtonEnabled(true);   // (developer pseudo-function)
                return;
            }

            // (2) Only the transaction master number is a valid value. The payment URL, purchase progress, etc.
            //     are defaults, so the DEFAULT sample's NOT_NEED_PAYMENT_WINDOW branch isn't needed here.
            //     Keep this number and use it when the Steam payment result arrives.
            g_PendingTxnNo = purchaseResult.GetTransactionMasterNumber();
        });

    // Around this call the Steam launcher shows the payment overlay over the game (no developer UI needed).
}

// (3) Receive the Steam payment result — call this from Steamworks' MicroTxnAuthorizationResponse_t callback.
//     Registering the callback and calling SteamAPI_RunCallbacks() belong to the game's Steamworks SDK.
void OnSteamMicroTxnAuthorized(bool authorized)
{
    Game::ShopUI::SetPurchaseButtonEnabled(true);   // (developer pseudo-function)

    if (!authorized || g_PendingTxnNo == 0)
    {
        // The user canceled or it wasn't approved — no grant.
        g_PendingTxnNo = 0;
        return;
    }

    // Confirm the purchase with the kept transaction master number. The Steam flow has no auto-confirmation.
    IAP_ConfirmPurchase(g_PendingTxnNo, OnConfirmPurchase);
    g_PendingTxnNo = 0;
}

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// Confirm the purchase with the transaction master number obtained from the StartPurchase result.
void IAP_ConfirmPurchase_Example(int64_t transactionMasterNumber)
{
    IAP_ConfirmPurchase(
        transactionMasterNumber,
        [](CallbackResult callbackResult, bool isPurchased,
           StovePCPurchasedProduct* purchasedProducts, uint32_t purchasedProductsSize,
           StovePCChargeInfo* chargeInfos, uint32_t chargeInfosSize)
        {
            if (callbackResult.GetResult().IsSuccessful() && isPurchased)
            {
                // Grant the item after the game server's second verification
            }
            else
            {
                // Purchase-verification failure handling
            }
        });
}

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

IAP_FetchInventory(
    [](CallbackResult callbackResult, StovePCInventoryItem* inventoryItems, uint32_t inventoryItemSize)
    {
        if (callbackResult.GetResult().IsSuccessful())
        {
            // Build the inventory UI from inventoryItems[0..inventoryItemSize)
        }
    });

#include "IAPSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
using namespace Stove::PCSDK::IAP;

// 1) Show the game-withdrawal (terms-withdrawal) UI
StovePCWithdrawGameOption withdrawOption;
withdrawOption.SetWebviewMode(Base::WebViewMode::INTERNAL);
withdrawOption.SetWebviewRect(0, 0, 800, 600);
IAP_WithdrawGame(&withdrawOption,
    [](CallbackResult callbackResult, bool gameWithdraw)
    {
        if (callbackResult.GetResult().IsSuccessful() && gameWithdraw)
        {
            // Implement the logic for game-cancellation (terms-withdrawal) success.
        }
    },
    [](CallbackResult callbackResult)
    {
        // Implement the logic after the game-cancellation (terms-withdrawal) pop-up closes.
    });

// 2) Close all open payment windows at once
IAP_CloseAllPopups();