@alephium/web3 0.5.0-rc.1 → 0.5.0-rc.3

package/dist/src/constants.d.ts

@@ -2,3 +2,4 @@ export declare const TOTAL_NUMBER_OF_GROUPS = 4;
 export declare const MIN_UTXO_SET_AMOUNT: bigint;
 export declare const ALPH_TOKEN_ID: string;
 export declare const ONE_ALPH: bigint;
+export declare const DUST_AMOUNT: bigint;

package/dist/src/constants.js

@@ -17,8 +17,9 @@ 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.ONE_ALPH = exports.ALPH_TOKEN_ID = exports.MIN_UTXO_SET_AMOUNT = exports.TOTAL_NUMBER_OF_GROUPS = void 0;
+exports.DUST_AMOUNT = exports.ONE_ALPH = exports.ALPH_TOKEN_ID = 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);
 exports.ALPH_TOKEN_ID = ''.padStart(64, '0');
 exports.ONE_ALPH = 10n ** 18n;
+exports.DUST_AMOUNT = 10n ** 15n;

package/dist/src/contract/codegen.d.ts

@@ -0,0 +1,2 @@
+import { Project } from './contract';
+export declare function codegen(project: Project): void;

package/dist/src/contract/codegen.js

@@ -0,0 +1,359 @@
+"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;
+    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 (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.codegen = void 0;
+const prettier = __importStar(require("prettier"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const contract_1 = require("./contract");
+const header = `/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\n\n`;
+function array(str, size) {
+    const result = Array(size).fill(str).join(', ');
+    return `[${result}]`;
+}
+function parseArrayType(tpe) {
+    const ignored = '[;]';
+    const tokens = [];
+    let acc = '';
+    for (let index = 0; index < tpe.length; index++) {
+        if (!ignored.includes(tpe.charAt(index))) {
+            acc = acc + tpe.charAt(index);
+        }
+        else if (acc !== '') {
+            tokens.push(acc);
+            acc = '';
+        }
+    }
+    const baseTsType = toTsType(tokens[0]);
+    const sizes = tokens.slice(1).map((str) => parseInt(str));
+    return sizes.reduce((acc, size) => array(acc, size), baseTsType);
+}
+function toTsType(ralphType) {
+    switch (ralphType) {
+        case 'U256':
+        case 'I256':
+            return 'bigint';
+        case 'Bool':
+            return 'boolean';
+        case 'Address':
+        case 'ByteVec':
+            return 'HexString';
+        default: // array type
+            return parseArrayType(ralphType);
+    }
+}
+function formatParameters(fieldsSig) {
+    return fieldsSig.names.map((name, idx) => `${name}: ${toTsType(fieldsSig.types[`${idx}`])}`).join(', ');
+}
+function genCallMethod(contractName, functionSig) {
+    if (!functionSig.isPublic || functionSig.returnTypes.length === 0) {
+        return '';
+    }
+    const funcName = functionSig.name.charAt(0).toUpperCase() + functionSig.name.slice(1);
+    const funcHasArgs = functionSig.paramNames.length > 0;
+    const params = funcHasArgs
+        ? `params: CallContractParams<{${formatParameters({
+            names: functionSig.paramNames,
+            types: functionSig.paramTypes
+        })}}>`
+        : `params?: Omit<CallContractParams<{}>, 'args'>`;
+    const tsReturnTypes = functionSig.returnTypes.map((tpe) => toTsType(tpe));
+    const retType = tsReturnTypes.length === 0
+        ? `CallContractResult<null>`
+        : tsReturnTypes.length === 1
+            ? `CallContractResult<${tsReturnTypes[0]}>`
+            : `CallContractResult<[${tsReturnTypes.join(', ')}]>`;
+    const callParams = funcHasArgs ? 'params' : 'params === undefined ? {} : params';
+    return `
+    async call${funcName}Method(${params}): Promise<${retType}> {
+      return callMethod(${contractName}, this, "${functionSig.name}", ${callParams})
+    }
+  `;
+}
+function getInstanceName(contract) {
+    return `${contract.name}Instance`;
+}
+function genAttach(instanceName) {
+    return `
+  at(address: string): ${instanceName} {
+    return new ${instanceName}(address)
+  }
+  `;
+}
+function contractTypes(contractName) {
+    return `${contractName}Types`;
+}
+function contractFieldType(contract) {
+    const hasFields = contract.fieldsSig.names.length > 0;
+    return hasFields ? `${contractTypes(contract.name)}.Fields` : '{}';
+}
+function genFetchState(contract) {
+    return `
+  async fetchState(): Promise<${contractTypes(contract.name)}.State> {
+    return fetchContractState(${contract.name}, this)
+  }
+  `;
+}
+function getEventType(event) {
+    return event.name + 'Event';
+}
+function genEventType(event) {
+    if (event.fieldNames.length === 0) {
+        return `export type ${getEventType(event)} = Omit<ContractEvent, 'fields'>`;
+    }
+    const fieldsType = `{${formatParameters({ names: event.fieldNames, types: event.fieldTypes })}}`;
+    return `export type ${getEventType(event)} = ContractEvent<${fieldsType}>`;
+}
+function genSubscribeSystemEvent(event) {
+    return `
+    subscribe${event.eventSig.name}Event(options: SubscribeOptions<${event.eventType}>, fromCount?: number): EventSubscription {
+      return subscribe${event.eventSig.name}Event(this, options, fromCount)
+    }
+  `;
+}
+function genSubscribeEvent(contractName, event) {
+    const eventType = getEventType(event);
+    const scopedEventType = `${contractTypes(contractName)}.${eventType}`;
+    return `
+    subscribe${eventType}(options: SubscribeOptions<${scopedEventType}>, fromCount?: number): EventSubscription {
+      return subscribeContractEvent(${contractName}.contract, this, options, "${event.name}", fromCount)
+    }
+  `;
+}
+function genSubscribeAllEvents(contract, systemEvents) {
+    const contractEventTypes = contract.eventsSig.map((e) => `${contractTypes(contract.name)}.${getEventType(e)}`);
+    const systemEventTypes = systemEvents.map((e) => e.eventType);
+    const eventTypes = contractEventTypes.concat(systemEventTypes).join(' | ');
+    return `
+    subscribeAllEvents(options: SubscribeOptions<${eventTypes}>, fromCount?: number): EventSubscription {
+      return subscribeAllEvents(${contract.name}.contract, this, options, fromCount)
+    }
+  `;
+}
+function genContractStateType(contract) {
+    if (contract.fieldsSig.names.length === 0) {
+        return `export type State = Omit<ContractState<any>, 'fields'>`;
+    }
+    return `
+    export type Fields = {
+      ${formatParameters(contract.fieldsSig)}
+    }
+
+    export type State = ContractState<Fields>
+  `;
+}
+function genTestMethod(contract, functionSig) {
+    const funcName = functionSig.name.charAt(0).toUpperCase() + functionSig.name.slice(1);
+    const funcHasArgs = functionSig.paramNames.length > 0;
+    const contractHasFields = contract.fieldsSig.names.length > 0;
+    const argsType = funcHasArgs
+        ? `{${formatParameters({ names: functionSig.paramNames, types: functionSig.paramTypes })}}`
+        : 'never';
+    const fieldsType = contractHasFields ? `${contractFieldType(contract)}` : 'never';
+    const params = funcHasArgs && contractHasFields
+        ? `params: TestContractParams<${fieldsType}, ${argsType}>`
+        : funcHasArgs
+            ? `params: Omit<TestContractParams<${fieldsType}, ${argsType}>, 'initialFields'>`
+            : contractHasFields
+                ? `params: Omit<TestContractParams<${fieldsType}, ${argsType}>, 'testArgs'>`
+                : `params?: Omit<TestContractParams<${fieldsType}, ${argsType}>, 'testArgs' | 'initialFields'>`;
+    const tsReturnTypes = functionSig.returnTypes.map((tpe) => toTsType(tpe));
+    const retType = tsReturnTypes.length === 0
+        ? `TestContractResult<null>`
+        : tsReturnTypes.length === 1
+            ? `TestContractResult<${tsReturnTypes[0]}>`
+            : `TestContractResult<[${tsReturnTypes.join(', ')}]>`;
+    const callParams = funcHasArgs || contractHasFields ? 'params' : 'params === undefined ? {} : params';
+    return `
+    async test${funcName}Method(${params}): Promise<${retType}> {
+      return testMethod(this, "${functionSig.name}", ${callParams})
+    }
+  `;
+}
+function genContract(project, contract, artifactRelativePath) {
+    const contractInfo = project.projectArtifact.infos.get(contract.name);
+    if (contractInfo === undefined) {
+        throw new Error(`Contract info does not exist: ${contract.name}`);
+    }
+    const systemEvents = [
+        {
+            eventSig: contract_1.Contract.ContractCreatedEvent,
+            eventIndex: contract_1.Contract.ContractCreatedEventIndex,
+            eventType: 'ContractCreatedEvent'
+        },
+        {
+            eventSig: contract_1.Contract.ContractDestroyedEvent,
+            eventIndex: contract_1.Contract.ContractDestroyedEventIndex,
+            eventType: 'ContractDestroyedEvent'
+        }
+    ];
+    const source = `
+    ${header}
+
+    import {
+      Address, Contract, ContractState, TestContractResult, HexString, ContractFactory,
+      SubscribeOptions, EventSubscription, CallContractParams, CallContractResult,
+      TestContractParams, ContractEvent, subscribeContractCreatedEvent, subscribeContractDestroyedEvent, subscribeContractEvent, subscribeAllEvents, testMethod, callMethod, fetchContractState,
+      ContractCreatedEvent, ContractDestroyedEvent, ContractInstance
+    } from '@alephium/web3'
+    import { default as ${contract.name}ContractJson } from '../${artifactRelativePath}'
+
+    // Custom types for the contract
+    export namespace ${contract.name}Types {
+      ${genContractStateType(contract)}
+      ${contract.eventsSig.map((e) => genEventType(e)).join('\n')}
+    }
+
+    class Factory extends ContractFactory<${contract.name}Instance, ${contractFieldType(contract)}> {
+      ${genAttach(getInstanceName(contract))}
+      ${contract.functions.map((f) => genTestMethod(contract, f)).join('\n')}
+    }
+
+    // Use this object to test and deploy the contract
+    export const ${contract.name} = new Factory(Contract.fromJson(
+      ${contract.name}ContractJson,
+      '${contractInfo.bytecodeDebugPatch}',
+      '${contractInfo.codeHashDebug}',
+    ))
+
+    // Use this class to interact with the blockchain
+    export class ${contract.name}Instance extends ContractInstance {
+      constructor(address: Address) {
+        super(address)
+      }
+
+      ${genFetchState(contract)}
+      ${systemEvents.map((e) => genSubscribeSystemEvent(e)).join('\n')}
+      ${contract.eventsSig.map((e) => genSubscribeEvent(contract.name, e)).join('\n')}
+      ${genSubscribeAllEvents(contract, systemEvents)}
+      ${contract.functions.map((f) => genCallMethod(contract.name, f)).join('\n')}
+    }
+`;
+    return prettier.format(source, { parser: 'typescript' });
+}
+function genScript(script) {
+    console.log(`Generating code for script ${script.name}`);
+    const usePreapprovedAssets = script.functions[0].usePreapprovedAssets;
+    const fieldsType = script.fieldsSig.names.length > 0 ? `{${formatParameters(script.fieldsSig)}}` : '{}';
+    const paramsType = usePreapprovedAssets
+        ? `ExecuteScriptParams<${fieldsType}>`
+        : `Omit<ExecuteScriptParams<${fieldsType}>, 'attoAlphAmount' | 'tokens'>`;
+    return `
+    export namespace ${script.name} {
+      export async function execute(signer: SignerProvider, params: ${paramsType}): Promise<ExecuteScriptResult> {
+        const signerParams = await script.txParamsForExecution(signer, params)
+        return await signer.signAndSubmitExecuteScriptTx(signerParams)
+      }
+
+      export const script = Script.fromJson(${script.name}ScriptJson)
+    }
+  `;
+}
+function genScripts(project, outDir, exports) {
+    const artifactDir = project.artifactsRootDir;
+    exports.push('./scripts');
+    const scriptPath = path_1.default.join(outDir, 'scripts.ts');
+    const scripts = Array.from(project.scripts.values());
+    const importArtifacts = Array.from(scripts)
+        .map((s) => {
+        const artifactPath = s.sourceInfo.getArtifactPath(artifactDir);
+        const artifactRelativePath = path_1.default.relative(artifactDir, artifactPath);
+        return `import { default as ${s.artifact.name}ScriptJson } from '../${artifactRelativePath}'`;
+    })
+        .join('\n');
+    const scriptsSource = scripts.map((s) => genScript(s.artifact)).join('\n');
+    const source = `
+    ${header}
+
+    import {
+      ExecuteScriptParams,
+      ExecuteScriptResult,
+      Script,
+      SignerProvider,
+      HexString
+    } from '@alephium/web3'
+    ${importArtifacts}
+
+    ${scriptsSource}
+  `;
+    const formatted = prettier.format(source, { parser: 'typescript' });
+    fs_1.default.writeFileSync(scriptPath, formatted, 'utf8');
+}
+function genIndexTs(outDir, exports) {
+    const indexPath = path_1.default.join(outDir, 'index.ts');
+    const exportStatements = exports.map((e) => `export * from "${e}"`).join('\n');
+    const source = prettier.format(header + exportStatements, { parser: 'typescript' });
+    fs_1.default.writeFileSync(indexPath, source, 'utf8');
+}
+function genContracts(project, outDir, exports) {
+    const artifactDir = project.artifactsRootDir;
+    Array.from(project.contracts.values()).forEach((c) => {
+        console.log(`Generating code for contract ${c.artifact.name}`);
+        exports.push(`./${c.artifact.name}`);
+        const filename = `${c.artifact.name}.ts`;
+        const sourcePath = path_1.default.join(outDir, filename);
+        const artifactPath = c.sourceInfo.getArtifactPath(artifactDir);
+        const artifactRelativePath = path_1.default.relative(artifactDir, artifactPath);
+        const sourceCode = genContract(project, c.artifact, artifactRelativePath);
+        fs_1.default.writeFileSync(sourcePath, sourceCode, 'utf8');
+    });
+}
+function codegen(project) {
+    const outDirTemp = path_1.default.join(project.artifactsRootDir, 'ts');
+    const outDir = path_1.default.isAbsolute(outDirTemp) ? outDirTemp : path_1.default.resolve(outDirTemp);
+    if (!fs_1.default.existsSync(outDir)) {
+        fs_1.default.mkdirSync(outDir, { recursive: true });
+    }
+    const exports = [];
+    try {
+        genContracts(project, outDir, exports);
+        genScripts(project, outDir, exports);
+        genIndexTs(outDir, exports);
+    }
+    catch (error) {
+        console.log(`Failed to generate code: ${error}`);
+    }
+}
+exports.codegen = codegen;

package/dist/src/contract/contract.js

@@ -55,6 +55,7 @@ const global_1 = require("../global");
 const path = __importStar(require("path"));
 const events_1 = require("./events");
 const constants_1 = require("../constants");
+const codegen_1 = require("./codegen");
 var SourceKind;
 (function (SourceKind) {
     SourceKind[SourceKind["Contract"] = 0] = "Contract";
@@ -292,6 +293,7 @@ class Project {
         const projectArtifact = Project.buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions);
         const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
         await project.saveArtifactsToFile(projectRootDir);
+        (0, codegen_1.codegen)(project);
         return project;
     }
     static async loadArtifacts(provider, sourceInfos, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.5.0-rc.1",
+  "version": "0.5.0-rc.3",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",

package/src/constants.ts

@@ -20,3 +20,4 @@ export const TOTAL_NUMBER_OF_GROUPS = 4
 export const MIN_UTXO_SET_AMOUNT = BigInt(1000000000000)
 export const ALPH_TOKEN_ID = ''.padStart(64, '0')
 export const ONE_ALPH = 10n ** 18n
+export const DUST_AMOUNT = 10n ** 15n