@alephium/web3 0.0.3 → 0.1.0-rc.0

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

@@ -0,0 +1,29 @@
+import { node } from '../api';
+import { NodeProvider } from '../api';
+declare type EventCallback = (event: node.ContractEvent) => Promise<void>;
+declare type ErrorCallback = (error: any, subscription: Subscription) => Promise<void>;
+export interface SubscribeOptions {
+    provider: NodeProvider;
+    contractAddress: string;
+    fromCount?: number;
+    pollingInterval: number;
+    eventCallback: EventCallback;
+    errorCallback: ErrorCallback;
+}
+export declare class Subscription {
+    provider: NodeProvider;
+    readonly contractAddress: string;
+    pollingInterval: number;
+    private fromCount;
+    private eventCallback;
+    private errorCallback;
+    private task;
+    private cancelled;
+    private eventEmitter;
+    constructor(options: SubscribeOptions);
+    unsubscribe(): void;
+    currentEventCount(): number;
+    private fetchEvents;
+}
+export declare function subscribe(options: SubscribeOptions): Subscription;
+export {};

package/dist/src/contract/events.js

@@ -0,0 +1,77 @@
+"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.subscribe = exports.Subscription = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+class Subscription {
+    constructor(options) {
+        this.provider = options.provider;
+        this.contractAddress = options.contractAddress;
+        this.fromCount = typeof options.fromCount === 'undefined' ? 0 : options.fromCount;
+        this.pollingInterval = options.pollingInterval;
+        this.eventCallback = options.eventCallback;
+        this.errorCallback = options.errorCallback;
+        this.task = undefined;
+        this.cancelled = false;
+        this.eventEmitter = new eventemitter3_1.default();
+        this.eventEmitter.on('tick', async () => {
+            await this.fetchEvents();
+        });
+        this.eventEmitter.emit('tick');
+    }
+    unsubscribe() {
+        this.eventEmitter.removeAllListeners();
+        this.cancelled = true;
+        if (typeof this.task !== 'undefined') {
+            clearTimeout(this.task);
+        }
+    }
+    currentEventCount() {
+        return this.fromCount;
+    }
+    async fetchEvents() {
+        try {
+            const events = await this.provider.events.getEventsContractContractaddress(this.contractAddress, {
+                start: this.fromCount
+            });
+            if (this.cancelled) {
+                return;
+            }
+            if (this.fromCount === events.nextStart) {
+                this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval);
+                return;
+            }
+            const promises = events.events.map((event) => this.eventCallback(event));
+            await Promise.all(promises);
+            this.fromCount = events.nextStart;
+            await this.fetchEvents();
+        }
+        catch (err) {
+            await this.errorCallback(err, this);
+        }
+    }
+}
+exports.Subscription = Subscription;
+function subscribe(options) {
+    return new Subscription(options);
+}
+exports.subscribe = subscribe;

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

@@ -0,0 +1,3 @@
+export * from './ralph';
+export * from './contract';
+export * from './events';

package/dist/src/contract/index.js

@@ -0,0 +1,32 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ralph"), exports);
+__exportStar(require("./contract"), exports);
+__exportStar(require("./events"), exports);

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

@@ -0,0 +1,12 @@
+import { node } from '../api';
+import { Fields, Val } from './contract';
+export declare function encodeBool(bool: boolean): Uint8Array;
+export declare function encodeI256(i256: bigint): Uint8Array;
+export declare function encodeU256(u256: bigint): Uint8Array;
+export declare function encodeByteVec(bytes: string): Uint8Array;
+export declare function encodeAddress(address: string): Uint8Array;
+export declare function encodeScriptFieldAsString(tpe: string, value: Val): string;
+export declare function encodeScriptField(tpe: string, value: Val): Uint8Array;
+export declare function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: node.FieldsSig): string;
+export declare function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: node.FieldsSig): string;
+export declare function encodeContractField(tpe: string, value: Val): Uint8Array[];

package/dist/src/contract/ralph.js

