phantasma-sdk-ts 0.5.1 → 0.5.2

package/dist/cjs/core/tx/ContractArtifacts.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContractArtifactBundle = exports.buildContractArtifactManifest = exports.coerceContractBytes = exports.normalizeContractName = void 0;
+const sha256_js_1 = __importDefault(require("crypto-js/sha256.js"));
+const enc_hex_js_1 = __importDefault(require("crypto-js/enc-hex.js"));
+const index_js_1 = require("../utils/index.js");
+function sha256Hex(bytes) {
+    return (0, sha256_js_1.default)(enc_hex_js_1.default.parse((0, index_js_1.bytesToHex)(bytes))).toString(enc_hex_js_1.default);
+}
+function buildFileEntry(path, bytes) {
+    const trimmedPath = path.trim();
+    if (!trimmedPath) {
+        throw new Error('artifact path cannot be empty');
+    }
+    return {
+        path: trimmedPath,
+        size: bytes.length,
+        sha256: sha256Hex(bytes),
+    };
+}
+function normalizeContractName(contractName) {
+    const trimmed = contractName.trim();
+    if (!trimmed) {
+        throw new Error('contractName cannot be empty');
+    }
+    return trimmed;
+}
+exports.normalizeContractName = normalizeContractName;
+function coerceContractBytes(input, label) {
+    if (input instanceof Uint8Array) {
+        if (input.length === 0) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        // Copy mutable buffers so callers can keep reusing their original arrays safely.
+        return new Uint8Array(input);
+    }
+    if (typeof input === 'string') {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        const bytes = (0, index_js_1.hexToBytes)(trimmed);
+        if (bytes.length === 0) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        return bytes;
+    }
+    throw new Error(`${label} must be Uint8Array or hex string`);
+}
+exports.coerceContractBytes = coerceContractBytes;
+function buildContractArtifactManifest(params) {
+    // The manifest is the stable handoff contract between compiler, CLI, frontend, and runbooks.
+    const contractName = normalizeContractName(params.contractName);
+    const compilerName = params.compilerName.trim();
+    const compilerVersion = params.compilerVersion.trim();
+    if (!compilerName) {
+        throw new Error('compilerName cannot be empty');
+    }
+    if (!compilerVersion) {
+        throw new Error('compilerVersion cannot be empty');
+    }
+    const scriptBytes = coerceContractBytes(params.script, 'script');
+    const abiBytes = coerceContractBytes(params.abi, 'abi');
+    let debugEntry;
+    if (params.debugPath !== undefined || params.debug !== undefined) {
+        if (!params.debugPath || params.debug === undefined) {
+            throw new Error('debugPath and debug must be provided together');
+        }
+        debugEntry = buildFileEntry(params.debugPath, coerceContractBytes(params.debug, 'debug'));
+    }
+    const manifest = {
+        format: 'pha.contract.artifacts/v1',
+        contractName,
+        createdAtUtc: (params.createdAtUtc ?? new Date().toISOString()).trim(),
+        compiler: {
+            name: compilerName,
+            version: compilerVersion,
+        },
+        files: {
+            script: buildFileEntry(params.scriptPath, scriptBytes),
+            abi: buildFileEntry(params.abiPath, abiBytes),
+            ...(debugEntry ? { debug: debugEntry } : {}),
+        },
+        ...(params.sourceFile ? { sourceFile: params.sourceFile } : {}),
+    };
+    if (!manifest.createdAtUtc) {
+        throw new Error('createdAtUtc cannot be empty');
+    }
+    return manifest;
+}
+exports.buildContractArtifactManifest = buildContractArtifactManifest;
+function buildContractArtifactBundle(params) {
+    // Keep bundle materialization small and explicit so higher layers can choose their own IO/layout policy.
+    const bundle = {
+        contractName: normalizeContractName(params.contractName),
+        script: coerceContractBytes(params.script, 'script'),
+        abi: coerceContractBytes(params.abi, 'abi'),
+        ...(params.debug !== undefined ? { debug: coerceContractBytes(params.debug, 'debug') } : {}),
+        ...(params.manifest ? { manifest: params.manifest } : {}),
+    };
+    return bundle;
+}
+exports.buildContractArtifactBundle = buildContractArtifactBundle;

