Making International Remittances Easy with Pay by Phone

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";

// this function is called after Step #1
// querying the TA and turns out Receiver does have a pending TA
‍const createClaimSendToPhoneTransaction = async ({
 receiverStellarAddress,
 tempPayment,
 jwtTokens, // jwt token received from vibrant and lobstr recovery server
‍}: {
 receiverStellarAddress: string;
 tempPayment: Payment; // custom type
‍ jwtTokens: { [key: string]: string };
}) => {

/**
 * Step 2: Receiver constructs a transaction and gets it signed
 */
‍
// the payment the sender sent to the TA
‍ const { currency, amount, asset: USDC, tempAccountPubkey } = tempPayment;

// returns a horizon endpoint
‍ const horizon = getHorizon();

// returns an object of vibrant recovery server detail
‍ const localRecoveryServer = getLocalRecoveryServer();

// returns an object of lobstr recovery server detail
‍ const lobstrRecoveryServer = getLobstrRecoveryServer();

 const operations = [
 Operation.payment({
 destination: receiverStellarAddress,
 asset: USDC,
 amount,
 }),
 Operation.changeTrust({
 asset: USDC,
 limit: "0", // means we’re removing the trustline
‍ }),

 // accountMerge means we’re merging the TA to Receiver’s account
‍ // in another word, delete the TA account
‍ Operation.accountMerge({
 destination: receiverStellarAddress,
 }),
 ];

// building a transaction with operations we set from the above
‍ const transaction = await buildTransaction(
 {
 publicKey: tempAccountPubkey,
 operations,
 },
 );

 try {
// addRecoveryServerSignature calls
// SEP-30 POST /accounts/<TA’s pubkey>/sign/<signing-address>
// signs a transaction that has operations for the TA using the signing key of recovery servers
‍ 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,
 });
 }

/**
 * Step 3: Receivers submits the transaction
 */
‍ try {
 // fee bump the tx in order to submit the tx
‍ const feeBumpedTransaction = await feeBumpTransaction({ transaction });

 // we are submitting the tx that includes a payment operation
‍ // that transfers the funds from the TA to Receiver
‍ // tx has been fee bumped and signed by both recovery signers
‍ await horizon.submitTransaction(feeBumpedTransaction);

 // Once it’s submitted, we call removeTempAcctFromRecoverySigner
‍ // which calls SEP-30 DELETE /accounts/<TA’s address> to each
‍ // recovery server to delete the record for the TA since
‍ // it no longer exists on Stellar network
‍ await removeTempAcctFromRecoverySigner({
 publicKey: tempAccountPubkey,
 idToken: jwtTokens[localRecoveryServer.id],
 recoveryServer: localRecoveryServer,
 });

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