@monerium/sdk 2.0.16 → 2.0.18

package/dist/index.mjs

@@ -0,0 +1,748 @@
+var ne = Object.defineProperty;
+var oe = (e, t, o) =>
+  t in e
+    ? ne(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o })
+    : (e[t] = o);
+var E = (e, t, o) => (oe(e, typeof t != "symbol" ? t + "" : t, o), o),
+  I = (e, t, o) => {
+    if (!t.has(e)) throw TypeError("Cannot " + o);
+  };
+var U = (e, t, o) => (
+    I(e, t, "read from private field"), o ? o.call(e) : t.get(e)
+  ),
+  P = (e, t, o) => {
+    if (t.has(e))
+      throw TypeError("Cannot add the same private member more than once");
+    t instanceof WeakSet ? t.add(e) : t.set(e, o);
+  },
+  M = (e, t, o, a) => (
+    I(e, t, "write to private field"), a ? a.call(e, o) : t.set(e, o), o
+  );
+var B = (e, t, o) => (I(e, t, "access private method"), o);
+var O =
+  typeof globalThis < "u"
+    ? globalThis
+    : typeof window < "u"
+    ? window
+    : typeof global < "u"
+    ? global
+    : typeof self < "u"
+    ? self
+    : {};
+function ie(e) {
+  if (e.__esModule) return e;
+  var t = e.default;
+  if (typeof t == "function") {
+    var o = function a() {
+      if (this instanceof a) {
+        var w = [null];
+        w.push.apply(w, arguments);
+        var l = Function.bind.apply(t, w);
+        return new l();
+      }
+      return t.apply(this, arguments);
+    };
+    o.prototype = t.prototype;
+  } else o = {};
+  return (
+    Object.defineProperty(o, "__esModule", { value: !0 }),
+    Object.keys(e).forEach(function (a) {
+      var w = Object.getOwnPropertyDescriptor(e, a);
+      Object.defineProperty(
+        o,
+        a,
+        w.get
+          ? w
+          : {
+              enumerable: !0,
+              get: function () {
+                return e[a];
+              },
+            }
+      );
+    }),
+    o
+  );
+}
+var D = {},
+  se = {
+    get exports() {
+      return D;
+    },
+    set exports(e) {
+      D = e;
+    },
+  };
+function ae(e) {
+  throw new Error(
+    'Could not dynamically require "' +
+      e +
+      '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.'
+  );
+}
+var q = {},
+  ce = {
+    get exports() {
+      return q;
+    },
+    set exports(e) {
+      q = e;
+    },
+  };
+const ue = {},
+  fe = /* @__PURE__ */ Object.freeze(
+    /* @__PURE__ */ Object.defineProperty(
+      {
+        __proto__: null,
+        default: ue,
+      },
+      Symbol.toStringTag,
+      { value: "Module" }
+    )
+  ),
+  he = /* @__PURE__ */ ie(fe);
+var G;
+function J() {
+  return (
+    G ||
+      ((G = 1),
+      (function (e, t) {
+        (function (o, a) {
+          e.exports = a();
+        })(O, function () {
+          var o =
+            o ||
+            (function (a, w) {
+              var l;
+              if (
+                (typeof window < "u" && window.crypto && (l = window.crypto),
+                typeof self < "u" && self.crypto && (l = self.crypto),
+                typeof globalThis < "u" &&
+                  globalThis.crypto &&
+                  (l = globalThis.crypto),
+                !l &&
+                  typeof window < "u" &&
+                  window.msCrypto &&
+                  (l = window.msCrypto),
+                !l && typeof O < "u" && O.crypto && (l = O.crypto),
+                !l && typeof ae == "function")
+              )
+                try {
+                  l = he;
+                } catch {}
+              var S = function () {
+                  if (l) {
+                    if (typeof l.getRandomValues == "function")
+                      try {
+                        return l.getRandomValues(new Uint32Array(1))[0];
+                      } catch {}
+                    if (typeof l.randomBytes == "function")
+                      try {
+                        return l.randomBytes(4).readInt32LE();
+                      } catch {}
+                  }
+                  throw new Error(
+                    "Native crypto module could not be used to get secure random number."
+                  );
+                },
+                k =
+                  Object.create ||
+                  (function () {
+                    function r() {}
+                    return function (n) {
+                      var s;
+                      return (
+                        (r.prototype = n),
+                        (s = new r()),
+                        (r.prototype = null),
+                        s
+                      );
+                    };
+                  })(),
+                _ = {},
+                C = (_.lib = {}),
+                y = (C.Base = (function () {
+                  return {
+                    extend: function (r) {
+                      var n = k(this);
+                      return (
+                        r && n.mixIn(r),
+                        (!n.hasOwnProperty("init") || this.init === n.init) &&
+                          (n.init = function () {
+                            n.$super.init.apply(this, arguments);
+                          }),
+                        (n.init.prototype = n),
+                        (n.$super = this),
+                        n
+                      );
+                    },
+                    create: function () {
+                      var r = this.extend();
+                      return r.init.apply(r, arguments), r;
+                    },
+                    init: function () {},
+                    mixIn: function (r) {
+                      for (var n in r) r.hasOwnProperty(n) && (this[n] = r[n]);
+                      r.hasOwnProperty("toString") &&
+                        (this.toString = r.toString);
+                    },
+                    clone: function () {
+                      return this.init.prototype.extend(this);
+                    },
+                  };
+                })()),
+                d = (C.WordArray = y.extend({
+                  init: function (r, n) {
+                    (r = this.words = r || []),
+                      n != w
+                        ? (this.sigBytes = n)
+                        : (this.sigBytes = r.length * 4);
+                  },
+                  toString: function (r) {
+                    return (r || u).stringify(this);
+                  },
+                  concat: function (r) {
+                    var n = this.words,
+                      s = r.words,
+                      c = this.sigBytes,
+                      p = r.sigBytes;
+                    if ((this.clamp(), c % 4))
+                      for (var g = 0; g < p; g++) {
+                        var m = (s[g >>> 2] >>> (24 - (g % 4) * 8)) & 255;
+                        n[(c + g) >>> 2] |= m << (24 - ((c + g) % 4) * 8);
+                      }
+                    else
+                      for (var b = 0; b < p; b += 4)
+                        n[(c + b) >>> 2] = s[b >>> 2];
+                    return (this.sigBytes += p), this;
+                  },
+                  clamp: function () {
+                    var r = this.words,
+                      n = this.sigBytes;
+                    (r[n >>> 2] &= 4294967295 << (32 - (n % 4) * 8)),
+                      (r.length = a.ceil(n / 4));
+                  },
+                  clone: function () {
+                    var r = y.clone.call(this);
+                    return (r.words = this.words.slice(0)), r;
+                  },
+                  random: function (r) {
+                    for (var n = [], s = 0; s < r; s += 4) n.push(S());
+                    return new d.init(n, r);
+                  },
+                })),
+                v = (_.enc = {}),
+                u = (v.Hex = {
+                  stringify: function (r) {
+                    for (
+                      var n = r.words, s = r.sigBytes, c = [], p = 0;
+                      p < s;
+                      p++
+                    ) {
+                      var g = (n[p >>> 2] >>> (24 - (p % 4) * 8)) & 255;
+                      c.push((g >>> 4).toString(16)),
+                        c.push((g & 15).toString(16));
+                    }
+                    return c.join("");
+                  },
+                  parse: function (r) {
+                    for (var n = r.length, s = [], c = 0; c < n; c += 2)
+                      s[c >>> 3] |=
+                        parseInt(r.substr(c, 2), 16) << (24 - (c % 8) * 4);
+                    return new d.init(s, n / 2);
+                  },
+                }),
+                h = (v.Latin1 = {
+                  stringify: function (r) {
+                    for (
+                      var n = r.words, s = r.sigBytes, c = [], p = 0;
+                      p < s;
+                      p++
+                    ) {
+                      var g = (n[p >>> 2] >>> (24 - (p % 4) * 8)) & 255;
+                      c.push(String.fromCharCode(g));
+                    }
+                    return c.join("");
+                  },
+                  parse: function (r) {
+                    for (var n = r.length, s = [], c = 0; c < n; c++)
+                      s[c >>> 2] |=
+                        (r.charCodeAt(c) & 255) << (24 - (c % 4) * 8);
+                    return new d.init(s, n);
+                  },
+                }),
+                i = (v.Utf8 = {
+                  stringify: function (r) {
+                    try {
+                      return decodeURIComponent(escape(h.stringify(r)));
+                    } catch {
+                      throw new Error("Malformed UTF-8 data");
+                    }
+                  },
+                  parse: function (r) {
+                    return h.parse(unescape(encodeURIComponent(r)));
+                  },
+                }),
+                f = (C.BufferedBlockAlgorithm = y.extend({
+                  reset: function () {
+                    (this._data = new d.init()), (this._nDataBytes = 0);
+                  },
+                  _append: function (r) {
+                    typeof r == "string" && (r = i.parse(r)),
+                      this._data.concat(r),
+                      (this._nDataBytes += r.sigBytes);
+                  },
+                  _process: function (r) {
+                    var n,
+                      s = this._data,
+                      c = s.words,
+                      p = s.sigBytes,
+                      g = this.blockSize,
+                      m = g * 4,
+                      b = p / m;
+                    r
+                      ? (b = a.ceil(b))
+                      : (b = a.max((b | 0) - this._minBufferSize, 0));
+                    var z = b * g,
+                      H = a.min(z * 4, p);
+                    if (z) {
+                      for (var L = 0; L < z; L += g) this._doProcessBlock(c, L);
+                      (n = c.splice(0, z)), (s.sigBytes -= H);
+                    }
+                    return new d.init(n, H);
+                  },
+                  clone: function () {
+                    var r = y.clone.call(this);
+                    return (r._data = this._data.clone()), r;
+                  },
+                  _minBufferSize: 0,
+                }));
+              C.Hasher = f.extend({
+                cfg: y.extend(),
+                init: function (r) {
+                  (this.cfg = this.cfg.extend(r)), this.reset();
+                },
+                reset: function () {
+                  f.reset.call(this), this._doReset();
+                },
+                update: function (r) {
+                  return this._append(r), this._process(), this;
+                },
+                finalize: function (r) {
+                  r && this._append(r);
+                  var n = this._doFinalize();
+                  return n;
+                },
+                blockSize: 16,
+                _createHelper: function (r) {
+                  return function (n, s) {
+                    return new r.init(s).finalize(n);
+                  };
+                },
+                _createHmacHelper: function (r) {
+                  return function (n, s) {
+                    return new x.HMAC.init(r, s).finalize(n);
+                  };
+                },
+              });
+              var x = (_.algo = {});
+              return _;
+            })(Math);
+          return o;
+        });
+      })(ce)),
+    q
+  );
+}
+(function (e, t) {
+  (function (o, a) {
+    e.exports = a(J());
+  })(O, function (o) {
+    return (
+      (function () {
+        var a = o,
+          w = a.lib,
+          l = w.WordArray,
+          S = a.enc;
+        S.Base64url = {
+          stringify: function (_, C = !0) {
+            var y = _.words,
+              d = _.sigBytes,
+              v = C ? this._safe_map : this._map;
+            _.clamp();
+            for (var u = [], h = 0; h < d; h += 3)
+              for (
+                var i = (y[h >>> 2] >>> (24 - (h % 4) * 8)) & 255,
+                  f = (y[(h + 1) >>> 2] >>> (24 - ((h + 1) % 4) * 8)) & 255,
+                  x = (y[(h + 2) >>> 2] >>> (24 - ((h + 2) % 4) * 8)) & 255,
+                  r = (i << 16) | (f << 8) | x,
+                  n = 0;
+                n < 4 && h + n * 0.75 < d;
+                n++
+              )
+                u.push(v.charAt((r >>> (6 * (3 - n))) & 63));
+            var s = v.charAt(64);
+            if (s) for (; u.length % 4; ) u.push(s);
+            return u.join("");
+          },
+          parse: function (_, C = !0) {
+            var y = _.length,
+              d = C ? this._safe_map : this._map,
+              v = this._reverseMap;
+            if (!v) {
+              v = this._reverseMap = [];
+              for (var u = 0; u < d.length; u++) v[d.charCodeAt(u)] = u;
+            }
+            var h = d.charAt(64);
+            if (h) {
+              var i = _.indexOf(h);
+              i !== -1 && (y = i);
+            }
+            return k(_, y, v);
+          },
+          _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+          _safe_map:
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+        };
+        function k(_, C, y) {
+          for (var d = [], v = 0, u = 0; u < C; u++)
+            if (u % 4) {
+              var h = y[_.charCodeAt(u - 1)] << ((u % 4) * 2),
+                i = y[_.charCodeAt(u)] >>> (6 - (u % 4) * 2),
+                f = h | i;
+              (d[v >>> 2] |= f << (24 - (v % 4) * 8)), v++;
+            }
+          return l.create(d, v);
+        }
+      })(),
+      o.enc.Base64url
+    );
+  });
+})(se);
+var V = {},
+  le = {
+    get exports() {
+      return V;
+    },
+    set exports(e) {
+      V = e;
+    },
+  };
+(function (e, t) {
+  (function (o, a) {
+    e.exports = a(J());
+  })(O, function (o) {
+    return (
+      (function (a) {
+        var w = o,
+          l = w.lib,
+          S = l.WordArray,
+          k = l.Hasher,
+          _ = w.algo,
+          C = [],
+          y = [];
+        (function () {
+          function u(x) {
+            for (var r = a.sqrt(x), n = 2; n <= r; n++) if (!(x % n)) return !1;
+            return !0;
+          }
+          function h(x) {
+            return ((x - (x | 0)) * 4294967296) | 0;
+          }
+          for (var i = 2, f = 0; f < 64; )
+            u(i) &&
+              (f < 8 && (C[f] = h(a.pow(i, 1 / 2))),
+              (y[f] = h(a.pow(i, 1 / 3))),
+              f++),
+              i++;
+        })();
+        var d = [],
+          v = (_.SHA256 = k.extend({
+            _doReset: function () {
+              this._hash = new S.init(C.slice(0));
+            },
+            _doProcessBlock: function (u, h) {
+              for (
+                var i = this._hash.words,
+                  f = i[0],
+                  x = i[1],
+                  r = i[2],
+                  n = i[3],
+                  s = i[4],
+                  c = i[5],
+                  p = i[6],
+                  g = i[7],
+                  m = 0;
+                m < 64;
+                m++
+              ) {
+                if (m < 16) d[m] = u[h + m] | 0;
+                else {
+                  var b = d[m - 15],
+                    z =
+                      ((b << 25) | (b >>> 7)) ^
+                      ((b << 14) | (b >>> 18)) ^
+                      (b >>> 3),
+                    H = d[m - 2],
+                    L =
+                      ((H << 15) | (H >>> 17)) ^
+                      ((H << 13) | (H >>> 19)) ^
+                      (H >>> 10);
+                  d[m] = z + d[m - 7] + L + d[m - 16];
+                }
+                var K = (s & c) ^ (~s & p),
+                  Y = (f & x) ^ (f & r) ^ (x & r),
+                  ee =
+                    ((f << 30) | (f >>> 2)) ^
+                    ((f << 19) | (f >>> 13)) ^
+                    ((f << 10) | (f >>> 22)),
+                  re =
+                    ((s << 26) | (s >>> 6)) ^
+                    ((s << 21) | (s >>> 11)) ^
+                    ((s << 7) | (s >>> 25)),
+                  N = g + re + K + y[m] + d[m],
+                  te = ee + Y;
+                (g = p),
+                  (p = c),
+                  (c = s),
+                  (s = (n + N) | 0),
+                  (n = r),
+                  (r = x),
+                  (x = f),
+                  (f = (N + te) | 0);
+              }
+              (i[0] = (i[0] + f) | 0),
+                (i[1] = (i[1] + x) | 0),
+                (i[2] = (i[2] + r) | 0),
+                (i[3] = (i[3] + n) | 0),
+                (i[4] = (i[4] + s) | 0),
+                (i[5] = (i[5] + c) | 0),
+                (i[6] = (i[6] + p) | 0),
+                (i[7] = (i[7] + g) | 0);
+            },
+            _doFinalize: function () {
+              var u = this._data,
+                h = u.words,
+                i = this._nDataBytes * 8,
+                f = u.sigBytes * 8;
+              return (
+                (h[f >>> 5] |= 128 << (24 - (f % 32))),
+                (h[(((f + 64) >>> 9) << 4) + 14] = a.floor(i / 4294967296)),
+                (h[(((f + 64) >>> 9) << 4) + 15] = i),
+                (u.sigBytes = h.length * 4),
+                this._process(),
+                this._hash
+              );
+            },
+            clone: function () {
+              var u = k.clone.call(this);
+              return (u._hash = this._hash.clone()), u;
+            },
+          }));
+        (w.SHA256 = k._createHelper(v)),
+          (w.HmacSHA256 = k._createHmacHelper(v));
+      })(Math),
+      o.SHA256
+    );
+  });
+})(le);
+const de = () => {
+    let e = "";
+    const t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+      o = t.length;
+    let a = 0;
+    for (; a < 128; ) (e += t.charAt(Math.floor(Math.random() * o))), (a += 1);
+    return e;
+  },
+  pe = {
+    environments: {
+      production: {
+        api: "https://api.monerium.app",
+        web: "https://monerium.app",
+      },
+      sandbox: {
+        api: "https://api.monerium.dev",
+        web: "https://sandbox.monerium.dev",
+      },
+    },
+  };
+var $, W, A, R, T, Q, j, X, F, Z;
+class Re {
+  constructor(t = "sandbox") {
+    P(this, A);
+    P(this, T);
+    P(this, j);
+    P(this, F);
+    P(this, $, void 0);
+    P(this, W, void 0);
+    E(this, "codeVerifier");
+    E(this, "bearerProfile");
+    E(this, "pkceRequest", (t) => this.getAuthFlowURI(t));
+    M(this, $, pe.environments[t]);
+  }
+  async auth(t) {
+    let o;
+    if (B(this, T, Q).call(this, t))
+      o = { ...t, grant_type: "authorization_code" };
+    else if (B(this, j, X).call(this, t))
+      o = { ...t, grant_type: "refresh_token" };
+    else if (B(this, F, Z).call(this, t))
+      o = { ...t, grant_type: "client_credentials" };
+    else throw new Error("Authentication method could not be detected.");
+    (this.bearerProfile = await B(this, A, R).call(
+      this,
+      "post",
+      "auth/token",
+      new URLSearchParams(o),
+      !0
+    )),
+      M(this, W, `Bearer ${this.bearerProfile.access_token}`);
+  }
+  getAuthFlowURI(t) {
+    this.codeVerifier = de();
+    const o = D.stringify(V(this.codeVerifier)),
+      a = {
+        ...t,
+        client_id: t == null ? void 0 : t.client_id,
+        code_challenge: o,
+        code_challenge_method: "S256",
+        response_type: "code",
+      };
+    return `${U(this, $).api}/auth?${new URLSearchParams(a)}`;
+  }
+  getAuthContext() {
+    return B(this, A, R).call(this, "get", "auth/context");
+  }
+  getProfile(t) {
+    return B(this, A, R).call(this, "get", `profiles/${t}`);
+  }
+  getBalances(t) {
+    return t
+      ? B(this, A, R).call(this, "get", `profiles/${t}/balances`)
+      : B(this, A, R).call(this, "get", "balances");
+  }
+  getOrders(t) {
+    const o = new URLSearchParams(t);
+    return B(this, A, R).call(this, "get", `orders?${o}`);
+  }
+  getOrder(t) {
+    return B(this, A, R).call(this, "get", `orders/${t}`);
+  }
+  getTokens() {
+    return B(this, A, R).call(this, "get", "tokens");
+  }
+  linkAddress(t, o) {
+    return B(this, A, R).call(
+      this,
+      "post",
+      `profiles/${t}/addresses`,
+      JSON.stringify(o)
+    );
+  }
+  placeOrder(t, o) {
+    return o
+      ? B(this, A, R).call(
+          this,
+          "post",
+          `profiles/${o}/orders`,
+          JSON.stringify(t)
+        )
+      : B(this, A, R).call(this, "post", "orders", JSON.stringify(t));
+  }
+  uploadSupportingDocument(t) {
+    const o = new URLSearchParams(t);
+    return B(this, A, R).call(this, "post", "files/supporting-document", o, !0);
+  }
+}
+($ = new WeakMap()),
+  (W = new WeakMap()),
+  (A = new WeakSet()),
+  (R = async function (t, o, a, w) {
+    const l = await fetch(`${U(this, $).api}/${o}`, {
+      method: t,
+      headers: {
+        "Content-Type": `application/${w ? "x-www-form-urlencoded" : "json"}`,
+        Authorization: U(this, W) || "",
+      },
+      body: a,
+    });
+    let S;
+    try {
+      S = await l.json();
+    } catch {
+      throw await l.text();
+    }
+    if (l.ok) return S;
+    throw S;
+  }),
+  (T = new WeakSet()),
+  (Q = function (t) {
+    return t.code != null;
+  }),
+  (j = new WeakSet()),
+  (X = function (t) {
+    return t.refresh_token != null;
+  }),
+  (F = new WeakSet()),
+  (Z = function (t) {
+    return t.client_secret != null;
+  });
+var ve = /* @__PURE__ */ ((e) => (
+    (e.eur = "eur"), (e.usd = "usd"), (e.gbp = "gbp"), (e.isk = "isk"), e
+  ))(ve || {}),
+  ge = /* @__PURE__ */ ((e) => (
+    (e.corporate = "corporate"), (e.personal = "personal"), e
+  ))(ge || {}),
+  ye = /* @__PURE__ */ ((e) => ((e.read = "read"), (e.write = "write"), e))(
+    ye || {}
+  ),
+  we = /* @__PURE__ */ ((e) => (
+    (e.absent = "absent"),
+    (e.submitted = "submitted"),
+    (e.pending = "pending"),
+    (e.confirmed = "confirmed"),
+    e
+  ))(we || {}),
+  _e = /* @__PURE__ */ ((e) => (
+    (e.approved = "approved"),
+    (e.rejected = "rejected"),
+    (e.unknown = "unknown"),
+    e
+  ))(_e || {}),
+  me = /* @__PURE__ */ ((e) => ((e.iban = "iban"), (e.scan = "scan"), e))(
+    me || {}
+  ),
+  be = /* @__PURE__ */ ((e) => (
+    (e.polygon = "polygon"), (e.ethereum = "ethereum"), (e.gnosis = "gnosis"), e
+  ))(be || {}),
+  Be = /* @__PURE__ */ ((e) => (
+    (e.mainnet = "mainnet"),
+    (e.chiado = "chiado"),
+    (e.goerli = "goerli"),
+    (e.mumbai = "mumbai"),
+    e
+  ))(Be || {}),
+  xe = /* @__PURE__ */ ((e) => ((e.redeem = "redeem"), (e.issue = "issue"), e))(
+    xe || {}
+  ),
+  Ae = /* @__PURE__ */ ((e) => (
+    (e.placed = "placed"),
+    (e.pending = "pending"),
+    (e.processed = "processed"),
+    (e.rejected = "rejected"),
+    e
+  ))(Ae || {});
+export {
+  be as Chain,
+  ve as Currency,
+  _e as KYCOutcome,
+  we as KYCState,
+  Re as MoneriumClient,
+  Be as Network,
+  xe as OrderKind,
+  Ae as OrderState,
+  me as PaymentStandard,
+  ye as Permission,
+  ge as ProfileType,
+};
+//# sourceMappingURL=index.mjs.map