@stellar/stellar-sdk 11.0.0

package/dist/stellar-sdk.min.js.LICENSE.txt

@@ -0,0 +1,71 @@
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*!
+ * URI.js - Mutating URLs
+ *
+ * Version: 1.19.11
+ *
+ * Author: Rodney Rehm
+ * Web: http://medialize.github.io/URI.js/
+ *
+ * Licensed under
+ *   MIT License http://www.opensource.org/licenses/mit-license
+ *
+ */
+
+/*!
+ * URI.js - Mutating URLs
+ * IPv6 Support
+ *
+ * Version: 1.19.11
+ *
+ * Author: Rodney Rehm
+ * Web: http://medialize.github.io/URI.js/
+ *
+ * Licensed under
+ *   MIT License http://www.opensource.org/licenses/mit-license
+ *
+ */
+
+/*!
+ * URI.js - Mutating URLs
+ * Second Level Domain (SLD) Support
+ *
+ * Version: 1.19.11
+ *
+ * Author: Rodney Rehm
+ * Web: http://medialize.github.io/URI.js/
+ *
+ * Licensed under
+ *   MIT License http://www.opensource.org/licenses/mit-license
+ *
+ */
+
+/*!
+ * URI.js - Mutating URLs
+ * URI Template Support - http://tools.ietf.org/html/rfc6570
+ *
+ * Version: 1.19.11
+ *
+ * Author: Rodney Rehm
+ * Web: http://medialize.github.io/URI.js/
+ *
+ * Licensed under
+ *   MIT License http://www.opensource.org/licenses/mit-license
+ *
+ */
+
+/*! https://mths.be/punycode v1.4.0 by @mathias */
+
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/lib/browser.d.ts

@@ -0,0 +1,6 @@
+export * from "./index";
+export * as StellarBase from "@stellar/stellar-base";
+import axios from "axios";
+export { axios };
+declare const _default: any;
+export default _default;

package/lib/browser.js

