@alephium/web3 0.0.3

package/dist/cli/create-project.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const process_1 = __importDefault(require("process"));
+const path_1 = __importDefault(require("path"));
+const find_up_1 = __importDefault(require("find-up"));
+const chalk_1 = __importDefault(require("chalk"));
+function getPackageRoot() {
+    const packageJsonPath = find_up_1.default.sync('package.json', { cwd: path_1.default.dirname(__filename) });
+    if (packageJsonPath) {
+        return path_1.default.dirname(packageJsonPath);
+    }
+    else {
+        throw new Error('Cannot find `package.json`');
+    }
+}
+const packageRoot = getPackageRoot();
+const projectParent = process_1.default.cwd();
+const projectName = process_1.default.argv[2];
+if (!projectName) {
+    console.log('Please provide a project name');
+    console.log(`  ${chalk_1.default.cyan('alephium')} ${chalk_1.default.green('<project-name>')}`);
+    console.log();
+    console.log('For example:');
+    console.log(`  ${chalk_1.default.cyan('alephium')} ${chalk_1.default.green('my-alephium-dapp')}`);
+    console.log();
+    process_1.default.exit(1);
+}
+const projectRoot = path_1.default.join(projectParent, projectName);
+if (fs_extra_1.default.existsSync(projectRoot)) {
+    console.log(`Project ${projectName} already exists. Try a different name.`);
+    console.log();
+    process_1.default.exit(1);
+}
+console.log('Copying files');
+console.log(`  from ${packageRoot}`);
+console.log(`  to ${projectRoot}`);
+console.log('...');
+function copy(dir, files) {
+    const packageDevDir = path_1.default.join(packageRoot, dir);
+    const projectDevDir = path_1.default.join(projectRoot, dir);
+    fs_extra_1.default.mkdirSync(projectDevDir);
+    for (const file of files) {
+        fs_extra_1.default.copyFileSync(path_1.default.join(packageDevDir, file), path_1.default.join(projectDevDir, file));
+    }
+}
+copy('', ['.gitattributes']);
+copy('dev', ['user.conf']);
+copy('scripts', ['start-devnet.js', 'stop-devnet.js']);
+copy('contracts', ['greeter.ral', 'greeter-main.ral']);
+fs_extra_1.default.mkdirSync(path_1.default.join(projectRoot, 'src'));
+fs_extra_1.default.copySync(path_1.default.join(packageRoot, 'gitignore'), path_1.default.join(projectRoot, '.gitignore'));
+fs_extra_1.default.copySync(path_1.default.join(packageRoot, 'templates', 'package.json'), path_1.default.join(projectRoot, 'package.json'));
+fs_extra_1.default.copySync(path_1.default.join(packageRoot, 'templates', 'tsconfig.json'), path_1.default.join(projectRoot, 'tsconfig.json'));
+fs_extra_1.default.copySync(path_1.default.join(packageRoot, 'templates', 'README.md'), path_1.default.join(projectRoot, 'README.md'));
+fs_extra_1.default.copySync(path_1.default.join(packageRoot, 'templates', 'greeter.ts'), path_1.default.join(projectRoot, 'src', 'greeter.ts'));
+console.log('✅ Done.');
+console.log();
+console.log('✨ Project is initialized!');
+console.log();
+console.log('Next steps:');
+console.log(`  ${chalk_1.default.cyan(`cd ${projectName}`)}`);
+console.log(`  ${chalk_1.default.cyan('npm install')}`);
+console.log(`  ${chalk_1.default.cyan('npm run compile')}`);
+console.log(`  ${chalk_1.default.cyan('npm run devnet:start')}`);
+console.log(`  ${chalk_1.default.cyan('node dist/greeter.js')}`);

package/dist/lib/address.d.ts

@@ -0,0 +1 @@
+export declare function addressToGroup(address: string, totalNumberOfGroups: number): number;

package/dist/lib/address.js

@@ -0,0 +1,42 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressToGroup = void 0;
+const bs58_1 = __importDefault(require("./bs58"));
+const djb2_1 = __importDefault(require("../lib/djb2"));
+function addressToGroup(address, totalNumberOfGroups) {
+    const bytes = bs58_1.default.decode(address).slice(1);
+    const value = (0, djb2_1.default)(bytes) | 1;
+    const hash = toPosInt(xorByte(value));
+    const group = hash % totalNumberOfGroups;
+    return group;
+}
+exports.addressToGroup = addressToGroup;
+function xorByte(value) {
+    const byte0 = value >> 24;
+    const byte1 = value >> 16;
+    const byte2 = value >> 8;
+    return byte0 ^ byte1 ^ byte2 ^ value;
+}
+function toPosInt(byte) {
+    return byte & 0xff;
+}