package/dist/cjs/core/tx/ContractTxHelper.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractTxHelper = void 0;
+const ProofOfWork_js_1 = require("../link/interfaces/ProofOfWork.js");
+const DomainSettings_js_1 = require("../types/DomainSettings.js");
+const index_js_1 = require("../utils/index.js");
+const index_js_2 = require("../vm/index.js");
+const Transaction_js_1 = require("./Transaction.js");
+const ContractArtifacts_js_1 = require("./ContractArtifacts.js");
+class ContractTxHelper {
+    static buildDeployScript(params) {
+        return this.buildContractLifecycleScript('Runtime.DeployContract', params);
+    }
+    static buildUpgradeScript(params) {
+        return this.buildContractLifecycleScript('Runtime.UpgradeContract', params);
+    }
+    static buildDeployTransaction(params) {
+        return this.buildContractLifecycleTransaction(this.buildDeployScript(params), params);
+    }
+    static buildUpgradeTransaction(params) {
+        return this.buildContractLifecycleTransaction(this.buildUpgradeScript(params), params);
+    }
+    static buildDeployTransactionAndEncode(params) {
+        const tx = this.buildDeployTransaction(params);
+        this.signTransaction(tx, params.signer, params.proofOfWork);
+        return tx.ToStringEncoded(true).toUpperCase();
+    }
+    static buildUpgradeTransactionAndEncode(params) {
+        const tx = this.buildUpgradeTransaction(params);
+        this.signTransaction(tx, params.signer, params.proofOfWork);
+        return tx.ToStringEncoded(true).toUpperCase();
+    }
+    static buildDeployScriptFromBundle(bundle, from, gasPrice, gasLimit) {
+        return this.buildDeployScript({
+            from,
+            contractName: bundle.contractName,
+            script: bundle.script,
+            abi: bundle.abi,
+            gasPrice,
+            gasLimit,
+        });
+    }
+    static buildUpgradeScriptFromBundle(bundle, from, gasPrice, gasLimit) {
+        return this.buildUpgradeScript({
+            from,
+            contractName: bundle.contractName,
+            script: bundle.script,
+            abi: bundle.abi,
+            gasPrice,
+            gasLimit,
+        });
+    }
+    static encodePayloadText(text) {
+        return (0, index_js_1.bytesToHex)(new TextEncoder().encode(text));
+    }
+    static buildContractLifecycleScript(interopName, params) {
+        // Keep deploy/upgrade on the same legacy VM script path so CLI and wallet flows generate identical transactions.
+        const fromAddress = this.normalizeAddress(params.from);
+        const contractName = (0, ContractArtifacts_js_1.normalizeContractName)(params.contractName);
+        const scriptBytes = (0, ContractArtifacts_js_1.coerceContractBytes)(params.script, 'script');
+        const abiBytes = (0, ContractArtifacts_js_1.coerceContractBytes)(params.abi, 'abi');
+        const gasPrice = this.normalizeSmallInteger(params.gasPrice ?? this.DefaultGasPrice, 'gasPrice');
+        const gasLimit = this.normalizeSmallInteger(params.gasLimit ?? this.DefaultGasLimit, 'gasLimit');
+        const nullAddress = new index_js_2.ScriptBuilder().NullAddress;
+        return new index_js_2.ScriptBuilder()
+            .BeginScript()
+            .AllowGas(fromAddress, nullAddress, gasPrice, gasLimit)
+            .CallInterop(interopName, [fromAddress, contractName, scriptBytes, abiBytes])
+            .SpendGas(fromAddress)
+            .EndScript();
+    }
+    static buildContractLifecycleTransaction(scriptHex, params) {
+        // Transaction construction stays separate from signing so callers can inspect or override the unsigned tx first.
+        const nexus = params.nexus.trim();
+        const chain = (params.chain ?? DomainSettings_js_1.DomainSettings.RootChainName).trim();
+        if (!nexus) {
+            throw new Error('nexus cannot be empty');
+        }
+        if (!chain) {
+            throw new Error('chain cannot be empty');
+        }
+        const payloadHex = params.payloadHex?.trim() ?? '';
+        return new Transaction_js_1.Transaction(nexus, chain, scriptHex, params.expiration ?? new Date(Date.now() + 5 * 60 * 1000), payloadHex);
+    }
+    static signTransaction(tx, signer, proofOfWork = ProofOfWork_js_1.ProofOfWork.Minimal) {
+        // Mining/signing is the only mutation stage; everything above should remain deterministic and side-effect free.
+        if (proofOfWork > 0) {
+            tx.mineTransaction(proofOfWork);
+        }
+        if (typeof signer === 'string') {
+            const trimmedWif = signer.trim();
+            if (!trimmedWif) {
+                throw new Error('signer WIF cannot be empty');
+            }
+            tx.sign(trimmedWif);
+            return;
+        }
+        tx.signWithKeys(signer);
+    }
+    static normalizeAddress(address) {
+        if (typeof address === 'string') {
+            const trimmed = address.trim();
+            if (!trimmed) {
+                throw new Error('from cannot be empty');
+            }
+            return trimmed;
+        }
+        return address;
+    }
+    static normalizeSmallInteger(value, label) {
+        const numeric = typeof value === 'bigint' ? Number(value) : value;
+        if (!Number.isSafeInteger(numeric) || numeric <= 0) {
+            throw new Error(`${label} must be a positive safe integer`);
+        }
+        return numeric;
+    }
+}
+exports.ContractTxHelper = ContractTxHelper;
+ContractTxHelper.DefaultGasPrice = DomainSettings_js_1.DomainSettings.DefaultMinimumGasFee;
+ContractTxHelper.DefaultGasLimit = 100000;

