Cash In and Cash Out USDC with MoneyGram

npm install @getpara/react-sdk@3.23.0 @stellar/stellar-sdk@14.6.1

import { Asset, Horizon, Networks } from "@stellar/stellar-sdk";

const networkPassphrase = Networks.TESTNET;
const horizon = new Horizon.Server("https://horizon-testnet.stellar.org");
const usdc = new Asset("USDC", "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5");

import { useParaStellarSigner } from "@getpara/react-sdk";

const { stellarSigner } = useParaStellarSigner({ networkPassphrase });

import { BASE_FEE, Operation, TransactionBuilder } from "@stellar/stellar-sdk";

const account = await horizon.loadAccount(stellarSigner.address);

const hasUsdcTrustline = account.balances.some(
  (balance) =>
    "asset_code" in balance &&
    balance.asset_code === usdc.getCode() &&
    balance.asset_issuer === usdc.getIssuer(),
);

if (!hasUsdcTrustline) {
  const transaction = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase })
    .addOperation(Operation.changeTrust({ asset: usdc }))
    .setTimeout(180)
    .build();

  const { signedTxXdr } = await stellarSigner.signTransaction(transaction.toXDR());
  await horizon.submitTransaction(TransactionBuilder.fromXDR(signedTxXdr, networkPassphrase));
}

const response = await fetch(`${process.env.MONEYGRAM_API_URL}/v1/sessions`, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": process.env.MONEYGRAM_SECRET_KEY!,
  },
  body: JSON.stringify({ walletAddress, chain: "stellar" }),
});

const { sessionToken, widgetUrl } = await response.json();

import { Asset, BASE_FEE, Memo, Operation, TransactionBuilder } from "@stellar/stellar-sdk";

const onSignTransaction = async (payment: {
  to: string;
  amount: string;
  memo?: string;
  tokenAddress?: string;
  issuer?: string;
  requiredNetwork?: string;
}) => {
  if (payment.requiredNetwork !== "testnet") {
    throw new Error("MoneyGram payment is not for Stellar testnet");
  }

  const account = await horizon.loadAccount(stellarSigner.address);
  const asset = new Asset(payment.tokenAddress ?? "USDC", payment.issuer ?? usdc.getIssuer());

  const builder = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase })
    .addOperation(Operation.payment({ destination: payment.to, asset, amount: payment.amount }))
    .setTimeout(180);
  if (payment.memo) builder.addMemo(Memo.id(payment.memo.trim()));

  const { signedTxXdr } = await stellarSigner.signTransaction(builder.build().toXDR());
  const result = await horizon.submitTransaction(TransactionBuilder.fromXDR(signedTxXdr, networkPassphrase));
  return result.hash;
};

<script src="https://playground.xramps.moneygram.com/sdk/index.global.js"></script>

const mode = "off-ramp";

const url = new URL(widgetUrl);
url.searchParams.set("mode", mode);

const widget = window.RampsSDK.createRamps({
  container,
  sessionToken,
  widgetUrl: url.toString(),
  mode,
  wallet: {
    address: stellarSigner.address,
    chain: "stellar",
    asset: "USDC",
    walletType: "non-custodial",
  },
  transaction: { type: mode },
  onSignTransaction,
  onTransactionCreated,
  onComplete,
});

widget.open();

curl "$MONEYGRAM_API_URL/v1/transactions/$TRANSACTION_ID/status?sync=true" \
  -H "x-api-key: $MONEYGRAM_SECRET_KEY"

npm install @solana/kit@2.3.0 @solana-program/token@0.5.1

import { createSolanaRpc } from "@solana/kit";

const rpc = createSolanaRpc("https://api.devnet.solana.com");

import { useParaSolanaSigner } from "@getpara/react-sdk";

const { solanaSigner } = useParaSolanaSigner({ rpc });

import {
  address,
  appendTransactionMessageInstruction,
  createTransactionMessage,
  getBase64EncodedWireTransaction,
  pipe,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners,
} from "@solana/kit";
import { TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda, getTransferCheckedInstruction } from "@solana-program/token";

const onSignTransaction = async (payment: {
  to: string;
  amount: string;
  tokenAddress?: string;
  tokenDecimals?: number;
  requiredNetwork?: string;
}) => {
  if (payment.requiredNetwork !== "testnet") {
    throw new Error("MoneyGram payment is not for Solana devnet");
  }
  if (!payment.tokenAddress || payment.tokenDecimals === undefined) {
    throw new Error("MoneyGram payment is missing the USDC mint or decimals");
  }

  const mint = address(payment.tokenAddress);
  const decimals = payment.tokenDecimals;
  const [whole, fraction = ""] = payment.amount.split(".");
  if (fraction.length > decimals) throw new Error(`Amount has more than ${decimals} decimal places`);
  const amount = BigInt(whole + fraction.padEnd(decimals, "0"));

  const [source] = await findAssociatedTokenPda({ owner: solanaSigner.address, mint, tokenProgram: TOKEN_PROGRAM_ADDRESS });
  const [destination] = await findAssociatedTokenPda({ owner: address(payment.to), mint, tokenProgram: TOKEN_PROGRAM_ADDRESS });
  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

  const message = pipe(
    createTransactionMessage({ version: 0 }),
    (tx) => setTransactionMessageFeePayerSigner(solanaSigner, tx),
    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
    (tx) =>
      appendTransactionMessageInstruction(
        getTransferCheckedInstruction({ source, mint, destination, authority: solanaSigner, amount, decimals }),
        tx,
      ),
  );

  const signedTransaction = await signTransactionMessageWithSigners(message);
  return rpc.sendTransaction(getBase64EncodedWireTransaction(signedTransaction), { encoding: "base64" }).send();
};