package/dist/lib/bs58.d.ts

@@ -0,0 +1,4 @@
+/** This source is under MIT License and come originally from https://github.com/cryptocoinjs/bs58 **/
+import basex from 'base-x';
+declare const _default: basex.BaseConverter;
+export default _default;

package/dist/lib/bs58.js

@@ -0,0 +1,26 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** This source is under MIT License and come originally from https://github.com/cryptocoinjs/bs58 **/
+const base_x_1 = __importDefault(require("base-x"));
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+exports.default = (0, base_x_1.default)(ALPHABET);

package/dist/lib/clique.d.ts

@@ -0,0 +1,23 @@
+import * as api from '../api/api-alephium';
+import { Api, SelfClique } from '../api/api-alephium';
+import { NodeClient } from './node';
+/**
+ * Clique Client
+ */
+export declare class CliqueClient extends Api<null> {
+    clique: SelfClique;
+    clients: NodeClient[];
+    init(isMultiNodesClique: boolean): Promise<void>;
+    static convert<T>(response: api.HttpResponse<T, {
+        detail: string;
+    }>): T;
+    selfClique(): Promise<api.HttpResponse<api.SelfClique, api.BadRequest | api.InternalServerError | api.NotFound | api.ServiceUnavailable | api.Unauthorized>>;
+    getClientIndex(address: string): number;
+    getBalance(address: string): Promise<api.HttpResponse<api.Balance, api.BadRequest | api.InternalServerError | api.NotFound | api.ServiceUnavailable | api.Unauthorized>>;
+    getWebSocket(node_i: number): WebSocket | undefined;
+    transactionCreate(fromAddress: string, fromPublicKey: string, toAddress: string, amount: string, lockTime?: number, gas?: number, gasPrice?: string): Promise<api.HttpResponse<api.BuildTransactionResult, api.BadRequest | api.InternalServerError | api.NotFound | api.ServiceUnavailable | api.Unauthorized>>;
+    transactionConsolidateUTXOs(fromPublicKey: string, fromAddress: string, toAddress: string): Promise<api.HttpResponse<api.BuildSweepAddressTransactionsResult, api.BadRequest | api.InternalServerError | api.NotFound | api.ServiceUnavailable | api.Unauthorized>>;
+    transactionSend(fromAddress: string, tx: string, signature: string): Promise<api.HttpResponse<api.TxResult, api.BadRequest | api.InternalServerError | api.NotFound | api.ServiceUnavailable | api.Unauthorized>>;
+    transactionSign(txHash: string, privateKey: string): string;
+    transactionVerifySignature(txHash: string, publicKey: string, signature: string): boolean;
+}

package/dist/lib/clique.js

