@tonconnect/sdk 0.0.43 → 0.0.45

package/lib/esm/provider/injected/injected-provider.js

@@ -0,0 +1,121 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { WalletNotInjectedError } from "../../errors/wallet/wallet-not-injected.error";
+import { BridgeConnectionStorage } from "../../storage/bridge-connection-storage";
+import { getWindow } from "../../utils/web-api";
+import { PROTOCOL_VERSION } from "../../resources/protocol";
+export class InjectedProvider {
+    constructor(injectedWalletKey) {
+        this.type = 'injected';
+        this.unsubscribeCallback = null;
+        this.listenSubscriptions = false;
+        this.listeners = [];
+        const window = InjectedProvider.window;
+        if (!InjectedProvider.isWindowContainsWallet(window, injectedWalletKey)) {
+            throw new WalletNotInjectedError();
+        }
+        this.injectedWallet = window[injectedWalletKey].tonconnect;
+    }
+    static fromStorage(storage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bridgeConnectionStorage = new BridgeConnectionStorage(storage);
+            const connection = yield bridgeConnectionStorage.getInjectedConnection();
+            return new InjectedProvider(connection.jsBridgeKey);
+        });
+    }
+    static isWalletInjected(injectedWalletKey) {
+        return InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey);
+    }
+    static isInsideWalletBrowser(injectedWalletKey) {
+        if (InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey)) {
+            return this.window[injectedWalletKey].tonconnect.isWalletBrowser;
+        }
+        return false;
+    }
+    static isWindowContainsWallet(window, injectedWalletKey) {
+        return (!!window &&
+            injectedWalletKey in window &&
+            typeof window[injectedWalletKey] === 'object' &&
+            'tonconnect' in window[injectedWalletKey]);
+    }
+    connect(message, auto = false) {
+        this.injectedWallet
+            .connect(PROTOCOL_VERSION, message, auto)
+            .then(connectEvent => {
+            if (connectEvent.event === 'connect') {
+                this.makeSubscriptions();
+                this.listenSubscriptions = true;
+            }
+            this.listeners.forEach(listener => listener(connectEvent));
+        })
+            .catch(e => {
+            const connectEventError = {
+                event: 'connect_error',
+                payload: {
+                    code: 0,
+                    message: e === null || e === void 0 ? void 0 : e.toString()
+                }
+            };
+            this.listeners.forEach(listener => listener(connectEventError));
+        });
+    }
+    restoreConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connectEvent = yield this.injectedWallet.restoreConnection();
+                if (connectEvent.event === 'connect') {
+                    this.makeSubscriptions();
+                    this.listenSubscriptions = true;
+                    this.listeners.forEach(listener => listener(connectEvent));
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    closeConnection() {
+        if (this.listenSubscriptions) {
+            this.injectedWallet.disconnect();
+        }
+        this.closeAllListeners();
+    }
+    disconnect() {
+        this.closeAllListeners();
+        this.injectedWallet.disconnect();
+        return Promise.resolve();
+    }
+    closeAllListeners() {
+        var _a;
+        this.listenSubscriptions = false;
+        this.listeners = [];
+        (_a = this.unsubscribeCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    listen(eventsCallback) {
+        this.listeners.push(eventsCallback);
+        return () => (this.listeners = this.listeners.filter(listener => listener !== eventsCallback));
+    }
+    sendRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.injectedWallet.send(Object.assign(Object.assign({}, request), { id: '0' }));
+        });
+    }
+    makeSubscriptions() {
+        this.unsubscribeCallback = this.injectedWallet.listen(e => {
+            if (this.listenSubscriptions) {
+                this.listeners.forEach(listener => listener(e));
+            }
+            if (e.event === 'disconnect') {
+                this.disconnect();
+            }
+        });
+    }
+}
+InjectedProvider.window = getWindow();

package/lib/esm/provider/injected/models/injected-wallet-api.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/provider/provider.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/resources/protocol.js

@@ -0,0 +1 @@
+export const PROTOCOL_VERSION = 2;

package/lib/esm/storage/bridge-connection-storage.js

