@stellar/stellar-base 10.0.0

package/lib/get_liquidity_pool_id.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LiquidityPoolFeeV18 = void 0;
+exports.getLiquidityPoolId = getLiquidityPoolId;
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _asset = require("./asset");
+var _hashing = require("./hashing");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+// LiquidityPoolFeeV18 is the default liquidity pool fee in protocol v18. It defaults to 30 base points (0.3%).
+var LiquidityPoolFeeV18 = exports.LiquidityPoolFeeV18 = 30;
+
+/**
+ * getLiquidityPoolId computes the Pool ID for the given assets, fee and pool type.
+ *
+ * @see [stellar-core getPoolID](https://github.com/stellar/stellar-core/blob/9f3a48c6a8f1aa77b6043a055d0638661f718080/src/ledger/test/LedgerTxnTests.cpp#L3746-L3751)
+ *
+ * @export
+ * @param {string} liquidityPoolType – A string representing the liquidity pool type.
+ * @param {object} liquidityPoolParameters        – The liquidity pool parameters.
+ * @param {Asset}  liquidityPoolParameters.assetA – The first asset in the Pool, it must respect the rule assetA < assetB.
+ * @param {Asset}  liquidityPoolParameters.assetB – The second asset in the Pool, it must respect the rule assetA < assetB.
+ * @param {number} liquidityPoolParameters.fee    – The liquidity pool fee. For now the only fee supported is `30`.
+ *
+ * @return {Buffer} the raw Pool ID buffer, which can be stringfied with `toString('hex')`
+ */
+function getLiquidityPoolId(liquidityPoolType) {
+  var liquidityPoolParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (liquidityPoolType !== 'constant_product') {
+    throw new Error('liquidityPoolType is invalid');
+  }
+  var assetA = liquidityPoolParameters.assetA,
+    assetB = liquidityPoolParameters.assetB,
+    fee = liquidityPoolParameters.fee;
+  if (!assetA || !(assetA instanceof _asset.Asset)) {
+    throw new Error('assetA is invalid');
+  }
+  if (!assetB || !(assetB instanceof _asset.Asset)) {
+    throw new Error('assetB is invalid');
+  }
+  if (!fee || fee !== LiquidityPoolFeeV18) {
+    throw new Error('fee is invalid');
+  }
+  if (_asset.Asset.compare(assetA, assetB) !== -1) {
+    throw new Error('Assets are not in lexicographic order');
+  }
+  var lpTypeData = _xdr["default"].LiquidityPoolType.liquidityPoolConstantProduct().toXDR();
+  var lpParamsData = new _xdr["default"].LiquidityPoolConstantProductParameters({
+    assetA: assetA.toXDRObject(),
+    assetB: assetB.toXDRObject(),
+    fee: fee
+  }).toXDR();
+  var payload = Buffer.concat([lpTypeData, lpParamsData]);
+  return (0, _hashing.hash)(payload);
+}

package/lib/hashing.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hash = hash;
+var _sha = require("sha.js");
+function hash(data) {
+  var hasher = new _sha.sha256();
+  hasher.update(data, 'utf8');
+  return hasher.digest();
+}

package/lib/index.js

