@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/esm/utils/unknownFields.js

@@ -1,169 +0,0 @@
-import { RawWitness, ScriptNum } from "@scure/btc-signer";
-import { hex } from "@scure/base";
-import { sequenceToTimelock } from "./timelock.js";
-/**
- * ArkPsbtFieldKey are the available key names for the Arkade PSBT custom fields.
- */
-export var ArkPsbtFieldKey;
-(function (ArkPsbtFieldKey) {
-    ArkPsbtFieldKey["VtxoTaprootTree"] = "taptree";
-    ArkPsbtFieldKey["VtxoTreeExpiry"] = "expiry";
-    ArkPsbtFieldKey["Cosigner"] = "cosigner";
-    ArkPsbtFieldKey["ConditionWitness"] = "condition";
-})(ArkPsbtFieldKey || (ArkPsbtFieldKey = {}));
-/**
- * ArkPsbtFieldKeyType is the key type of the Arkade PSBT custom field.
- * Every Arkade PSBT field has key type 222.
- */
-export const ArkPsbtFieldKeyType = 222;
-/**
- * setArkPsbtField appends a new unknown field to the input at inputIndex
- *
- * @example
- * ```typescript
- * setArkPsbtField(tx, 0, VtxoTaprootTree, myTaprootTree);
- * setArkPsbtField(tx, 0, VtxoTreeExpiry, myVtxoTreeExpiry);
- * ```
- */
-export function setArkPsbtField(tx, inputIndex, coder, value) {
-    tx.updateInput(inputIndex, {
-        unknown: [
-            ...(tx.getInput(inputIndex)?.unknown ?? []),
-            coder.encode(value),
-        ],
-    });
-}
-/**
- * getArkPsbtFields returns all the values of the given coder for the input at inputIndex
- * Multiple fields of the same type can exist in a single input.
- *
- * @example
- * ```typescript
- * const vtxoTaprootTreeFields = getArkPsbtFields(tx, 0, VtxoTaprootTree);
- * console.log(`input has ${vtxoTaprootTreeFields.length} vtxoTaprootTree fields`);
- */
-export function getArkPsbtFields(tx, inputIndex, coder) {
-    const unknown = tx.getInput(inputIndex)?.unknown ?? [];
-    const fields = [];
-    for (const u of unknown) {
-        const v = coder.decode(u);
-        if (v)
-            fields.push(v);
-    }
-    return fields;
-}
-/**
- * VtxoTaprootTree is set to pass all spending leaves of the vtxo input
- *
- * @example
- * ```typescript
- * const vtxoTaprootTree = VtxoTaprootTree.encode(myTaprootTree);
- */
-export const VtxoTaprootTree = {
-    key: ArkPsbtFieldKey.VtxoTaprootTree,
-    encode: (value) => [
-        {
-            type: ArkPsbtFieldKeyType,
-            key: encodedPsbtFieldKey[ArkPsbtFieldKey.VtxoTaprootTree],
-        },
-        value,
-    ],
-    decode: (value) => nullIfCatch(() => {
-        if (!checkKeyIncludes(value[0], ArkPsbtFieldKey.VtxoTaprootTree))
-            return null;
-        return value[1];
-    }),
-};
-/**
- * ConditionWitness is set to pass the witness data used to finalize the conditionMultisigClosure
- *
- * @example
- * ```typescript
- * const conditionWitness = ConditionWitness.encode(myConditionWitness);
- */
-export const ConditionWitness = {
-    key: ArkPsbtFieldKey.ConditionWitness,
-    encode: (value) => [
-        {
-            type: ArkPsbtFieldKeyType,
-            key: encodedPsbtFieldKey[ArkPsbtFieldKey.ConditionWitness],
-        },
-        RawWitness.encode(value),
-    ],
-    decode: (value) => nullIfCatch(() => {
-        if (!checkKeyIncludes(value[0], ArkPsbtFieldKey.ConditionWitness))
-            return null;
-        return RawWitness.decode(value[1]);
-    }),
-};
-/**
- * CosignerPublicKey is set on every TxGraph transactions to identify the musig2 public keys
- *
- * @example
- * ```typescript
- * const cosignerPublicKey = CosignerPublicKey.encode(myCosignerPublicKey);
- */
-export const CosignerPublicKey = {
-    key: ArkPsbtFieldKey.Cosigner,
-    encode: (value) => [
-        {
-            type: ArkPsbtFieldKeyType,
-            key: new Uint8Array([
-                ...encodedPsbtFieldKey[ArkPsbtFieldKey.Cosigner],
-                value.index,
-            ]),
-        },
-        value.key,
-    ],
-    decode: (unknown) => nullIfCatch(() => {
-        if (!checkKeyIncludes(unknown[0], ArkPsbtFieldKey.Cosigner))
-            return null;
-        return {
-            index: unknown[0].key[unknown[0].key.length - 1],
-            key: unknown[1],
-        };
-    }),
-};
-/**
- * VtxoTreeExpiry is set to pass the expiry time of the input
- *
- * @example
- * ```typescript
- * const vtxoTreeExpiry = VtxoTreeExpiry.encode(myVtxoTreeExpiry);
- */
-export const VtxoTreeExpiry = {
-    key: ArkPsbtFieldKey.VtxoTreeExpiry,
-    encode: (value) => [
-        {
-            type: ArkPsbtFieldKeyType,
-            key: encodedPsbtFieldKey[ArkPsbtFieldKey.VtxoTreeExpiry],
-        },
-        ScriptNum(6, true).encode(value.value === 0n ? 0n : value.value),
-    ],
-    decode: (unknown) => nullIfCatch(() => {
-        if (!checkKeyIncludes(unknown[0], ArkPsbtFieldKey.VtxoTreeExpiry))
-            return null;
-        const v = ScriptNum(6, true).decode(unknown[1]);
-        if (!v)
-            return null;
-        return sequenceToTimelock(Number(v));
-    }),
-};
-const encodedPsbtFieldKey = Object.fromEntries(Object.values(ArkPsbtFieldKey).map((key) => [
-    key,
-    new TextEncoder().encode(key),
-]));
-const nullIfCatch = (fn) => {
-    try {
-        return fn();
-    }
-    catch (err) {
-        return null;
-    }
-};
-function checkKeyIncludes(key, arkPsbtFieldKey) {
-    const expected = hex.encode(encodedPsbtFieldKey[arkPsbtFieldKey]);
-    return hex
-        .encode(new Uint8Array([key.type, ...key.key]))
-        .includes(expected);
-}

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

