Google Pay

<script src="https://pay.google.com/gp/p/js/pay.js"></script>
<!-- or, as a component: npm install @google-pay/button-element -->

val moneyHash = MoneyHashSDKBuilder
    .setPublicKey("<YOUR_PUBLIC_API_KEY>")
    .apply {
        setNativeGooglePayConfig(NativeGooglePayConfig(
            environment = GooglePayEnvironment.TEST, // PRODUCTION before going live
        ))
    }
    .build()

final moneyHash = MoneyHashSDKBuilder()
    .setNativeGooglePayConfig(NativeGooglePayConfig(
      environment: GooglePayEnvironment.test, // production before going live
      collectibleBillingData: [],
    ))
    .build();

const moneyHash = MoneyHashSDKBuilder.setNativeGooglePayConfig({
  environment: GooglePayEnvironment.TEST, // PRODUCTION before going live
  collectibleBillingData: [],
}).build();

// The <google-pay-button> element checks isReadyToPay for you and
// only renders when Google Pay is available on this device/browser.

// In your Composable — create and bind the launcher once:
val googlePayLauncher = rememberGooglePayLauncher(object : GooglePayResultCallback {
    override fun onResult(result: IntentDetails) { viewModel.onGooglePayResult(result) }
    override fun onError(throwable: Throwable) { viewModel.onGooglePayFailed(throwable) }
    override fun onCancel() { viewModel.onGooglePayCancelled() } // sheet dismissed
})
BindEffect(googlePayLauncher)

// Then, before showing the button:
val isReady = googlePayLauncher.isReady(
    allowedCardNetworks = googlePayData.allowedCardNetworks,
    allowedCardAuthMethods = googlePayData.allowedCardAuthMethods,
)

if (!Platform.isAndroid) return; // Google Pay APIs throw off-Android
final isReady = await moneyHash.isReadyForGooglePay();
if (!isReady) return; // hide the button

if (Platform.OS !== "android") return; // Google Pay APIs reject off-Android
const isReady = await moneyHash.isReadyForGooglePay();
if (!isReady) return; // hide the button

const { expressMethods } = await moneyHash.getMethods({
  currency: "<currency>",
  amount: "<amount>",
});

const googlePayMethod = expressMethods.find((method) => method.id === "GOOGLE_PAY");
const googlePayNativeData = googlePayMethod?.nativePayData;

val methods = moneyHash.getMethods(
    intentId = "<YOUR_INTENT_ID>",
    intentType = IntentType.Payment
)

val googlePayMethod = methods.expressMethods?.firstOrNull { it.id == "GOOGLE_PAY" }
val googlePayData = googlePayMethod?.nativePayData as? NativePayData.GooglePay
    ?: return // Google Pay not available on this flow

final methods = await moneyHash.getMethods(
  GetMethodsParams.withIntent("<YOUR_INTENT_ID>", IntentType.payment),
);

final googlePayMethod =
    methods.expressMethods?.firstWhere((m) => m.id == "GOOGLE_PAY");
final googlePayData = googlePayMethod?.nativePayData as GooglePayData?;
if (googlePayData == null) return; // Google Pay not available on this flow

const methods = await moneyHash.getMethods("<YOUR_INTENT_ID>", IntentType.Payment);

const googlePayMethod = methods.expressMethods?.find((m) => m.id === "GOOGLE_PAY");
const googlePayData = googlePayMethod?.nativePayData;
if (!googlePayData) return; // Google Pay not available on this flow

import "@google-pay/button-element";

const button = document.querySelector("google-pay-button");

