locklift
Version:
Node JS framework for working with Ever contracts. Inspired by Truffle and Hardhat. Helps you to build, test, run and maintain your smart contracts.
194 lines (193 loc) • 7.82 kB
JavaScript
;
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 __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 () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
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);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Factory = void 0;
const path_1 = __importDefault(require("path"));
const directory_tree_1 = __importDefault(require("directory-tree"));
const utils = __importStar(require("../../utils"));
const deployer_1 = require("./deployer");
const utils_1 = require("./utils");
const utils_2 = require("../cli/builder/utils");
const account2_1 = require("./account2");
const utils_3 = require("../tracing/utils");
const logger_1 = require("../logger");
__exportStar(require("./giver"), exports);
__exportStar(require("./deployer"), exports);
class Factory {
ever;
giver;
factoryCache = {};
accounts;
constructor(ever, giver, accountsStorage) {
this.ever = ever;
this.giver = giver;
this.accounts = new account2_1.AccountFactory2(this, (...params) => giver().sendTo(...params), accountsStorage);
}
static async setup(ever, giver, accountsStorage, preloadedAccounts) {
const factory = new Factory(ever, giver, accountsStorage);
await factory.getContractsArtifacts().then(artifacts => {
artifacts.forEach(({ artifacts, contractName }) => {
factory.factoryCache[contractName] = artifacts;
});
});
if (preloadedAccounts) {
preloadedAccounts.forEach(({ contractName, abi, codeHash }) => {
factory.factoryCache[contractName] = {
code: "",
tvc: "",
abi,
codeHash,
map: {},
};
});
}
return factory;
}
get deployer() {
return new deployer_1.Deployer(this.ever, this.giver());
}
deployContract = async (args) => {
const { tvc, abi } = this.getContractArtifacts(args.contract);
const deployer = args.giver ? new deployer_1.Deployer(this.ever, args.giver) : this.deployer;
return deployer.deployContract(abi, {
tvc: args.tvc || tvc,
workchain: args.workchain,
publicKey: args.publicKey,
initParams: args.initParams,
}, args.constructorParams, args.value);
};
getDeployedContract = (name, address) => {
return new this.ever.Contract(this.getContractArtifacts(name)?.abi, address);
};
initializeContract = async (name, resolvedPath) => {
const tvc = utils.tryLoadTvcFromFile(path_1.default.resolve(resolvedPath, name + ".tvc")) ||
utils.loadBase64FromFile(path_1.default.resolve(resolvedPath, name + ".base64"));
if (!tvc) {
throw new Error(`Not found TVC of Contract ${name}, need to provide .tvc or .base64 sources`);
}
const abi = utils.loadJSONFromFile(path_1.default.resolve(resolvedPath, name + ".abi.json"));
let map = utils.loadJSONFromFile(path_1.default.resolve(resolvedPath, name + ".map.json")) ||
utils.loadJSONFromFile(path_1.default.resolve(resolvedPath, name + ".debug.json"));
if (map && "map" in map) {
map = map.map;
}
if (!abi) {
throw new Error(`Not found ABI of Contract ${name}`);
}
const { code } = await this.ever.splitTvc(tvc);
if (code == null) {
throw new Error(`Contract TVC ${name} doesn't contain code`);
}
const codeHash = await this.ever.getBocHash(code);
return {
tvc,
code,
abi,
codeHash,
map,
};
};
getContractArtifacts = (name) => {
return this.factoryCache[name];
};
getAllArtifacts = () => {
return Object.entries(this.factoryCache).map(([contractName, artifacts]) => ({
contractName,
artifacts,
}));
};
getContractByCodeHash = (codeHash, address) => {
const contractArtifacts = this.getAllArtifacts().find(({ artifacts }) => artifacts.codeHash === codeHash);
if (contractArtifacts) {
return {
contract: this.getDeployedContract(contractArtifacts.contractName, address),
name: contractArtifacts.contractName,
...contractArtifacts.artifacts,
};
}
};
getContractByCodeHashOrDefault = (codeHash, address) => {
const existingContract = this.getContractByCodeHash(codeHash, address);
if (existingContract) {
return existingContract;
}
const contractName = (0, utils_1.tryToDetectContract)(address, codeHash);
return {
contract: new this.ever.Contract(utils_1.emptyContractAbi, address),
name: contractName,
code: "",
codeHash: "",
abi: {},
map: {},
tvc: "",
};
};
async getContractsArtifacts() {
const resolvedBuildPath = path_1.default.resolve(process.cwd(), "build");
const contractsNestedTree = (0, directory_tree_1.default)(resolvedBuildPath, {
extensions: /\.json/,
});
const contractNames = (0, utils_2.flatDirTree)(contractsNestedTree)
?.filter(el => el.name.endsWith(".abi.json"))
.map(el => el.name.slice(0, -9));
return await Promise.all([...contractNames].map(async (contractName) => {
try {
return {
artifacts: await this.initializeContract(contractName, resolvedBuildPath),
contractName,
};
}
catch (e) {
logger_1.logger.printWarn(e);
return undefined;
}
}))
.then(res => res.filter(utils_3.isT))
.then(async (res) => {
res.push({
artifacts: await this.initializeContract("LockliftWallet", path_1.default.resolve((0, utils_2.tryToGetNodeModules)(), "locklift/src/lockliftWalletSources")),
contractName: "LockliftWallet",
});
return res;
});
}
}
exports.Factory = Factory;