@@ -0,0 +1,37 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  StellarBase: true,
+  axios: true
+};
+exports.StellarBase = void 0;
+Object.defineProperty(exports, "axios", {
+  enumerable: true,
+  get: function get() {
+    return _axios.default;
+  }
+});
+exports.default = void 0;
+var _index = require("./index");
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _index[key];
+    }
+  });
+});
+var _StellarBase = _interopRequireWildcard(require("@stellar/stellar-base"));
+exports.StellarBase = _StellarBase;
+var _axios = _interopRequireDefault(require("axios"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+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; }
+var _default = exports.default = module.exports;

package/lib/config.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Global config class.
+ *
+ * Usage node:
+ * ```
+ * import {Config} from 'stellar-sdk';
+ * Config.setAllowHttp(true);
+ * Config.setTimeout(5000);
+ * ```
+ *
+ * Usage browser:
+ * ```
+ * StellarSdk.Config.setAllowHttp(true);
+ * StellarSdk.Config.setTimeout(5000);
+ * ```
+ * @static
+ */
+declare class Config {
+    /**
+     * Sets `allowHttp` flag globally. When set to `true`, connections to insecure http protocol servers will be allowed.
+     * Must be set to `false` in production. Default: `false`.
+     * @param {boolean} value new allowHttp value
+     * @returns {void}
+     * @static
+     */
+    static setAllowHttp(value: boolean): void;
+    /**
+     * Sets `timeout` flag globally. When set to anything besides 0, the request will timeout after specified time (ms).
+     * Default: 0.
+     * @param {number} value new timeout value
+     * @returns {void}
+     * @static
+     */
+    static setTimeout(value: number): void;
+    /**
+     * @static
+     * @returns {boolean} allowHttp flag
+     */
+    static isAllowHttp(): boolean;
+    /**
+     * @static
+     * @returns {number} timeout flag
+     */
+    static getTimeout(): number;
+    /**
+     * Sets all global config flags to default values.
+     * @static
+     * @returns {void}
+     */
+    static setDefault(): void;
+}
+export { Config };

package/lib/config.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Config = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var defaultConfig = {
+  allowHttp: false,
+  timeout: 0
+};
+var config = Object.assign({}, defaultConfig);
+var Config = exports.Config = function () {
+  function Config() {
+    _classCallCheck(this, Config);
+  }
+  _createClass(Config, null, [{
+    key: "setAllowHttp",
+    value: function setAllowHttp(value) {
+      config.allowHttp = value;
+    }
+  }, {
+    key: "setTimeout",
+    value: function setTimeout(value) {
+      config.timeout = value;
+    }
+  }, {
+    key: "isAllowHttp",
+    value: function isAllowHttp() {
+      return config.allowHttp;
+    }
+  }, {
+    key: "getTimeout",
+    value: function getTimeout() {
+      return config.timeout;
+    }
+  }, {
+    key: "setDefault",
+    value: function setDefault() {
+      config = Object.assign({}, defaultConfig);
+    }
+  }]);
+  return Config;
+}();

package/lib/contract_spec.d.ts

@@ -0,0 +1,130 @@
+import { xdr } from '@stellar/stellar-base';
+export interface Union<T> {
+    tag: string;
+    values?: T;
+}
+/**
+ * Provides a ContractSpec class which can contains the XDR types defined by the contract.
+ * This allows the class to be used to convert between native and raw `xdr.ScVal`s.
+ *
+ * @example
+ * const specEntries = [...]; // XDR spec entries of a smart contract
+ * const contractSpec = new ContractSpec(specEntries);
+ *
+ * // Convert native value to ScVal
+ * const args = {
+ *   arg1: 'value1',
+ *   arg2: 1234
+ * };
+ * const scArgs = contractSpec.funcArgsToScVals('funcName', args);
+ *
+ * // Call contract
+ * const resultScv = await callContract(contractId, 'funcName', scArgs);
+ *
+ * // Convert result ScVal back to native value
+ * const result = contractSpec.funcResToNative('funcName', resultScv);
+ *
+ * console.log(result); // {success: true}
+ */
+export declare class ContractSpec {
+    entries: xdr.ScSpecEntry[];
+    /**
+     * Constructs a new ContractSpec from an array of XDR spec entries.
+     *
+     * @param {xdr.ScSpecEntry[] | string[]} entries the XDR spec entries
+     *
+     * @throws {Error} if entries is invalid
+     */
+    constructor(entries: xdr.ScSpecEntry[] | string[]);
+    /**
+     * Gets the XDR function spec for the given function name.
+     *
+     * @param {string} name the name of the function
+     * @returns {xdr.ScSpecFunctionV0} the function spec
+     *
+     * @throws {Error} if no function with the given name exists
+     */
+    getFunc(name: string): xdr.ScSpecFunctionV0;
+    /**
+     * Converts native JS arguments to ScVals for calling a contract function.
+     *
+     * @param {string} name the name of the function
+     * @param {Object} args the arguments object
+     * @returns {xdr.ScVal[]} the converted arguments
+     *
+     * @throws {Error} if argument is missing or incorrect type
+     *
+     * @example
+     * ```js
+     * const args = {
+     *   arg1: 'value1',
+     *   arg2: 1234
+     * };
+     * const scArgs = contractSpec.funcArgsToScVals('funcName', args);
+     * ```
+     */
+    funcArgsToScVals(name: string, args: object): xdr.ScVal[];
+    /**
+     * Converts the result ScVal of a function call to a native JS value.
+     *
+     * @param {string} name the name of the function
+     * @param {xdr.ScVal | string} val_or_base64 the result ScVal or base64 encoded string
+     * @returns {any} the converted native value
+     *
+     * @throws {Error} if return type mismatch or invalid input
+     *
+     * @example
+     * ```js
+     * const resultScv = 'AAA=='; // Base64 encoded ScVal
+     * const result = contractSpec.funcResToNative('funcName', resultScv);
+     * ```
+     */
+    funcResToNative(name: string, val_or_base64: xdr.ScVal | string): any;
+    /**
+     * Finds the XDR spec entry for the given name.
+     *
+     * @param {string} name the name to find
+     * @returns {xdr.ScSpecEntry} the entry
+     *
+     * @throws {Error} if no entry with the given name exists
+     */
+    findEntry(name: string): xdr.ScSpecEntry;
+    /**
+     * Converts a native JS value to an ScVal based on the given type.
+     *
+     * @param {any} val the native JS value
+     * @param {xdr.ScSpecTypeDef} [ty] the expected type
+     * @returns {xdr.ScVal} the converted ScVal
+     *
+     * @throws {Error} if value cannot be converted to the given type
+     */
+    nativeToScVal(val: any, ty: xdr.ScSpecTypeDef): xdr.ScVal;
+    private nativeToUdt;
+    private nativeToUnion;
+    private nativeToStruct;
+    private nativeToEnum;
+    /**
+     * Converts an base64 encoded ScVal back to a native JS value based on the given type.
+     *
+     * @param {string} scv the base64 encoded ScVal
+     * @param {xdr.ScSpecTypeDef} typeDef the expected type
+     * @returns {any} the converted native JS value
+     *
+     * @throws {Error} if ScVal cannot be converted to the given type
+     */
+    scValStrToNative<T>(scv: string, typeDef: xdr.ScSpecTypeDef): T;
+    /**
+     * Converts an ScVal back to a native JS value based on the given type.
+     *
+     * @param {xdr.ScVal} scv the ScVal
+     * @param {xdr.ScSpecTypeDef} typeDef the expected type
+     * @returns {any} the converted native JS value
+     *
+     * @throws {Error} if ScVal cannot be converted to the given type
+     */
+    scValToNative<T>(scv: xdr.ScVal, typeDef: xdr.ScSpecTypeDef): T;
+    private scValUdtToNative;
+    private unionToNative;
+    private structToNative;
+    private enumToNative;
+}