lib/server.js

  1. "use strict";
  3. Object.defineProperty(exports, "__esModule", {
  4.   value: true
  5. });
  6. exports.Server = exports.SUBMIT_TRANSACTION_TIMEOUT = exports.Durability = void 0;
  7. var _urijs = _interopRequireDefault(require("urijs"));
  8. var _stellarBase = require("stellar-base");
  9. var _axios = _interopRequireDefault(require("./axios"));
  10. var jsonrpc = _interopRequireWildcard(require("./jsonrpc"));
  11. var _soroban_rpc = require("./soroban_rpc");
  12. var _transaction = require("./transaction");
  13. var _parsers = require("./parsers");
  14. function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
  15. function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
  16. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  17. /* tslint:disable:variable-name no-namespace */
  19. const SUBMIT_TRANSACTION_TIMEOUT = exports.SUBMIT_TRANSACTION_TIMEOUT = 60 * 1000;
  21. /**
  22.  * Specifies the durability namespace of contract-related ledger entries.
  23.  */
  24. let Durability = exports.Durability = /*#__PURE__*/function (Durability) {
  25.   Durability["Temporary"] = "temporary";
  26.   Durability["Persistent"] = "persistent";
  27.   return Durability;
  28. }({});
  29. /**
  30.  * Handles the network connection to a Soroban RPC instance, exposing an
  31.  * interface for requests to that instance.
  32.  *
  33.  * @constructor
  34.  *
  35.  * @param {string} serverURL Soroban-RPC Server URL (ex.
  36.  *    `http://localhost:8000/soroban/rpc`).
  37.  * @param {object} [opts] Options object
  38.  * @param {boolean} [opts.allowHttp]  allows connecting to insecure http servers
  39.  *    (default: `false`). This must be set to false in production deployments!
  40.  *    You can also use {@link Config} class to set this globally.
  41.  * @param {Record<string, string>} [opts.headers] allows setting custom headers
  42.  *
  43.  * @see https://soroban.stellar.org/api/methods
  44.  */
  45. class Server {
  46.   /** Soroban RPC Server URL (ex. `http://localhost:8000/soroban/rpc`). */
  48.   constructor(serverURL, opts = {}) {
  49.     this.serverURL = (0, _urijs.default)(serverURL);
  50.     if (opts.headers && Object.keys(opts.headers).length === 0) {
  51.       _axios.default.interceptors.request.use(config => {
  52.         // merge the custom headers into any existing headers
  53.         config.headers = Object.assign(config.headers, opts.headers);
  54.         return config;
  55.       });
  56.     }
  57.     if (this.serverURL.protocol() !== 'https' && !opts.allowHttp) {
  58.       throw new Error("Cannot connect to insecure Soroban RPC server if `allowHttp` isn't set");
  59.     }
  60.   }
  62.   /**
  63.    * Fetch a minimal set of current info about a Stellar account.
  64.    *
  65.    * Needed to get the current sequence number for the account so you can build
  66.    * a successful transaction with {@link TransactionBuilder}.
  67.    *
  68.    * @param {string} address - The public address of the account to load.
  69.    *
  70.    * @returns {Promise<Account>}  a promise to the {@link Account} object with
  71.    *    a populated sequence number
  72.    *
  73.    * @see https://soroban.stellar.org/api/methods/getLedgerEntries
  74.    * @example
  75.    * const accountId = "GBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4";
  76.    * server.getAccount(accountId).then((account) => {
  77.    *   console.log("sequence:", account.sequence);
  78.    * });
  79.    */
  80.   async getAccount(address) {
  81.     const ledgerKey = _stellarBase.xdr.LedgerKey.account(new _stellarBase.xdr.LedgerKeyAccount({
  82.       accountId: _stellarBase.Keypair.fromPublicKey(address).xdrPublicKey()
  83.     }));
  84.     const resp = await this.getLedgerEntries(ledgerKey);
  85.     if (resp.entries.length === 0) {
  86.       return Promise.reject({
  87.         code: 404,
  88.         message: `Account not found: ${address}`
  89.       });
  90.     }
  91.     const accountEntry = resp.entries[0].val.account();
  92.     return new _stellarBase.Account(address, accountEntry.seqNum().toString());
  93.   }
  95.   /**
  96.    * General node health check.
  97.    *
  98.    * @returns {Promise<SorobanRpc.GetHealthResponse>}   a promise to the
  99.    *    {@link SorobanRpc.GetHealthResponse} object with the status of the
  100.    *    server (e.g. "healthy").
  101.    *
  102.    * @see https://soroban.stellar.org/api/methods/getHealth
  103.    * @example
  104.    * server.getHealth().then((health) => {
  105.    *   console.log("status:", health.status);
  106.    * });
  107.    */
  108.   async getHealth() {
  109.     return jsonrpc.post(this.serverURL.toString(), 'getHealth');
  110.   }
  112.   /**
  113.    * Reads the current value of contract data ledger entries directly.
  114.    *
  115.    * Allows you to directly inspect the current state of a contract. This is a
  116.    * backup way to access your contract data which may not be available via
  117.    * events or {@link Server.simulateTransaction}.
  118.    *
  119.    * @param {string|Address|Contract} contract    the contract ID containing the
  120.    *    data to load as a strkey (`C...` form), a {@link Contract}, or an
  121.    *    {@link Address} instance
  122.    * @param {xdr.ScVal} key   the key of the contract data to load
  123.    * @param {Durability} [durability=Durability.Persistent]   the "durability
  124.    *    keyspace" that this ledger key belongs to, which is either 'temporary'
  125.    *    or 'persistent' (the default), see {@link Durability}.
  126.    *
  127.    * @returns {Promise<SorobanRpc.LedgerEntryResult>}   the current data value
  128.    *
  129.    * @warning If the data entry in question is a 'temporary' entry, it's
  130.    *    entirely possible that it has expired out of existence.
  131.    *
  132.    * @see https://soroban.stellar.org/api/methods/getLedgerEntries
  133.    * @example
  134.    * const contractId = "CCJZ5DGASBWQXR5MPFCJXMBI333XE5U3FSJTNQU7RIKE3P5GN2K2WYD5";
  135.    * const key = xdr.ScVal.scvSymbol("counter");
  136.    * server.getContractData(contractId, key, Durability.Temporary).then(data => {
  137.    *   console.log("value:", data.val);
  138.    *   console.log("liveUntilLedgerSeq:", data.liveUntilLedgerSeq);
  139.    *   console.log("lastModified:", data.lastModifiedLedgerSeq);
  140.    *   console.log("latestLedger:", data.latestLedger);
  141.    * });
  142.    */
  143.   async getContractData(contract, key, durability = Durability.Persistent) {
  144.     // coalesce `contract` param variants to an ScAddress
  145.     let scAddress;
  146.     if (typeof contract === 'string') {
  147.       scAddress = new _stellarBase.Contract(contract).address().toScAddress();
  148.     } else if (contract instanceof _stellarBase.Address) {
  149.       scAddress = contract.toScAddress();
  150.     } else if (contract instanceof _stellarBase.Contract) {
  151.       scAddress = contract.address().toScAddress();
  152.     } else {
  153.       throw new TypeError(`unknown contract type: ${contract}`);
  154.     }
  155.     let xdrDurability;
  156.     switch (durability) {
  157.       case Durability.Temporary:
  158.         xdrDurability = _stellarBase.xdr.ContractDataDurability.temporary();
  159.         break;
  160.       case Durability.Persistent:
  161.         xdrDurability = _stellarBase.xdr.ContractDataDurability.persistent();
  162.         break;
  163.       default:
  164.         throw new TypeError(`invalid durability: ${durability}`);
  165.     }
  166.     let contractKey = _stellarBase.xdr.LedgerKey.contractData(new _stellarBase.xdr.LedgerKeyContractData({
  167.       key,
  168.       contract: scAddress,
  169.       durability: xdrDurability
  170.     }));
  171.     return this.getLedgerEntries(contractKey).then(r => {
  172.       if (r.entries.length === 0) {
  173.         return Promise.reject({
  174.           code: 404,
  175.           message: `Contract data not found. Contract: ${_stellarBase.Address.fromScAddress(scAddress).toString()}, Key: ${key.toXDR('base64')}, Durability: ${durability}`
  176.         });
  177.       }
  178.       return r.entries[0];
  179.     });
  180.   }
  182.   /**
  183.    * Reads the current value of arbitrary ledger entries directly.
  184.    *
  185.    * Allows you to directly inspect the current state of contracts, contract's
  186.    * code, accounts, or any other ledger entries.
  187.    *
  188.    * To fetch a contract's WASM byte-code, built the appropriate
  189.    * {@link xdr.LedgerKeyContractCode} ledger entry key (or see
  190.    * {@link Contract.getFootprint}).
  191.    *
  192.    * @param {xdr.ScVal[]} keys  one or more ledger entry keys to load
  193.    *
  194.    * @returns {Promise<SorobanRpc.GetLedgerEntriesResponse>}  the current
  195.    *    on-chain values for the given ledger keys
  196.    *
  197.    * @see Server._getLedgerEntries
  198.    * @see https://soroban.stellar.org/api/methods/getLedgerEntries
  199.    * @example
  200.    * const contractId = "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM";
  201.    * const key = xdr.LedgerKey.contractData(new xdr.LedgerKeyContractData({
  202.    *   contractId: StrKey.decodeContract(contractId),
  203.    *   key: xdr.ScVal.scvSymbol("counter"),
  204.    * }));
  205.    *
  206.    * server.getLedgerEntries([key]).then(response => {
  207.    *   const ledgerData = response.entries[0];
  208.    *   console.log("key:", ledgerData.key);
  209.    *   console.log("value:", ledgerData.val);
  210.    *   console.log("liveUntilLedgerSeq:", ledgerData.liveUntilLedgerSeq);
  211.    *   console.log("lastModified:", ledgerData.lastModifiedLedgerSeq);
  212.    *   console.log("latestLedger:", response.latestLedger);
  213.    * });
  214.    */
  215.   async getLedgerEntries(...keys) {
  216.     return this._getLedgerEntries(...keys).then(_parsers.parseRawLedgerEntries);
  217.   }
  218.   async _getLedgerEntries(...keys) {
  219.     return jsonrpc.post(this.serverURL.toString(), 'getLedgerEntries', keys.map(k => k.toXDR('base64')));
  220.   }
  222.   /**
  223.    * Fetch the details of a submitted transaction.
  224.    *
  225.    * After submitting a transaction, clients should poll this to tell when the
  226.    * transaction has completed.
  227.    *
  228.    * @param {string} hash   hex-encoded hash of the transaction to check
  229.    *
  230.    * @returns {Promise<SorobanRpc.GetTransactionResponse>}  the status,
  231.    *    result, and other details about the transaction
  232.    *
  233.    * @see https://soroban.stellar.org/api/methods/getTransaction
  234.    * @example
  235.    * const transactionHash = "c4515e3bdc0897f21cc5dbec8c82cf0a936d4741cb74a8e158eb51b9fb00411a";
  236.    * server.getTransaction(transactionHash).then((tx) => {
  237.    *   console.log("status:", tx.status);
  238.    *   console.log("envelopeXdr:", tx.envelopeXdr);
  239.    *   console.log("resultMetaXdr:", tx.resultMetaXdr);
  240.    *   console.log("resultXdr:", tx.resultXdr);
  241.    * });
  242.    */
  243.   async getTransaction(hash) {
  244.     return this._getTransaction(hash).then(raw => {
  245.       let successInfo = {};
  246.       if (raw.status === _soroban_rpc.SorobanRpc.GetTransactionStatus.SUCCESS) {
  247.         var _meta$v3$sorobanMeta;
  248.         const meta = _stellarBase.xdr.TransactionMeta.fromXDR(raw.resultMetaXdr, 'base64');
  249.         successInfo = {
  250.           ledger: raw.ledger,
  251.           createdAt: raw.createdAt,
  252.           applicationOrder: raw.applicationOrder,
  253.           feeBump: raw.feeBump,
  254.           envelopeXdr: _stellarBase.xdr.TransactionEnvelope.fromXDR(raw.envelopeXdr, 'base64'),
  255.           resultXdr: _stellarBase.xdr.TransactionResult.fromXDR(raw.resultXdr, 'base64'),
  256.           resultMetaXdr: meta,
  257.           ...(meta.switch() === 3 && meta.v3().sorobanMeta() !== null && {
  258.             returnValue: (_meta$v3$sorobanMeta = meta.v3().sorobanMeta()) === null || _meta$v3$sorobanMeta === void 0 ? void 0 : _meta$v3$sorobanMeta.returnValue()
  259.           })
  260.         };
  261.       }
  262.       const result = {
  263.         status: raw.status,
  264.         latestLedger: raw.latestLedger,
  265.         latestLedgerCloseTime: raw.latestLedgerCloseTime,
  266.         oldestLedger: raw.oldestLedger,
  267.         oldestLedgerCloseTime: raw.oldestLedgerCloseTime,
  268.         ...successInfo
  269.       };
  270.       return result;
  271.     });
  272.   }
  273.   async _getTransaction(hash) {
  274.     return jsonrpc.post(this.serverURL.toString(), 'getTransaction', hash);
  275.   }
  277.   /**
  278.    * Fetch all events that match a given set of filters.
  279.    *
  280.    * The given filters (see {@link SorobanRpc.EventFilter} for detailed fields)
  281.    * are combined only in a logical OR fashion, and all of the fields in each
  282.    * filter are optional.
  283.    *
  284.    * To page through events, use the `pagingToken` field on the relevant
  285.    * {@link SorobanRpc.EventResponse} object to set the `cursor` parameter.
  286.    *
  287.    * @param {Server.GetEventsRequest} request   event filters
  288.    * @returns {Promise<SorobanRpc.GetEventsResponse>}   a paginatable set of the
  289.    *    events matching the given event filters
  290.    *
  291.    * @see https://soroban.stellar.org/api/methods/getEvents
  292.    * @example
  293.    * server.getEvents({
  294.    *    startLedger: 1000,
  295.    *    filters: [
  296.    *     {
  297.    *      type: "contract",
  298.    *      contractIds: [ "deadb33f..." ],
  299.    *      topics: [[ "AAAABQAAAAh0cmFuc2Zlcg==", "AAAAAQB6Mcc=", "*" ]]
  300.    *     }, {
  301.    *      type: "system",
  302.    *      contractIds: [ "...c4f3b4b3..." ],
  303.    *      topics: [[ "*" ], [ "*", "AAAAAQB6Mcc=" ]]
  304.    *     }, {
  305.    *      contractIds: [ "...c4f3b4b3..." ],
  306.    *      topics: [[ "AAAABQAAAAh0cmFuc2Zlcg==" ]]
  307.    *     }, {
  308.    *      type: "diagnostic",
  309.    *      topics: [[ "AAAAAQB6Mcc=" ]]
  310.    *     }
  311.    *    ],
  312.    *    limit: 10,
  313.    * });
  314.    */
  315.   async getEvents(request) {
  316.     return this._getEvents(request).then(_parsers.parseRawEvents);
  317.   }
  318.   async _getEvents(request) {
  319.     return jsonrpc.postObject(this.serverURL.toString(), 'getEvents', {
  320.       filters: request.filters ?? [],
  321.       pagination: {
  322.         ...(request.cursor && {
  323.           cursor: request.cursor
  324.         }),
  325.         // add if defined
  326.         ...(request.limit && {
  327.           limit: request.limit
  328.         })
  329.       },
  330.       ...(request.startLedger && {
  331.         startLedger: request.startLedger
  332.       })
  333.     });
  334.   }
  336.   /**
  337.    * Fetch metadata about the network this Soroban RPC server is connected to.
  338.    *
  339.    * @returns {Promise<SorobanRpc.GetNetworkResponse>}  metadata about the
  340.    *    current network this RPC server is connected to
  341.    *
  342.    * @see https://soroban.stellar.org/api/methods/getNetwork
  343.    * @example
  344.    * server.getNetwork().then((network) => {
  345.    *   console.log("friendbotUrl:", network.friendbotUrl);
  346.    *   console.log("passphrase:", network.passphrase);
  347.    *   console.log("protocolVersion:", network.protocolVersion);
  348.    * });
  349.    */
  350.   async getNetwork() {
  351.     return await jsonrpc.post(this.serverURL.toString(), 'getNetwork');
  352.   }
  354.   /**
  355.    * Fetch the latest ledger meta info from network which this Soroban RPC
  356.    * server is connected to.
  357.    *
  358.    * @returns {Promise<SorobanRpc.GetLatestLedgerResponse>}   metadata about the
  359.    *    latest ledger on the network that this RPC server is connected to
  360.    *
  361.    * @see https://soroban.stellar.org/api/methods/getLatestLedger
  362.    * @example
  363.    * server.getLatestLedger().then((response) => {
  364.    *   console.log("hash:", response.id);
  365.    *   console.log("sequence:", response.sequence);
  366.    *   console.log("protocolVersion:", response.protocolVersion);
  367.    * });
  368.    */
  369.   async getLatestLedger() {
  370.     return jsonrpc.post(this.serverURL.toString(), 'getLatestLedger');
  371.   }
  373.   /**
  374.    * Submit a trial contract invocation to get back return values, expected
  375.    * ledger footprint, expected authorizations, and expected costs.
  376.    *
  377.    * @param {Transaction | FeeBumpTransaction} transaction  the transaction to
  378.    *    simulate, which should include exactly one operation (one of
  379.    *    {@link xdr.InvokeHostFunctionOp}, {@link xdr.ExtendFootprintTTLOp},
  380.    *    or {@link xdr.RestoreFootprintOp}). Any provided footprint or auth
  381.    *    information will be ignored.
  382.    *
  383.    * @returns {Promise<SorobanRpc.SimulateTransactionResponse>}   an object with
  384.    *    the cost, footprint, result/auth requirements (if applicable), and error
  385.    *    of the transaction
  386.    *
  387.    * @see https://developers.stellar.org/docs/glossary/transactions/
  388.    * @see https://soroban.stellar.org/api/methods/simulateTransaction
  389.    * @see Server.prepareTransaction
  390.    * @see assembleTransaction
  391.    *
  392.    * @example
  393.    * const contractId = 'CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE';
  394.    * const contract = new SorobanClient.Contract(contractId);
  395.    *
  396.    * // Right now, this is just the default fee for this example.
  397.    * const fee = SorobanClient.BASE_FEE;
  398.    * const transaction = new SorobanClient.TransactionBuilder(account, { fee })
  399.    *   // Uncomment the following line to build transactions for the live network. Be
  400.    *   // sure to also change the horizon hostname.
  401.    *   //.setNetworkPassphrase(SorobanClient.Networks.PUBLIC)
  402.    *   .setNetworkPassphrase(SorobanClient.Networks.FUTURENET)
  403.    *   .setTimeout(30) // valid for the next 30s
  404.    *   // Add an operation to call increment() on the contract
  405.    *   .addOperation(contract.call("increment"))
  406.    *   .build();
  407.    *
  408.    * server.simulateTransaction(transaction).then((sim) => {
  409.    *   console.log("cost:", sim.cost);
  410.    *   console.log("result:", sim.result);
  411.    *   console.log("error:", sim.error);
  412.    *   console.log("latestLedger:", sim.latestLedger);
  413.    * });
  414.    */
  415.   async simulateTransaction(transaction) {
  416.     return this._simulateTransaction(transaction).then(_parsers.parseRawSimulation);
  417.   }
  418.   async _simulateTransaction(transaction) {
  419.     return jsonrpc.post(this.serverURL.toString(), 'simulateTransaction', transaction.toXDR());
  420.   }
  422.   /**
  423.    * Submit a trial contract invocation, first run a simulation of the contract
  424.    * invocation as defined on the incoming transaction, and apply the results to
  425.    * a new copy of the transaction which is then returned. Setting the ledger
  426.    * footprint and authorization, so the resulting transaction is ready for
  427.    * signing & sending.
  428.    *
  429.    * The returned transaction will also have an updated fee that is the sum of
  430.    * fee set on incoming transaction with the contract resource fees estimated
  431.    * from simulation. It is adviseable to check the fee on returned transaction
  432.    * and validate or take appropriate measures for interaction with user to
  433.    * confirm it is acceptable.
  434.    *
  435.    * You can call the {@link Server.simulateTransaction} method directly first
  436.    * if you want to inspect estimated fees for a given transaction in detail
  437.    * first, then re-assemble it manually or via {@link assembleTransaction}.
  438.    *
  439.    * @param {Transaction | FeeBumpTransaction} transaction  the transaction to
  440.    *    prepare. It should include exactly one operation, which must be one of
  441.    *    {@link xdr.InvokeHostFunctionOp}, {@link xdr.ExtendFootprintTTLOp},
  442.    *    or {@link xdr.RestoreFootprintOp}.
  443.    *
  444.    *    Any provided footprint will be overwritten. However, if your operation
  445.    *    has existing auth entries, they will be preferred over ALL auth entries
  446.    *    from the simulation. In other words, if you include auth entries, you
  447.    *    don't care about the auth returned from the simulation. Other fields
  448.    *    (footprint, etc.) will be filled as normal.
  449.    * @param {string} [networkPassphrase]  explicitly provide a network
  450.    *    passphrase (default: requested from the server via
  451.    *    {@link Server.getNetwork}).
  452.    *
  453.    * @returns {Promise<Transaction | FeeBumpTransaction>}   a copy of the
  454.    *    transaction with the expected authorizations (in the case of
  455.    *    invocation), resources, and ledger footprints added. The transaction fee
  456.    *    will also automatically be padded with the contract's minimum resource
  457.    *    fees discovered from the simulation.
  458.    *
  459.    * @see assembleTransaction
  460.    * @see https://soroban.stellar.org/api/methods/simulateTransaction
  461.    * @throws {jsonrpc.Error<any> | Error}   if simulation fails
  462.    * @example
  463.    * const contractId = 'CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE';
  464.    * const contract = new SorobanClient.Contract(contractId);
  465.    *
  466.    * // Right now, this is just the default fee for this example.
  467.    * const fee = SorobanClient.BASE_FEE;
  468.    * const transaction = new SorobanClient.TransactionBuilder(account, { fee })
  469.    *   // Uncomment the following line to build transactions for the live network. Be
  470.    *   // sure to also change the horizon hostname.
  471.    *   //.setNetworkPassphrase(SorobanClient.Networks.PUBLIC)
  472.    *   .setNetworkPassphrase(SorobanClient.Networks.FUTURENET)
  473.    *   .setTimeout(30) // valid for the next 30s
  474.    *   // Add an operation to call increment() on the contract
  475.    *   .addOperation(contract.call("increment"))
  476.    *   .build();
  477.    *
  478.    * const preparedTransaction = await server.prepareTransaction(transaction);
  479.    *
  480.    * // Sign this transaction with the secret key
  481.    * // NOTE: signing is transaction is network specific. Test network transactions
  482.    * // won't work in the public network. To switch networks, use the Network object
  483.    * // as explained above (look for SorobanClient.Network).
  484.    * const sourceKeypair = SorobanClient.Keypair.fromSecret(sourceSecretKey);
  485.    * preparedTransaction.sign(sourceKeypair);
  486.    *
  487.    * server.sendTransaction(transaction).then(result => {
  488.    *   console.log("hash:", result.hash);
  489.    *   console.log("status:", result.status);
  490.    *   console.log("errorResultXdr:", result.errorResultXdr);
  491.    * });
  492.    */
  493.   async prepareTransaction(transaction, networkPassphrase) {
  494.     const [{
  495.       passphrase
  496.     }, simResponse] = await Promise.all([networkPassphrase ? Promise.resolve({
  497.       passphrase: networkPassphrase
  498.     }) : this.getNetwork(), this.simulateTransaction(transaction)]);
  499.     if (_soroban_rpc.SorobanRpc.isSimulationError(simResponse)) {
  500.       throw simResponse.error;
  501.     }
  502.     if (!simResponse.result) {
  503.       throw new Error('transaction simulation failed');
  504.     }
  505.     return (0, _transaction.assembleTransaction)(transaction, passphrase, simResponse).build();
  506.   }
  508.   /**
  509.    * Submit a real transaction to the Stellar network.
  510.    *
  511.    * Unlike Horizon, Soroban RPC does not wait for transaction completion. It
  512.    * simply validates the transaction and enqueues it. Clients should call
  513.    * {@link Server.getTransactionStatus} to learn about transaction
  514.    * success/failure.
  515.    *
  516.    * @param {Transaction | FeeBumpTransaction} transaction  to submit
  517.    * @returns {Promise<SorobanRpc.SendTransactionResponse>}   the
  518.    *    transaction id, status, and any error if available
  519.    *
  520.    * @see https://developers.stellar.org/docs/glossary/transactions/
  521.    * @see https://soroban.stellar.org/api/methods/sendTransaction
  522.    * @example
  523.    * const contractId = 'CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE';
  524.    * const contract = new SorobanClient.Contract(contractId);
  525.    *
  526.    * // Right now, this is just the default fee for this example.
  527.    * const fee = SorobanClient.BASE_FEE;
  528.    * const transaction = new SorobanClient.TransactionBuilder(account, { fee })
  529.    *   // Uncomment the following line to build transactions for the live network. Be
  530.    *   // sure to also change the horizon hostname.
  531.    *   //.setNetworkPassphrase(SorobanClient.Networks.PUBLIC)
  532.    *   .setNetworkPassphrase(SorobanClient.Networks.FUTURENET)
  533.    *   .setTimeout(30) // valid for the next 30s
  534.    *   // Add an operation to call increment() on the contract
  535.    *   .addOperation(contract.call("increment"))
  536.    *   .build();
  537.    *
  538.    * // Sign this transaction with the secret key
  539.    * // NOTE: signing is transaction is network specific. Test network transactions
  540.    * // won't work in the public network. To switch networks, use the Network object
  541.    * // as explained above (look for SorobanClient.Network).
  542.    * const sourceKeypair = SorobanClient.Keypair.fromSecret(sourceSecretKey);
  543.    * transaction.sign(sourceKeypair);
  544.    *
  545.    * server.sendTransaction(transaction).then((result) => {
  546.    *   console.log("hash:", result.hash);
  547.    *   console.log("status:", result.status);
  548.    *   console.log("errorResultXdr:", result.errorResultXdr);
  549.    * });
  550.    */
  551.   async sendTransaction(transaction) {
  552.     return this._sendTransaction(transaction).then(_parsers.parseRawSendTransaction);
  553.   }
  554.   async _sendTransaction(transaction) {
  555.     return jsonrpc.post(this.serverURL.toString(), 'sendTransaction', transaction.toXDR());
  556.   }
  558.   /**
  559.    * Fund a new account using the network's friendbot faucet, if any.
  560.    *
  561.    * @param {string | Account} address  the address or account instance that we
  562.    *    want to create and fund with friendbot
  563.    * @param {string} [friendbotUrl]     optionally, an explicit address for
  564.    *    friendbot (by default: this calls the Soroban RPC
  565.    *    {@link Server.getNetwork} method to try to discover this network's
  566.    *    Friendbot url).
  567.    *
  568.    * @returns {Promise<Account>}  an {@link Account} object for the created
  569.    *    account, or the existing account if it's already funded with the
  570.    *    populated sequence number (note that the account will not be "topped
  571.    *    off" if it already exists)
  572.    *
  573.    * @throws if Friendbot is not configured on this network or request failure
  574.    *
  575.    * @see
  576.    * https://developers.stellar.org/docs/fundamentals-and-concepts/testnet-and-pubnet#friendbot
  577.    * @see Friendbot.Response
  578.    * @example
  579.    * server
  580.    *    .requestAirdrop("GBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4")
  581.    *    .then((accountCreated) => {
  582.    *      console.log("accountCreated:", accountCreated);
  583.    *    }).catch((error) => {
  584.    *      console.error("error:", error);
  585.    *    });
  586.    */
  587.   async requestAirdrop(address, friendbotUrl) {
  588.     const account = typeof address === 'string' ? address : address.accountId();
  589.     friendbotUrl = friendbotUrl || (await this.getNetwork()).friendbotUrl;
  590.     if (!friendbotUrl) {
  591.       throw new Error('No friendbot URL configured for current network');
  592.     }
  593.     try {
  594.       const response = await _axios.default.post(`${friendbotUrl}?addr=${encodeURIComponent(account)}`);
  595.       const meta = _stellarBase.xdr.TransactionMeta.fromXDR(response.data.result_meta_xdr, 'base64');
  596.       const sequence = findCreatedAccountSequenceInTransactionMeta(meta);
  597.       return new _stellarBase.Account(account, sequence);
  598.     } catch (error) {
  599.       var _error$response;
  600.       if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 400) {
  601.         var _error$response$detai;
  602.         if ((_error$response$detai = error.response.detail) !== null && _error$response$detai !== void 0 && _error$response$detai.includes('createAccountAlreadyExist')) {
  603.           // Account already exists, load the sequence number
  604.           return this.getAccount(account);
  605.         }
  606.       }
  607.       throw error;
  608.     }
  609.   }
  610. }
  611. exports.Server = Server;
  612. function findCreatedAccountSequenceInTransactionMeta(meta) {
  613.   let operations = [];
  614.   switch (meta.switch()) {
  615.     case 0:
  616.       operations = meta.operations();
  617.       break;
  618.     case 1:
  619.     case 2:
  620.     case 3:
  621.       // all three have the same interface
  622.       operations = meta.value().operations();
  623.       break;
  624.     default:
  625.       throw new Error('Unexpected transaction meta switch value');
  626.   }
  627.   for (const op of operations) {
  628.     for (const c of op.changes()) {
  629.       if (c.switch() !== _stellarBase.xdr.LedgerEntryChangeType.ledgerEntryCreated()) {
  630.         continue;
  631.       }
  632.       const data = c.created().data();
  633.       if (data.switch() !== _stellarBase.xdr.LedgerEntryType.account()) {
  634.         continue;
  635.       }
  636.       return data.account().seqNum().toString();
  637.     }
  638.   }
  639.   throw new Error('No account created in transaction');
  640. }