@@ -0,0 +1,362 @@
+"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 _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.encodeBool = void 0;
+const buffer_1 = require("buffer/");
+const utils_1 = require("../utils");
+const bigIntZero = BigInt(0);
+class UnSigned {
+}
+UnSigned.oneByteBound = BigInt(0x40);
+UnSigned.twoByteBound = UnSigned.oneByteBound << BigInt(8);
+UnSigned.fourByteBound = UnSigned.oneByteBound << BigInt(8 * 3);
+UnSigned.u256UpperBound = BigInt(1) << BigInt(256);
+class Signed {
+}
+_a = Signed;
+Signed.oneByteBound = BigInt(0x20);
+Signed.twoByteBound = Signed.oneByteBound << BigInt(8);
+Signed.fourByteBound = Signed.oneByteBound << BigInt(8 * 3);
+Signed.i256UpperBound = BigInt(1) << BigInt(255);
+Signed.i256LowerBound = -_a.i256UpperBound;
+class CompactInt {
+}
+CompactInt.oneBytePrefix = 0x00;
+CompactInt.oneByteNegPrefix = 0xc0;
+CompactInt.twoBytePrefix = 0x40;
+CompactInt.twoByteNegPrefix = 0x80;
+CompactInt.fourBytePrefix = 0x80;
+CompactInt.fourByteNegPrefix = 0x40;
+CompactInt.multiBytePrefix = 0xc0;
+function encodeBool(bool) {
+    return bool ? Uint8Array.from([1]) : Uint8Array.from([0]);
+}
+exports.encodeBool = encodeBool;
+function encodeI256(i256) {
+    if (i256 >= bigIntZero) {
+        return encodeI256Positive(i256);
+    }
+    else {
+        return encodeI256Negative(i256);
+    }
+}
+exports.encodeI256 = encodeI256;
+// n should be positive
+function toByteArray(n, signed, notBit) {
+    let hex = n.toString(16);
+    if (hex.length % 2 === 1) {
+        hex = '0' + hex;
+    }
+    else if (signed && hex[0] >= '8') {
+        hex = '00' + hex; // add the byte for sign
+    }
+    const byteLength = hex.length / 2;
+    const bytes = new Uint8Array(byteLength + 1);
+    for (let index = 0; index < byteLength; index++) {
+        const offset = index * 2;
+        const byte = parseInt(hex.slice(offset, offset + 2), 16);
+        bytes[`${index + 1}`] = notBit ? ~byte : byte;
+    }
+    const header = byteLength - 4 + CompactInt.multiBytePrefix;
+    bytes[0] = header;
+    return bytes;
+}
+function encodeI256Positive(i256) {
+    if (i256 < Signed.oneByteBound) {
+        return new Uint8Array([Number(i256) + CompactInt.oneBytePrefix]);
+    }
+    else if (i256 < Signed.twoByteBound) {
+        const num = Number(i256);
+        return new Uint8Array([(num >> 8) + CompactInt.twoBytePrefix, num & 0xff]);
+    }
+    else if (i256 < Signed.fourByteBound) {
+        const num = Number(i256);
+        return new Uint8Array([(num >> 24) + CompactInt.fourBytePrefix, (num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff]);
+    }
+    else if (i256 < Signed.i256UpperBound) {
+        return toByteArray(i256, true, false);
+    }
+    else {
+        throw Error(`Too large number for i256: ${i256}`);
+    }
+}
+function encodeI256Negative(i256) {
+    if (i256 >= -Signed.oneByteBound) {
+        const num = Number(i256);
+        return new Uint8Array([(num ^ CompactInt.oneByteNegPrefix) & 0xff]);
+    }
+    else if (i256 >= -Signed.twoByteBound) {
+        const num = Number(i256);
+        return new Uint8Array([((num >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, num & 0xff]);
+    }
+    else if (i256 >= -Signed.fourByteBound) {
+        const num = Number(i256);
+        return new Uint8Array([
+            ((num >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
+            (num >> 16) & 0xff,
+            (num >> 8) & 0xff,
+            num & 0xff
+        ]);
+    }
+    else if (i256 >= Signed.i256LowerBound) {
+        return toByteArray(~i256, true, true);
+    }
+    else {
+        throw Error(`Too small number for i256: ${i256}`);
+    }
+}
+function encodeU256(u256) {
+    if (u256 < bigIntZero) {
+        throw Error(`Negative number for U256: ${u256}`);
+    }
+    else if (u256 < UnSigned.oneByteBound) {
+        return new Uint8Array([Number(u256) + CompactInt.oneBytePrefix]);
+    }
+    else if (u256 < UnSigned.twoByteBound) {
+        const num = Number(u256);
+        return new Uint8Array([((num >> 8) & 0xff) + CompactInt.twoBytePrefix, num & 0xff]);
+    }
+    else if (u256 < UnSigned.fourByteBound) {
+        const num = Number(u256);
+        return new Uint8Array([
+            ((num >> 24) & 0xff) + CompactInt.fourBytePrefix,
+            (num >> 16) & 0xff,
+            (num >> 8) & 0xff,
+            num & 0xff
+        ]);
+    }
+    else if (u256 < UnSigned.u256UpperBound) {
+        return toByteArray(u256, false, false);
+    }
+    else {
+        throw Error(`Too large number for U256: ${u256}`);
+    }
+}
+exports.encodeU256 = encodeU256;
+function encodeByteVec(bytes) {
+    if (!(0, utils_1.isHexString)(bytes)) {
+        throw Error(`Given value ${bytes} is not a valid hex string`);
+    }
+    const buffer0 = buffer_1.Buffer.from(bytes, 'hex');
+    const buffer1 = buffer_1.Buffer.from(encodeI256(BigInt(buffer0.length)));
+    return buffer_1.Buffer.concat([buffer1, buffer0]);
+}
+exports.encodeByteVec = encodeByteVec;
+function encodeAddress(address) {
+    return utils_1.bs58.decode(address);
+}
+exports.encodeAddress = encodeAddress;
+function invalidScriptField(tpe, value) {
+    return Error(`Invalid script field ${value} for type ${tpe}`);
+}
+var Instruction;
+(function (Instruction) {
+    Instruction[Instruction["trueConst"] = 3] = "trueConst";
+    Instruction[Instruction["falseConst"] = 4] = "falseConst";
+    Instruction[Instruction["i256Const0"] = 5] = "i256Const0";
+    Instruction[Instruction["i256Const1"] = 6] = "i256Const1";
+    Instruction[Instruction["i256Const2"] = 7] = "i256Const2";
+    Instruction[Instruction["i256Const3"] = 8] = "i256Const3";
+    Instruction[Instruction["i256Const4"] = 9] = "i256Const4";
+    Instruction[Instruction["i256Const5"] = 10] = "i256Const5";
+    Instruction[Instruction["i256ConstN1"] = 11] = "i256ConstN1";
+    Instruction[Instruction["u256Const0"] = 12] = "u256Const0";
+    Instruction[Instruction["u256Const1"] = 13] = "u256Const1";
+    Instruction[Instruction["u256Const2"] = 14] = "u256Const2";
+    Instruction[Instruction["u256Const3"] = 15] = "u256Const3";
+    Instruction[Instruction["u256Const4"] = 16] = "u256Const4";
+    Instruction[Instruction["u256Const5"] = 17] = "u256Const5";
+    Instruction[Instruction["i256Const"] = 18] = "i256Const";
+    Instruction[Instruction["u256Const"] = 19] = "u256Const";
+    Instruction[Instruction["bytesConst"] = 20] = "bytesConst";
+    Instruction[Instruction["addressConst"] = 21] = "addressConst";
+})(Instruction || (Instruction = {}));
+// TODO: optimize
+function encodeScriptFieldI256(value) {
+    return new Uint8Array([Instruction.i256Const, ...encodeI256(value)]);
+}
+// TODO: optimize
+function encodeScriptFieldU256(value) {
+    return new Uint8Array([Instruction.u256Const, ...encodeU256(value)]);
+}
+function encodeScriptFieldAsString(tpe, value) {
+    return buffer_1.Buffer.from(encodeScriptField(tpe, value)).toString('hex');
+}
+exports.encodeScriptFieldAsString = encodeScriptFieldAsString;
+function encodeScriptField(tpe, value) {
+    switch (tpe) {
+        case 'Bool':
+            if (typeof value === 'boolean') {
+                const byte = value ? Instruction.trueConst : Instruction.falseConst;
+                return new Uint8Array([byte]);
+            }
+            break;
+        case 'I256':
+            if (typeof value === 'number' && Number.isInteger(value)) {
+                return encodeScriptFieldI256(BigInt(value));
+            }
+            else if (typeof value === 'bigint') {
+                return encodeScriptFieldI256(value);
+            }
+            break;
+        case 'U256':
+            if (typeof value === 'number' && Number.isInteger(value)) {
+                return encodeScriptFieldU256(BigInt(value));
+            }
+            else if (typeof value === 'bigint') {
+                return encodeScriptFieldU256(value);
+            }
+            break;
+        case 'ByteVec':
+            if (typeof value === 'string') {
+                return new Uint8Array([Instruction.bytesConst, ...encodeByteVec(value)]);
+            }
+            break;
+        case 'Address':
+            if (typeof value === 'string') {
+                return new Uint8Array([Instruction.addressConst, ...encodeAddress(value)]);
+            }
+            break;
+    }
+    throw invalidScriptField(tpe, value);
+}
+exports.encodeScriptField = encodeScriptField;
+const scriptFieldRegex = /\{([0-9]*)\}/g;
+function buildScriptByteCode(bytecodeTemplate, fields, fieldsSig) {
+    return bytecodeTemplate.replace(scriptFieldRegex, (_, fieldIndex) => {
+        const fieldName = fieldsSig.names[`${fieldIndex}`];
+        const fieldType = fieldsSig.types[`${fieldIndex}`];
+        if (fieldName in fields) {
+            const fieldValue = fields[`${fieldName}`];
+            return encodeScriptFieldAsString(fieldType, fieldValue);
+        }
+        else {
+            throw new Error(`The value of field ${fieldName} is not provided`);
+        }
+    });
+}
+exports.buildScriptByteCode = buildScriptByteCode;
+function buildContractByteCode(bytecode, fields, fieldsSig) {
+    const fieldsEncoded = fieldsSig.names.flatMap((fieldName, fieldIndex) => {
+        const fieldType = fieldsSig.types[`${fieldIndex}`];
+        if (fieldName in fields) {
+            const fieldValue = fields[`${fieldName}`];
+            return encodeContractField(fieldType, fieldValue);
+        }
+        else {
+            throw new Error(`The value of field ${fieldName} is not provided`);
+        }
+    });
+    const fieldsLength = buffer_1.Buffer.from(encodeI256(BigInt(fieldsEncoded.length))).toString('hex');
+    return bytecode + fieldsLength + fieldsEncoded.map((f) => buffer_1.Buffer.from(f).toString('hex')).join('');
+}
+exports.buildContractByteCode = buildContractByteCode;
+var ApiValType;
+(function (ApiValType) {
+    ApiValType[ApiValType["Bool"] = 0] = "Bool";
+    ApiValType[ApiValType["I256"] = 1] = "I256";
+    ApiValType[ApiValType["U256"] = 2] = "U256";
+    ApiValType[ApiValType["ByteVec"] = 3] = "ByteVec";
+    ApiValType[ApiValType["Address"] = 4] = "Address";
+})(ApiValType || (ApiValType = {}));
+function encodeContractFieldI256(value) {
+    return new Uint8Array([ApiValType.I256, ...encodeI256(value)]);
+}
+function encodeContractFieldU256(value) {
+    return new Uint8Array([ApiValType.U256, ...encodeU256(value)]);
+}
+function encodeContractFieldArray(tpe, val) {
+    if (!Array.isArray(val)) {
+        throw new Error(`Expected array, got ${val}`);
+    }
+    const semiColonIndex = tpe.lastIndexOf(';');
+    if (semiColonIndex == -1) {
+        throw new Error(`Invalid Array type: ${tpe}`);
+    }
+    const subType = tpe.slice(1, semiColonIndex);
+    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
+    if (val.length != dim) {
+        throw new Error(`Invalid val dimension: ${val}`);
+    }
+    else {
+        return val.flatMap((v) => encodeContractField(subType, v));
+    }
+}
+function encodeContractField(tpe, value) {
+    switch (tpe) {
+        case 'Bool':
+            if (typeof value === 'boolean') {
+                const byte = value ? 1 : 0;
+                return [new Uint8Array([ApiValType.Bool, byte])];
+            }
+            break;
+        case 'I256':
+            if (typeof value === 'number' && Number.isInteger(value)) {
+                return [encodeContractFieldI256(BigInt(value))];
+            }
+            else if (typeof value === 'bigint') {
+                return [encodeContractFieldI256(value)];
+            }
+            break;
+        case 'U256':
+            if (typeof value === 'number' && Number.isInteger(value)) {
+                return [encodeContractFieldU256(BigInt(value))];
+            }
+            else if (typeof value === 'bigint') {
+                return [encodeContractFieldU256(value)];
+            }
+            break;
+        case 'ByteVec':
+            if (typeof value === 'string') {
+                return [new Uint8Array([ApiValType.ByteVec, ...encodeByteVec(value)])];
+            }
+            break;
+        case 'Address':
+            if (typeof value === 'string') {
+                return [new Uint8Array([ApiValType.Address, ...encodeAddress(value)])];
+            }
+            break;
+        default:
+            // Array type
+            return encodeContractFieldArray(tpe, value);
+    }
+    throw invalidVal(tpe, value);
+}
+exports.encodeContractField = encodeContractField;
+function invalidVal(tpe, value) {
+    return Error(`Invalid API value ${value} for type ${tpe}`);
+}
+// export function buildContractByteCode(
+//   compiled: node.TemplateContractByteCode,
+//   templateVariables: TemplateVariables
+// ): string {
+//   const methodsBuilt = compiled.methodsByteCode.map((template) => buildByteCode(template, templateVariables))
+//   let count = 0
+//   const methodIndexes = methodsBuilt.map((hex) => {
+//     count += hex.length / 2
+//     return count
+//   })
+//   return (
+//     binToHex(encodeI256(BigInt(compiled.filedLength))) +
+//     binToHex(encodeI256(BigInt(methodIndexes.length))) +
+//     methodIndexes.map((index) => binToHex(encodeI256(BigInt(index)))).join('') +
+//     methodsBuilt.join('')
+//   )
+// }

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './contract';
+export * from './signer';
+export * from './utils';
+export * from './constants';

package/dist/src/index.js

@@ -0,0 +1,34 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./contract"), exports);
+__exportStar(require("./signer"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);

package/dist/src/signer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './signer';
+export * from './node-wallet';

package/dist/src/signer/index.js

@@ -0,0 +1,31 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./signer"), exports);
+__exportStar(require("./node-wallet"), exports);

package/dist/src/signer/node-wallet.d.ts

@@ -0,0 +1,13 @@
+import { NodeProvider } from '../api';
+import { Account, SignerWithNodeProvider } from '../signer';
+export declare class NodeWallet extends SignerWithNodeProvider {
+    walletName: string;
+    accounts: Account[] | undefined;
+    constructor(provider: NodeProvider, walletName: string, alwaysSubmitTx?: boolean);
+    getAccounts(): Promise<Account[]>;
+    private getAllAccounts;
+    static FromCliqueClient(provider: NodeProvider, walletName: string, alwaysSubmitTx?: boolean): Promise<NodeWallet>;
+    signRaw(signerAddress: string, hexString: string): Promise<string>;
+    unlock(password: string): Promise<void>;
+    lock(): Promise<void>;
+}

package/dist/src/signer/node-wallet.js

@@ -0,0 +1,60 @@
+"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.NodeWallet = void 0;
+const signer_1 = require("../signer");
+class NodeWallet extends signer_1.SignerWithNodeProvider {
+    constructor(provider, walletName, alwaysSubmitTx = true) {
+        super(provider, alwaysSubmitTx);
+        this.walletName = walletName;
+    }
+    async getAccounts() {
+        if (typeof this.accounts === 'undefined') {
+            this.accounts = await this.getAllAccounts();
+        }
+        return this.accounts;
+    }
+    async getAllAccounts() {
+        const walletAddresses = await this.provider.wallets.getWalletsWalletNameAddresses(this.walletName);
+        const accounts = walletAddresses.addresses.map((acc) => ({
+            publicKey: acc.publicKey,
+            address: acc.address,
+            group: acc.group
+        }));
+        return accounts;
+    }
+    static async FromCliqueClient(provider, walletName, alwaysSubmitTx = true) {
+        return new NodeWallet(provider, walletName, alwaysSubmitTx);
+    }
+    async signRaw(signerAddress, hexString) {
+        const currentActiveAddressResponse = await this.provider.wallets.getWalletsWalletNameAddresses(this.walletName);
+        const { activeAddress } = currentActiveAddressResponse;
+        await this.provider.wallets.postWalletsWalletNameChangeActiveAddress(this.walletName, { address: signerAddress });
+        const { signature } = await this.provider.wallets.postWalletsWalletNameSign(this.walletName, { data: hexString });
+        await this.provider.wallets.postWalletsWalletNameChangeActiveAddress(this.walletName, { address: activeAddress }); // set the address that's active back to previous state
+        return signature;
+    }
+    async unlock(password) {
+        return await this.provider.wallets.postWalletsWalletNameUnlock(this.walletName, { password });
+    }
+    async lock() {
+        return await this.provider.wallets.postWalletsWalletNameLock(this.walletName);
+    }
+}
+exports.NodeWallet = NodeWallet;