@alephium/web3 0.0.3

package/dist/lib/contract.js

@@ -0,0 +1,711 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractArray = exports.Script = exports.Contract = exports.Common = void 0;
+const cryptojs = __importStar(require("crypto-js"));
+const crypto = __importStar(require("crypto"));
+const bs58_1 = __importDefault(require("./bs58"));
+const fs_1 = __importDefault(require("fs"));
+const fs_2 = require("fs");
+const clique_1 = require("./clique");
+class Common {
+    constructor(fileName, sourceCodeSha256, bytecode, codeHash, functions) {
+        this.fileName = fileName;
+        this.sourceCodeSha256 = sourceCodeSha256;
+        this.bytecode = bytecode;
+        this.codeHash = codeHash;
+        this.functions = functions;
+    }
+    static _contractPath(fileName) {
+        return `./contracts/${fileName}`;
+    }
+    static _artifactPath(fileName) {
+        return `./artifacts/${fileName}.json`;
+    }
+    static _artifactsFolder() {
+        return './artifacts/';
+    }
+    static handleImports(contractStr, importsCache) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+                    result = result.concat('\n', importContractStr);
+                }
+            }
+            return result;
+        });
+    }
+    static _replaceVariables(contractStr, variables) {
+        if (variables) {
+            return contractStr.replace(Common.variableRegex, (match) => {
+                const variableName = match.split(/(\s+)/)[2];
+                if (variableName in variables) {
+                    return variables[variableName].toString();
+                }
+                else {
+                    throw new Error(`The value of variable ${variableName} is not provided`);
+                }
+            });
+        }
+        else {
+            return contractStr;
+        }
+    }
+    static _loadContractStr(fileName, importsCache, validate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contractPath = this._contractPath(fileName);
+            const contractBuffer = yield 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 _from(client, fileName, loadContractStr, loadContract, __from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            Common.checkFileNameExtension(fileName);
+            const contractStr = yield loadContractStr(fileName, []);
+            const contractHash = cryptojs.SHA256(contractStr).toString();
+            try {
+                const existingContract = yield loadContract(fileName);
+                return existingContract.sourceCodeSha256 === contractHash
+                    ? existingContract
+                    : __from(client, fileName, contractStr, contractHash);
+            }
+            catch (_) {
+                return __from(client, fileName, contractStr, contractHash);
+            }
+        });
+    }
+    static load(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Contract.loadContract(fileName).catch(() => Script.loadContract(fileName));
+        });
+    }
+    _saveToFile() {
+        const artifactPath = Common._artifactPath(this.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.scriptRegex = new RegExp('^TxScript [A-Z][a-zA-Z0-9]* \\{', 'mg');
+Common.variableRegex = new RegExp('\\{\\{\\s+[a-z][a-zA-Z0-9]*\\s+\\}\\}', 'g');
+class Contract extends Common {
+    constructor(fileName, sourceCodeSha256, bytecode, codeHash, fields, functions, events) {
+        super(fileName, sourceCodeSha256, bytecode, codeHash, functions);
+        this.fields = fields;
+        this.events = events;
+        this._contractAddresses = new Map();
+    }
+    static checkCodeType(fileName, contractStr) {
+        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 loadContractStr(fileName, importsCache, variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+            return Common._replaceVariables(result, variables);
+        });
+    }
+    static from(client, fileName, variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!fs_1.default.existsSync(Common._artifactsFolder())) {
+                fs_1.default.mkdirSync(Common._artifactsFolder(), { recursive: true });
+            }
+            return Common._from(client, fileName, (fileName, importCaches) => Contract.loadContractStr(fileName, importCaches, variables), Contract.loadContract, Contract.__from);
+        });
+    }
+    static __from(client, fileName, contractStr, contractHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const compiled = (yield client.contracts.postContractsCompileContract({ code: contractStr })).data;
+            const artifact = new Contract(fileName, contractHash, compiled.bytecode, compiled.codeHash, compiled.fields, compiled.functions, compiled.events);
+            yield artifact._saveToFile();
+            return artifact;
+        });
+    }
+    static loadContract(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const artifactPath = Contract._artifactPath(fileName);
+            const content = yield fs_2.promises.readFile(artifactPath);
+            const artifact = JSON.parse(content.toString());
+            if (artifact.bytecode == null || artifact.fields == null || artifact.functions == null || artifact.events == null) {
+                throw new Event('Compilation did not return the right data');
+            }
+            return new Contract(fileName, artifact.sourceCodeSha256, artifact.bytecode, artifact.codeHash, artifact.fields, artifact.functions, artifact.events);
+        });
+    }
+    toString() {
+        return JSON.stringify({
+            sourceCodeSha256: this.sourceCodeSha256,
+            bytecode: this.bytecode,
+            codeHash: this.codeHash,
+            fields: this.fields,
+            functions: this.functions,
+            events: this.events
+        }, null, 2);
+    }
+    toState(fields, asset, address) {
+        return {
+            fileName: this.fileName,
+            address: address,
+            bytecode: this.bytecode,
+            codeHash: this.codeHash,
+            fields: fields,
+            fieldTypes: this.fields.types,
+            asset: asset
+        };
+    }
+    static randomAddress() {
+        const bytes = crypto.randomBytes(33);
+        bytes[0] = 3;
+        return bs58_1.default.encode(bytes);
+    }
+    _randomAddressWithCache(fileName) {
+        const address = Contract.randomAddress();
+        this._contractAddresses.set(address, fileName);
+        return address;
+    }
+    test(client, funcName, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._contractAddresses.clear();
+            const apiParams = this.toTestContract(funcName, params);
+            const response = yield client.contracts.postContractsTestContract(apiParams);
+            const methodIndex = params.testMethodIndex ? params.testMethodIndex : this.getMethodIndex(funcName);
+            const result = yield this.fromTestContractResult(methodIndex, response.data);
+            this._contractAddresses.clear();
+            return result;
+        });
+    }
+    toApiFields(fields) {
+        return fields ? toApiFields(fields, this.fields.types) : [];
+    }
+    toApiArgs(funcName, args) {
+        if (args) {
+            const func = this.functions.find((func) => func.name == funcName);
+            if (func == null) {
+                throw new Error(`Invalid function name: ${funcName}`);
+            }
+            if (args.length === func.argTypes.length) {
+                return args.map((arg, index) => toApiVal(arg, func.argTypes[index]));
+            }
+            else {
+                throw new Error(`Invalid number of arguments: ${args}`);
+            }
+        }
+        else {
+            return [];
+        }
+    }
+    getMethodIndex(funcName) {
+        return this.functions.findIndex((func) => func.name === funcName);
+    }
+    toApiContractState(state) {
+        if (state.address) {
+            this._contractAddresses.set(state.address, state.fileName);
+            return toApiContractState(state, state.address);
+        }
+        else {
+            const address = this._randomAddressWithCache(state.fileName);
+            return toApiContractState(state, address);
+        }
+    }
+    toApiContractStates(states) {
+        return states ? states.map((state) => this.toApiContractState(state)) : undefined;
+    }
+    toTestContract(funcName, params) {
+        const address = params.address
+            ? (this._contractAddresses.set(params.address, this.fileName), params.address)
+            : this._randomAddressWithCache(this.fileName);
+        return {
+            group: params.group,
+            address: address,
+            bytecode: this.bytecode,
+            initialFields: this.toApiFields(params.initialFields),
+            initialAsset: params.initialAsset ? toApiAsset(params.initialAsset) : undefined,
+            testMethodIndex: this.getMethodIndex(funcName),
+            testArgs: this.toApiArgs(funcName, params.testArgs),
+            existingContracts: this.toApiContractStates(params.existingContracts),
+            inputAssets: toApiInputAssets(params.inputAssets)
+        };
+    }
+    static getContract(codeHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = yield fs_2.promises.readdir(Common._artifactsFolder());
+            for (const file of files) {
+                if (file.endsWith('.ral.json')) {
+                    const fileName = file.slice(0, -5);
+                    const contract = yield Common.load(fileName);
+                    if (contract.codeHash === codeHash) {
+                        return contract;
+                    }
+                }
+            }
+            throw new Error(`Unknown code with codeHash: ${codeHash}`);
+        });
+    }
+    static getFieldTypes(codeHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Contract.getContract(codeHash).then((contract) => contract.fields.types);
+        });
+    }
+    fromApiContractState(state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = yield Contract.getContract(state.codeHash);
+            return {
+                fileName: contract.fileName,
+                address: state.address,
+                bytecode: state.bytecode,
+                codeHash: state.codeHash,
+                fields: fromApiVals(state.fields, contract.fields.types),
+                fieldTypes: yield Contract.getFieldTypes(state.codeHash),
+                asset: fromApiAsset(state.asset)
+            };
+        });
+    }
+    static fromApiEvent(event, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let fieldTypes;
+            let name;
+            if (event.eventIndex == -1) {
+                name = 'ContractCreated';
+                fieldTypes = ['Address'];
+            }
+            else if (event.eventIndex == -2) {
+                name = 'ContractDestroyed';
+                fieldTypes = ['Address'];
+            }
+            else {
+                const contract = yield Contract.loadContract(fileName);
+                const eventDef = yield contract.events[event.eventIndex];
+                name = eventDef.name;
+                fieldTypes = eventDef.fieldTypes;
+            }
+            if (event.type === 'ContractEvent') {
+                return {
+                    blockHash: event.blockHash,
+                    contractAddress: event.contractAddress,
+                    txId: event.txId,
+                    name: name,
+                    fields: fromApiVals(event.fields, fieldTypes)
+                };
+            }
+            else {
+                throw new Error(`Expected ContractEvent only, but got ${event.type}`);
+            }
+        });
+    }
+    fromTestContractResult(methodIndex, result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                returns: fromApiVals(result.returns, this.functions[methodIndex].returnTypes),
+                gasUsed: result.gasUsed,
+                contracts: yield Promise.all(result.contracts.map((contract) => this.fromApiContractState(contract))),
+                txOutputs: result.txOutputs.map(fromApiOutput),
+                events: yield Promise.all(result.events.map((event) => {
+                    const contractAddress = event.contractAddress;
+                    return Contract.fromApiEvent(event, this._contractAddresses.get(contractAddress));
+                }))
+            };
+        });
+    }
+    transactionForDeployment(signer, initialFields, issueTokenAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                fromPublicKey: yield signer.getPublicKey(),
+                bytecode: this.bytecode,
+                initialFields: this.toApiFields(initialFields),
+                issueTokenAmount: issueTokenAmount
+            };
+            const response = yield signer.client.contracts.postContractsUnsignedTxBuildContract(params);
+            return fromApiDeployContractUnsignedTx(clique_1.CliqueClient.convert(response));
+        });
+    }
+}
+exports.Contract = Contract;
+class Script extends Common {
+    constructor(fileName, sourceCodeSha256, bytecode, codeHash, functions) {
+        super(fileName, sourceCodeSha256, bytecode, codeHash, functions);
+    }
+    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 loadContractStr(fileName, importsCache, variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield Common._loadContractStr(fileName, importsCache, (code) => Script.checkCodeType(fileName, code));
+            return yield Common._replaceVariables(result, variables);
+        });
+    }
+    static from(client, fileName, variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Common._from(client, fileName, (fileName, importsCache) => Script.loadContractStr(fileName, importsCache, variables), Script.loadContract, Script.__from);
+        });
+    }
+    static __from(client, fileName, scriptStr, contractHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const compiled = (yield client.contracts.postContractsCompileScript({ code: scriptStr })).data;
+            const artifact = new Script(fileName, contractHash, compiled.bytecode, compiled.codeHash, compiled.functions);
+            yield artifact._saveToFile();
+            return artifact;
+        });
+    }
+    static loadContract(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const artifactPath = Common._artifactPath(fileName);
+            const content = yield fs_2.promises.readFile(artifactPath);
+            const artifact = JSON.parse(content.toString());
+            if (artifact.bytecode == null || artifact.functions == null) {
+                throw new Event('= Compilation did not return the right data');
+            }
+            return new Script(fileName, artifact.sourceCodeSha256, artifact.bytecode, artifact.codeHash, artifact.functions);
+        });
+    }
+    toString() {
+        return JSON.stringify({
+            sourceCodeSha256: this.sourceCodeSha256,
+            bytecode: this.bytecode,
+            codeHash: this.codeHash,
+            functions: this.functions
+        }, null, 2);
+    }
+    transactionForDeployment(signer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apiParams = {
+                fromPublicKey: yield signer.getPublicKey(),
+                bytecode: this.bytecode,
+                alphAmount: params && params.alphAmount ? extractNumber256(params.alphAmount) : undefined,
+                tokens: params && params.tokens ? params.tokens.map(toApiToken) : undefined,
+                gas: params && params.gas ? params.gas : undefined,
+                gasPrice: params && params.gasPrice ? extractNumber256(params.gasPrice) : undefined,
+                utxosLimit: params && params.utxosLimit ? params.utxosLimit : undefined
+            };
+            const response = yield signer.client.contracts.postContractsUnsignedTxBuildScript(apiParams);
+            return clique_1.CliqueClient.convert(response);
+        });
+    }
+}
+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}`);
+    }
+}
+// TODO: check hex string
+function extractByteVec(v) {
+    if (typeof v === 'string') {
+        // try to convert from address to contract id
+        try {
+            const address = bs58_1.default.decode(v);
+            if (address.length == 33 && address[0] == 3) {
+                return 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 {
+            bs58_1.default.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);
+    }
+}
+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 fromApiVals(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 api.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 {
+        alphAmount: extractNumber256(asset.alphAmount),
+        tokens: asset.tokens ? asset.tokens.map(toApiToken) : []
+    };
+}
+function fromApiAsset(asset) {
+    return {
+        alphAmount: decodeNumber256(asset.alphAmount),
+        tokens: asset.tokens ? asset.tokens.map(fromApiToken) : undefined
+    };
+}
+function toApiContractState(state, address) {
+    return {
+        address: address,
+        bytecode: state.bytecode,
+        codeHash: state.codeHash,
+        fields: toApiFields(state.fields, state.fieldTypes),
+        asset: toApiAsset(state.asset)
+    };
+}
+function toApiFields(fields, fieldTypes) {
+    if (fields.length === fieldTypes.length) {
+        return fields.map((field, index) => toApiVal(field, fieldTypes[index]));
+    }
+    else {
+        throw new Error(`Invalid number of fields: ${fields}`);
+    }
+}
+function toApiInputAsset(inputAsset) {
+    return { address: inputAsset.address, asset: toApiAsset(inputAsset.asset) };
+}
+function toApiInputAssets(inputAssets) {
+    return inputAssets ? inputAssets.map(toApiInputAsset) : undefined;
+}
+function fromApiOutput(output) {
+    if (output.type === 'AssetOutput') {
+        const asset = output;
+        return {
+            type: 'AssetOutput',
+            address: asset.address,
+            alphAmount: decodeNumber256(asset.alphAmount),
+            tokens: asset.tokens.map(fromApiToken),
+            lockTime: asset.lockTime,
+            additionalData: asset.additionalData
+        };
+    }
+    else if (output.type === 'ContractOutput') {
+        const asset = output;
+        return {
+            type: 'ContractOutput',
+            address: asset.address,
+            alphAmount: decodeNumber256(asset.alphAmount),
+            tokens: asset.tokens.map(fromApiToken)
+        };
+    }
+    else {
+        throw new Error(`Unknown output type: ${output}`);
+    }
+}
+function fromApiDeployContractUnsignedTx(result) {
+    return result;
+}