button.paymentRequest = {
  apiVersion: 2,
  apiVersionMinor: 0,
  allowedPaymentMethods: [{
    type: "CARD",
    parameters: {
      allowedAuthMethods: googlePayNativeData.allowed_card_auth_methods,
      allowedCardNetworks: googlePayNativeData.allowed_card_networks,
      billingAddressRequired: true,
    },
    tokenizationSpecification: {
      type: "PAYMENT_GATEWAY",
      parameters: {
        gateway: googlePayNativeData.gateway,
        gatewayMerchantId: googlePayNativeData.gateway_merchant_id,
      },
    },
  }],
  merchantInfo: {
    merchantId: googlePayNativeData.merchant_id,
    merchantName: googlePayNativeData.merchant_name,
  },
  transactionInfo: {
    totalPriceStatus: "FINAL",
    totalPriceLabel: "Total",
    totalPrice: `${googlePayNativeData.amount}`,
    currencyCode: googlePayNativeData.currency_code,
    countryCode: googlePayNativeData.country_code,
  },
  emailRequired: true,
};

moneyHash.proceedWithMethod(
    intentId = "<YOUR_INTENT_ID>",
    intentType = IntentType.Payment,
    selectedMethodId = "GOOGLE_PAY",
    methodType = MethodType.EXPRESS_METHOD,
    methodMetaData = null
)

await moneyHash.proceedWithMethod(
  "<YOUR_INTENT_ID>",
  IntentType.payment,
  "GOOGLE_PAY",
  MethodType.expressMethod,
  null, // methodMetaData
  null, // useWalletBalance
);

await moneyHash.proceedWithMethod(
  "<YOUR_INTENT_ID>",
  IntentType.Payment,
  "GOOGLE_PAY",
  MethodType.ExpressMethod
);

button.addEventListener("loadpaymentdata", async (event) => {
  const { paymentMethodData, email } = event.detail;

  const googlePayReceipt = {
    receipt: paymentMethodData.tokenizationData.token,
    receiptBillingData: { email },
  };

  try {
    await moneyHash.proceedWith({
      type: "method",
      id: "GOOGLE_PAY",
      intentId,
    });

    const intentDetails = await moneyHash.submitPaymentReceipt({
      intentId,
      nativeReceiptData: googlePayReceipt,
    });

    // Handle success
  } catch (error) {
    // Handle error
  }
});

button.addEventListener("cancel", () => {
  // Customer closed the Google Pay sheet
});

// Presents the sheet, submits the token, and reports through the
// GooglePayResultCallback you registered in Step 2:
googlePayLauncher.presentForPaymentIntent(
    "<YOUR_INTENT_ID>",
    googlePayData.currencyCode.orEmpty(),
    googlePayData.countryCode.orEmpty(),
    googlePayData.amount ?: 0.0,
    googlePayData.gateway.orEmpty(),
    googlePayData.gatewayMerchantID.orEmpty(),
    googlePayData.merchantId.orEmpty(),
    googlePayData.merchantName.orEmpty(),
    googlePayData.allowedCardNetworks,
    googlePayData.allowedCardAuthMethods
)

// in the callback: onResult(result: IntentDetails) → render the state

// Presents the sheet, submits the token, and resolves with the result:
final intentDetails = await moneyHash.proceedWithGooglePay(
  "<YOUR_INTENT_ID>",
  googlePayData.currencyCode!,
  googlePayData.amount!,
  googlePayData.countryCode!,
  googlePayData.gateway!,
  googlePayData.gatewayMerchantId!,
  googlePayData.merchantId!,
  googlePayData.merchantName!,
  googlePayData.allowedCardNetworks,
  googlePayData.allowedCardAuthMethods,
);

// Presents the sheet, submits the token, and resolves with the result:
const intentDetails = await moneyHash.proceedWithGooglePay({
  intentId: "<YOUR_INTENT_ID>",
  currency: googlePayData.currencyCode!,
  amount: googlePayData.amount!,
  countryCode: googlePayData.countryCode!,
  gateway: googlePayData.gateway!,
  gatewayMerchantId: googlePayData.gatewayMerchantId!,
  merchantId: googlePayData.merchantId!,
  merchantName: googlePayData.merchantName!,
  allowedCardNetworks: googlePayData.allowedCardNetworks,
  allowedCardAuthMethods: googlePayData.allowedCardAuthMethods,
});