@alephium/web3 0.5.0-rc.12 → 0.5.0-rc.14

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

@@ -257,6 +257,8 @@ export interface CallContractResult<R> {
     txOutputs: Output[];
     events: ContractEvent[];
 }
+export declare const CreateContractEventAddress: string;
+export declare const DestroyContractEventAddress: string;
 export interface SystemEventSig extends EventSig {
     optionalFieldNames?: string[];
     optionalFieldTypes?: string[];
@@ -279,10 +281,11 @@ export declare abstract class ContractInstance {
     constructor(address: Address);
 }
 export declare function fetchContractState<F extends Fields, I extends ContractInstance>(contract: ContractFactory<I, F>, instance: ContractInstance): Promise<ContractState<F>>;
-export declare function subscribeContractCreatedEvent(instance: ContractInstance, options: SubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
-export declare function subscribeContractDestroyedEvent(instance: ContractInstance, options: SubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractCreatedEvent(options: SubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractDestroyedEvent(options: SubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
 export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, event: node.ContractEvent, targetEventIndex: number): M;
 export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: SubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
-export declare function subscribeAllEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
+export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
 export declare function callMethod<I, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>): Promise<CallContractResult<R>>;
+export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export {};

package/dist/src/contract/contract.js

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callMethod = exports.subscribeAllEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
+exports.getContractEventsCurrentCount = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -886,6 +886,13 @@ class ContractFactory {
     }
 }
 exports.ContractFactory = ContractFactory;
+function specialContractAddress(n) {
+    const bytes = new Uint8Array(32).fill(0);
+    bytes[31] = n;
+    return (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(bytes));
+}
+exports.CreateContractEventAddress = specialContractAddress(-1);
+exports.DestroyContractEventAddress = specialContractAddress(-2);
 function decodeSystemEvent(event, systemEventSig, eventIndex) {
     if (event.eventIndex !== eventIndex) {
         throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
@@ -968,20 +975,20 @@ async function fetchContractState(contract, instance) {
     };
 }
 exports.fetchContractState = fetchContractState;
-function subscribeContractCreatedEvent(instance, options, fromCount) {
-    return subscribeEventsFromContract(options, instance.address, Contract.ContractCreatedEventIndex, (event) => {
+function subscribeContractCreatedEvent(options, fromCount) {
+    return subscribeEventsFromContract(options, exports.CreateContractEventAddress, Contract.ContractCreatedEventIndex, (event) => {
         return {
             ...decodeContractCreatedEvent(event),
-            contractAddress: instance.address
+            contractAddress: exports.CreateContractEventAddress
         };
     }, fromCount);
 }
 exports.subscribeContractCreatedEvent = subscribeContractCreatedEvent;
-function subscribeContractDestroyedEvent(instance, options, fromCount) {
-    return subscribeEventsFromContract(options, instance.address, Contract.ContractDestroyedEventIndex, (event) => {
+function subscribeContractDestroyedEvent(options, fromCount) {
+    return subscribeEventsFromContract(options, exports.DestroyContractEventAddress, Contract.ContractDestroyedEventIndex, (event) => {
         return {
             ...decodeContractDestroyedEvent(event),
-            contractAddress: instance.address
+            contractAddress: exports.DestroyContractEventAddress
         };
     }, fromCount);
 }
@@ -1010,27 +1017,12 @@ function subscribeContractEvent(contract, instance, options, eventName, fromCoun
     return subscribeEventsFromContract(options, instance.address, eventIndex, (event) => decodeEvent(contract, instance, event, eventIndex), fromCount);
 }
 exports.subscribeContractEvent = subscribeContractEvent;
-function subscribeAllEvents(contract, instance, options, fromCount) {
+function subscribeContractEvents(contract, instance, options, fromCount) {
     const messageCallback = (event) => {
-        switch (event.eventIndex) {
-            case Contract.ContractCreatedEventIndex: {
-                return options.messageCallback({
-                    ...decodeContractCreatedEvent(event),
-                    contractAddress: instance.address
-                });
-            }
-            case Contract.ContractDestroyedEventIndex: {
-                return options.messageCallback({
-                    ...decodeContractDestroyedEvent(event),
-                    contractAddress: instance.address
-                });
-            }
-            default:
-                return options.messageCallback({
-                    ...decodeEvent(contract, instance, event, event.eventIndex),
-                    contractAddress: instance.address
-                });
-        }
+        return options.messageCallback({
+            ...decodeEvent(contract, instance, event, event.eventIndex),
+            contractAddress: instance.address
+        });
     };
     const errorCallback = (err, subscription) => {
         return options.errorCallback(err, subscription);
@@ -1042,7 +1034,7 @@ function subscribeAllEvents(contract, instance, options, fromCount) {
     };
     return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
 }
-exports.subscribeAllEvents = subscribeAllEvents;
+exports.subscribeContractEvents = subscribeContractEvents;
 async function callMethod(contract, instance, methodName, params) {
     const methodIndex = contract.contract.getMethodIndex(methodName);
     const txId = params?.txId ?? randomTxId();
@@ -1052,3 +1044,14 @@ async function callMethod(contract, instance, methodName, params) {
     return callResult;
 }
 exports.callMethod = callMethod;
+async function getContractEventsCurrentCount(contractAddress) {
+    return (0, global_1.getCurrentNodeProvider)()
+        .events.getEventsContractContractaddressCurrentCount(contractAddress)
+        .catch((error) => {
+        if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
+            return 0;
+        }
+        throw error;
+    });
+}
+exports.getContractEventsCurrentCount = getContractEventsCurrentCount;

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

@@ -1,6 +1,6 @@
 import { ExplorerProvider, NodeProvider } from '../api';
 import { node } from '../api';
-import { Account, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, KeyType } from './types';
+import { Account, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, KeyType, MessageHasher } from './types';
 export declare abstract class SignerProvider {
     abstract get nodeProvider(): NodeProvider | undefined;
     abstract get explorerProvider(): ExplorerProvider | undefined;
@@ -52,7 +52,9 @@ export declare abstract class SignerProviderWithCachedAccounts<T extends Account
     getAccounts(): Promise<T[]>;
     getAccount(address: string): Promise<T>;
 }
-export declare function verifySignedMessage(message: string, publicKey: string, signature: string, keyType?: KeyType): boolean;
+export declare function extendMessage(message: string): string;
+export declare function hashMessage(message: string, hasher: MessageHasher): string;
+export declare function verifySignedMessage(message: string, messageHasher: MessageHasher, publicKey: string, signature: string, keyType?: KeyType): boolean;
 export declare function toApiDestination(data: Destination): node.Destination;
 export declare function toApiDestinations(data: Destination[]): node.Destination[];
 export declare function fromApiDestination(data: node.Destination): Destination;

package/dist/src/signer/signer.js

@@ -43,7 +43,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.SignerProviderWithCachedAccounts = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = exports.InteractiveSignerProvider = exports.SignerProvider = void 0;
+exports.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.hashMessage = exports.extendMessage = exports.SignerProviderWithCachedAccounts = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = exports.InteractiveSignerProvider = exports.SignerProvider = void 0;
+const buffer_1 = require("buffer/");
+const crypto_1 = require("crypto");
 const api_1 = require("../api");
 const utils = __importStar(require("../utils"));
 const blakejs_1 = __importDefault(require("blakejs"));
@@ -135,9 +137,8 @@ class SignerProviderSimple extends SignerProvider {
         return { signature, ...response };
     }
     async signMessage(params) {
-        const extendedMessage = extendMessage(params.message);
-        const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
-        const signature = await this.signRaw(params.signerAddress, utils.binToHex(messageHash));
+        const messageHash = hashMessage(params.message, params.messageHasher);
+        const signature = await this.signRaw(params.signerAddress, messageHash);
         return { signature: signature };
     }
 }
@@ -198,10 +199,27 @@ exports.SignerProviderWithCachedAccounts = SignerProviderWithCachedAccounts;
 function extendMessage(message) {
     return 'Alephium Signed Message: ' + message;
 }
-function verifySignedMessage(message, publicKey, signature, keyType) {
-    const extendedMessage = extendMessage(message);
-    const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
-    return utils.verifySignature(utils.binToHex(messageHash), publicKey, signature, keyType);
+exports.extendMessage = extendMessage;
+function hashMessage(message, hasher) {
+    switch (hasher) {
+        case 'alephium':
+            return utils.binToHex(blakejs_1.default.blake2b(extendMessage(message), undefined, 32));
+        case 'sha256':
+            const sha256 = (0, crypto_1.createHash)('sha256');
+            sha256.update(buffer_1.Buffer.from(message));
+            return utils.binToHex(sha256.digest());
+        case 'blake2b':
+            return utils.binToHex(blakejs_1.default.blake2b(message, undefined, 32));
+        case 'identity':
+            return message;
+        default:
+            throw Error(`Invalid message hasher: ${hasher}`);
+    }
+}
+exports.hashMessage = hashMessage;
+function verifySignedMessage(message, messageHasher, publicKey, signature, keyType) {
+    const messageHash = hashMessage(message, messageHasher);
+    return utils.verifySignature(messageHash, publicKey, signature, keyType);
 }
 exports.verifySignedMessage = verifySignedMessage;
 function toApiDestination(data) {

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

@@ -88,10 +88,12 @@ export interface SignUnsignedTxResult {
     gasAmount: number;
     gasPrice: Number256;
 }
+export declare type MessageHasher = 'alephium' | 'sha256' | 'blake2b' | 'identity';
 export interface SignMessageParams {
     signerAddress: string;
     signerKeyType?: KeyType;
     message: string;
+    messageHasher: MessageHasher;
 }
 export interface SignMessageResult {
     signature: string;

package/package.json

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

package/src/contract/contract.ts

@@ -53,7 +53,8 @@ import {
   assertType,
   Eq,
   Optional,
-  groupOfAddress
+  groupOfAddress,
+  addressFromContractId
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
@@ -1360,6 +1361,15 @@ export interface CallContractResult<R> {
   events: ContractEvent[]
 }
 
+function specialContractAddress(n: number): string {
+  const bytes = new Uint8Array(32).fill(0)
+  bytes[31] = n
+  return addressFromContractId(binToHex(bytes))
+}
+
+export const CreateContractEventAddress = specialContractAddress(-1)
+export const DestroyContractEventAddress = specialContractAddress(-2)
+
 export interface SystemEventSig extends EventSig {
   optionalFieldNames?: string[]
   optionalFieldTypes?: string[]
@@ -1472,18 +1482,17 @@ export async function fetchContractState<F extends Fields, I extends ContractIns
 }
 
 export function subscribeContractCreatedEvent(
-  instance: ContractInstance,
   options: SubscribeOptions<ContractCreatedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
     options,
-    instance.address,
+    CreateContractEventAddress,
     Contract.ContractCreatedEventIndex,
     (event) => {
       return {
         ...decodeContractCreatedEvent(event),
-        contractAddress: instance.address
+        contractAddress: CreateContractEventAddress
       }
     },
     fromCount
@@ -1491,18 +1500,17 @@ export function subscribeContractCreatedEvent(
 }
 
 export function subscribeContractDestroyedEvent(
-  instance: ContractInstance,
   options: SubscribeOptions<ContractDestroyedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
     options,
-    instance.address,
+    DestroyContractEventAddress,
     Contract.ContractDestroyedEventIndex,
     (event) => {
       return {
         ...decodeContractDestroyedEvent(event),
-        contractAddress: instance.address
+        contractAddress: DestroyContractEventAddress
       }
     },
     fromCount
@@ -1552,34 +1560,17 @@ export function subscribeContractEvent<F extends Fields, M extends ContractEvent
   )
 }
 
-export function subscribeAllEvents(
+export function subscribeContractEvents(
   contract: Contract,
   instance: ContractInstance,
   options: SubscribeOptions<ContractEvent<any>>,
   fromCount?: number
 ): EventSubscription {
   const messageCallback = (event: node.ContractEvent): Promise<void> => {
-    switch (event.eventIndex) {
-      case Contract.ContractCreatedEventIndex: {
-        return options.messageCallback({
-          ...decodeContractCreatedEvent(event),
-          contractAddress: instance.address
-        })
-      }
-
-      case Contract.ContractDestroyedEventIndex: {
-        return options.messageCallback({
-          ...decodeContractDestroyedEvent(event),
-          contractAddress: instance.address
-        })
-      }
-
-      default:
-        return options.messageCallback({
-          ...decodeEvent(contract, instance, event, event.eventIndex),
-          contractAddress: instance.address
-        })
-    }
+    return options.messageCallback({
+      ...decodeEvent(contract, instance, event, event.eventIndex),
+      contractAddress: instance.address
+    })
   }
   const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
     return options.errorCallback(err, subscription as unknown as Subscription<ContractEvent<any>>)
@@ -1610,3 +1601,14 @@ export async function callMethod<I, F extends Fields, A extends Arguments, R>(
   const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex)
   return callResult as CallContractResult<R>
 }
+
+export async function getContractEventsCurrentCount(contractAddress: Address): Promise<number> {
+  return getCurrentNodeProvider()
+    .events.getEventsContractContractaddressCurrentCount(contractAddress)
+    .catch((error) => {
+      if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
+        return 0
+      }
+      throw error
+    })
+}

package/src/signer/signer.ts

@@ -16,6 +16,8 @@ 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/>.
 */
 
+import { Buffer } from 'buffer/'
+import { createHash } from 'crypto'
 import { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, toApiTokens } from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
@@ -38,7 +40,8 @@ import {
   SignUnsignedTxResult,
   SubmissionResult,
   SubmitTransactionParams,
-  KeyType
+  KeyType,
+  MessageHasher
 } from './types'
 import { TransactionBuilder } from './tx-builder'
 import { addressFromPublicKey, groupOfAddress } from '../utils'
@@ -176,9 +179,8 @@ export abstract class SignerProviderSimple extends SignerProvider {
   }
 
   async signMessage(params: SignMessageParams): Promise<SignMessageResult> {
-    const extendedMessage = extendMessage(params.message)
-    const messageHash = blake.blake2b(extendedMessage, undefined, 32)
-    const signature = await this.signRaw(params.signerAddress, utils.binToHex(messageHash))
+    const messageHash = hashMessage(params.message, params.messageHasher)
+    const signature = await this.signRaw(params.signerAddress, messageHash)
     return { signature: signature }
   }
 
@@ -242,14 +244,36 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   }
 }
 
-function extendMessage(message: string): string {
+export function extendMessage(message: string): string {
   return 'Alephium Signed Message: ' + message
 }
 
-export function verifySignedMessage(message: string, publicKey: string, signature: string, keyType?: KeyType): boolean {
-  const extendedMessage = extendMessage(message)
-  const messageHash = blake.blake2b(extendedMessage, undefined, 32)
-  return utils.verifySignature(utils.binToHex(messageHash), publicKey, signature, keyType)
+export function hashMessage(message: string, hasher: MessageHasher): string {
+  switch (hasher) {
+    case 'alephium':
+      return utils.binToHex(blake.blake2b(extendMessage(message), undefined, 32))
+    case 'sha256':
+      const sha256 = createHash('sha256')
+      sha256.update(Buffer.from(message))
+      return utils.binToHex(sha256.digest())
+    case 'blake2b':
+      return utils.binToHex(blake.blake2b(message, undefined, 32))
+    case 'identity':
+      return message
+    default:
+      throw Error(`Invalid message hasher: ${hasher}`)
+  }
+}
+
+export function verifySignedMessage(
+  message: string,
+  messageHasher: MessageHasher,
+  publicKey: string,
+  signature: string,
+  keyType?: KeyType
+): boolean {
+  const messageHash = hashMessage(message, messageHasher)
+  return utils.verifySignature(messageHash, publicKey, signature, keyType)
 }
 
 export function toApiDestination(data: Destination): node.Destination {

package/src/signer/types.ts

@@ -136,12 +136,19 @@ export interface SignUnsignedTxResult {
 }
 assertType<Eq<SignUnsignedTxResult, SignTransferTxResult>>
 
+export type MessageHasher =
+  | 'alephium' // Message is prefixed with 'Alephium signed message: ' before hashed with blake2b
+  | 'sha256'
+  | 'blake2b'
+  | 'identity' // No hash is used, the message to be 32 bytes
+
 export interface SignMessageParams {
   signerAddress: string
   signerKeyType?: KeyType
   message: string
+  messageHasher: MessageHasher
 }
-assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
+assertType<Eq<SignMessageParams, { message: string; messageHasher: MessageHasher } & SignerAddress>>()
 export interface SignMessageResult {
   signature: string
 }