@@ -1,325 +0,0 @@
-import { AssetGroup, AssetId, AssetInput, AssetOutput, AssetRef, Metadata, Packet, } from "../extension/asset/index.js";
-import { ArkAddress } from "../script/address.js";
-import { selectedCoinsToAssetInputs, selectCoinsWithAsset } from "./asset.js";
-import { Extension } from "../extension/index.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.controlAssetId - Optional control asset ID (for reissuable assets)
-     * @param params.metadata - Optional metadata to attach to the asset
-     * @returns Promise resolving to the Arkade transaction ID and asset ID
-     *
-     * @example
-     * ```typescript
-     * // Issue a simple non-reissuable asset
-     * const result = await wallet.assetManager.issue({ amount: 1000 });
-     * console.log('Asset ID:', result.assetId);
-     *
-     * // Issue a reissuable asset with an existing control asset
-     * const result = await wallet.assetManager.issue({
-     *   amount: 1000,
-     *   controlAssetId: 'existingControlAssetId'
-     * });
-     * console.log('Asset ID:', result.assetId);
-     * ```
-     */
-    async issue(params) {
-        if (params.amount <= 0n) {
-            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 + amount);
-            }
-        }
-        const groups = [];
-        // issued asset group
-        const issuedAssetOutput = AssetOutput.create(0, 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, 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),
-            },
-            Extension.create([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 Arkade transaction ID
-     *
-     * @example
-     * ```typescript
-     * const txid = await wallet.assetManager.reissue({
-     *   assetId: 'def456...',
-     *   amount: 500
-     * });
-     * ```
-     */
-    async reissue(params) {
-        if (params.amount <= 0n) {
-            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 += amount;
-                    continue;
-                }
-                const existing = assetChanges.get(assetId) ?? 0n;
-                assetChanges.set(assetId, existing + 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 += amount;
-                        continue;
-                    }
-                    const existing = assetChanges.get(assetId) ?? 0n;
-                    assetChanges.set(assetId, existing + 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, asset.amount));
-            }
-        }
-        // the total output amount of the asset to reissue = new + (optional) selected amount
-        const totalAssetAmount = assetToReissueAmount + 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, 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),
-            },
-            Extension.create([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 Arkade transaction ID
-     *
-     * @example
-     * ```typescript
-     * const txid = await wallet.assetManager.burn({
-     *   assetId: 'abc123...',
-     *   amount: 100
-     * });
-     * ```
-     */
-    async burn(params) {
-        if (params.amount <= 0n) {
-            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 virtual outputs with the asset to burn
-        const { selected: assetCoins } = selectCoinsWithAsset(virtualCoins, params.assetId, 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 + amount);
-            }
-        }
-        // subtract the amount to burn from the asset change
-        assetChanges.set(params.assetId, (assetChanges.get(params.assetId) ?? 0n) - 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 + 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, 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),
-            },
-            Extension.create([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;
-}

package/dist/esm/wallet/asset.js

@@ -1,113 +0,0 @@
-import { AssetGroup, AssetId, AssetInput, AssetOutput, Packet, } from "../extension/asset/index.js";
-/**
- * Creates an asset packet from asset inputs and receivers.
- * Groups inputs and outputs by asset ID and creates the Packet object
- * @param assetInputs - map input index -> assets
- * @param receivers - array of recipients with their asset allocations
- * @param changeReceiver - (optional) change receiver containing remaining assets
- * @returns packet containing all asset groups
- */
-export function createAssetPacket(assetInputs, receivers, changeReceiver) {
-    // map inputs by asset id
-    const inputsByAssetId = new Map();
-    for (const [inputIndex, assets] of assetInputs) {
-        for (const asset of assets) {
-            const existing = inputsByAssetId.get(asset.assetId);
-            inputsByAssetId.set(asset.assetId, [
-                ...(existing ?? []),
-                AssetInput.create(inputIndex, asset.amount),
-            ]);
-        }
-    }
-    // map outputs by asset id
-    const outputsByAssetId = new Map();
-    // track tx output index
-    let outputIndex = 0;
-    for (const receiver of receivers) {
-        if (receiver.assets) {
-            for (const asset of receiver.assets) {
-                const existing = outputsByAssetId.get(asset.assetId);
-                outputsByAssetId.set(asset.assetId, [
-                    ...(existing ?? []),
-                    AssetOutput.create(outputIndex, asset.amount),
-                ]);
-            }
-        }
-        outputIndex++;
-    }
-    // add change receiver assets if present
-    if (changeReceiver?.assets) {
-        for (const asset of changeReceiver.assets) {
-            const existing = outputsByAssetId.get(asset.assetId);
-            outputsByAssetId.set(asset.assetId, [
-                ...(existing ?? []),
-                AssetOutput.create(outputIndex, asset.amount),
-            ]);
-        }
-    }
-    const groups = [];
-    // get all unique asset ids from both inputs and outputs
-    const allAssetIds = new Set([
-        ...inputsByAssetId.keys(),
-        ...outputsByAssetId.keys(),
-    ]);
-    for (const assetIdStr of allAssetIds) {
-        const inputs = inputsByAssetId.get(assetIdStr);
-        const outputs = outputsByAssetId.get(assetIdStr);
-        const assetId = AssetId.fromString(assetIdStr);
-        const group = AssetGroup.create(assetId, null, inputs ?? [], outputs ?? [], []);
-        groups.push(group);
-    }
-    return Packet.create(groups);
-}
-/**
- * Selects coins that contain a specific asset.
- * Returns coins sorted by amount (smallest first for better coin selection).
- */
-export function selectCoinsWithAsset(coins, assetId, requiredAmount) {
-    // filter only coins that have the specified asset
-    const coinsWithAsset = coins.filter((coin) => coin.assets?.some((a) => a.assetId === assetId));
-    // sort by asset amount (smallest first for better selection)
-    coinsWithAsset.sort((a, b) => {
-        const amountA = a.assets?.find((asset) => asset.assetId === assetId)?.amount ?? 0n;
-        const amountB = b.assets?.find((asset) => asset.assetId === assetId)?.amount ?? 0n;
-        // Array.sort callback returns number; reduce the bigint diff to
-        // -1/0/1 (the only thing sort actually consults).
-        return amountA < amountB ? -1 : amountA > amountB ? 1 : 0;
-    });
-    const selected = [];
-    let totalAssetAmount = 0n;
-    for (const coin of coinsWithAsset) {
-        if (totalAssetAmount >= requiredAmount)
-            break;
-        selected.push(coin);
-        const assetAmount = coin.assets?.find((a) => a.assetId === assetId)?.amount ?? 0n;
-        totalAssetAmount += assetAmount;
-    }
-    if (totalAssetAmount < requiredAmount) {
-        throw new Error(`Insufficient asset balance: have ${totalAssetAmount}, need ${requiredAmount}`);
-    }
-    return { selected, totalAssetAmount };
-}
-export function computeAssetChange(inputAssets, outputAssets) {
-    const change = new Map();
-    for (const [assetId, inputAmount] of inputAssets) {
-        const outputAmount = outputAssets.get(assetId) ?? 0n;
-        const changeAmount = inputAmount - outputAmount;
-        if (changeAmount > 0n) {
-            change.set(assetId, changeAmount);
-        }
-    }
-    return change;
-}
-export function selectedCoinsToAssetInputs(selectedCoins) {
-    const assetInputs = new Map();
-    for (let inputIndex = 0; inputIndex < selectedCoins.length; inputIndex++) {
-        const coin = selectedCoins[inputIndex];
-        if (!coin.assets || coin.assets.length === 0) {
-            continue;
-        }
-        assetInputs.set(inputIndex, coin.assets);
-    }
-    return assetInputs;
-}