@@ -0,0 +1,96 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SessionCrypto } from '@tonconnect/protocol';
+import { TonConnectError } from "../errors";
+export class BridgeConnectionStorage {
+    constructor(storage) {
+        this.storage = storage;
+        this.storeKey = 'ton-connect-storage_bridge-connection';
+    }
+    storeConnection(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (connection.type === 'injected') {
+                return this.storage.setItem(this.storeKey, JSON.stringify(connection));
+            }
+            const rawSession = {
+                sessionKeyPair: connection.session.sessionCrypto.stringifyKeypair(),
+                walletPublicKey: connection.session.walletPublicKey,
+                walletConnectionSource: connection.session.walletConnectionSource
+            };
+            const rawConnection = {
+                type: 'http',
+                connectEvent: connection.connectEvent,
+                session: rawSession
+            };
+            return this.storage.setItem(this.storeKey, JSON.stringify(rawConnection));
+        });
+    }
+    removeConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.removeItem(this.storeKey);
+        });
+    }
+    getConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stored = yield this.storage.getItem(this.storeKey);
+            if (!stored) {
+                return null;
+            }
+            const connection = JSON.parse(stored);
+            if (connection.type === 'injected') {
+                return connection;
+            }
+            const sessionCrypto = new SessionCrypto(connection.session.sessionKeyPair);
+            return {
+                type: 'http',
+                connectEvent: connection.connectEvent,
+                session: {
+                    sessionCrypto,
+                    walletConnectionSource: connection.session.walletConnectionSource,
+                    walletPublicKey: connection.session.walletPublicKey
+                }
+            };
+        });
+    }
+    getHttpConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            if (!connection) {
+                throw new TonConnectError('Trying to read HTTP connection source while nothing is stored');
+            }
+            if (connection.type === 'injected') {
+                throw new TonConnectError('Trying to read HTTP connection source while injected connection is stored');
+            }
+            return connection;
+        });
+    }
+    getInjectedConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            if (!connection) {
+                throw new TonConnectError('Trying to read Injected bridge connection source while nothing is stored');
+            }
+            if ((connection === null || connection === void 0 ? void 0 : connection.type) === 'http') {
+                throw new TonConnectError('Trying to read Injected bridge connection source while HTTP connection is stored');
+            }
+            return connection;
+        });
+    }
+    storedConnectionType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stored = yield this.storage.getItem(this.storeKey);
+            if (!stored) {
+                return null;
+            }
+            const connection = JSON.parse(stored);
+            return connection.type;
+        });
+    }
+}

package/lib/esm/storage/default-storage.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LocalstorageNotFoundError } from "../errors/storage/localstorage-not-found.error";
+import { getWindow } from "../utils/web-api";
+export class DefaultStorage {
+    constructor() {
+        const window = getWindow();
+        if (!(window === null || window === void 0 ? void 0 : window.localStorage)) {
+            throw new LocalstorageNotFoundError();
+        }
+        this.window = window;
+    }
+    getItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(this.window.localStorage.getItem(key));
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.window.localStorage.removeItem(key);
+            return Promise.resolve();
+        });
+    }
+    setItem(key, value) {
+        this.window.localStorage.setItem(key, value);
+        return Promise.resolve();
+    }
+}

package/lib/esm/storage/http-bridge-gateway-storage.js

@@ -0,0 +1,34 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class HttpBridgeGatewayStorage {
+    constructor(storage) {
+        this.storage = storage;
+        this.storeKey = 'ton-connect-storage_http-bridge-gateway';
+    }
+    storeLastEventId(lastEventId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.setItem(this.storeKey, lastEventId);
+        });
+    }
+    removeLastEventId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.removeItem(this.storeKey);
+        });
+    }
+    getLastEventId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stored = yield this.storage.getItem(this.storeKey);
+            if (!stored) {
+                return null;
+            }
+            return stored;
+        });
+    }
+}

package/lib/esm/storage/models/storage.interface.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/ton-connect.interface.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/ton-connect.js