@@ -0,0 +1,385 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  xdr: true,
+  hash: true,
+  sign: true,
+  verify: true,
+  FastSigning: true,
+  getLiquidityPoolId: true,
+  LiquidityPoolFeeV18: true,
+  Keypair: true,
+  UnsignedHyper: true,
+  Hyper: true,
+  TransactionBase: true,
+  Transaction: true,
+  FeeBumpTransaction: true,
+  TransactionBuilder: true,
+  TimeoutInfinite: true,
+  BASE_FEE: true,
+  Asset: true,
+  LiquidityPoolAsset: true,
+  LiquidityPoolId: true,
+  Operation: true,
+  AuthRequiredFlag: true,
+  AuthRevocableFlag: true,
+  AuthImmutableFlag: true,
+  AuthClawbackEnabledFlag: true,
+  Account: true,
+  MuxedAccount: true,
+  Claimant: true,
+  Networks: true,
+  StrKey: true,
+  SignerKey: true,
+  Soroban: true,
+  decodeAddressToMuxedAccount: true,
+  encodeMuxedAccountToAddress: true,
+  extractBaseAddress: true,
+  encodeMuxedAccount: true,
+  Contract: true,
+  Address: true
+};
+Object.defineProperty(exports, "Account", {
+  enumerable: true,
+  get: function get() {
+    return _account.Account;
+  }
+});
+Object.defineProperty(exports, "Address", {
+  enumerable: true,
+  get: function get() {
+    return _address.Address;
+  }
+});
+Object.defineProperty(exports, "Asset", {
+  enumerable: true,
+  get: function get() {
+    return _asset.Asset;
+  }
+});
+Object.defineProperty(exports, "AuthClawbackEnabledFlag", {
+  enumerable: true,
+  get: function get() {
+    return _operation.AuthClawbackEnabledFlag;
+  }
+});
+Object.defineProperty(exports, "AuthImmutableFlag", {
+  enumerable: true,
+  get: function get() {
+    return _operation.AuthImmutableFlag;
+  }
+});
+Object.defineProperty(exports, "AuthRequiredFlag", {
+  enumerable: true,
+  get: function get() {
+    return _operation.AuthRequiredFlag;
+  }
+});
+Object.defineProperty(exports, "AuthRevocableFlag", {
+  enumerable: true,
+  get: function get() {
+    return _operation.AuthRevocableFlag;
+  }
+});
+Object.defineProperty(exports, "BASE_FEE", {
+  enumerable: true,
+  get: function get() {
+    return _transaction_builder.BASE_FEE;
+  }
+});
+Object.defineProperty(exports, "Claimant", {
+  enumerable: true,
+  get: function get() {
+    return _claimant.Claimant;
+  }
+});
+Object.defineProperty(exports, "Contract", {
+  enumerable: true,
+  get: function get() {
+    return _contract.Contract;
+  }
+});
+Object.defineProperty(exports, "FastSigning", {
+  enumerable: true,
+  get: function get() {
+    return _signing.FastSigning;
+  }
+});
+Object.defineProperty(exports, "FeeBumpTransaction", {
+  enumerable: true,
+  get: function get() {
+    return _fee_bump_transaction.FeeBumpTransaction;
+  }
+});
+Object.defineProperty(exports, "Hyper", {
+  enumerable: true,
+  get: function get() {
+    return _jsXdr.Hyper;
+  }
+});
+Object.defineProperty(exports, "Keypair", {
+  enumerable: true,
+  get: function get() {
+    return _keypair.Keypair;
+  }
+});
+Object.defineProperty(exports, "LiquidityPoolAsset", {
+  enumerable: true,
+  get: function get() {
+    return _liquidity_pool_asset.LiquidityPoolAsset;
+  }
+});
+Object.defineProperty(exports, "LiquidityPoolFeeV18", {
+  enumerable: true,
+  get: function get() {
+    return _get_liquidity_pool_id.LiquidityPoolFeeV18;
+  }
+});
+Object.defineProperty(exports, "LiquidityPoolId", {
+  enumerable: true,
+  get: function get() {
+    return _liquidity_pool_id.LiquidityPoolId;
+  }
+});
+Object.defineProperty(exports, "MuxedAccount", {
+  enumerable: true,
+  get: function get() {
+    return _muxed_account.MuxedAccount;
+  }
+});
+Object.defineProperty(exports, "Networks", {
+  enumerable: true,
+  get: function get() {
+    return _network.Networks;
+  }
+});
+Object.defineProperty(exports, "Operation", {
+  enumerable: true,
+  get: function get() {
+    return _operation.Operation;
+  }
+});
+Object.defineProperty(exports, "SignerKey", {
+  enumerable: true,
+  get: function get() {
+    return _signerkey.SignerKey;
+  }
+});
+Object.defineProperty(exports, "Soroban", {
+  enumerable: true,
+  get: function get() {
+    return _soroban.Soroban;
+  }
+});
+Object.defineProperty(exports, "StrKey", {
+  enumerable: true,
+  get: function get() {
+    return _strkey.StrKey;
+  }
+});
+Object.defineProperty(exports, "TimeoutInfinite", {
+  enumerable: true,
+  get: function get() {
+    return _transaction_builder.TimeoutInfinite;
+  }
+});
+Object.defineProperty(exports, "Transaction", {
+  enumerable: true,
+  get: function get() {
+    return _transaction.Transaction;
+  }
+});
+Object.defineProperty(exports, "TransactionBase", {
+  enumerable: true,
+  get: function get() {
+    return _transaction_base.TransactionBase;
+  }
+});
+Object.defineProperty(exports, "TransactionBuilder", {
+  enumerable: true,
+  get: function get() {
+    return _transaction_builder.TransactionBuilder;
+  }
+});
+Object.defineProperty(exports, "UnsignedHyper", {
+  enumerable: true,
+  get: function get() {
+    return _jsXdr.UnsignedHyper;
+  }
+});
+Object.defineProperty(exports, "decodeAddressToMuxedAccount", {
+  enumerable: true,
+  get: function get() {
+    return _decode_encode_muxed_account.decodeAddressToMuxedAccount;
+  }
+});
+exports["default"] = void 0;
+Object.defineProperty(exports, "encodeMuxedAccount", {
+  enumerable: true,
+  get: function get() {
+    return _decode_encode_muxed_account.encodeMuxedAccount;
+  }
+});
+Object.defineProperty(exports, "encodeMuxedAccountToAddress", {
+  enumerable: true,
+  get: function get() {
+    return _decode_encode_muxed_account.encodeMuxedAccountToAddress;
+  }
+});
+Object.defineProperty(exports, "extractBaseAddress", {
+  enumerable: true,
+  get: function get() {
+    return _decode_encode_muxed_account.extractBaseAddress;
+  }
+});
+Object.defineProperty(exports, "getLiquidityPoolId", {
+  enumerable: true,
+  get: function get() {
+    return _get_liquidity_pool_id.getLiquidityPoolId;
+  }
+});
+Object.defineProperty(exports, "hash", {
+  enumerable: true,
+  get: function get() {
+    return _hashing.hash;
+  }
+});
+Object.defineProperty(exports, "sign", {
+  enumerable: true,
+  get: function get() {
+    return _signing.sign;
+  }
+});
+Object.defineProperty(exports, "verify", {
+  enumerable: true,
+  get: function get() {
+    return _signing.verify;
+  }
+});
+Object.defineProperty(exports, "xdr", {
+  enumerable: true,
+  get: function get() {
+    return _xdr["default"];
+  }
+});
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _hashing = require("./hashing");
+var _signing = require("./signing");
+var _get_liquidity_pool_id = require("./get_liquidity_pool_id");
+var _keypair = require("./keypair");
+var _jsXdr = require("@stellar/js-xdr");
+var _transaction_base = require("./transaction_base");
+var _transaction = require("./transaction");
+var _fee_bump_transaction = require("./fee_bump_transaction");
+var _transaction_builder = require("./transaction_builder");
+var _asset = require("./asset");
+var _liquidity_pool_asset = require("./liquidity_pool_asset");
+var _liquidity_pool_id = require("./liquidity_pool_id");
+var _operation = require("./operation");
+var _memo = require("./memo");
+Object.keys(_memo).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _memo[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _memo[key];
+    }
+  });
+});
+var _account = require("./account");
+var _muxed_account = require("./muxed_account");
+var _claimant = require("./claimant");
+var _network = require("./network");
+var _strkey = require("./strkey");
+var _signerkey = require("./signerkey");
+var _soroban = require("./soroban");
+var _decode_encode_muxed_account = require("./util/decode_encode_muxed_account");
+var _contract = require("./contract");
+var _address = require("./address");
+var _numbers = require("./numbers");
+Object.keys(_numbers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _numbers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _numbers[key];
+    }
+  });
+});
+var _scval = require("./scval");
+Object.keys(_scval).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _scval[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _scval[key];
+    }
+  });
+});
+var _events = require("./events");
+Object.keys(_events).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _events[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _events[key];
+    }
+  });
+});
+var _sorobandata_builder = require("./sorobandata_builder");
+Object.keys(_sorobandata_builder).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _sorobandata_builder[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _sorobandata_builder[key];
+    }
+  });
+});
+var _auth = require("./auth");
+Object.keys(_auth).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _auth[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _auth[key];
+    }
+  });
+});
+var _invocation = require("./invocation");
+Object.keys(_invocation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _invocation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _invocation[key];
+    }
+  });
+});
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/* eslint-disable import/no-import-module-exports */
+
+_bignumber["default"].DEBUG = true; // gives us exceptions on bad constructor values
+
+//
+// Soroban
+//
+var _default = exports["default"] = module.exports;

