@unspent/phi/dist/main/common/map.js

a collection of anyone can spend contracts

import { binToHex, hexToBin, lockingBytecodeToCashAddress } from "@bitauth/libauth";
import { Network } from "cashscript";
import { nameMap, contractMap } from "../contract/constant.js";
import { decodeNullDataScript } from "./util.js";
import { BaseUtxPhiContract } from "./contract.js";
import { PsiNetworkProvider } from "@unspent/psi";
export function parseOpReturn(serialized, network = 'mainnet') {
    if (typeof serialized === "string") {
        serialized = hexToBin(serialized);
    }
    const data = BaseUtxPhiContract.parseOpReturn(serialized, network);
    return {
        name: nameMap[data.code],
        opReturn: serialized,
        ...data,
    };
}
export function parseOutputs(serialized) {
    if (typeof serialized === "string")
        serialized = hexToBin(serialized);
    return BaseUtxPhiContract.parseOutputs(serialized);
}
export function opReturnToInstance(serialized, network) {
    if (typeof serialized === "string") {
        serialized = hexToBin(serialized);
    }
    const serializedBinChunks = decodeNullDataScript(serialized);
    const contractCode = binToHex(serializedBinChunks[1]);
    const code = String.fromCharCode(parseInt(contractCode, 16));
    const instance = contractMap[code].fromOpReturn(serialized, network);
    if (instance.isSpecial())
        throw ("Too Special: " + serialized);
    return instance;
}
export function opReturnToExecutorAllowance(serialized, network) {
    if (typeof serialized === "string") {
        serialized = hexToBin(serialized);
    }
    const serializedBinChunks = decodeNullDataScript(serialized);
    const contractCode = binToHex(serializedBinChunks[1]);
    const code = String.fromCharCode(parseInt(contractCode, 16));
    const exAllowance = contractMap[code].getExecutorAllowance(serialized, network);
    return exAllowance;
}
export async function opReturnToSpendableBalance(serialized, network = Network.MAINNET, networkProvider, blockHeight) {
    if (typeof serialized === "string") {
        serialized = hexToBin(serialized);
    }
    const serializedBinChunks = decodeNullDataScript(serialized);
    const contractCode = binToHex(serializedBinChunks[1]);
    const code = String.fromCharCode(parseInt(contractCode, 16));
    if (!networkProvider)
        networkProvider = new PsiNetworkProvider(network);
    if (!blockHeight)
        blockHeight = await networkProvider.getBlockHeight();
    try {
        const spendableBalance = await contractMap[code].getSpendableBalance(serialized, network, networkProvider, blockHeight);
        return spendableBalance;
    }
    catch (e) {
        console.log(`error getting balance for ${binToHex(serialized)}`);
        return 0n;
    }
}
export async function opReturnToBalance(serialized, network = Network.MAINNET, networkProvider, blockHeight) {
    if (typeof serialized === "string") {
        serialized = hexToBin(serialized);
    }
    const serializedBinChunks = decodeNullDataScript(serialized);
    const address = lockingBytecodeToCashAddress({ bytecode: serializedBinChunks.pop(), prefix: "bitcoincash" });
    if (typeof address !== "string")
        throw Error("couldn't decode cashaddr");
    if (!networkProvider)
        networkProvider = new PsiNetworkProvider(network);
    if (!blockHeight)
        blockHeight = await networkProvider.getBlockHeight();
    const balance = await BaseUtxPhiContract.getBalance(address, networkProvider);
    return balance;
}
export function opReturnToSerializedString(serialized, network) {
    const instance = opReturnToInstance(serialized, network);
    if (instance) {
        return instance.toString();
    }
    else {
        return;
    }
}
export function stringToInstance(serialized, network) {
    const code = serialized[0];
    try {
        const instance = contractMap[code].fromString(serialized, network);
        return instance;
    }
    catch (e) {
        console.warn(`Couldn't parse serialized contract, ${e}`);
        return;
    }
}
export function castConstructorParametersFromArtifact(parameters, artifact) {
    const result = [];
    const inputs = artifact.constructorInputs;
    parameters.forEach(function (value, i) {
        const abiInput = inputs[i];
        let parsedVal = undefined;
        if (abiInput.type.startsWith("bytes")) {
            if (typeof value === "string") {
                if (value.includes(",")) {
                    parsedVal = Uint8Array.from(value.split(",").map((vStr) => parseInt(vStr)));
                }
                else {
                    parsedVal = hexToBin(value);
                }
            }
            else {
                throw Error(`Couldn't parse ${value} from string to bytes`);
            }
        }
        else if (abiInput.type === "int") {
            parsedVal = parseInt(value);
        }
        else if (abiInput.type === "boolean") {
            parsedVal = Boolean(value);
        }
        else {
            throw Error(`Couldn't parse type ${abiInput.type}`);
        }
        result.push({
            name: abiInput.name,
            cashScriptType: abiInput.type,
            value: parsedVal,
        });
    });
}
//# sourceMappingURL=map.js.map