@arkade-os/sdk 0.3.13 → 0.4.0-next.1

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 }),
                     });
                 }
             }

package/dist/esm/wallet/asset-manager.js

@@ -0,0 +1,333 @@
+import { AssetGroup, AssetId, AssetInput, AssetOutput, AssetRef, Metadata, Packet, } from '../asset/index.js';
+import { ArkAddress } from '../script/address.js';
+import { selectedCoinsToAssetInputs, selectCoinsWithAsset } from './asset.js';
+import { selectVirtualCoins } from './wallet.js';
+export class ReadonlyAssetManager {
+    constructor(indexer) {
+        this.indexer = indexer;
+    }
+    async getAssetDetails(assetId) {
+        // TODO: rely on db, and fallback to indexer if not found
+        return this.indexer.getAssetDetails(assetId);
+    }
+}
+export class AssetManager extends ReadonlyAssetManager {
+    constructor(wallet) {
+        super(wallet.indexerProvider);
+        this.wallet = wallet;
+    }
+    /**
+     * Issue a new asset.
+     * @param params - Parameters for asset issuance
+     * @param params.amount - Amount of asset units to issue
+     * @param params.controlAsset - Optional control asset (for reissuable assets)
+     * @param params.metadata - Optional metadata to attach to the asset
+     * @returns Promise resolving to the ark transaction ID and asset ID
+     *
+     * @example
+     * ```typescript
+     * // Issue a simple non-reissuable asset
+     * const result = await wallet.issueAsset({ amount: 1000 });
+     * console.log('Asset ID:', result.assetId);
+     *
+     * // Issue a reissuable asset with a new control asset
+     * const result = await wallet.issueAsset({
+     *   amount: 1000,
+     *   controlAsset: 1 // creates new control asset with amount 1
+     * });
+     * console.log('Control Asset ID:', result.controlAssetId);
+     * console.log('Asset ID:', result.assetId);
+     *
+     * // Issue a reissuable asset with an existing control asset
+     * const result = await wallet.issueAsset({
+     *   amount: 1000,
+     *   controlAsset: 'controlAssetId'
+     * });
+     * console.log('Control Asset ID:', result.controlAssetId);
+     * console.log('Asset ID:', result.assetId);
+     * ```
+     */
+    async issue(params) {
+        if (params.amount <= 0) {
+            throw new Error(`Issue amount must be greater than 0, got ${params.amount}`);
+        }
+        const metadata = castMetadata(params.metadata);
+        const virtualCoins = await this.wallet.getVtxos({
+            withRecoverable: false,
+        });
+        const controlAssetRef = params.controlAssetId
+            ? AssetRef.fromId(AssetId.fromString(params.controlAssetId))
+            : null;
+        const coinSelection = selectVirtualCoins(virtualCoins, Number(this.wallet.dustAmount));
+        let totalBtcSelected = 0n;
+        // keep track of asset changes
+        const assetChanges = new Map();
+        for (const coin of coinSelection.inputs) {
+            totalBtcSelected += BigInt(coin.value);
+            if (!coin.assets)
+                continue;
+            for (const { assetId, amount } of coin.assets) {
+                const existing = assetChanges.get(assetId) ?? 0n;
+                assetChanges.set(assetId, existing + BigInt(amount));
+            }
+        }
+        const groups = [];
+        // issued asset group
+        const issuedAssetOutput = AssetOutput.create(0, BigInt(params.amount));
+        const issuedAssetGroup = AssetGroup.create(null, controlAssetRef, [], [issuedAssetOutput], metadata);
+        groups.push(issuedAssetGroup);
+        // add asset groups for each asset change
+        if (assetChanges.size > 0) {
+            const assetInputs = selectedCoinsToAssetInputs(coinSelection.inputs);
+            for (const [assetId, amount] of assetChanges) {
+                const changeInputs = [];
+                // collect all inputs for the asset change
+                for (const [inputIndex, assets] of assetInputs) {
+                    for (const asset of assets) {
+                        if (asset.assetId !== assetId)
+                            continue;
+                        changeInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+                    }
+                }
+                // add the change asset group
+                groups.push(AssetGroup.create(AssetId.fromString(assetId), null, changeInputs, [AssetOutput.create(0, amount)], []));
+            }
+        }
+        // build transaction outputs
+        const address = await this.wallet.getAddress();
+        const outputAddress = ArkAddress.decode(address);
+        const outputs = [
+            {
+                script: outputAddress.pkScript,
+                amount: BigInt(totalBtcSelected),
+            },
+            Packet.create(groups).txOut(),
+        ];
+        const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(coinSelection.inputs, outputs);
+        return {
+            arkTxId: arkTxid,
+            assetId: AssetId.create(arkTxid, 0).toString(),
+        };
+    }
+    /**
+     * Reissue more units of an existing asset.
+     * Requires ownership of the control asset.
+     *
+     * @param params - Parameters for asset reissuance
+     * @param params.assetId - The asset ID to reissue (control asset ID is resolved via getAssetDetails)
+     * @param params.amount - Amount of additional units to issue
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.assetManager.reissue({
+     *   assetId: 'def456...',
+     *   amount: 500
+     * });
+     * ```
+     */
+    async reissue(params) {
+        if (params.amount <= 0) {
+            throw new Error(`Reissuance amount must be greater than 0, got ${params.amount}`);
+        }
+        const { controlAssetId } = await this.getAssetDetails(params.assetId);
+        if (!controlAssetId) {
+            throw new Error(`Asset ${params.assetId} is not reissuable`);
+        }
+        const virtualCoins = await this.wallet.getVtxos({
+            withRecoverable: false,
+        });
+        const assetChanges = new Map();
+        // select control asset inputs
+        const { selected: controlCoins } = selectCoinsWithAsset(virtualCoins, controlAssetId, 1n);
+        let selectedCoins = [...controlCoins];
+        let assetToReissueAmount = 0n;
+        // all control inputs assets go to asset changes, including the control asset itself
+        for (const coin of controlCoins) {
+            if (!coin.assets)
+                continue;
+            for (const { assetId, amount } of coin.assets) {
+                if (assetId === params.assetId) {
+                    assetToReissueAmount += BigInt(amount);
+                    continue;
+                }
+                const existing = assetChanges.get(assetId) ?? 0n;
+                assetChanges.set(assetId, existing + BigInt(amount));
+            }
+        }
+        // select at least dust amount
+        const minBtcNeeded = Number(this.wallet.dustAmount);
+        let totalBtcSelected = selectedCoins.reduce((sum, c) => sum + c.value, 0);
+        if (totalBtcSelected < minBtcNeeded) {
+            const remainingCoins = virtualCoins.filter((c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout));
+            const additional = selectVirtualCoins(remainingCoins, minBtcNeeded - totalBtcSelected);
+            for (const coin of additional.inputs) {
+                // additional inputs assets go to asset changes
+                if (!coin.assets)
+                    continue;
+                for (const { assetId, amount } of coin.assets) {
+                    if (assetId === params.assetId) {
+                        assetToReissueAmount += BigInt(amount);
+                        continue;
+                    }
+                    const existing = assetChanges.get(assetId) ?? 0n;
+                    assetChanges.set(assetId, existing + BigInt(amount));
+                }
+            }
+            selectedCoins = [...selectedCoins, ...additional.inputs];
+            totalBtcSelected += additional.inputs.reduce((sum, c) => sum + c.value, 0);
+        }
+        const assetInputs = selectedCoinsToAssetInputs(selectedCoins);
+        // collect all inputs for the asset to reissue
+        const reissueInputs = [];
+        for (const [inputIndex, assets] of assetInputs) {
+            for (const asset of assets) {
+                if (asset.assetId !== params.assetId)
+                    continue;
+                reissueInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+            }
+        }
+        // the total output amount of the asset to reissue = new + (optional) selected amount
+        const totalAssetAmount = assetToReissueAmount + BigInt(params.amount);
+        const reissueAssetIdObj = AssetId.fromString(params.assetId);
+        // create the reissuance asset group
+        const reissueAssetGroup = AssetGroup.create(reissueAssetIdObj, null, reissueInputs, [AssetOutput.create(0, totalAssetAmount)], []);
+        const groups = [reissueAssetGroup];
+        // for each asset change, create a new asset group
+        for (const [assetId, amount] of assetChanges) {
+            const changeInputs = [];
+            for (const [inputIndex, assets] of assetInputs) {
+                for (const asset of assets) {
+                    if (asset.assetId !== assetId)
+                        continue;
+                    changeInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+                }
+            }
+            groups.push(AssetGroup.create(AssetId.fromString(assetId), null, changeInputs, [AssetOutput.create(0, amount)], []));
+        }
+        // build transaction outputs
+        const address = await this.wallet.getAddress();
+        const outputAddress = ArkAddress.decode(address);
+        const outputs = [
+            {
+                script: outputAddress.pkScript,
+                amount: BigInt(totalBtcSelected),
+            },
+            Packet.create(groups).txOut(),
+        ];
+        const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
+        return arkTxid;
+    }
+    /**
+     * Burn assets.
+     * @param params - Parameters for burning
+     * @param params.assetId - The asset ID to burn
+     * @param params.amount - Amount of units to burn
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.assetManager.burn({
+     *   assetId: 'abc123...',
+     *   amount: 100
+     * });
+     * ```
+     */
+    async burn(params) {
+        if (params.amount <= 0) {
+            throw new Error(`Burn amount must be greater than 0, got ${params.amount}`);
+        }
+        const virtualCoins = await this.wallet.getVtxos({
+            withRecoverable: false,
+        });
+        const assetChanges = new Map();
+        // select vtxos with the asset to burn
+        const { selected: assetCoins } = selectCoinsWithAsset(virtualCoins, params.assetId, BigInt(params.amount));
+        const selectedCoins = [...assetCoins];
+        let totalBtcSelected = 0;
+        // add the selected coins to asset changes, including the asset to burn
+        for (const coin of assetCoins) {
+            totalBtcSelected += coin.value;
+            if (!coin.assets)
+                continue;
+            for (const { assetId, amount } of coin.assets) {
+                const existing = assetChanges.get(assetId) ?? 0n;
+                assetChanges.set(assetId, existing + BigInt(amount));
+            }
+        }
+        // subtract the amount to burn from the asset change
+        assetChanges.set(params.assetId, (assetChanges.get(params.assetId) ?? 0n) - BigInt(params.amount));
+        const minBtcNeeded = Number(this.wallet.dustAmount);
+        // we need to ensure at least dust amount is selected
+        // if not, select additional coins
+        if (totalBtcSelected < minBtcNeeded) {
+            const remainingCoins = virtualCoins.filter((c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout));
+            const additional = selectVirtualCoins(remainingCoins, minBtcNeeded - totalBtcSelected);
+            // additional inputs assets go to asset changes
+            for (const coin of additional.inputs) {
+                totalBtcSelected += coin.value;
+                if (!coin.assets)
+                    continue;
+                for (const { assetId, amount } of coin.assets) {
+                    const existing = assetChanges.get(assetId) ?? 0n;
+                    assetChanges.set(assetId, existing + BigInt(amount));
+                }
+            }
+            selectedCoins.push(...additional.inputs);
+        }
+        const groups = [];
+        const assetInputs = selectedCoinsToAssetInputs(selectedCoins);
+        // for each asset, create a new asset group
+        for (const [assetId, amount] of assetChanges) {
+            const changeInputs = [];
+            for (const [inputIndex, assets] of assetInputs) {
+                for (const asset of assets) {
+                    if (asset.assetId !== assetId)
+                        continue;
+                    changeInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+                }
+            }
+            groups.push(AssetGroup.create(AssetId.fromString(assetId), null, changeInputs, amount > 0n ? [AssetOutput.create(0, amount)] : [], []));
+        }
+        // build transaction outputs
+        const address = await this.wallet.getAddress();
+        const outputAddress = ArkAddress.decode(address);
+        const outputs = [
+            {
+                script: outputAddress.pkScript,
+                amount: BigInt(totalBtcSelected),
+            },
+            Packet.create(groups).txOut(),
+        ];
+        const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
+        return arkTxid;
+    }
+}
+function castMetadata(metadata) {
+    if (!metadata) {
+        return [];
+    }
+    const md = [];
+    const textEncoder = new TextEncoder();
+    for (const [key, value] of Object.entries(metadata)) {
+        // convert value to bytes
+        let valueBytes;
+        if (typeof value === "string") {
+            valueBytes = textEncoder.encode(value);
+        }
+        else if (typeof value === "number") {
+            valueBytes = textEncoder.encode(String(value));
+        }
+        else if (value instanceof Uint8Array) {
+            valueBytes = value;
+        }
+        else if (value instanceof ArrayBuffer) {
+            valueBytes = new Uint8Array(value);
+        }
+        else {
+            throw new Error("Invalid metadata value type");
+        }
+        md.push(Metadata.create(textEncoder.encode(key), valueBytes));
+    }
+    return md;
+}