package/lib/invocation.js

@@ -0,0 +1,195 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildInvocationTree = buildInvocationTree;
+exports.walkInvocationTree = walkInvocationTree;
+var _asset = require("./asset");
+var _address = require("./address");
+var _scval = require("./scval");
+/**
+ * @typedef CreateInvocation
+ *
+ * @prop {'wasm'|'sac'} type  a type indicating if this creation was a custom
+ *    contract or a wrapping of an existing Stellar asset
+ * @prop {string} [token] when `type=='sac'`, the canonical {@link Asset} that
+ *    is being wrapped by this Stellar Asset Contract
+ * @prop {object} [wasm]  when `type=='wasm'`, add'l creation parameters
+ *
+ * @prop {string} wasm.hash     hex hash of WASM bytecode backing this contract
+ * @prop {string} wasm.address  contract address of this deployment
+ * @prop {string} wasm.salt     hex salt that the user consumed when creating
+ *    this contract (encoded in the resulting address)
+ */
+
+/**
+ * @typedef ExecuteInvocation
+ *
+ * @prop {string} source    the strkey of the contract (C...) being invoked
+ * @prop {string} function  the name of the function being invoked
+ * @prop {any[]}  args      the natively-represented parameters to the function
+ *    invocation (see {@link scValToNative}) for rules on how they're
+ *    represented a JS types
+ */
+
+/**
+ * @typedef InvocationTree
+ * @prop {'execute' | 'create'} type  the type of invocation occurring, either
+ *    contract creation or host function execution
+ * @prop {CreateInvocation | ExecuteInvocation} args  the parameters to the
+ *    invocation, depending on the type
+ * @prop {InvocationTree[]} invocations   any sub-invocations that (may) occur
+ *    as a result of this invocation (i.e. a tree of call stacks)
+ */
+
+/**
+ * Turns a raw invocation tree into a human-readable format.
+ *
+ * This is designed to make the invocation tree easier to understand in order to
+ * inform users about the side-effects of their contract calls. This will help
+ * make informed decisions about whether or not a particular invocation will
+ * result in what you expect it to.
+ *
+ * @param {xdr.SorobanAuthorizedInvocation} root  the raw XDR of the invocation,
+ *    likely acquired from transaction simulation. this is either from the
+ *    {@link Operation.invokeHostFunction} itself (the `func` field), or from
+ *    the authorization entries ({@link xdr.SorobanAuthorizationEntry}, the
+ *    `rootInvocation` field)
+ *
+ * @returns {InvocationTree}  a human-readable version of the invocation tree
+ *
+ * @example
+ * Here, we show a browser modal after simulating an arbitrary transaction,
+ * `tx`, which we assume has an `Operation.invokeHostFunction` inside of it:
+ *
+ * ```typescript
+ * import { Server, buildInvocationTree } from 'soroban-client';
+ *
+ * const s = new Server("fill in accordingly");
+ *
+ * s.simulateTransaction(tx).then(
+ *  (resp: SorobanRpc.SimulateTransactionResponse) => {
+ *    if (SorobanRpc.isSuccessfulSim(resp) && ) {
+ *      // bold assumption: there's a valid result with an auth entry
+ *      alert(
+ *        "You are authorizing the following invocation:\n" +
+ *        JSON.stringify(
+ *          buildInvocationTree(resp.result!.auth[0].rootInvocation()),
+ *          null,
+ *          2
+ *        )
+ *      );
+ *    }
+ *  }
+ * );
+ * ```
+ */
+function buildInvocationTree(root) {
+  var fn = root["function"]();
+
+  /** @type {InvocationTree} */
+  var output = {};
+
+  /** @type {xdr.CreateContractArgs | xdr.InvokeContractArgs} */
+  var inner = fn.value();
+  switch (fn["switch"]().value) {
+    // sorobanAuthorizedFunctionTypeContractFn
+    case 0:
+      output.type = 'execute';
+      output.args = {
+        source: _address.Address.fromScAddress(inner.contractAddress()).toString(),
+        "function": inner.functionName(),
+        args: inner.args().map(function (arg) {
+          return (0, _scval.scValToNative)(arg);
+        })
+      };
+      break;
+
+    // sorobanAuthorizedFunctionTypeCreateContractHostFn
+    case 1:
+      {
+        output.type = 'create';
+        output.args = {};
+
+        // If the executable is a WASM, the preimage MUST be an address. If it's a
+        // token, the preimage MUST be an asset. This is a cheeky way to check
+        // that, because wasm=0, token=1 and address=0, asset=1 in the XDR switch
+        // values.
+        //
+        // The first part may not be true in V2, but we'd need to update this code
+        // anyway so it can still be an error.
+        var _ref = [inner.executable(), inner.contractIdPreimage()],
+          exec = _ref[0],
+          preimage = _ref[1];
+        if (!!exec["switch"]().value !== !!preimage["switch"]().value) {
+          throw new Error("creation function appears invalid: ".concat(JSON.stringify(inner), " (should be wasm+address or token+asset)"));
+        }
+        switch (exec["switch"]().value) {
+          // contractExecutableWasm
+          case 0:
+            {
+              /** @type {xdr.ContractIdPreimageFromAddress} */
+              var details = preimage.fromAddress();
+              output.args.type = 'wasm';
+              output.args.wasm = {
+                salt: details.salt().toString('hex'),
+                hash: exec.wasmHash().toString('hex'),
+                address: _address.Address.fromScAddress(details.address()).toString()
+              };
+              break;
+            }
+
+          // contractExecutableStellarAsset
+          case 1:
+            output.args.type = 'sac';
+            output.args.asset = _asset.Asset.fromOperation(preimage.fromAsset()).toString();
+            break;
+          default:
+            throw new Error("unknown creation type: ".concat(JSON.stringify(exec)));
+        }
+        break;
+      }
+    default:
+      throw new Error("unknown invocation type (".concat(fn["switch"](), "): ").concat(JSON.stringify(fn)));
+  }
+  output.invocations = root.subInvocations().map(function (i) {
+    return buildInvocationTree(i);
+  });
+  return output;
+}
+
+/**
+ * @callback InvocationWalker
+ *
+ * @param {xdr.SorobanAuthorizedInvocation} node  the currently explored node
+ * @param {number} depth  the depth of the tree this node is occurring at (the
+ *    root starts at a depth of 1)
+ * @param {xdr.SorobanAuthorizedInvocation} [parent]  this `node`s parent node,
+ *    if any (i.e. this doesn't exist at the root)
+ *
+ * @returns {boolean?}   returning `false` is a hint to stop exploring
+ */
+
+/**
+ * Executes a callback function on each node in the tree until stopped.
+ *
+ * Nodes are walked in a depth-first order. Returning `false` from the callback
+ * stops further depth exploration at that node, but it does not stop the walk
+ * in a "global" view.
+ *
+ * @param {xdr.SorobanAuthorizedInvocation} root  the tree to explore
+ * @param {InvocationWalker} callback  the callback to execute for each node
+ * @returns {void}
+ */
+function walkInvocationTree(root, callback) {
+  walkHelper(root, 1, callback);
+}
+function walkHelper(node, depth, callback, parent) {
+  if (callback(node, depth, parent) === false /* allow void rv */) {
+    return;
+  }
+  node.subInvocations().forEach(function (i) {
+    return walkHelper(i, depth + 1, callback, node);
+  });
+}