@totemsdk/core 1.2.6 → 1.2.8

package/dist/cjs/scripts/dapp-types.d.ts

@@ -0,0 +1,119 @@
+export declare const TOTEM_SEND_TRANSACTION_VERSION = 1;
+export type DAppTransactionIntent = 'send' | 'token_send' | 'swap' | 'liquidity_add' | 'liquidity_remove' | 'contract_call' | 'multisig' | 'timelock' | 'htlc' | 'custom';
+export interface DAppStateVariable {
+    port: number;
+    value: string;
+    type?: 'number' | 'string' | 'hex' | 'address';
+}
+export interface DAppTransactionOutput {
+    address: string;
+    amount: string;
+    tokenId?: string;
+    state?: DAppStateVariable[];
+    storeState?: boolean;
+    script?: string;
+    scriptRef?: string;
+}
+export interface DAppTransactionInput {
+    coinId: string;
+    address?: string;
+    amount?: string;
+    tokenId?: string;
+}
+export interface DAppSwapParams {
+    fromTokenId: string;
+    toTokenId: string;
+    amountIn: string;
+    minAmountOut: string;
+    slippageBps?: number;
+    poolAddress?: string;
+}
+export interface DAppLiquidityParams {
+    poolAddress: string;
+    tokenAId: string;
+    tokenBId: string;
+    amountA?: string;
+    amountB?: string;
+    lpTokenAmount?: string;
+}
+export interface DAppMultisigParams {
+    requiredSignatures: number;
+    publicKeys: string[];
+    timeoutBlocks?: number;
+}
+export interface DAppTimelockParams {
+    releaseBlock: number;
+    fallbackAddress?: string;
+}
+export interface DAppHtlcParams {
+    hashlock: string;
+    timeoutBlocks: number;
+    recipientAddress: string;
+    refundAddress: string;
+}
+export interface DAppContractCallParams {
+    contractAddress: string;
+    method?: string;
+    args?: Record<string, string>;
+    script?: string;
+}
+export interface TotemSendTransactionRequest {
+    version: typeof TOTEM_SEND_TRANSACTION_VERSION;
+    intent: DAppTransactionIntent;
+    outputs: DAppTransactionOutput[];
+    inputs?: DAppTransactionInput[];
+    burn?: string;
+    memo?: string;
+    metadata?: {
+        appName?: string;
+        description?: string;
+        iconUrl?: string;
+    };
+    options?: {
+        verifyWithTotemidea?: boolean;
+        skipPreview?: boolean;
+        useSourceAddress?: string;
+        excludeAddresses?: string[];
+    };
+    swap?: DAppSwapParams;
+    liquidity?: DAppLiquidityParams;
+    multisig?: DAppMultisigParams;
+    timelock?: DAppTimelockParams;
+    htlc?: DAppHtlcParams;
+    contract?: DAppContractCallParams;
+}
+export interface TotemSendTransactionResponse {
+    success: boolean;
+    txpowid?: string;
+    status?: 'pending' | 'submitted' | 'confirmed' | 'rejected';
+    artifactId?: string;
+    digestHex?: string;
+    error?: string;
+    errorCode?: TotemTransactionErrorCode;
+    verification?: {
+        totemideaValid?: boolean;
+        totemideaWarnings?: string[];
+        totemideaNotes?: string[];
+    };
+}
+export type TotemTransactionErrorCode = 'INVALID_REQUEST' | 'INSUFFICIENT_FUNDS' | 'PERMISSION_DENIED' | 'USER_REJECTED' | 'SITE_NOT_CONNECTED' | 'SPENDING_LIMIT_EXCEEDED' | 'TOKEN_NOT_ALLOWED' | 'VERIFICATION_FAILED' | 'BUILD_FAILED' | 'SIGN_FAILED' | 'BROADCAST_FAILED' | 'TIMEOUT';
+export interface SiteTransactionPermission {
+    origin: string;
+    grantedAt: number;
+    expiresAt: number;
+    scopes: TransactionScope[];
+}
+export interface TransactionScope {
+    tokenId: string;
+    tokenSymbol?: string;
+    maxAmountPerTx: string;
+    maxDailyAmount: string;
+    dailyUsed: string;
+    lastResetDate: string;
+    allowedIntents: DAppTransactionIntent[];
+}
+export declare function validateSendTransactionRequest(request: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+export declare function simpleTotemSendRequest(to: string, amount: string, tokenId?: string): TotemSendTransactionRequest;

package/dist/cjs/scripts/dapp-types.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOTEM_SEND_TRANSACTION_VERSION = void 0;
+exports.validateSendTransactionRequest = validateSendTransactionRequest;
+exports.simpleTotemSendRequest = simpleTotemSendRequest;
+exports.TOTEM_SEND_TRANSACTION_VERSION = 1;
+function validateSendTransactionRequest(request) {
+    const errors = [];
+    if (!request || typeof request !== 'object') {
+        return { valid: false, errors: ['Request must be an object'] };
+    }
+    const req = request;
+    if (req.version !== exports.TOTEM_SEND_TRANSACTION_VERSION) {
+        errors.push(`Invalid version: expected ${exports.TOTEM_SEND_TRANSACTION_VERSION}, got ${req.version}`);
+    }
+    const validIntents = [
+        'send', 'token_send', 'swap', 'liquidity_add', 'liquidity_remove',
+        'contract_call', 'multisig', 'timelock', 'htlc', 'custom'
+    ];
+    if (!validIntents.includes(req.intent)) {
+        errors.push(`Invalid intent: ${req.intent}. Must be one of: ${validIntents.join(', ')}`);
+    }
+    if (!Array.isArray(req.outputs) || req.outputs.length === 0) {
+        errors.push('outputs must be a non-empty array');
+    }
+    else {
+        for (let i = 0; i < req.outputs.length; i++) {
+            const output = req.outputs[i];
+            if (!output.address || typeof output.address !== 'string') {
+                errors.push(`outputs[${i}].address is required and must be a string`);
+            }
+            if (!output.amount || typeof output.amount !== 'string') {
+                errors.push(`outputs[${i}].amount is required and must be a string`);
+            }
+            const amountNum = parseFloat(output.amount);
+            if (isNaN(amountNum) || amountNum <= 0) {
+                errors.push(`outputs[${i}].amount must be a positive number`);
+            }
+        }
+    }
+    if (req.burn !== undefined) {
+        const burnNum = parseFloat(req.burn);
+        if (isNaN(burnNum) || burnNum < 0) {
+            errors.push('burn must be a non-negative number string');
+        }
+    }
+    if (req.intent === 'swap' && !req.swap) {
+        errors.push('swap params required for swap intent');
+    }
+    if ((req.intent === 'liquidity_add' || req.intent === 'liquidity_remove') && !req.liquidity) {
+        errors.push('liquidity params required for liquidity intent');
+    }
+    if (req.intent === 'multisig' && !req.multisig) {
+        errors.push('multisig params required for multisig intent');
+    }
+    if (req.intent === 'timelock' && !req.timelock) {
+        errors.push('timelock params required for timelock intent');
+    }
+    if (req.intent === 'htlc' && !req.htlc) {
+        errors.push('htlc params required for htlc intent');
+    }
+    if (req.intent === 'contract_call' && !req.contract) {
+        errors.push('contract params required for contract_call intent');
+    }
+    return { valid: errors.length === 0, errors };
+}
+function simpleTotemSendRequest(to, amount, tokenId) {
+    return {
+        version: exports.TOTEM_SEND_TRANSACTION_VERSION,
+        intent: tokenId && tokenId !== '0x00' ? 'token_send' : 'send',
+        outputs: [{
+                address: to,
+                amount,
+                tokenId: tokenId || '0x00'
+            }]
+    };
+}

package/dist/cjs/scripts/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './dapp-types.js';
+export { encodeMiniNumber, encodeMiniData, encodeMiniString, serializeMMRProofChunk, serializeScriptProofWithProof, STATETYPE_HEX, STATETYPE_NUMBER, STATETYPE_STRING, STATETYPE_BOOL, encodeStateValue, serializeStateVariables, buildScriptProofFromDescriptor, deduplicateScriptDescriptors, serializeExtraScripts, aggregateSignatures, validateExternalSignature, computeScriptAddress, } from './witness-serializer.js';
+export * from './contract-helpers.js';

package/dist/cjs/scripts/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeScriptAddress = exports.validateExternalSignature = exports.aggregateSignatures = exports.serializeExtraScripts = exports.deduplicateScriptDescriptors = exports.buildScriptProofFromDescriptor = exports.serializeStateVariables = exports.encodeStateValue = exports.STATETYPE_BOOL = exports.STATETYPE_STRING = exports.STATETYPE_NUMBER = exports.STATETYPE_HEX = exports.serializeScriptProofWithProof = exports.serializeMMRProofChunk = exports.encodeMiniString = exports.encodeMiniData = exports.encodeMiniNumber = void 0;
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./dapp-types.js"), exports);
+var witness_serializer_js_1 = require("./witness-serializer.js");
+Object.defineProperty(exports, "encodeMiniNumber", { enumerable: true, get: function () { return witness_serializer_js_1.encodeMiniNumber; } });
+Object.defineProperty(exports, "encodeMiniData", { enumerable: true, get: function () { return witness_serializer_js_1.encodeMiniData; } });
+Object.defineProperty(exports, "encodeMiniString", { enumerable: true, get: function () { return witness_serializer_js_1.encodeMiniString; } });
+Object.defineProperty(exports, "serializeMMRProofChunk", { enumerable: true, get: function () { return witness_serializer_js_1.serializeMMRProofChunk; } });
+Object.defineProperty(exports, "serializeScriptProofWithProof", { enumerable: true, get: function () { return witness_serializer_js_1.serializeScriptProofWithProof; } });
+Object.defineProperty(exports, "STATETYPE_HEX", { enumerable: true, get: function () { return witness_serializer_js_1.STATETYPE_HEX; } });
+Object.defineProperty(exports, "STATETYPE_NUMBER", { enumerable: true, get: function () { return witness_serializer_js_1.STATETYPE_NUMBER; } });
+Object.defineProperty(exports, "STATETYPE_STRING", { enumerable: true, get: function () { return witness_serializer_js_1.STATETYPE_STRING; } });
+Object.defineProperty(exports, "STATETYPE_BOOL", { enumerable: true, get: function () { return witness_serializer_js_1.STATETYPE_BOOL; } });
+Object.defineProperty(exports, "encodeStateValue", { enumerable: true, get: function () { return witness_serializer_js_1.encodeStateValue; } });
+Object.defineProperty(exports, "serializeStateVariables", { enumerable: true, get: function () { return witness_serializer_js_1.serializeStateVariables; } });
+Object.defineProperty(exports, "buildScriptProofFromDescriptor", { enumerable: true, get: function () { return witness_serializer_js_1.buildScriptProofFromDescriptor; } });
+Object.defineProperty(exports, "deduplicateScriptDescriptors", { enumerable: true, get: function () { return witness_serializer_js_1.deduplicateScriptDescriptors; } });
+Object.defineProperty(exports, "serializeExtraScripts", { enumerable: true, get: function () { return witness_serializer_js_1.serializeExtraScripts; } });
+Object.defineProperty(exports, "aggregateSignatures", { enumerable: true, get: function () { return witness_serializer_js_1.aggregateSignatures; } });
+Object.defineProperty(exports, "validateExternalSignature", { enumerable: true, get: function () { return witness_serializer_js_1.validateExternalSignature; } });
+Object.defineProperty(exports, "computeScriptAddress", { enumerable: true, get: function () { return witness_serializer_js_1.computeScriptAddress; } });
+__exportStar(require("./contract-helpers.js"), exports);

package/dist/cjs/scripts/types.d.ts

@@ -0,0 +1,81 @@
+import type { MMRProofChunk, MMRProof } from '../mmr.js';
+export type { MMRProof };
+export type StateVariableType = 'STATE' | 'PREVSTATE' | 'SAMESTATE';
+export interface StateValue {
+    port: number;
+    value: string | bigint | Uint8Array | boolean;
+    type: 'bool' | 'number' | 'hex' | 'string';
+}
+export interface VerifyOutExpectation {
+    inputIndex: number | '@INPUT';
+    outputAddress: string;
+    amount: string | bigint;
+    tokenId: string;
+    keepState: boolean;
+}
+export type ScriptType = 'signedby' | 'multisig' | 'multisig_mofn' | 'timelock' | 'htlc' | 'mast' | 'exchange' | 'vault' | 'flashcash' | 'slowcash' | 'stateful' | 'custom';
+export interface ScriptDescriptor {
+    address: string;
+    scriptType: ScriptType;
+    script: string;
+    wotsRootPublicKey?: string;
+    mastProof?: MMRProof;
+    extraScripts?: Map<string, string>;
+    stateVariables?: StateValue[];
+    storeState?: boolean;
+    verifyOutExpectations?: VerifyOutExpectation[];
+    timelockBlock?: bigint;
+    htlcHash?: string;
+    htlcPreimage?: string;
+    multisigKeys?: string[];
+    multisigThreshold?: number;
+    externalSignatures?: ExternalSignature[];
+}
+export interface ExternalSignature {
+    publicKey: string;
+    signature: string;
+    proof?: MMRProof;
+    signatureType: 'wots' | 'standard';
+    validated?: boolean;
+}
+export interface ScriptCatalogEntry {
+    address: string;
+    script: string;
+    scriptType: ScriptType;
+    createdAt: number;
+    lastUsed: number;
+}
+export interface ScriptProofResult {
+    script: string;
+    proof: MMRProof;
+    serialized: Uint8Array;
+}
+export interface TransactionRoundState {
+    round: number;
+    previousRound: number;
+    preservedPorts: number[];
+    newStates: StateValue[];
+}
+export interface FlatMMRProofChunk {
+    isLeft: boolean;
+    data: Uint8Array;
+}
+export interface LegacyMMRProof {
+    blockTime: bigint;
+    proofChain: FlatMMRProofChunk[];
+}
+export declare function convertFlatChunkToSDK(chunk: FlatMMRProofChunk): MMRProofChunk;
+export declare function convertLegacyProofToSDK(legacy: LegacyMMRProof): {
+    proof: MMRProof;
+    blockTime: bigint;
+};
+export declare function createEmptyMMRProof(): MMRProof;
+export declare function createSignedByDescriptor(address: string, wotsRootPublicKey: string): ScriptDescriptor;
+export declare function createMultisigDescriptor(address: string, publicKey1: string, publicKey2: string, ownPublicKey: string): ScriptDescriptor;
+export declare function createMofNMultisigDescriptor(address: string, threshold: number, publicKeys: string[], ownPublicKey: string): ScriptDescriptor;
+export declare function createTimelockDescriptor(address: string, publicKey: string, unlockBlock: bigint): ScriptDescriptor;
+export declare function createHTLCDescriptor(address: string, ownerPublicKey: string, recipientPublicKey: string, hashLock: string, timeoutBlock: bigint, isOwner: boolean, preimage?: string): ScriptDescriptor;
+export declare function createMASTDescriptor(address: string, rootHash: string, branchScript: string, branchProof: string, wotsPublicKey?: string): ScriptDescriptor;
+export declare function createExchangeDescriptor(address: string, ownerPublicKey: string, desiredAddress: string, desiredAmount: string, desiredTokenId: string): ScriptDescriptor;
+export declare function createFlashCashDescriptor(address: string, ownerPublicKey: string, interestMultiplier?: string): ScriptDescriptor;
+export declare function createSlowCashDescriptor(address: string, ownerPublicKey: string, withdrawalPercent?: string, cooldownBlocks?: bigint): ScriptDescriptor;

package/dist/cjs/scripts/types.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFlatChunkToSDK = convertFlatChunkToSDK;
+exports.convertLegacyProofToSDK = convertLegacyProofToSDK;
+exports.createEmptyMMRProof = createEmptyMMRProof;
+exports.createSignedByDescriptor = createSignedByDescriptor;
+exports.createMultisigDescriptor = createMultisigDescriptor;
+exports.createMofNMultisigDescriptor = createMofNMultisigDescriptor;
+exports.createTimelockDescriptor = createTimelockDescriptor;
+exports.createHTLCDescriptor = createHTLCDescriptor;
+exports.createMASTDescriptor = createMASTDescriptor;
+exports.createExchangeDescriptor = createExchangeDescriptor;
+exports.createFlashCashDescriptor = createFlashCashDescriptor;
+exports.createSlowCashDescriptor = createSlowCashDescriptor;
+function kissHex(hex) {
+    const raw = hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
+    return '0x' + raw.toUpperCase();
+}
+function convertFlatChunkToSDK(chunk) {
+    return {
+        isLeft: chunk.isLeft,
+        mmrData: { data: chunk.data, value: 0n }
+    };
+}
+function convertLegacyProofToSDK(legacy) {
+    return {
+        proof: {
+            chunks: legacy.proofChain.map(convertFlatChunkToSDK)
+        },
+        blockTime: legacy.blockTime
+    };
+}
+function createEmptyMMRProof() {
+    return { chunks: [] };
+}
+function createSignedByDescriptor(address, wotsRootPublicKey) {
+    return {
+        address,
+        scriptType: 'signedby',
+        script: `RETURN SIGNEDBY(${kissHex(wotsRootPublicKey)})`,
+        wotsRootPublicKey,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+function createMultisigDescriptor(address, publicKey1, publicKey2, ownPublicKey) {
+    return {
+        address,
+        scriptType: 'multisig',
+        script: `RETURN SIGNEDBY(${kissHex(publicKey1)}) AND SIGNEDBY(${kissHex(publicKey2)})`,
+        wotsRootPublicKey: ownPublicKey,
+        multisigKeys: [publicKey1, publicKey2],
+        multisigThreshold: 2,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+function createMofNMultisigDescriptor(address, threshold, publicKeys, ownPublicKey) {
+    const formattedKeys = publicKeys.map(pk => kissHex(pk)).join(' ');
+    return {
+        address,
+        scriptType: 'multisig_mofn',
+        script: `RETURN MULTISIG(${threshold} ${formattedKeys})`,
+        wotsRootPublicKey: ownPublicKey,
+        multisigKeys: publicKeys,
+        multisigThreshold: threshold,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+function createTimelockDescriptor(address, publicKey, unlockBlock) {
+    return {
+        address,
+        scriptType: 'timelock',
+        script: `RETURN SIGNEDBY(${kissHex(publicKey)}) AND @BLOCK GT ${unlockBlock}`,
+        wotsRootPublicKey: publicKey,
+        timelockBlock: unlockBlock,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+function createHTLCDescriptor(address, ownerPublicKey, recipientPublicKey, hashLock, timeoutBlock, isOwner, preimage) {
+    const script = `IF @BLOCK GT ${timeoutBlock} AND SIGNEDBY(${kissHex(ownerPublicKey)}) THEN RETURN TRUE ENDIF RETURN (SIGNEDBY(${kissHex(recipientPublicKey)}) AND SHA3(STATE(1)) EQ ${kissHex(hashLock)})`;
+    const descriptor = {
+        address,
+        scriptType: 'htlc',
+        script,
+        wotsRootPublicKey: isOwner ? ownerPublicKey : recipientPublicKey,
+        htlcHash: hashLock,
+        timelockBlock: timeoutBlock,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+    if (preimage) {
+        descriptor.htlcPreimage = preimage;
+        descriptor.stateVariables = [{ port: 1, value: preimage, type: 'string' }];
+    }
+    return descriptor;
+}
+function createMASTDescriptor(address, rootHash, branchScript, branchProof, wotsPublicKey) {
+    return {
+        address,
+        scriptType: 'mast',
+        script: `MAST ${kissHex(rootHash)}`,
+        wotsRootPublicKey: wotsPublicKey,
+        extraScripts: new Map([[branchScript, branchProof]]),
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+function createExchangeDescriptor(address, ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId) {
+    const ownerPk = kissHex(ownerPublicKey);
+    const script = `IF SIGNEDBY(PREVSTATE(0)) THEN RETURN TRUE ENDIF ASSERT VERIFYOUT(@INPUT PREVSTATE(1) PREVSTATE(2) PREVSTATE(3) TRUE) RETURN TRUE`;
+    return {
+        address,
+        scriptType: 'exchange',
+        script,
+        wotsRootPublicKey: ownerPublicKey,
+        stateVariables: [
+            { port: 0, value: ownerPk, type: 'hex' },
+            { port: 1, value: desiredAddress, type: 'hex' },
+            { port: 2, value: desiredAmount, type: 'number' },
+            { port: 3, value: desiredTokenId, type: 'hex' }
+        ],
+        verifyOutExpectations: [{
+                inputIndex: '@INPUT',
+                outputAddress: desiredAddress,
+                amount: desiredAmount,
+                tokenId: desiredTokenId,
+                keepState: true
+            }],
+        mastProof: createEmptyMMRProof(),
+        storeState: true
+    };
+}
+function createFlashCashDescriptor(address, ownerPublicKey, interestMultiplier = '1.01') {
+    const script = `IF SIGNEDBY(PREVSTATE(1)) THEN RETURN TRUE ENDIF ASSERT SAMESTATE(1 1) RETURN VERIFYOUT(@INPUT @ADDRESS @AMOUNT*${interestMultiplier} @TOKENID TRUE)`;
+    return {
+        address,
+        scriptType: 'flashcash',
+        script,
+        wotsRootPublicKey: ownerPublicKey,
+        stateVariables: [{ port: 1, value: ownerPublicKey, type: 'hex' }],
+        mastProof: createEmptyMMRProof(),
+        storeState: true
+    };
+}
+function createSlowCashDescriptor(address, ownerPublicKey, withdrawalPercent = '0.9', cooldownBlocks = 10000n) {
+    const script = `IF @COINAGE LT ${cooldownBlocks} THEN RETURN FALSE ENDIF ASSERT SIGNEDBY(${kissHex(ownerPublicKey)}) AND VERIFYOUT(@INPUT @ADDRESS @AMOUNT*${withdrawalPercent} @TOKENID TRUE)`;
+    return {
+        address,
+        scriptType: 'slowcash',
+        script,
+        wotsRootPublicKey: ownerPublicKey,
+        timelockBlock: cooldownBlocks,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}

package/dist/cjs/scripts/witness-serializer.d.ts

@@ -0,0 +1,29 @@
+import type { MMRProof, MMRProofChunk } from '../mmr.js';
+import type { ScriptDescriptor, StateValue, ExternalSignature, ScriptProofResult } from './types.js';
+declare function concat(...arrays: Uint8Array[]): Uint8Array;
+export declare function encodeMiniNumber(value: bigint, scale?: number): Uint8Array;
+export declare function encodeMiniData(data: Uint8Array): Uint8Array;
+export declare function encodeMiniString(str: string): Uint8Array;
+export declare function serializeMMRProofChunk(chunk: MMRProofChunk): Uint8Array;
+export declare function serializeRealMMRProof(proof: MMRProof, blockTime?: bigint): Uint8Array;
+export declare function parseMMRProofFromHex(proofHex: string): {
+    proof: MMRProof;
+    blockTime: bigint;
+};
+export declare function serializeScriptProofWithProof(script: string, proof: MMRProof, blockTime?: bigint): Uint8Array;
+export declare const STATETYPE_HEX = 1;
+export declare const STATETYPE_NUMBER = 2;
+export declare const STATETYPE_STRING = 4;
+export declare const STATETYPE_BOOL = 8;
+export declare function encodeStateValue(stateValue: StateValue): Uint8Array;
+export declare function serializeStateVariables(stateValues: StateValue[]): Uint8Array;
+export declare function buildScriptProofFromDescriptor(descriptor: ScriptDescriptor): ScriptProofResult;
+export declare function deduplicateScriptDescriptors(descriptors: ScriptDescriptor[]): Map<string, ScriptDescriptor>;
+export declare function serializeExtraScripts(extraScripts: Map<string, string>): Uint8Array;
+export declare function aggregateSignatures(totemSignature: {
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+}, externalSignatures: ExternalSignature[]): Uint8Array[];
+export declare function validateExternalSignature(signature: ExternalSignature, transactionDigest: Uint8Array): boolean;
+export declare function computeScriptAddress(script: string): string;
+export { concat };