@@ -0,0 +1,149 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliqueClient = void 0;
+const elliptic_1 = require("elliptic");
+const api_alephium_1 = require("../api/api-alephium");
+const node_1 = require("./node");
+const utils = __importStar(require("./utils"));
+const ec = new elliptic_1.ec('secp256k1');
+/**
+ * Clique Client
+ */
+class CliqueClient extends api_alephium_1.Api {
+    init(isMultiNodesClique) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clients = [];
+            const res = yield this.selfClique();
+            if (isMultiNodesClique) {
+                this.clique = res.data;
+                if (this.clique.nodes) {
+                    for (const node of this.clique.nodes) {
+                        const client = new node_1.NodeClient({
+                            baseUrl: `http://${node.address}:${node.restPort}`
+                        });
+                        this.clients.push(client);
+                    }
+                }
+            }
+            else {
+                const client = new node_1.NodeClient({
+                    baseUrl: this.baseUrl
+                });
+                this.clients.push(client);
+            }
+        });
+    }
+    static convert(response) {
+        if (response.error) {
+            console.log(response.error.detail);
+            throw new Error(response.error.detail);
+        }
+        else {
+            return response.data;
+        }
+    }
+    selfClique() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.infos.getInfosSelfClique();
+            if (res.error)
+                throw new Error(res.error.detail);
+            return res;
+        });
+    }
+    getClientIndex(address) {
+        if (this.clients.length === 0)
+            throw new Error('No nodes in the clique');
+        const group = utils.groupOfAddress(address);
+        return group % this.clients.length;
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientIndex = this.getClientIndex(address);
+            return yield this.clients[clientIndex].getBalance(address);
+        });
+    }
+    getWebSocket(node_i) {
+        if (this.clique.nodes) {
+            const node = this.clique.nodes[node_i];
+            return new WebSocket('ws://' + node.address + ':' + node.wsPort + '/events');
+        }
+    }
+    transactionCreate(fromAddress, fromPublicKey, toAddress, amount, lockTime, gas, gasPrice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientIndex = this.getClientIndex(fromAddress);
+            return yield this.clients[clientIndex].transactionCreate(fromPublicKey, toAddress, amount, lockTime, gas, gasPrice);
+        });
+    }
+    transactionConsolidateUTXOs(fromPublicKey, fromAddress, toAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientIndex = this.getClientIndex(fromAddress);
+            return yield this.clients[clientIndex].transactionConsolidateUTXOs(fromPublicKey, toAddress);
+        });
+    }
+    transactionSend(fromAddress, tx, signature) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientIndex = this.getClientIndex(fromAddress);
+            return yield this.clients[clientIndex].transactionSend(tx, signature);
+        });
+    }
+    transactionSign(txHash, privateKey) {
+        const keyPair = ec.keyFromPrivate(privateKey);
+        const signature = keyPair.sign(txHash);
+        return utils.signatureEncode(ec, signature);
+    }
+    transactionVerifySignature(txHash, publicKey, signature) {
+        try {
+            const key = ec.keyFromPublic(publicKey, 'hex');
+            return key.verify(txHash, utils.signatureDecode(ec, signature));
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+exports.CliqueClient = CliqueClient;

package/dist/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const TOTAL_NUMBER_OF_GROUPS = 4;
+export declare const MIN_UTXO_SET_AMOUNT: bigint;

package/dist/lib/constants.js

@@ -0,0 +1,22 @@
+"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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_UTXO_SET_AMOUNT = exports.TOTAL_NUMBER_OF_GROUPS = void 0;
+exports.TOTAL_NUMBER_OF_GROUPS = 4;
+exports.MIN_UTXO_SET_AMOUNT = BigInt(1000000000000);

package/dist/lib/contract.d.ts

@@ -0,0 +1,152 @@
+import { CliqueClient } from './clique';
+import * as api from '../api/api-alephium';
+import { Signer } from './signer';
+export declare abstract class Common {
+    readonly fileName: string;
+    readonly sourceCodeSha256: string;
+    readonly bytecode: string;
+    readonly codeHash: string;
+    readonly functions: api.FunctionSig[];
+    static readonly importRegex: RegExp;
+    static readonly contractRegex: RegExp;
+    static readonly scriptRegex: RegExp;
+    static readonly variableRegex: RegExp;
+    constructor(fileName: string, sourceCodeSha256: string, bytecode: string, codeHash: string, functions: api.FunctionSig[]);
+    protected static _contractPath(fileName: string): string;
+    protected static _artifactPath(fileName: string): string;
+    protected static _artifactsFolder(): string;
+    static handleImports(contractStr: string, importsCache: string[]): Promise<string>;
+    protected static _replaceVariables(contractStr: string, variables?: any): string;
+    protected static _loadContractStr(fileName: string, importsCache: string[], validate: (fileName: string) => void): Promise<string>;
+    static checkFileNameExtension(fileName: string): void;
+    protected static _from<T extends {
+        sourceCodeSha256: string;
+    }>(client: CliqueClient, fileName: string, loadContractStr: (fileName: string, importsCache: string[]) => Promise<string>, loadContract: (fileName: string) => Promise<T>, __from: (client: CliqueClient, fileName: string, contractStr: string, contractHash: string) => Promise<T>): Promise<T>;
+    static load(fileName: string): Promise<Contract | Script>;
+    protected _saveToFile(): Promise<void>;
+}
+export declare class Contract extends Common {
+    readonly fields: api.FieldsSig;
+    readonly events: api.EventSig[];
+    private _contractAddresses;
+    constructor(fileName: string, sourceCodeSha256: string, bytecode: string, codeHash: string, fields: api.FieldsSig, functions: api.FunctionSig[], events: api.EventSig[]);
+    static checkCodeType(fileName: string, contractStr: string): void;
+    static loadContractStr(fileName: string, importsCache: string[], variables?: any): Promise<string>;
+    static from(client: CliqueClient, fileName: string, variables?: any): Promise<Contract>;
+    private static __from;
+    static loadContract(fileName: string): Promise<Contract>;
+    toString(): string;
+    toState(fields: Val[], asset: Asset, address: string): ContractState;
+    static randomAddress(): string;
+    private _randomAddressWithCache;
+    test(client: CliqueClient, funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    toApiFields(fields?: Val[]): api.Val[];
+    toApiArgs(funcName: string, args?: Val[]): api.Val[];
+    getMethodIndex(funcName: string): number;
+    toApiContractState(state: ContractState): api.ContractState;
+    toApiContractStates(states?: ContractState[]): api.ContractState[] | undefined;
+    toTestContract(funcName: string, params: TestContractParams): api.TestContract;
+    static getContract(codeHash: string): Promise<Contract>;
+    static getFieldTypes(codeHash: string): Promise<string[]>;
+    fromApiContractState(state: api.ContractState): Promise<ContractState>;
+    static fromApiEvent(event: api.Event, fileName: string): Promise<ContractEvent>;
+    fromTestContractResult(methodIndex: number, result: api.TestContractResult): Promise<TestContractResult>;
+    transactionForDeployment(signer: Signer, initialFields?: Val[], issueTokenAmount?: string): Promise<DeployContractTransaction>;
+}
+export declare class Script extends Common {
+    constructor(fileName: string, sourceCodeSha256: string, bytecode: string, codeHash: string, functions: api.FunctionSig[]);
+    static checkCodeType(fileName: string, contractStr: string): void;
+    static loadContractStr(fileName: string, importsCache: string[], variables?: any): Promise<string>;
+    static from(client: CliqueClient, fileName: string, variables?: any): Promise<Script>;
+    private static __from;
+    static loadContract(fileName: string): Promise<Script>;
+    toString(): string;
+    transactionForDeployment(signer: Signer, params?: BuildScriptTx): Promise<BuildScriptTxResult>;
+}
+export declare type Number256 = number | bigint;
+export declare type Val = Number256 | boolean | string | Val[];
+export declare function extractArray(tpe: string, v: Val): api.Val;
+export interface Asset {
+    alphAmount: Number256;
+    tokens?: Token[];
+}
+export interface Token {
+    id: string;
+    amount: Number256;
+}
+export interface InputAsset {
+    address: string;
+    asset: Asset;
+}
+export interface ContractState {
+    fileName: string;
+    address: string;
+    bytecode: string;
+    codeHash: string;
+    fields: Val[];
+    fieldTypes: string[];
+    asset: Asset;
+}
+export interface TestContractParams {
+    group?: number;
+    address?: string;
+    initialFields?: Val[];
+    initialAsset?: Asset;
+    testMethodIndex?: number;
+    testArgs?: Val[];
+    existingContracts?: ContractState[];
+    inputAssets?: InputAsset[];
+}
+declare type Event = ContractEvent | TxScriptEvent;
+export interface ContractEvent {
+    blockHash: string;
+    contractAddress: string;
+    txId: string;
+    name: string;
+    fields: Val[];
+}
+export interface TxScriptEvent {
+    blockHash: string;
+    txId: string;
+    name: string;
+    fields: Val[];
+}
+export interface TestContractResult {
+    returns: Val[];
+    gasUsed: number;
+    contracts: ContractState[];
+    txOutputs: Output[];
+    events: Event[];
+}
+export declare type Output = AssetOutput | ContractOutput;
+export interface AssetOutput extends Asset {
+    type: string;
+    address: string;
+    lockTime: number;
+    additionalData: string;
+}
+export interface ContractOutput {
+    type: string;
+    address: string;
+    alphAmount: Number256;
+    tokens: Token[];
+}
+export interface DeployContractTransaction {
+    group: number;
+    unsignedTx: string;
+    txId: string;
+    contractAddress: string;
+}
+export interface BuildScriptTx {
+    alphAmount?: Number256;
+    tokens?: Token[];
+    gas?: number;
+    gasPrice?: Number256;
+    utxosLimit?: number;
+}
+export interface BuildScriptTxResult {
+    unsignedTx: string;
+    txId: string;
+    group: number;
+}
+export {};