@@ -0,0 +1,252 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { DappMetadataError } from "./errors/dapp/dapp-metadata.error";
+import { ManifestContentErrorError } from "./errors/protocol/events/connect/manifest-content-error.error";
+import { ManifestNotFoundError } from "./errors/protocol/events/connect/manifest-not-found.error";
+import { TonConnectError } from "./errors/ton-connect.error";
+import { WalletAlreadyConnectedError } from "./errors/wallet/wallet-already-connected.error";
+import { WalletNotConnectedError } from "./errors/wallet/wallet-not-connected.error";
+import { WalletNotSupportFeatureError } from "./errors/wallet/wallet-not-support-feature.error";
+import { isWalletConnectionSourceJS } from "./models/wallet/wallet-connection-source";
+import { connectErrorsParser } from "./parsers/connect-errors-parser";
+import { sendTransactionParser } from "./parsers/send-transaction-parser";
+import { BridgeProvider } from "./provider/bridge/bridge-provider";
+import { InjectedProvider } from "./provider/injected/injected-provider";
+import { BridgeConnectionStorage } from "./storage/bridge-connection-storage";
+import { DefaultStorage } from "./storage/default-storage";
+import { getWebPageManifest } from "./utils/web-api";
+import { WalletsListManager } from "./wallets-list-manager";
+export class TonConnect {
+    constructor(options) {
+        this.walletsList = new WalletsListManager();
+        this._wallet = null;
+        this.provider = null;
+        this.statusChangeSubscriptions = [];
+        this.statusChangeErrorSubscriptions = [];
+        this.dappSettings = {
+            manifestUrl: (options === null || options === void 0 ? void 0 : options.manifestUrl) || getWebPageManifest(),
+            storage: (options === null || options === void 0 ? void 0 : options.storage) || new DefaultStorage()
+        };
+        if (!this.dappSettings.manifestUrl) {
+            throw new DappMetadataError('Dapp tonconnect-manifest.json must be specified if window.location.origin is undefined. See more https://github.com/ton-connect/docs/blob/main/requests-responses.md#app-manifest');
+        }
+        this.bridgeConnectionStorage = new BridgeConnectionStorage(this.dappSettings.storage);
+    }
+    /**
+     * Shows if the wallet is connected right now.
+     */
+    get connected() {
+        return this._wallet !== null;
+    }
+    /**
+     * Current connected account or null if no account is connected.
+     */
+    get account() {
+        var _a;
+        return ((_a = this._wallet) === null || _a === void 0 ? void 0 : _a.account) || null;
+    }
+    /**
+     * Current connected wallet or null if no account is connected.
+     */
+    get wallet() {
+        return this._wallet;
+    }
+    set wallet(value) {
+        this._wallet = value;
+        this.statusChangeSubscriptions.forEach(callback => callback(this._wallet));
+    }
+    /**
+     * Returns available wallets list.
+     */
+    getWallets() {
+        return this.walletsList.getWallets();
+    }
+    /**
+     * Allows to subscribe to connection status changes and handle connection errors.
+     * @param callback will be called after connections status changes with actual wallet or null.
+     * @param errorsHandler (optional) will be called with some instance of TonConnectError when connect error is received.
+     * @returns unsubscribe callback.
+     */
+    onStatusChange(callback, errorsHandler) {
+        this.statusChangeSubscriptions.push(callback);
+        if (errorsHandler) {
+            this.statusChangeErrorSubscriptions.push(errorsHandler);
+        }
+        return () => {
+            this.statusChangeSubscriptions = this.statusChangeSubscriptions.filter(item => item !== callback);
+            if (errorsHandler) {
+                this.statusChangeErrorSubscriptions = this.statusChangeErrorSubscriptions.filter(item => item !== errorsHandler);
+            }
+        };
+    }
+    connect(wallet, request) {
+        var _a;
+        if (this.connected) {
+            throw new WalletAlreadyConnectedError();
+        }
+        (_a = this.provider) === null || _a === void 0 ? void 0 : _a.closeConnection();
+        this.provider = this.createProvider(wallet);
+        return this.provider.connect(this.createConnectRequest(request));
+    }
+    /**
+     * Try to restore existing session and reconnect to the corresponding wallet. Call it immediately when your app is loaded.
+     */
+    restoreConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [bridgeConnectionType, embeddedWallet] = yield Promise.all([
+                this.bridgeConnectionStorage.storedConnectionType(),
+                this.walletsList.getEmbeddedWallet()
+            ]);
+            switch (bridgeConnectionType) {
+                case 'http':
+                    this.provider = yield BridgeProvider.fromStorage(this.dappSettings.storage);
+                    break;
+                case 'injected':
+                    this.provider = yield InjectedProvider.fromStorage(this.dappSettings.storage);
+                    break;
+                default:
+                    if (embeddedWallet) {
+                        this.provider = yield this.createProvider(embeddedWallet);
+                    }
+                    else {
+                        return;
+                    }
+            }
+            this.provider.listen(this.walletEventsListener.bind(this));
+            return this.provider.restoreConnection();
+        });
+    }
+    /**
+     * Asks connected wallet to sign and send the transaction.
+     * @param transaction transaction to send.
+     * @returns signed transaction boc that allows you to find the transaction in the blockchain.
+     * If user rejects transaction, method will throw the corresponding error.
+     */
+    sendTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkConnection();
+            this.checkFeatureSupport('SendTransaction');
+            const { validUntil } = transaction, tx = __rest(transaction, ["validUntil"]);
+            const response = yield this.provider.sendRequest(sendTransactionParser.convertToRpcRequest(Object.assign(Object.assign({}, tx), { valid_until: validUntil })));
+            if (sendTransactionParser.isError(response)) {
+                return sendTransactionParser.parseAndThrowError(response);
+            }
+            return sendTransactionParser.convertFromRpcResponse(response);
+        });
+    }
+    /**
+     * Disconnect form thw connected wallet and drop current session.
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                throw new WalletNotConnectedError();
+            }
+            yield this.provider.disconnect();
+            this.onWalletDisconnected();
+        });
+    }
+    createProvider(wallet) {
+        let provider;
+        if (isWalletConnectionSourceJS(wallet)) {
+            provider = new InjectedProvider(wallet.jsBridgeKey);
+        }
+        else {
+            provider = new BridgeProvider(this.dappSettings.storage, wallet);
+        }
+        provider.listen(this.walletEventsListener.bind(this));
+        return provider;
+    }
+    walletEventsListener(e) {
+        switch (e.event) {
+            case 'connect':
+                this.onWalletConnected(e.payload);
+                break;
+            case 'connect_error':
+                this.onWalletConnectError(e.payload);
+                break;
+            case 'disconnect':
+                this.onWalletDisconnected();
+        }
+    }
+    onWalletConnected(connectEvent) {
+        const tonAccountItem = connectEvent.items.find(item => item.name === 'ton_addr');
+        const tonProofItem = connectEvent.items.find(item => item.name === 'ton_proof');
+        if (!tonAccountItem) {
+            throw new TonConnectError('ton_addr connection item was not found');
+        }
+        const wallet = {
+            device: connectEvent.device,
+            provider: this.provider.type,
+            account: {
+                address: tonAccountItem.address,
+                chain: tonAccountItem.network,
+                walletStateInit: tonAccountItem.walletStateInit
+            }
+        };
+        if (tonProofItem) {
+            wallet.connectItems = {
+                tonProof: tonProofItem
+            };
+        }
+        this.wallet = wallet;
+    }
+    onWalletConnectError(connectEventError) {
+        const error = connectErrorsParser.parseError(connectEventError);
+        this.statusChangeErrorSubscriptions.forEach(errorsHandler => errorsHandler(error));
+        console.debug(error);
+        if (error instanceof ManifestNotFoundError || error instanceof ManifestContentErrorError) {
+            console.error(error);
+            throw error;
+        }
+    }
+    onWalletDisconnected() {
+        this.wallet = null;
+    }
+    checkConnection() {
+        if (!this.connected) {
+            throw new WalletNotConnectedError();
+        }
+    }
+    checkFeatureSupport(feature) {
+        var _a;
+        if (!((_a = this.wallet) === null || _a === void 0 ? void 0 : _a.device.features.includes(feature))) {
+            throw new WalletNotSupportFeatureError();
+        }
+    }
+    createConnectRequest(request) {
+        const items = [
+            {
+                name: 'ton_addr'
+            }
+        ];
+        if (request === null || request === void 0 ? void 0 : request.tonProof) {
+            items.push({
+                name: 'ton_proof',
+                payload: request.tonProof
+            });
+        }
+        return {
+            manifestUrl: this.dappSettings.manifestUrl,
+            items
+        };
+    }
+}

package/lib/esm/utils/address.js

@@ -0,0 +1,83 @@
+import { WrongAddressError, ParseHexError } from "../errors";
+import { Base64 } from '@tonconnect/protocol';
+export function toUserFriendlyAddress(hexAddress) {
+    const { wc, hex } = parseHexAddress(hexAddress);
+    const bounceableTag = 0x11;
+    const addr = new Int8Array(34);
+    addr[0] = bounceableTag;
+    addr[1] = wc;
+    addr.set(hex, 2);
+    const addressWithChecksum = new Uint8Array(36);
+    addressWithChecksum.set(addr);
+    addressWithChecksum.set(crc16(addr), 34);
+    let addressBase64 = Base64.encode(addressWithChecksum);
+    return addressBase64.replace(/\+/g, '-').replace(/\//g, '_');
+}
+function parseHexAddress(hexAddress) {
+    if (!hexAddress.includes(':')) {
+        throw new WrongAddressError(`Wrong address ${hexAddress}. Address must include ":".`);
+    }
+    const parts = hexAddress.split(':');
+    if (parts.length !== 2) {
+        throw new WrongAddressError(`Wrong address ${hexAddress}. Address must include ":" only once.`);
+    }
+    const wc = parseInt(parts[0]);
+    if (wc !== 0 && wc !== -1) {
+        throw new WrongAddressError(`Wrong address ${hexAddress}. WC must be eq 0 or -1, but ${wc} received.`);
+    }
+    const hex = parts[1];
+    if ((hex === null || hex === void 0 ? void 0 : hex.length) !== 64) {
+        throw new WrongAddressError(`Wrong address ${hexAddress}. Hex part must be 64bytes length, but ${hex === null || hex === void 0 ? void 0 : hex.length} received.`);
+    }
+    return {
+        wc,
+        hex: hexToBytes(hex)
+    };
+}
+function crc16(data) {
+    const poly = 0x1021;
+    let reg = 0;
+    const message = new Uint8Array(data.length + 2);
+    message.set(data);
+    for (let byte of message) {
+        let mask = 0x80;
+        while (mask > 0) {
+            reg <<= 1;
+            if (byte & mask) {
+                reg += 1;
+            }
+            mask >>= 1;
+            if (reg > 0xffff) {
+                reg &= 0xffff;
+                reg ^= poly;
+            }
+        }
+    }
+    return new Uint8Array([Math.floor(reg / 256), reg % 256]);
+}
+const toByteMap = {};
+for (let ord = 0; ord <= 0xff; ord++) {
+    let s = ord.toString(16);
+    if (s.length < 2) {
+        s = '0' + s;
+    }
+    toByteMap[s] = ord;
+}
+function hexToBytes(hex) {
+    hex = hex.toLowerCase();
+    const length2 = hex.length;
+    if (length2 % 2 !== 0) {
+        throw new ParseHexError('Hex string must have length a multiple of 2: ' + hex);
+    }
+    const length = length2 / 2;
+    const result = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        const doubled = i * 2;
+        const hexSubstring = hex.substring(doubled, doubled + 2);
+        if (!toByteMap.hasOwnProperty(hexSubstring)) {
+            throw new ParseHexError('Invalid hex character: ' + hexSubstring);
+        }
+        result[i] = toByteMap[hexSubstring];
+    }
+    return result;
+}

package/lib/esm/utils/options.js

@@ -0,0 +1,8 @@
+import deepmerge from 'deepmerge';
+export function mergeOptions(options, defaultOptions) {
+    if (!options) {
+        return defaultOptions;
+    }
+    const overwriteMerge = (_, sourceArray, __) => sourceArray;
+    return deepmerge(defaultOptions, options, { arrayMerge: overwriteMerge });
+}

package/lib/esm/utils/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/utils/url.js

@@ -0,0 +1,9 @@
+export function removeUrlLastSlash(url) {
+    if (url.slice(-1) === '/') {
+        return url.slice(0, -1);
+    }
+    return url;
+}
+export function addPathToUrl(url, path) {
+    return removeUrlLastSlash(url) + '/' + path;
+}