@arkade-os/sdk 0.3.12 → 0.4.0-next.0

package/dist/esm/repositories/migrations/walletRepositoryImpl.js

@@ -0,0 +1,176 @@
+import { hex } from "@scure/base";
+import { TaprootControlBlock } from "@scure/btc-signer";
+const getVtxosStorageKey = (address) => `vtxos:${address}`;
+const getUtxosStorageKey = (address) => `utxos:${address}`;
+const getTransactionsStorageKey = (address) => `tx:${address}`;
+const walletStateStorageKey = "wallet:state";
+// Utility functions for (de)serializing complex structures
+const serializeVtxo = (v) => ({
+    ...v,
+    tapTree: hex.encode(v.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
+    extraWitness: v.extraWitness?.map(hex.encode),
+});
+const serializeUtxo = (u) => ({
+    ...u,
+    tapTree: hex.encode(u.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
+    extraWitness: u.extraWitness?.map(hex.encode),
+});
+const deserializeVtxo = (o) => ({
+    ...o,
+    createdAt: new Date(o.createdAt),
+    tapTree: hex.decode(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(hex.decode),
+});
+const deserializeUtxo = (o) => ({
+    ...o,
+    tapTree: hex.decode(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(hex.decode),
+});
+const serializeTapLeaf = ([cb, s]) => ({
+    cb: hex.encode(TaprootControlBlock.encode(cb)),
+    s: hex.encode(s),
+});
+const deserializeTapLeaf = (t) => {
+    const cb = TaprootControlBlock.decode(hex.decode(t.cb));
+    const s = hex.decode(t.s);
+    return [cb, s];
+};
+/**
+ * @deprecated This is only to be used in migration from storage V1
+ */
+export class WalletRepositoryImpl {
+    constructor(storage) {
+        this.version = 1;
+        this.storage = storage;
+    }
+    async getVtxos(address) {
+        const stored = await this.storage.getItem(getVtxosStorageKey(address));
+        if (!stored)
+            return [];
+        try {
+            const parsed = JSON.parse(stored);
+            return parsed.map(deserializeVtxo);
+        }
+        catch (error) {
+            console.error(`Failed to parse VTXOs for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveVtxos(address, vtxos) {
+        const storedVtxos = await this.getVtxos(address);
+        for (const vtxo of vtxos) {
+            const existing = storedVtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
+            if (existing !== -1) {
+                storedVtxos[existing] = vtxo;
+            }
+            else {
+                storedVtxos.push(vtxo);
+            }
+        }
+        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(storedVtxos.map(serializeVtxo)));
+    }
+    async clearVtxos(address) {
+        return this.deleteVtxos(address);
+    }
+    async deleteVtxos(address) {
+        await this.storage.removeItem(getVtxosStorageKey(address));
+    }
+    async getUtxos(address) {
+        const stored = await this.storage.getItem(getUtxosStorageKey(address));
+        if (!stored)
+            return [];
+        try {
+            const parsed = JSON.parse(stored);
+            return parsed.map(deserializeUtxo);
+        }
+        catch (error) {
+            console.error(`Failed to parse UTXOs for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveUtxos(address, utxos) {
+        const storedUtxos = await this.getUtxos(address);
+        utxos.forEach((utxo) => {
+            const existing = storedUtxos.findIndex((u) => u.txid === utxo.txid && u.vout === utxo.vout);
+            if (existing !== -1) {
+                storedUtxos[existing] = utxo;
+            }
+            else {
+                storedUtxos.push(utxo);
+            }
+        });
+        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(storedUtxos.map(serializeUtxo)));
+    }
+    async clearUtxos(address) {
+        return this.deleteVtxos(address);
+    }
+    async deleteUtxos(address) {
+        await this.storage.removeItem(getUtxosStorageKey(address));
+    }
+    async getTransactionHistory(address) {
+        const storageKey = getTransactionsStorageKey(address);
+        const stored = await this.storage.getItem(storageKey);
+        if (!stored)
+            return [];
+        try {
+            return JSON.parse(stored);
+        }
+        catch (error) {
+            console.error(`Failed to parse transactions for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveTransactions(address, txs) {
+        const storedTransactions = await this.getTransactionHistory(address);
+        for (const tx of txs) {
+            const existing = storedTransactions.findIndex((t) => t.key.boardingTxid === tx.key.boardingTxid &&
+                t.key.commitmentTxid === tx.key.commitmentTxid &&
+                t.key.arkTxid === tx.key.arkTxid);
+            if (existing !== -1) {
+                storedTransactions[existing] = tx;
+            }
+            else {
+                storedTransactions.push(tx);
+            }
+        }
+        await this.storage.setItem(getTransactionsStorageKey(address), JSON.stringify(storedTransactions));
+    }
+    async clearTransactions(address) {
+        return this.deleteTransactions(address);
+    }
+    async deleteTransactions(address) {
+        await this.storage.removeItem(getTransactionsStorageKey(address));
+    }
+    async getWalletState() {
+        const stored = await this.storage.getItem(walletStateStorageKey);
+        if (!stored)
+            return null;
+        try {
+            const state = JSON.parse(stored);
+            return state;
+        }
+        catch (error) {
+            console.error("Failed to parse wallet state:", error);
+            return null;
+        }
+    }
+    async saveWalletState(state) {
+        await this.storage.setItem(walletStateStorageKey, JSON.stringify(state));
+    }
+    // New method added in V2, not implemented for legacy
+    async clear() {
+        throw new Error("Method not implemented.");
+    }
+    async [Symbol.asyncDispose]() {
+        // deprecated StorageAdapter doesn't have a `close()` method
+        return;
+    }
+}

package/dist/esm/repositories/walletRepository.js

@@ -1,167 +1 @@
-import { hex } from "@scure/base";
-import { TaprootControlBlock } from "@scure/btc-signer";
-const getVtxosStorageKey = (address) => `vtxos:${address}`;
-const getUtxosStorageKey = (address) => `utxos:${address}`;
-const getTransactionsStorageKey = (address) => `tx:${address}`;
-const walletStateStorageKey = "wallet:state";
-// Utility functions for (de)serializing complex structures
-const toHex = (b) => (b ? hex.encode(b) : undefined);
-const fromHex = (h) => h ? hex.decode(h) : undefined;
-const serializeTapLeaf = ([cb, s]) => ({
-    cb: hex.encode(TaprootControlBlock.encode(cb)),
-    s: hex.encode(s),
-});
-const serializeVtxo = (v) => ({
-    ...v,
-    tapTree: toHex(v.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
-    extraWitness: v.extraWitness?.map(toHex),
-});
-const serializeUtxo = (u) => ({
-    ...u,
-    tapTree: toHex(u.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
-    extraWitness: u.extraWitness?.map(toHex),
-});
-const deserializeTapLeaf = (t) => {
-    const cb = TaprootControlBlock.decode(fromHex(t.cb));
-    const s = fromHex(t.s);
-    return [cb, s];
-};
-const deserializeVtxo = (o) => ({
-    ...o,
-    createdAt: new Date(o.createdAt),
-    tapTree: fromHex(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(fromHex),
-});
-const deserializeUtxo = (o) => ({
-    ...o,
-    tapTree: fromHex(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(fromHex),
-});
-export class WalletRepositoryImpl {
-    constructor(storage) {
-        this.storage = storage;
-    }
-    async getVtxos(address) {
-        const stored = await this.storage.getItem(getVtxosStorageKey(address));
-        if (!stored)
-            return [];
-        try {
-            const parsed = JSON.parse(stored);
-            return parsed.map(deserializeVtxo);
-        }
-        catch (error) {
-            console.error(`Failed to parse VTXOs for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveVtxos(address, vtxos) {
-        const storedVtxos = await this.getVtxos(address);
-        for (const vtxo of vtxos) {
-            const existing = storedVtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
-            if (existing !== -1) {
-                storedVtxos[existing] = vtxo;
-            }
-            else {
-                storedVtxos.push(vtxo);
-            }
-        }
-        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(storedVtxos.map(serializeVtxo)));
-    }
-    async removeVtxo(address, vtxoId) {
-        const vtxos = await this.getVtxos(address);
-        const [txid, vout] = vtxoId.split(":");
-        const filtered = vtxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(filtered.map(serializeVtxo)));
-    }
-    async clearVtxos(address) {
-        await this.storage.removeItem(getVtxosStorageKey(address));
-    }
-    async getUtxos(address) {
-        const stored = await this.storage.getItem(getUtxosStorageKey(address));
-        if (!stored)
-            return [];
-        try {
-            const parsed = JSON.parse(stored);
-            return parsed.map(deserializeUtxo);
-        }
-        catch (error) {
-            console.error(`Failed to parse UTXOs for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveUtxos(address, utxos) {
-        const storedUtxos = await this.getUtxos(address);
-        utxos.forEach((utxo) => {
-            const existing = storedUtxos.findIndex((u) => u.txid === utxo.txid && u.vout === utxo.vout);
-            if (existing !== -1) {
-                storedUtxos[existing] = utxo;
-            }
-            else {
-                storedUtxos.push(utxo);
-            }
-        });
-        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(storedUtxos.map(serializeUtxo)));
-    }
-    async removeUtxo(address, utxoId) {
-        const utxos = await this.getUtxos(address);
-        const [txid, vout] = utxoId.split(":");
-        const filtered = utxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(filtered.map(serializeUtxo)));
-    }
-    async clearUtxos(address) {
-        await this.storage.removeItem(getUtxosStorageKey(address));
-    }
-    async getTransactionHistory(address) {
-        const storageKey = getTransactionsStorageKey(address);
-        const stored = await this.storage.getItem(storageKey);
-        if (!stored)
-            return [];
-        try {
-            return JSON.parse(stored);
-        }
-        catch (error) {
-            console.error(`Failed to parse transactions for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveTransactions(address, txs) {
-        const storedTransactions = await this.getTransactionHistory(address);
-        for (const tx of txs) {
-            const existing = storedTransactions.findIndex((t) => t.key === tx.key);
-            if (existing !== -1) {
-                storedTransactions[existing] = tx;
-            }
-            else {
-                storedTransactions.push(tx);
-            }
-        }
-        await this.storage.setItem(getTransactionsStorageKey(address), JSON.stringify(storedTransactions));
-    }
-    async clearTransactions(address) {
-        await this.storage.removeItem(getTransactionsStorageKey(address));
-    }
-    async getWalletState() {
-        const stored = await this.storage.getItem(walletStateStorageKey);
-        if (!stored)
-            return null;
-        try {
-            const state = JSON.parse(stored);
-            return state;
-        }
-        catch (error) {
-            console.error("Failed to parse wallet state:", error);
-            return null;
-        }
-    }
-    async saveWalletState(state) {
-        await this.storage.setItem(walletStateStorageKey, JSON.stringify(state));
-    }
-}
+export {};

package/dist/esm/script/base.js

@@ -1,9 +1,10 @@
 import { Script, Address, p2tr, taprootListToTree, TAPROOT_UNSPENDABLE_KEY, } from "@scure/btc-signer";
+import * as bip68 from "bip68";
 import { TAP_LEAF_VERSION } from "@scure/btc-signer/payment.js";
 import { PSBTOutput } from "@scure/btc-signer/psbt.js";
 import { hex } from "@scure/base";
 import { ArkAddress } from './address.js';
-import { ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from './tapscript.js';
+import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from './tapscript.js';
 export const TapTreeCoder = PSBTOutput.tapTree[2];
 export function scriptFromTapLeafScript(leaf) {
     return leaf[1].subarray(0, leaf[1].length - 1); // remove the version byte
@@ -90,3 +91,22 @@ export class VtxoScript {
         return paths;
     }
 }
+export function getSequence(tapLeafScript) {
+    let sequence = undefined;
+    try {
+        const scriptWithLeafVersion = tapLeafScript[1];
+        const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
+        try {
+            const params = CSVMultisigTapscript.decode(script).params;
+            sequence = bip68.encode(params.timelock.type === "blocks"
+                ? { blocks: Number(params.timelock.value) }
+                : { seconds: Number(params.timelock.value) });
+        }
+        catch {
+            const params = CLTVMultisigTapscript.decode(script).params;
+            sequence = Number(params.absoluteTimelock);
+        }
+    }
+    catch { }
+    return sequence;
+}

package/dist/esm/script/delegate.js

@@ -0,0 +1,46 @@
+import { DefaultVtxo } from './default.js';
+import { MultisigTapscript } from './tapscript.js';
+import { VtxoScript } from './base.js';
+import { hex } from "@scure/base";
+/**
+ * DelegateVtxo extends DefaultVtxo with an extra delegator path
+ */
+export var DelegateVtxo;
+(function (DelegateVtxo) {
+    /**
+     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.
+     * @example
+     * ```typescript
+     * const vtxoScript = new DelegateVtxo.Script({
+     *     pubKey: new Uint8Array(32),
+     *     serverPubKey: new Uint8Array(32),
+     *     delegatePubKey: new Uint8Array(32),
+     * });
+     *
+     * console.log("script pub key:", vtxoScript.pkScript)
+     * ```
+     */
+    class Script extends VtxoScript {
+        constructor(options) {
+            const defaultVtxo = new DefaultVtxo.Script(options);
+            const { delegatePubKey, pubKey, serverPubKey } = options;
+            const delegateScript = MultisigTapscript.encode({
+                pubkeys: [pubKey, delegatePubKey, serverPubKey],
+            }).script;
+            super([...defaultVtxo.scripts, delegateScript]);
+            this.options = options;
+            this.defaultVtxo = defaultVtxo;
+            this.delegateScript = hex.encode(delegateScript);
+        }
+        forfeit() {
+            return this.findLeaf(this.defaultVtxo.forfeitScript);
+        }
+        exit() {
+            return this.findLeaf(this.defaultVtxo.exitScript);
+        }
+        delegate() {
+            return this.findLeaf(this.delegateScript);
+        }
+    }
+    DelegateVtxo.Script = Script;
+})(DelegateVtxo || (DelegateVtxo = {}));

package/dist/esm/storage/asyncStorage.js

@@ -1,4 +1,7 @@
-// Note: This requires @react-native-async-storage/async-storage to be installed
+/**
+ * @deprecated Use repositories instead
+ * Note: This requires @react-native-async-storage/async-storage to be installed
+ */
 export class AsyncStorageAdapter {
     constructor() {
         try {

package/dist/esm/storage/fileSystem.js

@@ -1,5 +1,8 @@
 import * as fs from "fs/promises";
 import * as path from "path";
+/**
+ * @deprecated Use repositories instead
+ */
 export class FileSystemStorageAdapter {
     constructor(dirPath) {
         // Normalize and resolve the storage base path once

package/dist/esm/storage/inMemory.js

@@ -1,3 +1,6 @@
+/**
+ * @deprecated Use repositories instead
+ */
 export class InMemoryStorageAdapter {
     constructor() {
         this.store = new Map();

package/dist/esm/storage/indexedDB.js

@@ -1,5 +1,9 @@
+import { DB_VERSION } from '../repositories/indexedDB/db.js';
+/**
+ * @deprecated Use repositories instead
+ */
 export class IndexedDBStorageAdapter {
-    constructor(dbName, version = 1) {
+    constructor(dbName, version = DB_VERSION) {
         this.db = null;
         this.dbName = dbName;
         this.version = version;

package/dist/esm/storage/localStorage.js

@@ -1,3 +1,6 @@
+/**
+ * @deprecated Use repositories instead
+ */
 export class LocalStorageAdapter {
     getSafeLocalStorage() {
         try {

package/dist/esm/utils/arkTransaction.js

@@ -7,6 +7,7 @@ import { scriptFromTapLeafScript, VtxoScript, } from '../script/base.js';
 import { P2A } from './anchor.js';
 import { setArkPsbtField, VtxoTaprootTree } from './unknownFields.js';
 import { Transaction } from './transaction.js';
+import { ArkAddress } from '../script/address.js';
 /**
  * Builds an offchain transaction with checkpoint transactions.
  *
@@ -232,3 +233,17 @@ export function combineTapscriptSigs(signedTx, originalTx) {
     }
     return originalTx;
 }
+/**
+ * Validates if a given string is a valid Ark address by attempting to decode it.
+ * @param address The Ark address to validate.
+ * @returns True if the address is valid, false otherwise.
+ */
+export function isValidArkAddress(address) {
+    try {
+        ArkAddress.decode(address);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/esm/utils/transactionHistory.js

@@ -4,6 +4,46 @@ const txKey = {
     boardingTxid: "",
     arkTxid: "",
 };
+function collectAssets(vtxos) {
+    const map = new Map();
+    for (const vtxo of vtxos) {
+        if (vtxo.assets) {
+            for (const a of vtxo.assets) {
+                map.set(a.assetId, (map.get(a.assetId) ?? 0) + a.amount);
+            }
+        }
+    }
+    if (map.size === 0)
+        return undefined;
+    return Array.from(map, ([assetId, amount]) => ({ assetId, amount }));
+}
+function subtractAssets(spent, change) {
+    const map = new Map();
+    for (const vtxo of change) {
+        if (vtxo.assets) {
+            for (const a of vtxo.assets) {
+                map.set(a.assetId, (map.get(a.assetId) ?? 0) + a.amount);
+            }
+        }
+    }
+    for (const vtxo of spent) {
+        if (vtxo.assets) {
+            for (const a of vtxo.assets) {
+                const current = map.get(a.assetId) ?? 0;
+                const remaining = current - a.amount;
+                if (remaining !== 0) {
+                    map.set(a.assetId, remaining);
+                }
+                else {
+                    map.delete(a.assetId);
+                }
+            }
+        }
+    }
+    if (map.size === 0)
+        return undefined;
+    return Array.from(map, ([assetId, amount]) => ({ assetId, amount }));
+}
 /**
  * Builds the transaction history by analyzing virtual coins (VTXOs), boarding transactions, and ignored commitments.
  * History is sorted from newest to oldest and is composed only of SENT and RECEIVED transactions.
@@ -23,6 +63,7 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
             // it's translated into a received batch transaction
             if (!commitmentsToIgnore.has(vtxo.virtualStatus.commitmentTxIds[0]) &&
                 fromOldestVtxo.filter((v) => v.settledBy === vtxo.virtualStatus.commitmentTxIds[0]).length === 0) {
+                const assets = collectAssets([vtxo]);
                 received.push({
                     key: {
                         ...txKey,
@@ -33,12 +74,14 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                     amount: vtxo.value,
                     settled: vtxo.status.isLeaf || vtxo.isSpent,
                     createdAt: vtxo.createdAt.getTime(),
+                    ...(assets && { assets }),
                 });
             }
         }
         else if (fromOldestVtxo.filter((v) => v.arkTxId === vtxo.txid).length === 0) {
             // If this vtxo is preconfirmed and does not spend any other vtxos,
             // it's translated into a received offchain transaction
+            const assets = collectAssets([vtxo]);
             received.push({
                 key: { ...txKey, arkTxid: vtxo.txid },
                 tag: "offchain",
@@ -46,6 +89,7 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                 amount: vtxo.value,
                 settled: vtxo.status.isLeaf || vtxo.isSpent,
                 createdAt: vtxo.createdAt.getTime(),
+                ...(assets && { assets }),
             });
         }
         // If the vtxo is spent, it's translated into a sent transaction unless:
@@ -74,6 +118,7 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                         ? await getTxCreatedAt(vtxo.arkTxId)
                         : vtxo.createdAt.getTime() + 1;
                 }
+                const assets = subtractAssets(allSpent, changes);
                 sent.push({
                     key: { ...txKey, arkTxid: vtxo.arkTxId },
                     tag: "offchain",
@@ -81,6 +126,7 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                     amount: txAmount,
                     settled: true,
                     createdAt: txTime,
+                    ...(assets && { assets }),
                 });
             }
             // If the vtxo is forfeited in a batch and the total sum of forfeited vtxos is bigger than the sum of new vtxos,
@@ -97,6 +143,7 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                     // forfeitAmount > settledAmount --> collaborative exit with offchain change
                     // TODO: make this support fees!
                     if (forfeitAmount > settledAmount) {
+                        const assets = subtractAssets(forfeitVtxos, changes);
                         sent.push({
                             key: { ...txKey, commitmentTxid: vtxo.settledBy },
                             tag: "exit",
@@ -104,11 +151,13 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                             amount: forfeitAmount - settledAmount,
                             settled: true,
                             createdAt: changes[0].createdAt.getTime(),
+                            ...(assets && { assets }),
                         });
                     }
                 }
                 else {
                     // forfeitAmount > 0 && settledAmount == 0 --> collaborative exit without any offchain change
+                    const assets = subtractAssets(forfeitVtxos, []);
                     sent.push({
                         key: { ...txKey, commitmentTxid: vtxo.settledBy },
                         tag: "exit",
@@ -117,6 +166,7 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                         settled: true,
                         // TODO: fetch commitment tx with /v1/indexer/commitmentTx/<commitmentTxid> to know when the tx was made
                         createdAt: vtxo.createdAt.getTime() + 1,
+                        ...(assets && { assets }),
                     });
                 }
             }