package/dist/cjs/core/tx/index.js

@@ -15,5 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ExecutionState.js"), exports);
+__exportStar(require("./ContractArtifacts.js"), exports);
+__exportStar(require("./ContractTxHelper.js"), exports);
 __exportStar(require("./Transaction.js"), exports);
 __exportStar(require("./utils.js"), exports);

package/dist/cjs/core/utils/Hex.js

@@ -18,7 +18,7 @@ function bytesToHex(bytes) {
 exports.bytesToHex = bytesToHex;
 function hexToBytes(hex) {
     const trimmed = hex.trim();
-    const normalized = trimmed.startsWith('0x') ? trimmed.slice(2) : trimmed;
+    const normalized = trimmed.startsWith('0x') || trimmed.startsWith('0X') ? trimmed.slice(2) : trimmed;
     if (normalized.length === 0) {
         return new Uint8Array();
     }

package/dist/esm/core/tx/ContractArtifacts.js

@@ -0,0 +1,96 @@
+import SHA256 from 'crypto-js/sha256.js';
+import hexEncoding from 'crypto-js/enc-hex.js';
+import { bytesToHex, hexToBytes } from '../utils/index.js';
+function sha256Hex(bytes) {
+    return SHA256(hexEncoding.parse(bytesToHex(bytes))).toString(hexEncoding);
+}
+function buildFileEntry(path, bytes) {
+    const trimmedPath = path.trim();
+    if (!trimmedPath) {
+        throw new Error('artifact path cannot be empty');
+    }
+    return {
+        path: trimmedPath,
+        size: bytes.length,
+        sha256: sha256Hex(bytes),
+    };
+}
+export function normalizeContractName(contractName) {
+    const trimmed = contractName.trim();
+    if (!trimmed) {
+        throw new Error('contractName cannot be empty');
+    }
+    return trimmed;
+}
+export function coerceContractBytes(input, label) {
+    if (input instanceof Uint8Array) {
+        if (input.length === 0) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        // Copy mutable buffers so callers can keep reusing their original arrays safely.
+        return new Uint8Array(input);
+    }
+    if (typeof input === 'string') {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        const bytes = hexToBytes(trimmed);
+        if (bytes.length === 0) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        return bytes;
+    }
+    throw new Error(`${label} must be Uint8Array or hex string`);
+}
+export function buildContractArtifactManifest(params) {
+    // The manifest is the stable handoff contract between compiler, CLI, frontend, and runbooks.
+    const contractName = normalizeContractName(params.contractName);
+    const compilerName = params.compilerName.trim();
+    const compilerVersion = params.compilerVersion.trim();
+    if (!compilerName) {
+        throw new Error('compilerName cannot be empty');
+    }
+    if (!compilerVersion) {
+        throw new Error('compilerVersion cannot be empty');
+    }
+    const scriptBytes = coerceContractBytes(params.script, 'script');
+    const abiBytes = coerceContractBytes(params.abi, 'abi');
+    let debugEntry;
+    if (params.debugPath !== undefined || params.debug !== undefined) {
+        if (!params.debugPath || params.debug === undefined) {
+            throw new Error('debugPath and debug must be provided together');
+        }
+        debugEntry = buildFileEntry(params.debugPath, coerceContractBytes(params.debug, 'debug'));
+    }
+    const manifest = {
+        format: 'pha.contract.artifacts/v1',
+        contractName,
+        createdAtUtc: (params.createdAtUtc ?? new Date().toISOString()).trim(),
+        compiler: {
+            name: compilerName,
+            version: compilerVersion,
+        },
+        files: {
+            script: buildFileEntry(params.scriptPath, scriptBytes),
+            abi: buildFileEntry(params.abiPath, abiBytes),
+            ...(debugEntry ? { debug: debugEntry } : {}),
+        },
+        ...(params.sourceFile ? { sourceFile: params.sourceFile } : {}),
+    };
+    if (!manifest.createdAtUtc) {
+        throw new Error('createdAtUtc cannot be empty');
+    }
+    return manifest;
+}
+export function buildContractArtifactBundle(params) {
+    // Keep bundle materialization small and explicit so higher layers can choose their own IO/layout policy.
+    const bundle = {
+        contractName: normalizeContractName(params.contractName),
+        script: coerceContractBytes(params.script, 'script'),
+        abi: coerceContractBytes(params.abi, 'abi'),
+        ...(params.debug !== undefined ? { debug: coerceContractBytes(params.debug, 'debug') } : {}),
+        ...(params.manifest ? { manifest: params.manifest } : {}),
+    };
+    return bundle;
+}

package/dist/esm/core/tx/ContractTxHelper.js

@@ -0,0 +1,116 @@
+import { ProofOfWork } from '../link/interfaces/ProofOfWork.js';
+import { DomainSettings } from '../types/DomainSettings.js';
+import { bytesToHex } from '../utils/index.js';
+import { ScriptBuilder } from '../vm/index.js';
+import { Transaction } from './Transaction.js';
+import { coerceContractBytes, normalizeContractName } from './ContractArtifacts.js';
+export class ContractTxHelper {
+    static buildDeployScript(params) {
+        return this.buildContractLifecycleScript('Runtime.DeployContract', params);
+    }
+    static buildUpgradeScript(params) {
+        return this.buildContractLifecycleScript('Runtime.UpgradeContract', params);
+    }
+    static buildDeployTransaction(params) {
+        return this.buildContractLifecycleTransaction(this.buildDeployScript(params), params);
+    }
+    static buildUpgradeTransaction(params) {
+        return this.buildContractLifecycleTransaction(this.buildUpgradeScript(params), params);
+    }
+    static buildDeployTransactionAndEncode(params) {
+        const tx = this.buildDeployTransaction(params);
+        this.signTransaction(tx, params.signer, params.proofOfWork);
+        return tx.ToStringEncoded(true).toUpperCase();
+    }
+    static buildUpgradeTransactionAndEncode(params) {
+        const tx = this.buildUpgradeTransaction(params);
+        this.signTransaction(tx, params.signer, params.proofOfWork);
+        return tx.ToStringEncoded(true).toUpperCase();
+    }
+    static buildDeployScriptFromBundle(bundle, from, gasPrice, gasLimit) {
+        return this.buildDeployScript({
+            from,
+            contractName: bundle.contractName,
+            script: bundle.script,
+            abi: bundle.abi,
+            gasPrice,
+            gasLimit,
+        });
+    }
+    static buildUpgradeScriptFromBundle(bundle, from, gasPrice, gasLimit) {
+        return this.buildUpgradeScript({
+            from,
+            contractName: bundle.contractName,
+            script: bundle.script,
+            abi: bundle.abi,
+            gasPrice,
+            gasLimit,
+        });
+    }
+    static encodePayloadText(text) {
+        return bytesToHex(new TextEncoder().encode(text));
+    }
+    static buildContractLifecycleScript(interopName, params) {
+        // Keep deploy/upgrade on the same legacy VM script path so CLI and wallet flows generate identical transactions.
+        const fromAddress = this.normalizeAddress(params.from);
+        const contractName = normalizeContractName(params.contractName);
+        const scriptBytes = coerceContractBytes(params.script, 'script');
+        const abiBytes = coerceContractBytes(params.abi, 'abi');
+        const gasPrice = this.normalizeSmallInteger(params.gasPrice ?? this.DefaultGasPrice, 'gasPrice');
+        const gasLimit = this.normalizeSmallInteger(params.gasLimit ?? this.DefaultGasLimit, 'gasLimit');
+        const nullAddress = new ScriptBuilder().NullAddress;
+        return new ScriptBuilder()
+            .BeginScript()
+            .AllowGas(fromAddress, nullAddress, gasPrice, gasLimit)
+            .CallInterop(interopName, [fromAddress, contractName, scriptBytes, abiBytes])
+            .SpendGas(fromAddress)
+            .EndScript();
+    }
+    static buildContractLifecycleTransaction(scriptHex, params) {
+        // Transaction construction stays separate from signing so callers can inspect or override the unsigned tx first.
+        const nexus = params.nexus.trim();
+        const chain = (params.chain ?? DomainSettings.RootChainName).trim();
+        if (!nexus) {
+            throw new Error('nexus cannot be empty');
+        }
+        if (!chain) {
+            throw new Error('chain cannot be empty');
+        }
+        const payloadHex = params.payloadHex?.trim() ?? '';
+        return new Transaction(nexus, chain, scriptHex, params.expiration ?? new Date(Date.now() + 5 * 60 * 1000), payloadHex);
+    }
+    static signTransaction(tx, signer, proofOfWork = ProofOfWork.Minimal) {
+        // Mining/signing is the only mutation stage; everything above should remain deterministic and side-effect free.
+        if (proofOfWork > 0) {
+            tx.mineTransaction(proofOfWork);
+        }
+        if (typeof signer === 'string') {
+            const trimmedWif = signer.trim();
+            if (!trimmedWif) {
+                throw new Error('signer WIF cannot be empty');
+            }
+            tx.sign(trimmedWif);
+            return;
+        }
+        tx.signWithKeys(signer);
+    }
+    static normalizeAddress(address) {
+        if (typeof address === 'string') {
+            const trimmed = address.trim();
+            if (!trimmed) {
+                throw new Error('from cannot be empty');
+            }
+            return trimmed;
+        }
+        return address;
+    }
+    static normalizeSmallInteger(value, label) {
+        const numeric = typeof value === 'bigint' ? Number(value) : value;
+        if (!Number.isSafeInteger(numeric) || numeric <= 0) {
+            throw new Error(`${label} must be a positive safe integer`);
+        }
+        return numeric;
+    }
+}
+ContractTxHelper.DefaultGasPrice = DomainSettings.DefaultMinimumGasFee;
+ContractTxHelper.DefaultGasLimit = 100000;

package/dist/esm/core/tx/index.js

@@ -1,3 +1,5 @@
 export * from './ExecutionState.js';
+export * from './ContractArtifacts.js';
+export * from './ContractTxHelper.js';
 export * from './Transaction.js';
 export * from './utils.js';

package/dist/esm/core/utils/Hex.js

@@ -14,7 +14,7 @@ export function bytesToHex(bytes) {
 }
 export function hexToBytes(hex) {
     const trimmed = hex.trim();
-    const normalized = trimmed.startsWith('0x') ? trimmed.slice(2) : trimmed;
+    const normalized = trimmed.startsWith('0x') || trimmed.startsWith('0X') ? trimmed.slice(2) : trimmed;
     if (normalized.length === 0) {
         return new Uint8Array();
     }

package/dist/types/core/tx/ContractArtifacts.d.ts

@@ -0,0 +1,53 @@
+export type ContractBinaryInput = Uint8Array | string;
+export interface ContractArtifactFileEntry {
+    path: string;
+    size: number;
+    sha256: string;
+}
+export interface ContractArtifactManifest {
+    format: 'pha.contract.artifacts/v1';
+    contractName: string;
+    createdAtUtc: string;
+    compiler: {
+        name: string;
+        version: string;
+    };
+    sourceFile?: string;
+    files: {
+        script: ContractArtifactFileEntry;
+        abi: ContractArtifactFileEntry;
+        debug?: ContractArtifactFileEntry;
+    };
+}
+export interface ContractArtifactBundle {
+    contractName: string;
+    script: Uint8Array;
+    abi: Uint8Array;
+    debug?: Uint8Array;
+    manifest?: ContractArtifactManifest;
+}
+export interface BuildContractArtifactManifestParams {
+    contractName: string;
+    compilerName: string;
+    compilerVersion: string;
+    scriptPath: string;
+    script: ContractBinaryInput;
+    abiPath: string;
+    abi: ContractBinaryInput;
+    sourceFile?: string;
+    debugPath?: string;
+    debug?: ContractBinaryInput;
+    createdAtUtc?: string;
+}
+export interface BuildContractArtifactBundleParams {
+    contractName: string;
+    script: ContractBinaryInput;
+    abi: ContractBinaryInput;
+    debug?: ContractBinaryInput;
+    manifest?: ContractArtifactManifest;
+}
+export declare function normalizeContractName(contractName: string): string;
+export declare function coerceContractBytes(input: ContractBinaryInput, label: string): Uint8Array;
+export declare function buildContractArtifactManifest(params: BuildContractArtifactManifestParams): ContractArtifactManifest;
+export declare function buildContractArtifactBundle(params: BuildContractArtifactBundleParams): ContractArtifactBundle;
+//# sourceMappingURL=ContractArtifacts.d.ts.map

package/dist/types/core/tx/ContractArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractArtifacts.d.ts","sourceRoot":"","sources":["../../../../src/core/tx/ContractArtifacts.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,2BAA2B,CAAC;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE;QACL,MAAM,EAAE,yBAAyB,CAAC;QAClC,GAAG,EAAE,yBAAyB,CAAC;QAC/B,KAAK,CAAC,EAAE,yBAAyB,CAAC;KACnC,CAAC;CACH;AAED,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,UAAU,CAAC;IACnB,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,wBAAwB,CAAC;CACrC;AAED,MAAM,WAAW,mCAAmC;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,mBAAmB,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iCAAiC;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,GAAG,EAAE,mBAAmB,CAAC;IACzB,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,CAAC,EAAE,wBAAwB,CAAC;CACrC;AAmBD,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAOlE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAwBzF;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mCAAmC,GAC1C,wBAAwB,CA6C1B;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,iCAAiC,GACxC,sBAAsB,CAWxB"}

package/dist/types/core/tx/ContractTxHelper.d.ts

@@ -0,0 +1,41 @@
+import { Address } from '../types/Address.js';
+import { PhantasmaKeys } from '../types/PhantasmaKeys.js';
+import { Transaction } from './Transaction.js';
+import { ContractArtifactBundle, ContractBinaryInput } from './ContractArtifacts.js';
+export interface ContractScriptBuildParams {
+    from: string | Address;
+    contractName: string;
+    script: ContractBinaryInput;
+    abi: ContractBinaryInput;
+    gasPrice?: number | bigint;
+    gasLimit?: number | bigint;
+}
+export interface ContractTransactionBuildParams extends ContractScriptBuildParams {
+    nexus: string;
+    chain?: string;
+    expiration?: Date;
+    payloadHex?: string;
+}
+export interface ContractTransactionSignParams extends ContractTransactionBuildParams {
+    signer: string | PhantasmaKeys;
+    proofOfWork?: number;
+}
+export declare class ContractTxHelper {
+    static readonly DefaultGasPrice: number;
+    static readonly DefaultGasLimit = 100000;
+    static buildDeployScript(params: ContractScriptBuildParams): string;
+    static buildUpgradeScript(params: ContractScriptBuildParams): string;
+    static buildDeployTransaction(params: ContractTransactionBuildParams): Transaction;
+    static buildUpgradeTransaction(params: ContractTransactionBuildParams): Transaction;
+    static buildDeployTransactionAndEncode(params: ContractTransactionSignParams): string;
+    static buildUpgradeTransactionAndEncode(params: ContractTransactionSignParams): string;
+    static buildDeployScriptFromBundle(bundle: ContractArtifactBundle, from: string | Address, gasPrice?: number | bigint, gasLimit?: number | bigint): string;
+    static buildUpgradeScriptFromBundle(bundle: ContractArtifactBundle, from: string | Address, gasPrice?: number | bigint, gasLimit?: number | bigint): string;
+    static encodePayloadText(text: string): string;
+    private static buildContractLifecycleScript;
+    private static buildContractLifecycleTransaction;
+    private static signTransaction;
+    private static normalizeAddress;
+    private static normalizeSmallInteger;
+}
+//# sourceMappingURL=ContractTxHelper.d.ts.map

package/dist/types/core/tx/ContractTxHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTxHelper.d.ts","sourceRoot":"","sources":["../../../../src/core/tx/ContractTxHelper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG1D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAA8C,MAAM,wBAAwB,CAAC;AAEjI,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,GAAG,EAAE,mBAAmB,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,8BAA+B,SAAQ,yBAAyB;IAC/E,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,6BAA8B,SAAQ,8BAA8B;IACnF,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,gBAAgB;IAC3B,MAAM,CAAC,QAAQ,CAAC,eAAe,SAAuC;IACtE,MAAM,CAAC,QAAQ,CAAC,eAAe,UAAW;IAE1C,MAAM,CAAC,iBAAiB,CAAC,MAAM,EAAE,yBAAyB,GAAG,MAAM;IAInE,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,GAAG,MAAM;IAIpE,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,8BAA8B,GAAG,WAAW;IAIlF,MAAM,CAAC,uBAAuB,CAAC,MAAM,EAAE,8BAA8B,GAAG,WAAW;IAInF,MAAM,CAAC,+BAA+B,CAAC,MAAM,EAAE,6BAA6B,GAAG,MAAM;IAMrF,MAAM,CAAC,gCAAgC,CAAC,MAAM,EAAE,6BAA6B,GAAG,MAAM;IAMtF,MAAM,CAAC,2BAA2B,CAAC,MAAM,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAW1J,MAAM,CAAC,4BAA4B,CAAC,MAAM,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAW3J,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI9C,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAqB3C,OAAO,CAAC,MAAM,CAAC,iCAAiC;IAyBhD,OAAO,CAAC,MAAM,CAAC,eAAe;IAsB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAY/B,OAAO,CAAC,MAAM,CAAC,qBAAqB;CAQrC"}

package/dist/types/core/tx/index.d.ts

@@ -1,4 +1,6 @@
 export * from './ExecutionState.js';
+export * from './ContractArtifacts.js';
+export * from './ContractTxHelper.js';
 export * from './Transaction.js';
 export * from './utils.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/core/tx/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/tx/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/tx/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phantasma-sdk-ts",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Typescript SDK for interacting with the Phantasma Chain",
   "author": "Phantasma Team",
   "main": "dist/cjs/index.js",