@alephium/web3 0.0.1-test.0

package/dist/src/contract/contract.js

@@ -0,0 +1,760 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toApiVal = exports.extractArray = exports.Script = exports.Contract = exports.Common = void 0;
+const buffer_1 = require("buffer/");
+const cryptojs = __importStar(require("crypto-js"));
+const crypto = __importStar(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const fs_2 = require("fs");
+const ralph = __importStar(require("./ralph"));
+const utils_1 = require("../utils");
+class Common {
+    constructor(sourceCodeSha256, functions) {
+        this.sourceCodeSha256 = sourceCodeSha256;
+        this.functions = functions;
+    }
+    static _getArtifactFromCache(codeHash) {
+        return this._artifactCache.get(codeHash);
+    }
+    static _putArtifactToCache(contract) {
+        if (!this._artifactCache.has(contract.codeHash)) {
+            if (this._artifactCache.size >= this.artifactCacheCapacity) {
+                const keyToDelete = this._artifactCache.keys().next().value;
+                this._artifactCache.delete(keyToDelete);
+            }
+            this._artifactCache.set(contract.codeHash, contract);
+        }
+    }
+    static _contractPath(fileName) {
+        if (fileName.endsWith('.json')) {
+            return `./contracts/${fileName.slice(0, -5)}`;
+        }
+        else {
+            return `./contracts/${fileName}`;
+        }
+    }
+    static _artifactPath(fileName) {
+        if (fileName.endsWith('.json')) {
+            return `./artifacts/${fileName}`;
+        }
+        else {
+            return `./artifacts/${fileName}.json`;
+        }
+    }
+    static _artifactsFolder() {
+        return './artifacts/';
+    }
+    static async _handleImports(contractStr, importsCache) {
+        const localImportsCache = [];
+        let result = contractStr.replace(Common.importRegex, (match) => {
+            localImportsCache.push(match);
+            return '';
+        });
+        for (const myImport of localImportsCache) {
+            const fileName = myImport.slice(8, -1);
+            if (!importsCache.includes(fileName)) {
+                importsCache.push(fileName);
+                const importContractStr = await Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+                result = result.concat('\n', importContractStr);
+            }
+        }
+        return result;
+    }
+    static async _loadContractStr(fileName, importsCache, validate) {
+        const contractPath = this._contractPath(fileName);
+        const contractBuffer = await fs_2.promises.readFile(contractPath);
+        const contractStr = contractBuffer.toString();
+        validate(contractStr);
+        return Common._handleImports(contractStr, importsCache);
+    }
+    static checkFileNameExtension(fileName) {
+        if (!fileName.endsWith('.ral')) {
+            throw new Error('Smart contract file name should end with ".ral"');
+        }
+    }
+    static async _from(provider, fileName, loadContractStr, compile) {
+        Common.checkFileNameExtension(fileName);
+        const contractStr = await loadContractStr(fileName, []);
+        const contractHash = cryptojs.SHA256(contractStr).toString();
+        const existingContract = this._getArtifactFromCache(contractHash);
+        if (typeof existingContract !== 'undefined') {
+            return existingContract;
+        }
+        else {
+            return compile(provider, fileName, contractStr, contractHash);
+        }
+    }
+    _saveToFile(fileName) {
+        const artifactPath = Common._artifactPath(fileName);
+        return fs_2.promises.writeFile(artifactPath, this.toString());
+    }
+}
+exports.Common = Common;
+Common.importRegex = new RegExp('^import "[a-z][a-z_0-9]*.ral"', 'mg');
+Common.contractRegex = new RegExp('^TxContract [A-Z][a-zA-Z0-9]*', 'mg');
+Common.interfaceRegex = new RegExp('^Interface [A-Z][a-zA-Z0-9]* \\{', 'mg');
+Common.scriptRegex = new RegExp('^TxScript [A-Z][a-zA-Z0-9]*', 'mg');
+Common._artifactCache = new Map();
+Common.artifactCacheCapacity = 20;
+class Contract extends Common {
+    constructor(sourceCodeSha256, bytecode, codeHash, fieldsSig, eventsSig, functions) {
+        super(sourceCodeSha256, functions);
+        this.bytecode = bytecode;
+        this.codeHash = codeHash;
+        this.fieldsSig = fieldsSig;
+        this.eventsSig = eventsSig;
+    }
+    static checkCodeType(fileName, contractStr) {
+        const interfaceMatches = contractStr.match(Contract.interfaceRegex);
+        if (interfaceMatches) {
+            return;
+        }
+        const contractMatches = contractStr.match(Contract.contractRegex);
+        if (contractMatches === null) {
+            throw new Error(`No contract found in: ${fileName}`);
+        }
+        else if (contractMatches.length > 1) {
+            throw new Error(`Multiple contracts in: ${fileName}`);
+        }
+        else {
+            return;
+        }
+    }
+    static async loadContractStr(fileName, importsCache) {
+        return Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+    }
+    static async fromSource(provider, fileName) {
+        if (!fs_1.default.existsSync(Common._artifactsFolder())) {
+            fs_1.default.mkdirSync(Common._artifactsFolder(), { recursive: true });
+        }
+        const contract = await Common._from(provider, fileName, (fileName, importCaches) => Contract.loadContractStr(fileName, importCaches), Contract.compile);
+        this._putArtifactToCache(contract);
+        return contract;
+    }
+    static async compile(provider, fileName, contractStr, contractHash) {
+        const compiled = await provider.contracts.postContractsCompileContract({ code: contractStr });
+        const artifact = new Contract(contractHash, compiled.bytecode, compiled.codeHash, compiled.fields, compiled.events, compiled.functions);
+        await artifact._saveToFile(fileName);
+        return artifact;
+    }
+    // TODO: safely parse json
+    static fromJson(artifact) {
+        if (artifact.sourceCodeSha256 == null ||
+            artifact.bytecode == null ||
+            artifact.codeHash == null ||
+            artifact.fieldsSig == null ||
+            artifact.eventsSig == null ||
+            artifact.functions == null) {
+            throw Error('The artifact JSON for contract is incomplete');
+        }
+        const contract = new Contract(artifact.sourceCodeSha256, artifact.bytecode, artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
+        this._putArtifactToCache(contract);
+        return contract;
+    }
+    // support both 'code.ral' and 'code.ral.json'
+    static async fromArtifactFile(fileName) {
+        const artifactPath = Contract._artifactPath(fileName);
+        const content = await fs_2.promises.readFile(artifactPath);
+        const artifact = JSON.parse(content.toString());
+        return Contract.fromJson(artifact);
+    }
+    toString() {
+        return JSON.stringify({
+            sourceCodeSha256: this.sourceCodeSha256,
+            bytecode: this.bytecode,
+            codeHash: this.codeHash,
+            fieldsSig: this.fieldsSig,
+            eventsSig: this.eventsSig,
+            functions: this.functions
+        }, null, 2);
+    }
+    toState(fields, asset, address) {
+        const addressDef = typeof address !== 'undefined' ? address : Contract.randomAddress();
+        return {
+            address: addressDef,
+            contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(addressDef)),
+            bytecode: this.bytecode,
+            codeHash: this.codeHash,
+            fields: fields,
+            fieldsSig: this.fieldsSig,
+            asset: asset
+        };
+    }
+    static randomAddress() {
+        const bytes = crypto.randomBytes(33);
+        bytes[0] = 3;
+        return utils_1.bs58.encode(bytes);
+    }
+    async _test(provider, funcName, params, expectPublic, accessType) {
+        const apiParams = this.toTestContract(funcName, params);
+        const apiResult = await provider.contracts.postContractsTestContract(apiParams);
+        const methodIndex = typeof params.testMethodIndex !== 'undefined' ? params.testMethodIndex : this.getMethodIndex(funcName);
+        const isPublic = this.functions[`${methodIndex}`].signature.indexOf('pub ') !== -1;
+        if (isPublic === expectPublic) {
+            const result = await this.fromTestContractResult(methodIndex, apiResult);
+            return result;
+        }
+        else {
+            throw new Error(`The test method ${funcName} is not ${accessType}`);
+        }
+    }
+    async testPublicMethod(provider, funcName, params) {
+        return this._test(provider, funcName, params, true, 'public');
+    }
+    async testPrivateMethod(provider, funcName, params) {
+        return this._test(provider, funcName, params, false, 'private');
+    }
+    toApiFields(fields) {
+        if (typeof fields === 'undefined') {
+            return [];
+        }
+        else {
+            return toApiFields(fields, this.fieldsSig);
+        }
+    }
+    toApiArgs(funcName, args) {
+        if (args) {
+            const func = this.functions.find((func) => func.name == funcName);
+            if (func == null) {
+                throw new Error(`Invalid function name: ${funcName}`);
+            }
+            return toApiArgs(args, func);
+        }
+        else {
+            return [];
+        }
+    }
+    getMethodIndex(funcName) {
+        return this.functions.findIndex((func) => func.name === funcName);
+    }
+    toApiContractStates(states) {
+        return typeof states != 'undefined' ? states.map((state) => toApiContractState(state)) : undefined;
+    }
+    toTestContract(funcName, params) {
+        return {
+            group: params.group,
+            address: params.address,
+            bytecode: this.bytecode,
+            initialFields: this.toApiFields(params.initialFields),
+            initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
+            methodIndex: this.getMethodIndex(funcName),
+            args: this.toApiArgs(funcName, params.testArgs),
+            existingContracts: this.toApiContractStates(params.existingContracts),
+            inputAssets: toApiInputAssets(params.inputAssets)
+        };
+    }
+    static async fromCodeHash(codeHash) {
+        const cached = this._getArtifactFromCache(codeHash);
+        if (typeof cached !== 'undefined') {
+            return cached;
+        }
+        const files = await fs_2.promises.readdir(Common._artifactsFolder());
+        for (const file of files) {
+            if (file.endsWith('.ral.json')) {
+                try {
+                    const contract = await Contract.fromArtifactFile(file);
+                    if (contract.codeHash === codeHash) {
+                        return contract;
+                    }
+                }
+                catch (_) { }
+            }
+        }
+        throw new Error(`Unknown code with code hash: ${codeHash}`);
+    }
+    static async getFieldsSig(state) {
+        return Contract.fromCodeHash(state.codeHash).then((contract) => contract.fieldsSig);
+    }
+    async fromApiContractState(state) {
+        const contract = await Contract.fromCodeHash(state.codeHash);
+        return {
+            address: state.address,
+            contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(state.address)),
+            bytecode: state.bytecode,
+            initialStateHash: state.initialStateHash,
+            codeHash: state.codeHash,
+            fields: fromApiFields(state.fields, contract.fieldsSig),
+            fieldsSig: await Contract.getFieldsSig(state),
+            asset: fromApiAsset(state.asset)
+        };
+    }
+    static async fromApiEvent(event, codeHash) {
+        let eventSig;
+        if (event.eventIndex == -1) {
+            eventSig = this.ContractCreatedEvent;
+        }
+        else if (event.eventIndex == -2) {
+            eventSig = this.ContractDestroyedEvent;
+        }
+        else {
+            const contract = await Contract.fromCodeHash(codeHash);
+            eventSig = contract.eventsSig[event.eventIndex];
+        }
+        return {
+            blockHash: event.blockHash,
+            contractAddress: event.contractAddress,
+            name: eventSig.name,
+            fields: fromApiEventFields(event.fields, eventSig)
+        };
+    }
+    async fromTestContractResult(methodIndex, result) {
+        const addressToCodeHash = new Map();
+        addressToCodeHash.set(result.address, result.codeHash);
+        result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
+        return {
+            address: result.address,
+            contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.address)),
+            returns: fromApiArray(result.returns, this.functions[`${methodIndex}`].returnTypes),
+            gasUsed: result.gasUsed,
+            contracts: await Promise.all(result.contracts.map((contract) => this.fromApiContractState(contract))),
+            txOutputs: result.txOutputs.map(fromApiOutput),
+            events: await Promise.all(result.events.map((event) => {
+                const contractAddress = event.contractAddress;
+                const codeHash = addressToCodeHash.get(contractAddress);
+                if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
+                    return Contract.fromApiEvent(event, codeHash);
+                }
+                else {
+                    throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
+                }
+            }))
+        };
+    }
+    async paramsForDeployment(params) {
+        const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {});
+        const signerParams = {
+            signerAddress: params.signerAddress,
+            bytecode: bytecode,
+            initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
+            issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
+            initialTokenAmounts: params.initialTokenAmounts?.map(toApiToken),
+            gasAmount: params.gasAmount,
+            gasPrice: extractOptionalNumber256(params.gasPrice)
+        };
+        return signerParams;
+    }
+    async transactionForDeployment(signer, params) {
+        const signerParams = await this.paramsForDeployment({
+            ...params,
+            signerAddress: (await signer.getAccounts())[0].address
+        });
+        const response = await signer.buildContractCreationTx(signerParams);
+        return fromApiDeployContractUnsignedTx(response);
+    }
+    buildByteCodeToDeploy(initialFields) {
+        return ralph.buildContractByteCode(this.bytecode, initialFields, this.fieldsSig);
+    }
+}
+exports.Contract = Contract;
+Contract.ContractCreatedEvent = {
+    name: 'ContractCreated',
+    signature: 'event ContractCreated(address:Address)',
+    fieldNames: ['address'],
+    fieldTypes: ['Address']
+};
+Contract.ContractDestroyedEvent = {
+    name: 'ContractDestroyed',
+    signature: 'event ContractDestroyed(address:Address)',
+    fieldNames: ['address'],
+    fieldTypes: ['Address']
+};
+class Script extends Common {
+    constructor(sourceCodeSha256, bytecodeTemplate, fieldsSig, functions) {
+        super(sourceCodeSha256, functions);
+        this.bytecodeTemplate = bytecodeTemplate;
+        this.fieldsSig = fieldsSig;
+    }
+    static checkCodeType(fileName, contractStr) {
+        const scriptMatches = contractStr.match(this.scriptRegex);
+        if (scriptMatches === null) {
+            throw new Error(`No script found in: ${fileName}`);
+        }
+        else if (scriptMatches.length > 1) {
+            throw new Error(`Multiple scripts in: ${fileName}`);
+        }
+        else {
+            return;
+        }
+    }
+    static async loadContractStr(fileName, importsCache) {
+        return Common._loadContractStr(fileName, importsCache, (code) => Script.checkCodeType(fileName, code));
+    }
+    static async fromSource(provider, fileName) {
+        return Common._from(provider, fileName, (fileName, importsCache) => Script.loadContractStr(fileName, importsCache), Script.compile);
+    }
+    static async compile(provider, fileName, scriptStr, contractHash) {
+        const compiled = await provider.contracts.postContractsCompileScript({ code: scriptStr });
+        const artifact = new Script(contractHash, compiled.bytecodeTemplate, compiled.fields, compiled.functions);
+        await artifact._saveToFile(fileName);
+        return artifact;
+    }
+    // TODO: safely parse json
+    static fromJson(artifact) {
+        if (artifact.sourceCodeSha256 == null ||
+            artifact.bytecodeTemplate == null ||
+            artifact.fieldsSig == null ||
+            artifact.functions == null) {
+            throw Error('The artifact JSON for script is incomplete');
+        }
+        return new Script(artifact.sourceCodeSha256, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
+    }
+    static async fromArtifactFile(fileName) {
+        const artifactPath = Common._artifactPath(fileName);
+        const content = await fs_2.promises.readFile(artifactPath);
+        const artifact = JSON.parse(content.toString());
+        return this.fromJson(artifact);
+    }
+    toString() {
+        return JSON.stringify({
+            sourceCodeSha256: this.sourceCodeSha256,
+            bytecodeTemplate: this.bytecodeTemplate,
+            fieldsSig: this.fieldsSig,
+            functions: this.functions
+        }, null, 2);
+    }
+    async paramsForDeployment(params) {
+        const signerParams = {
+            signerAddress: params.signerAddress,
+            bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
+            attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
+            tokens: typeof params.tokens !== 'undefined' ? params.tokens.map(toApiToken) : undefined,
+            gasAmount: params.gasAmount,
+            gasPrice: extractOptionalNumber256(params.gasPrice)
+        };
+        return signerParams;
+    }
+    async transactionForDeployment(signer, params) {
+        const signerParams = await this.paramsForDeployment({
+            ...params,
+            signerAddress: (await signer.getAccounts())[0].address
+        });
+        return await signer.buildScriptTx(signerParams);
+    }
+    buildByteCodeToDeploy(initialFields) {
+        return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig);
+    }
+}
+exports.Script = Script;
+function extractBoolean(v) {
+    if (typeof v === 'boolean') {
+        return v;
+    }
+    else {
+        throw new Error(`Invalid boolean value: ${v}`);
+    }
+}
+// TODO: check integer bounds
+function extractNumber256(v) {
+    if ((typeof v === 'number' && Number.isInteger(v)) || typeof v === 'bigint') {
+        return v.toString();
+    }
+    else if (typeof v === 'string') {
+        return v;
+    }
+    else {
+        throw new Error(`Invalid 256 bit number: ${v}`);
+    }
+}
+function extractOptionalNumber256(v) {
+    return typeof v !== 'undefined' ? extractNumber256(v) : undefined;
+}
+// TODO: check hex string
+function extractByteVec(v) {
+    if (typeof v === 'string') {
+        // try to convert from address to contract id
+        try {
+            const address = utils_1.bs58.decode(v);
+            if (address.length == 33 && address[0] == 3) {
+                return buffer_1.Buffer.from(address.slice(1)).toString('hex');
+            }
+        }
+        catch (_) {
+            return v;
+        }
+        return v;
+    }
+    else {
+        throw new Error(`Invalid string: ${v}`);
+    }
+}
+function extractBs58(v) {
+    if (typeof v === 'string') {
+        try {
+            utils_1.bs58.decode(v);
+            return v;
+        }
+        catch (error) {
+            throw new Error(`Invalid base58 string: ${v}`);
+        }
+    }
+    else {
+        throw new Error(`Invalid string: ${v}`);
+    }
+}
+function decodeNumber256(n) {
+    if (Number.isSafeInteger(Number.parseInt(n))) {
+        return Number(n);
+    }
+    else {
+        return BigInt(n);
+    }
+}
+function extractArray(tpe, v) {
+    if (!Array.isArray(v)) {
+        throw new Error(`Expected array, got ${v}`);
+    }
+    const semiColonIndex = tpe.lastIndexOf(';');
+    if (semiColonIndex == -1) {
+        throw new Error(`Invalid Val type: ${tpe}`);
+    }
+    const subType = tpe.slice(1, semiColonIndex);
+    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
+    if (v.length != dim) {
+        throw new Error(`Invalid val dimension: ${v}`);
+    }
+    else {
+        return { value: v.map((v) => toApiVal(v, subType)), type: 'Array' };
+    }
+}
+exports.extractArray = extractArray;
+function toApiVal(v, tpe) {
+    if (tpe === 'Bool') {
+        return { value: extractBoolean(v), type: tpe };
+    }
+    else if (tpe === 'U256' || tpe === 'I256') {
+        return { value: extractNumber256(v), type: tpe };
+    }
+    else if (tpe === 'ByteVec') {
+        return { value: extractByteVec(v), type: tpe };
+    }
+    else if (tpe === 'Address') {
+        return { value: extractBs58(v), type: tpe };
+    }
+    else {
+        return extractArray(tpe, v);
+    }
+}
+exports.toApiVal = toApiVal;
+function decodeArrayType(tpe) {
+    const semiColonIndex = tpe.lastIndexOf(';');
+    if (semiColonIndex === -1) {
+        throw new Error(`Invalid Val type: ${tpe}`);
+    }
+    const subType = tpe.slice(1, semiColonIndex);
+    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
+    if (subType[0] == '[') {
+        const [baseType, subDim] = decodeArrayType(subType);
+        return [baseType, (subDim.unshift(dim), subDim)];
+    }
+    else {
+        return [subType, [dim]];
+    }
+}
+function foldVals(vals, dims) {
+    if (dims.length == 1) {
+        return vals;
+    }
+    else {
+        const result = [];
+        const chunkSize = vals.length / dims[0];
+        const chunkDims = dims.slice(1);
+        for (let i = 0; i < vals.length; i += chunkSize) {
+            const chunk = vals.slice(i, i + chunkSize);
+            result.push(foldVals(chunk, chunkDims));
+        }
+        return result;
+    }
+}
+function _fromApiVal(vals, valIndex, tpe) {
+    if (vals.length === 0) {
+        throw new Error('Not enough Vals');
+    }
+    const firstVal = vals[`${valIndex}`];
+    if (tpe === 'Bool' && firstVal.type === tpe) {
+        return [firstVal.value, valIndex + 1];
+    }
+    else if ((tpe === 'U256' || tpe === 'I256') && firstVal.type === tpe) {
+        return [decodeNumber256(firstVal.value), valIndex + 1];
+    }
+    else if ((tpe === 'ByteVec' || tpe === 'Address') && firstVal.type === tpe) {
+        return [firstVal.value, valIndex + 1];
+    }
+    else {
+        const [baseType, dims] = decodeArrayType(tpe);
+        const arraySize = dims.reduce((a, b) => a * b);
+        const nextIndex = valIndex + arraySize;
+        const valsToUse = vals.slice(valIndex, nextIndex);
+        if (valsToUse.length == arraySize && valsToUse.every((val) => val.type === baseType)) {
+            const localVals = valsToUse.map((val) => fromApiVal(val, baseType));
+            return [foldVals(localVals, dims), nextIndex];
+        }
+        else {
+            throw new Error(`Invalid array Val type: ${valsToUse}, ${tpe}`);
+        }
+    }
+}
+function fromApiFields(vals, fieldsSig) {
+    return fromApiVals(vals, fieldsSig.names, fieldsSig.types);
+}
+function fromApiEventFields(vals, eventSig) {
+    return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes);
+}
+function fromApiVals(vals, names, types) {
+    let valIndex = 0;
+    const result = {};
+    types.forEach((currentType, index) => {
+        const currentName = names[`${index}`];
+        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType);
+        valIndex = nextIndex;
+        result[`${currentName}`] = val;
+    });
+    return result;
+}
+function fromApiArray(vals, types) {
+    let valIndex = 0;
+    const result = [];
+    for (const currentType of types) {
+        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType);
+        result.push(val);
+        valIndex = nextIndex;
+    }
+    return result;
+}
+function fromApiVal(v, tpe) {
+    if (v.type === 'Bool' && v.type === tpe) {
+        return v.value;
+    }
+    else if ((v.type === 'U256' || v.type === 'I256') && v.type === tpe) {
+        return decodeNumber256(v.value);
+    }
+    else if ((v.type === 'ByteVec' || v.type === 'Address') && v.type === tpe) {
+        return v.value;
+    }
+    else {
+        throw new Error(`Invalid node.Val type: ${v}`);
+    }
+}
+function toApiToken(token) {
+    return { id: token.id, amount: extractNumber256(token.amount) };
+}
+function fromApiToken(token) {
+    return { id: token.id, amount: decodeNumber256(token.amount) };
+}
+function toApiAsset(asset) {
+    return {
+        attoAlphAmount: extractNumber256(asset.alphAmount),
+        tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(toApiToken) : []
+    };
+}
+function fromApiAsset(asset) {
+    return {
+        alphAmount: decodeNumber256(asset.attoAlphAmount),
+        tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(fromApiToken) : undefined
+    };
+}
+function getVal(vals, name) {
+    if (name in vals) {
+        return vals[`${name}`];
+    }
+    else {
+        throw Error(`No Val exists for ${name}`);
+    }
+}
+function toApiContractState(state) {
+    return {
+        address: state.address,
+        bytecode: state.bytecode,
+        codeHash: state.codeHash,
+        initialStateHash: state.initialStateHash,
+        fields: toApiFields(state.fields, state.fieldsSig),
+        asset: toApiAsset(state.asset)
+    };
+}
+function toApiFields(fields, fieldsSig) {
+    return toApiVals(fields, fieldsSig.names, fieldsSig.types);
+}
+function toApiArgs(args, funcSig) {
+    return toApiVals(args, funcSig.argNames, funcSig.argTypes);
+}
+function toApiVals(fields, names, types) {
+    return names.map((name, index) => {
+        const val = getVal(fields, name);
+        const tpe = types[`${index}`];
+        return toApiVal(val, tpe);
+    });
+}
+function toApiInputAsset(inputAsset) {
+    return { address: inputAsset.address, asset: toApiAsset(inputAsset.asset) };
+}
+function toApiInputAssets(inputAssets) {
+    return typeof inputAssets !== 'undefined' ? inputAssets.map(toApiInputAsset) : undefined;
+}
+function fromApiOutput(output) {
+    if (output.type === 'AssetOutput') {
+        const asset = output;
+        return {
+            type: 'AssetOutput',
+            address: asset.address,
+            alphAmount: decodeNumber256(asset.attoAlphAmount),
+            tokens: asset.tokens.map(fromApiToken),
+            lockTime: asset.lockTime,
+            message: asset.message
+        };
+    }
+    else if (output.type === 'ContractOutput') {
+        const asset = output;
+        return {
+            type: 'ContractOutput',
+            address: asset.address,
+            alphAmount: decodeNumber256(asset.attoAlphAmount),
+            tokens: asset.tokens.map(fromApiToken)
+        };
+    }
+    else {
+        throw new Error(`Unknown output type: ${output}`);
+    }
+}
+function fromApiDeployContractUnsignedTx(result) {
+    return { ...result, contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.contractAddress)) };
+}
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();