@monerium/sdk 1.0.20 → 2.0.0-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 monerium 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,93 +1,28 @@
 # @monerium/sdk
 
-Everything you need to interact with the Monerium API - An electronic money issuer.
+Everything you need to interact with the Monerium API - an electronic money issuer.
 
-_This package is in development. Please make sure to check if any future updates contain commits that may change the behavior of your application before you upgrade._
+_This package is in development. Please make sure to check if any future updates contain commits
+that may change the behavior of your application before you upgrade._
 
-## Authentication
+## Installing
 
-```ts
-import { MoneriumClient } from 'monerium-js';
-
-const client = await MoneriumClient.create();
-
-// Depending on the authentication method you want to use,
-// make sure to pass the correct arguments to the `auth` method.
-// Optional arguments can be omitted.
-
-// --- BASIC Authentication --- //
-
-await client.auth({ email: '<required>', password: '<required>' });
-
-// --- BEARER PKCE Authentication --- //
-
-// 1. Redirect to Monerium PKCE Authentication flow.
-await client
-	.auth({
-		client_id: '<required>',
-		state: '<recommended>',
-		address: '<optional>',
-		redirect_uri: '<optional>',
-		scope: '<optional>'
-	})
-	.then(() => {
-		// store the `code_verifier` from `client.codeVerifier` for later.
-		sessionStorage.setItem('code_verifier', client.codeVerifier);
-	});
-
-// User will be redirected to the redirect_url with
-// the code and the state in query parameters
-// Make sure to compare the state from the response and the one you passed.
-
-// 2. Redeem Code
-const bearerProfile = await client.auth({
-	client_id: '<required>',
-	code: '<required>',
-	code_verifier: sessionStorage.getItem('code_verifier'),
-	redirect_uri: '<can be omitted if not set in request>',
-	scope: '<optional>'
-});
-
-// Note: In case steps 1 and 2 are executed in different environments,
-// e.g. 1 in the browser and 2 on the server, you can pass a bearer
-// profile in order to authenticate as shown below.
-
-client.auth(bearerProfile);
-
-// --- BEARER Client Authentication --- //
-
-await client.auth({ client_id: '<required>', client_secret: '<required>', scope: '<optional>' });
-
-// --- Client Attributes --- //
-
-client.authContext;
-client.bearerProfile;
-```
-
-## Demo
-
-To check out the demo site for this pacakge, run the following commands:
-
-```bash
-yarn install
-yarn dev
+```sh
+# Node 
+yarn add @monerium/sdk
 ```
 
 ## Developing
 
-If you want to make any code contributions, make sure to run the following commands before you pr them:
+If you want to make any code contributions, make sure to run the following commands before you pr
+them:
 
-```bash
-yarn format
-yarn lint
-yarn test
+```sh
+deno fmt
+deno lint
+deno test --allow-net=api.monerium.dev
 ```
 
 ## Publishing
 
-If you want to modify and publish the package yourself, run the following commands:
-
-```bash
-yarn package
-yarn publish
-```
+Tagging a release on GitHub will publish the package to NPM and Deno Land.

package/esm/_dnt.shims.js

@@ -0,0 +1,76 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+import { crypto } from "@deno/shim-crypto";
+export { crypto } from "@deno/shim-crypto";
+import { fetch, File, FormData, Headers, Request, Response } from "undici";
+export { fetch, File, FormData, Headers, Request, Response } from "undici";
+import { TextEncoder } from "util";
+export { TextEncoder } from "util";
+const dntGlobals = {
+    Deno,
+    crypto,
+    fetch,
+    File,
+    FormData,
+    Headers,
+    Request,
+    Response,
+    TextEncoder,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/deps/deno.land/std@0.159.0/encoding/base64.js

@@ -0,0 +1,123 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+/**
+ * {@linkcode encode} and {@linkcode decode} for
+ * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
+ *
+ * This module is browser compatible.
+ *
+ * @module
+ */
+import * as dntShim from "../../../../_dnt.shims.js";
+const base64abc = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "+",
+    "/",
+];
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export function encode(data) {
+    const uint8 = typeof data === "string"
+        ? new dntShim.TextEncoder().encode(data)
+        : data instanceof Uint8Array
+            ? data
+            : new Uint8Array(data);
+    let result = "", i;
+    const l = uint8.length;
+    for (i = 2; i < l; i += 3) {
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
+        result += base64abc[uint8[i] & 0x3f];
+    }
+    if (i === l + 1) {
+        // 1 octet yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[(uint8[i - 2] & 0x03) << 4];
+        result += "==";
+    }
+    if (i === l) {
+        // 2 octets yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += base64abc[(uint8[i - 1] & 0x0f) << 2];
+        result += "=";
+    }
+    return result;
+}
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export function decode(b64) {
+    const binString = atob(b64);
+    const size = binString.length;
+    const bytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        bytes[i] = binString.charCodeAt(i);
+    }
+    return bytes;
+}

