Documentation GitHub npm

Source

lib/rpc/parsers.js

  1. "use strict";
  3. Object.defineProperty(exports, "__esModule", {
  4.   value: true
  5. });
  6. exports.parseRawEvents = parseRawEvents;
  7. exports.parseRawLedgerEntries = parseRawLedgerEntries;
  8. exports.parseRawSendTransaction = parseRawSendTransaction;
  9. exports.parseRawSimulation = parseRawSimulation;
  10. exports.parseRawTransactions = parseRawTransactions;
  11. exports.parseTransactionInfo = parseTransactionInfo;
  12. var _stellarBase = require("@stellar/stellar-base");
  13. var _api = require("./api");
  14. /**
  15.  * Parse the response from invoking the `submitTransaction` method of a Soroban RPC server.
  16.  * @memberof module:rpc
  17.  * @private
  18.  *
  19.  * @param {Api.RawSendTransactionResponse} raw the raw `submitTransaction` response from the Soroban RPC server to parse
  20.  * @returns {Api.SendTransactionResponse} transaction response parsed from the Soroban RPC server's response
  21.  */
  22. function parseRawSendTransaction(raw) {
  23.   const {
  24.     errorResultXdr,
  25.     diagnosticEventsXdr
  26.   } = raw;
  27.   delete raw.errorResultXdr;
  28.   delete raw.diagnosticEventsXdr;
  29.   if (errorResultXdr) {
  30.     return {
  31.       ...raw,
  32.       ...(diagnosticEventsXdr !== undefined && diagnosticEventsXdr.length > 0 && {
  33.         diagnosticEvents: diagnosticEventsXdr.map(evt => _stellarBase.xdr.DiagnosticEvent.fromXDR(evt, 'base64'))
  34.       }),
  35.       errorResult: _stellarBase.xdr.TransactionResult.fromXDR(errorResultXdr, 'base64')
  36.     };
  37.   }
  38.   return {
  39.     ...raw
  40.   };
  41. }
  42. function parseTransactionInfo(raw) {
  43.   const meta = _stellarBase.xdr.TransactionMeta.fromXDR(raw.resultMetaXdr, 'base64');
  44.   const info = {
  45.     ledger: raw.ledger,
  46.     createdAt: raw.createdAt,
  47.     applicationOrder: raw.applicationOrder,
  48.     feeBump: raw.feeBump,
  49.     envelopeXdr: _stellarBase.xdr.TransactionEnvelope.fromXDR(raw.envelopeXdr, 'base64'),
  50.     resultXdr: _stellarBase.xdr.TransactionResult.fromXDR(raw.resultXdr, 'base64'),
  51.     resultMetaXdr: meta
  52.   };
  53.   if (meta.switch() === 3 && meta.v3().sorobanMeta() !== null) {
  54.     info.returnValue = meta.v3().sorobanMeta()?.returnValue();
  55.   }
  56.   if ('diagnosticEventsXdr' in raw && raw.diagnosticEventsXdr) {
  57.     info.diagnosticEventsXdr = raw.diagnosticEventsXdr.map(diagnosticEvent => _stellarBase.xdr.DiagnosticEvent.fromXDR(diagnosticEvent, 'base64'));
  58.   }
  59.   return info;
  60. }
  61. function parseRawTransactions(r) {
  62.   return {
  63.     status: r.status,
  64.     txHash: r.txHash,
  65.     ...parseTransactionInfo(r)
  66.   };
  67. }
  69. /**
  70.  * Parse and return the retrieved events, if any, from a raw response from a Soroban RPC server.
  71.  * @memberof module:rpc
  72.  *
  73.  * @param {Api.RawGetEventsResponse} raw the raw `getEvents` response from the Soroban RPC server to parse
  74.  * @returns {Api.GetEventsResponse} events parsed from the Soroban RPC server's response
  75.  */
  76. function parseRawEvents(raw) {
  77.   return {
  78.     latestLedger: raw.latestLedger,
  79.     cursor: raw.cursor,
  80.     events: (raw.events ?? []).map(evt => {
  81.       const clone = {
  82.         ...evt
  83.       };
  84.       delete clone.contractId; // `as any` hack because contractId field isn't optional
  86.       // the contractId may be empty so we omit the field in that case
  87.       return {
  88.         ...clone,
  89.         ...(evt.contractId !== '' && {
  90.           contractId: new _stellarBase.Contract(evt.contractId)
  91.         }),
  92.         topic: evt.topic.map(topic => _stellarBase.xdr.ScVal.fromXDR(topic, 'base64')),
  93.         value: _stellarBase.xdr.ScVal.fromXDR(evt.value, 'base64')
  94.       };
  95.     })
  96.   };
  97. }
  99. /**
  100.  * Parse and return the retrieved ledger entries, if any, from a raw response from a Soroban RPC server.
  101.  * @memberof module:rpc
  102.  * @private
  103.  *
  104.  * @param {Api.RawGetLedgerEntriesResponse} raw he raw `getLedgerEntries` response from the Soroban RPC server to parse
  105.  * @returns {Api.GetLedgerEntriesResponse} ledger entries parsed from the Soroban RPC server's response
  106.  */
  107. function parseRawLedgerEntries(raw) {
  108.   return {
  109.     latestLedger: raw.latestLedger,
  110.     entries: (raw.entries ?? []).map(rawEntry => {
  111.       if (!rawEntry.key || !rawEntry.xdr) {
  112.         throw new TypeError(`invalid ledger entry: ${JSON.stringify(rawEntry)}`);
  113.       }
  114.       return {
  115.         lastModifiedLedgerSeq: rawEntry.lastModifiedLedgerSeq,
  116.         key: _stellarBase.xdr.LedgerKey.fromXDR(rawEntry.key, 'base64'),
  117.         val: _stellarBase.xdr.LedgerEntryData.fromXDR(rawEntry.xdr, 'base64'),
  118.         ...(rawEntry.liveUntilLedgerSeq !== undefined && {
  119.           liveUntilLedgerSeq: rawEntry.liveUntilLedgerSeq
  120.         })
  121.       };
  122.     })
  123.   };
  124. }
  126. /**
  127.  * Parse whether or not the transaction simulation was successful, returning the relevant response.
  128.  * @memberof module:rpc
  129.  * @private
  130.  *
  131.  * @param {Api.RawSimulateTransactionResponse} sim a raw response from the `simulateTransaction` method of the Soroban RPC server to parse
  132.  * @param {Api.BaseSimulateTransactionResponse} partial a partially built simulate transaction response that will be used to build the return response
  133.  * @returns {Api.SimulateTransactionRestoreResponse | Api.SimulateTransactionSuccessResponse} Either a simulation response indicating what ledger entries should be restored, or if the simulation was successful.
  134.  */
  135. function parseSuccessful(sim, partial) {
  136.   // success type: might have a result (if invoking) and...
  137.   const success = {
  138.     ...partial,
  139.     transactionData: new _stellarBase.SorobanDataBuilder(sim.transactionData),
  140.     minResourceFee: sim.minResourceFee,
  141.     // coalesce 0-or-1-element results[] list into a single result struct
  142.     // with decoded fields if present
  143.     // eslint-disable-next-line no-self-compare
  144.     ...((sim.results?.length ?? 0 > 0) && {
  145.       result: sim.results.map(row => ({
  146.         auth: (row.auth ?? []).map(entry => _stellarBase.xdr.SorobanAuthorizationEntry.fromXDR(entry, 'base64')),
  147.         // if return value is missing ("falsy") we coalesce to void
  148.         retval: row.xdr ? _stellarBase.xdr.ScVal.fromXDR(row.xdr, 'base64') : _stellarBase.xdr.ScVal.scvVoid()
  149.       }))[0]
  150.     }),
  151.     // eslint-disable-next-line no-self-compare
  152.     ...((sim.stateChanges?.length ?? 0 > 0) && {
  153.       stateChanges: sim.stateChanges?.map(entryChange => ({
  154.         type: entryChange.type,
  155.         key: _stellarBase.xdr.LedgerKey.fromXDR(entryChange.key, 'base64'),
  156.         before: entryChange.before ? _stellarBase.xdr.LedgerEntry.fromXDR(entryChange.before, 'base64') : null,
  157.         after: entryChange.after ? _stellarBase.xdr.LedgerEntry.fromXDR(entryChange.after, 'base64') : null
  158.       }))
  159.     })
  160.   };
  161.   if (!sim.restorePreamble || sim.restorePreamble.transactionData === '') {
  162.     return success;
  163.   }
  165.   // ...might have a restoration hint (if some state is expired)
  166.   return {
  167.     ...success,
  168.     restorePreamble: {
  169.       minResourceFee: sim.restorePreamble.minResourceFee,
  170.       transactionData: new _stellarBase.SorobanDataBuilder(sim.restorePreamble.transactionData)
  171.     }
  172.   };
  173. }
  175. /**
  176.  * Converts a raw response schema into one with parsed XDR fields and a simplified interface.
  177.  * @warning This API is only exported for testing purposes and should not be relied on or considered "stable".
  178.  * @memberof module:rpc
  179.  *
  180.  * @param {Api.SimulateTransactionResponse | Api.RawSimulateTransactionResponse} sim the raw response schema (parsed ones are allowed, best-effort
  181.  *    detected, and returned untouched)
  182.  * @returns {Api.SimulateTransactionResponse} the original parameter (if already parsed), parsed otherwise
  183.  */
  184. function parseRawSimulation(sim) {
  185.   const looksRaw = _api.Api.isSimulationRaw(sim);
  186.   if (!looksRaw) {
  187.     // Gordon Ramsey in shambles
  188.     return sim;
  189.   }
  191.   // shared across all responses
  192.   const base = {
  193.     _parsed: true,
  194.     id: sim.id,
  195.     latestLedger: sim.latestLedger,
  196.     events: sim.events?.map(evt => _stellarBase.xdr.DiagnosticEvent.fromXDR(evt, 'base64')) ?? []
  197.   };
  199.   // error type: just has error string
  200.   if (typeof sim.error === 'string') {
  201.     return {
  202.       ...base,
  203.       error: sim.error
  204.     };
  205.   }
  206.   return parseSuccessful(sim, base);
  207. }