Haciendo las Remesas Internacionales Fáciles con Pagar por Teléfono

import {
Operation,
} from "stellar-sdk";

function createVibrantTempAccount({
 senderStellarAddress,
 amount, // 3
‍ asset,
 phoneNumber,
}: {
 senderStellarAddress: string;
 amount: string;
 asset: Currency; // custom type
‍ phoneNumber: string;
}) {

/**
 * Step 1: Sender registers the temp account public key with the two recovery servers
 */
// generateStellarAccount() uses stellar-sdk’s Keypair to
// return temporary account’s public and private key
// make sure to follow the best practice to secure a private key
// https://stellar.github.io/js-stellar-sdk/Keypair.html
‍ const receiverTempAccount = generateStellarAccount();
 const USDC = asset;
// recoverysignerSigningKeys includes both recovery servers’ signatures
// that Sender registered earlier by calling
// SEP-30 POST /accounts/<TA's public key> with
// two identities “sender” and “receiver”
‍ let recoverysignerSigningKeys: Signer[] = [{...vibrant recovery server info}, {...lobstr recovery server info}];
// vibrant distribution account is the sponsor of the TA we’re creating
‍ let vibrantDistributionAccountPubkey: string = "GDEZ...";
‍
/**
 * Step 2: Sender constructs a transaction (tx) for backend and backend returns a partially signed tx
 */

// signerSetOptions will be used within operations = [] later
‍ const signerSetOptions = recoverysignerSigningKeys.map((signer) =>
 Operation.setOptions({
 signer: {
 ed25519PublicKey: signer.publicKey,
 weight: 10, // each recovery server to have weight of 10
‍ },
 source: receiverTempAccount.publicKey,
 }),
 );

 const operations = [
// beginSponsoringFutureReserves is needed to cover the initial funding needed for creating a TA, its trustline, and setting signers to the TA
//https://developers.stellar.org/docs/encyclopedia/sponsored-reserves#begin-and-end-sponsorships
‍ Operation.beginSponsoringFutureReserves({
 sponsoredId: receiverTempAccount.publicKey,
 source: vibrantDistributionAccountPubkey,
 }),

 Operation.createAccount({
 destination: receiverTempAccount.publicKey,
 startingBalance: "0",
 source: vibrantDistributionAccountPubkey,
 }),

 Operation.changeTrust({
 source: receiverTempAccount.publicKey,
 asset: USDC,
 }),

 ...signerSetOptions,

// endSponsoringFutureReserves allows the sponsored account (TA) to accept the sponsorship
// both Begin Sponsoring Future Reserves and End Sponsoring Future Reserves operations must appear in the sponsorship transaction, guaranteeing that both accounts agree to the sponsorship
‍ Operation.endSponsoringFutureReserves({
 source: receiverTempAccount.publicKey,
 }),

// setOptions to set TA account’s own signature weight and threshold values. // masterWeight to 0 so the TA account can’t do any kind of transaction on its own
// Setting all the thresholds to 20 so that once both recovery signers sign (10 weight + 10 weight = 20), they can access the account
// list of operations with thresholds: https://developers.stellar.org/docs/fundamentals-and-concepts/list-of-operations
‍ Operation.setOptions({
 masterWeight: 20,
 lowThreshold: 20,
 medThreshold: 20,
 highThreshold: 20,
 source: receiverTempAccount.publicKey,
 }),

// payment operation:
// sending 3 USDC from Sender to TA
‍ Operation.payment({
 destination: receiverTempAccount.publicKey,
 asset: USDC, // any Stellar asset works
‍ amount, // “3”
‍ source: senderStellarAddress,
 }),
 ];

// building a tx with operations we set from the above
// we use TransactionBuilder from js-stellar-sdk in this custom function
‍ const transaction = await buildTransaction(
 {
 publicKey: senderStellarAddress,
 operations,
 }
 );

/**
 * Step 3: Sender signs and submits the transaction
 */
‍ try {
 // Sender signs the tx with Sender's device key
‍ // and the TA’s private key
‍ await signWithKeyManager({
 transaction,
 signer: SENDER_DEVICE_KEY,
 });
 await signWithKeyManager({
 transaction,
 signer: TEMP_ACCOUNT_PRIVATE_KEY,
 });
 }

 try {
 // call the backend endpoint that validates and signs the tx,
‍ // fee-bumps it, and submits it to Horizon
‍ // TA account’s now created on Stellar network
‍ await appApi.createTempAccountAndSendPayment({
 transaction: transaction.toXDR(),
 phoneNumber,
 });
 }

import {
 Operation,
} from "stellar-sdk";

// esta función se llama después del Paso #1
// consultando el TA y resulta que el Receptor sí tiene un TA pendiente
‍const createClaimSendToPhoneTransaction = async ({
 receiverStellarAddress,
 tempPayment,
 jwtTokens, // jwt token recibido de vibrant y lobstr recovery server
‍}: {
 receiverStellarAddress: string;
 tempPayment: Payment; // tipo personalizado
‍ jwtTokens: { [key: string]: string };
}) => {

/**
 * Paso 2: El receptor construye una transacción y la firma
 */
‍
// el pago que el remitente envió al TA
‍ const { currency, amount, asset: USDC, tempAccountPubkey } = tempPayment;

// devuelve un endpoint de horizon
‍ const horizon = getHorizon();

// devuelve un objeto de detalle del servidor de recuperación de vibrant
‍ const localRecoveryServer = getLocalRecoveryServer();

// devuelve un objeto de detalle del servidor de recuperación de lobstr
‍ const lobstrRecoveryServer = getLobstrRecoveryServer();

 const operations = [
 Operation.payment({
 destination: receiverStellarAddress,
 asset: USDC,
 amount,
 }),
 Operation.changeTrust({
 asset: USDC,
 limit: "0", // significa que estamos eliminando la línea de confianza
‍ }),

 // accountMerge significa que estamos fusionando el TA a la cuenta del Receptor
‍ // en otras palabras, eliminar la cuenta del TA
‍ Operation.accountMerge({
 destination: receiverStellarAddress,
 }),
 ];

// construyendo una transacción con operaciones que establecimos desde arriba
‍ const transaction = await buildTransaction(
 {
 publicKey: tempAccountPubkey,
 operations,
 },
 );

 try {
// addRecoveryServerSignature llama
// SEP-30 POST /accounts/<TA’s pubkey>/sign/<signing-address>
// firma una transacción que tiene operaciones para el TA usando la llave de firma de servidores de recuperación
‍ await addRecoveryServerSignature({
 publicKey: tempAccountPubkey,
 transaction,
 idToken: jwtTokens[localRecoveryServer.id],
 recoveryServer: localRecoveryServer,
 signerKey: localRecoveryServer.publicKey,
 });

 await addRecoveryServerSignature({
 publicKey: tempAccountPubkey,
 transaction,
 idToken: jwtTokens[lobstrRecoveryServer.id],
 recoveryServer: lobstrRecoveryServer,
 signerKey: lobstrRecoveryServer.publicKey,
 });
 }

/**
 * Paso 3: El receptor envía la transacción
 */
‍ try {
 // aumentar la tarifa de la tx para poder enviar la tx
‍ const feeBumpedTransaction = await feeBumpTransaction({ transaction });

 // estamos enviando la tx que incluye una operación de pago
‍ // que transfiere los fondos del TA al Receptor
‍ // la tx ha sido aumentada de tarifa y firmada por ambos firmantes de recuperación
‍ await horizon.submitTransaction(feeBumpedTransaction);

 // Una vez que se envía, llamamos a removeTempAcctFromRecoverySigner
‍ // que llama a SEP-30 DELETE /accounts/<TA’s address> a cada
‍ // servidor de recuperación para eliminar el registro del TA ya que
‍ // ya no existe en la red de Stellar
‍ await removeTempAcctFromRecoverySigner({
 publicKey: tempAccountPubkey,
 idToken: jwtTokens[localRecoveryServer.id],
 recoveryServer: localRecoveryServer,
 });

 await removeAccountFromRecoverySignerWithToken({
 publicKey: tempAccountPubkey,
 idToken: jwtTokens[lobstrRecoveryServer.id],
 recoveryServer: lobstrRecoveryServer,
 });
 }
};