package/esm/deps/deno.land/std@0.159.0/encoding/base64url.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+/**
+ * {@linkcode encode} and {@linkcode decode} for
+ * [base64 URL safe](https://en.wikipedia.org/wiki/Base64#URL_applications) encoding.
+ *
+ * This module is browser compatible.
+ *
+ * @module
+ */
+import * as base64 from "./base64.js";
+/*
+ * Some variants allow or require omitting the padding '=' signs:
+ * https://en.wikipedia.org/wiki/Base64#The_URL_applications
+ * @param base64url
+ */
+function addPaddingToBase64url(base64url) {
+    if (base64url.length % 4 === 2)
+        return base64url + "==";
+    if (base64url.length % 4 === 3)
+        return base64url + "=";
+    if (base64url.length % 4 === 1) {
+        throw new TypeError("Illegal base64url string!");
+    }
+    return base64url;
+}
+function convertBase64urlToBase64(b64url) {
+    if (!/^[-_A-Z0-9]*?={0,2}$/i.test(b64url)) {
+        // Contains characters not part of base64url spec.
+        throw new TypeError("Failed to decode base64url: invalid character");
+    }
+    return addPaddingToBase64url(b64url).replace(/\-/g, "+").replace(/_/g, "/");
+}
+function convertBase64ToBase64url(b64) {
+    return b64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+/**
+ * Encodes a given ArrayBuffer or string into a base64url representation
+ * @param data
+ */
+export function encode(data) {
+    return convertBase64ToBase64url(base64.encode(data));
+}
+/**
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+export function decode(b64url) {
+    return base64.decode(convertBase64urlToBase64(b64url));
+}

package/esm/mod.js

@@ -0,0 +1 @@
+export { MoneriumClient } from "./src/client.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/src/client.js

@@ -0,0 +1,139 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MoneriumClient_instances, _MoneriumClient_env, _MoneriumClient_authPayload, _MoneriumClient_api, _MoneriumClient_isAuthCode, _MoneriumClient_isRefreshToken, _MoneriumClient_isClientCredentials;
+import * as dntShim from "../_dnt.shims.js";
+import { encode as encodeBase64 } from "../deps/deno.land/std@0.159.0/encoding/base64.js";
+import { encode as encodeBase64URL } from "../deps/deno.land/std@0.159.0/encoding/base64url.js";
+import { MONERIUM_CONFIG } from "./config.js";
+export class MoneriumClient {
+    constructor(env = "sandbox") {
+        _MoneriumClient_instances.add(this);
+        _MoneriumClient_env.set(this, void 0);
+        _MoneriumClient_authPayload.set(this, void 0);
+        Object.defineProperty(this, "codeVerifier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bearerProfile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        __classPrivateFieldSet(this, _MoneriumClient_env, MONERIUM_CONFIG.environments[env], "f");
+    }
+    // -- Authentication
+    async auth(args) {
+        let params;
+        if (__classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_isAuthCode).call(this, args)) {
+            params = { ...args, grant_type: "authorization_code" };
+        }
+        else if (__classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_isRefreshToken).call(this, args)) {
+            params = { ...args, grant_type: "refresh_token" };
+        }
+        else if (__classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_isClientCredentials).call(this, args)) {
+            params = { ...args, grant_type: "client_credentials" };
+        }
+        else {
+            throw new Error("Authentication method could not be detected.");
+        }
+        this.bearerProfile = (await __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "post", `auth/token`, new URLSearchParams(params), true));
+        __classPrivateFieldSet(this, _MoneriumClient_authPayload, `Bearer ${this.bearerProfile.access_token}`, "f");
+    }
+    async pkceRequest(args) {
+        const buffer = dntShim.crypto.getRandomValues(new Uint8Array(128 / 2));
+        let randomString = "";
+        for (let i = 0; i < buffer.length; ++i) {
+            randomString += ("0" + buffer[i].toString(16)).slice(-2);
+        }
+        this.codeVerifier = randomString;
+        const data = new dntShim.TextEncoder().encode(this.codeVerifier);
+        const digest = await dntShim.crypto.subtle.digest("SHA-256", data);
+        const base64Digest = encodeBase64(digest);
+        const challenge = encodeBase64URL(base64Digest);
+        const params = {
+            ...args,
+            code_challenge: challenge,
+            code_challenge_method: "S256",
+            response_type: "code",
+        };
+        return `${__classPrivateFieldGet(this, _MoneriumClient_env, "f").api}/auth?${new URLSearchParams(params)}`;
+    }
+    // -- Read Methods
+    getAuthContext() {
+        return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "get", `auth/context`);
+    }
+    getProfile(profileId) {
+        return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "get", `profiles/${profileId}`);
+    }
+    getBalances(profileId) {
+        if (profileId) {
+            return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "get", `profiles/${profileId}/balances`);
+        }
+        else {
+            return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "get", `balances`);
+        }
+    }
+    getOrders(filter) {
+        const searchParams = new URLSearchParams(filter);
+        return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "get", `orders?${searchParams}`);
+    }
+    getOrder(orderId) {
+        return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "get", `orders/${orderId}`);
+    }
+    getTokens() {
+        return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "get", "tokens");
+    }
+    // -- Write Methods
+    linkAddress(profileId, body) {
+        return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "post", `profiles/${profileId}/addresses`, JSON.stringify(body));
+    }
+    placeOrder(order, profileId) {
+        if (profileId) {
+            return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "post", `profiles/${profileId}/orders`, JSON.stringify(order));
+        }
+        else {
+            return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "post", `orders`, JSON.stringify(order));
+        }
+    }
+    uploadSupportingDocument(document) {
+        const searchParams = new URLSearchParams(document);
+        return __classPrivateFieldGet(this, _MoneriumClient_instances, "m", _MoneriumClient_api).call(this, "post", "files/supporting-document", searchParams, true);
+    }
+}
+_MoneriumClient_env = new WeakMap(), _MoneriumClient_authPayload = new WeakMap(), _MoneriumClient_instances = new WeakSet(), _MoneriumClient_api = 
+// -- Helper Methods
+async function _MoneriumClient_api(method, resource, body, isFormEncoded) {
+    const res = await dntShim.fetch(`${__classPrivateFieldGet(this, _MoneriumClient_env, "f").api}/${resource}`, {
+        method,
+        headers: {
+            "Content-Type": `application/${isFormEncoded ? "x-www-form-urlencoded" : "json"}`,
+            Authorization: __classPrivateFieldGet(this, _MoneriumClient_authPayload, "f") || "",
+        },
+        body,
+    });
+    const response = await res.json();
+    if (res.ok) {
+        return response;
+    }
+    else {
+        throw response;
+    }
+}, _MoneriumClient_isAuthCode = function _MoneriumClient_isAuthCode(args) {
+    return args.code != undefined;
+}, _MoneriumClient_isRefreshToken = function _MoneriumClient_isRefreshToken(args) {
+    return args.refresh_token != undefined;
+}, _MoneriumClient_isClientCredentials = function _MoneriumClient_isClientCredentials(args) {
+    return args.client_secret != undefined;
+};

package/esm/src/config.js

@@ -0,0 +1,13 @@
+const MONERIUM_CONFIG = {
+    environments: {
+        production: {
+            api: "https://api.monerium.app",
+            web: "https://monerium.app",
+        },
+        sandbox: {
+            api: "https://api.monerium.dev",
+            web: "https://sandbox.monerium.dev",
+        },
+    },
+};
+export { MONERIUM_CONFIG };

package/esm/src/types.js

@@ -0,0 +1,73 @@
+// --- Config --- //
+// --- Client Methods  --- //
+export var Currency;
+(function (Currency) {
+    Currency["eur"] = "eur";
+    Currency["usd"] = "usd";
+    Currency["gbp"] = "gbp";
+    Currency["isk"] = "isk";
+})(Currency || (Currency = {}));
+// -- authContext
+var Method;
+(function (Method) {
+    Method["password"] = "password";
+    Method["resource"] = "resource";
+    Method["jwt"] = "jwt";
+    Method["apiKey"] = "apiKey";
+})(Method || (Method = {}));
+var Type;
+(function (Type) {
+    Type["corporate"] = "corporate";
+    Type["personal"] = "personal";
+})(Type || (Type = {}));
+var Permission;
+(function (Permission) {
+    Permission["read"] = "read";
+    Permission["write"] = "write";
+})(Permission || (Permission = {}));
+// -- getProfile
+var KYCState;
+(function (KYCState) {
+    KYCState["absent"] = "absent";
+    KYCState["submitted"] = "submitted";
+    KYCState["pending"] = "pending";
+    KYCState["confirmed"] = "confirmed";
+})(KYCState || (KYCState = {}));
+var KYCOutcome;
+(function (KYCOutcome) {
+    KYCOutcome["approved"] = "approved";
+    KYCOutcome["rejected"] = "rejected";
+    KYCOutcome["unknown"] = "unknown";
+})(KYCOutcome || (KYCOutcome = {}));
+export var PaymentStandard;
+(function (PaymentStandard) {
+    PaymentStandard["iban"] = "iban";
+    PaymentStandard["scan"] = "scan";
+})(PaymentStandard || (PaymentStandard = {}));
+// -- getBalances
+export var Chain;
+(function (Chain) {
+    Chain["polygon"] = "polygon";
+    Chain["ethereum"] = "ethereum";
+    Chain["gnosis"] = "gnosis";
+})(Chain || (Chain = {}));
+export var Network;
+(function (Network) {
+    Network["mainnet"] = "mainnet";
+    Network["chiado"] = "chiado";
+    Network["goerli"] = "goerli";
+    Network["mumbai"] = "mumbai";
+})(Network || (Network = {}));
+// --getOrders
+export var OrderKind;
+(function (OrderKind) {
+    OrderKind["redeem"] = "redeem";
+    OrderKind["issue"] = "issue";
+})(OrderKind || (OrderKind = {}));
+var OrderState;
+(function (OrderState) {
+    OrderState["placed"] = "placed";
+    OrderState["pending"] = "pending";
+    OrderState["processed"] = "processed";
+    OrderState["rejected"] = "rejected";
+})(OrderState || (OrderState = {}));