@alephium/web3 0.14.6 → 0.15.0

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

@@ -49,3 +49,19 @@ export interface NFTCollectionMetaData {
     collectionUri: string;
     totalSupply: Number256;
 }
+export interface NFTTokenUriMetaData {
+    name: string;
+    description?: string;
+    image: string;
+    attributes?: [
+        {
+            trait_type: string;
+            value: string | number | boolean;
+        }
+    ];
+}
+export interface NFTCollectionUriMetaData {
+    name: string;
+    description: string;
+    image: string;
+}

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

@@ -1,7 +1,7 @@
-import { NamedVals, node, Number256, Token } from '../api';
+import { NamedVals, node, NodeProvider, Number256, Token } from '../api';
 import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
-import { SubscribeOptions, Optional } from '../utils';
-import { EventSubscription } from './events';
+import { Optional } from '../utils';
+import { EventSubscribeOptions, EventSubscription } from './events';
 export type FieldsSig = node.FieldsSig;
 export type EventSig = node.EventSig;
 export type FunctionSig = node.FunctionSig;
@@ -51,13 +51,14 @@ type CodeInfo = {
     codeHashDebug: string;
     warnings: string[];
 };
-declare class ProjectArtifact {
+export declare class ProjectArtifact {
     static readonly artifactFileName = ".project.json";
     fullNodeVersion: string;
     compilerOptionsUsed: node.CompilerOptions;
     infos: Map<string, CodeInfo>;
     static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void;
     constructor(fullNodeVersion: string, compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
+    static isCodeChanged(current: ProjectArtifact, previous: ProjectArtifact): boolean;
     saveToFile(rootPath: string): Promise<void>;
     needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean;
     static from(rootPath: string): Promise<ProjectArtifact | undefined>;
@@ -284,7 +285,7 @@ export type ContractCreatedEvent = ContractEvent<ContractCreatedEventFields>;
 export type ContractDestroyedEvent = ContractEvent<ContractDestroyedEventFields>;
 export declare function decodeContractCreatedEvent(event: node.ContractEvent): Omit<ContractCreatedEvent, 'contractAddress'>;
 export declare function decodeContractDestroyedEvent(event: node.ContractEvent): Omit<ContractDestroyedEvent, 'contractAddress'>;
-export declare function subscribeEventsFromContract<T extends Fields, M extends ContractEvent<T>>(options: SubscribeOptions<M>, address: string, eventIndex: number, decodeFunc: (event: node.ContractEvent) => M, fromCount?: number): EventSubscription;
+export declare function subscribeEventsFromContract<T extends Fields, M extends ContractEvent<T>>(options: EventSubscribeOptions<M>, address: string, eventIndex: number, decodeFunc: (event: node.ContractEvent) => M, fromCount?: number): EventSubscription;
 export declare function addStdIdToFields<F extends Fields>(contract: Contract, fields: F): F | (F & {
     __stdInterfaceId: HexString;
 });
@@ -296,12 +297,14 @@ 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(options: SubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
-export declare function subscribeContractDestroyedEvent(options: SubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractCreatedEvent(options: EventSubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractDestroyedEvent(options: EventSubscribeOptions<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 subscribeContractEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
+export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
+export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
 export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
 export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
 export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
+export declare const getContractIdFromTxId: (nodeProvider: NodeProvider, txId: string, groupIndex: number) => Promise<HexString>;
+export declare const getTokenIdFromTxId: (nodeProvider: NodeProvider, txId: string, groupIndex: number) => Promise<HexString>;
 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.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
+exports.getTokenIdFromTxId = exports.getContractIdFromTxId = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.ProjectArtifact = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
 const buffer_1 = require("buffer/");
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
@@ -54,6 +54,7 @@ const global_1 = require("../global");
 const path = __importStar(require("path"));
 const events_1 = require("./events");
 const constants_1 = require("../constants");
+const blake = __importStar(require("blakejs"));
 const crypto = new utils_1.WebCrypto();
 exports.StdIdFieldName = '__stdInterfaceId';
 var SourceKind;
@@ -140,6 +141,18 @@ class ProjectArtifact {
         this.compilerOptionsUsed = compilerOptionsUsed;
         this.infos = infos;
     }
+    static isCodeChanged(current, previous) {
+        if (current.infos.size !== previous.infos.size) {
+            return true;
+        }
+        for (const [name, codeInfo] of current.infos) {
+            const prevCodeInfo = previous.infos.get(name);
+            if (prevCodeInfo?.codeHashDebug !== codeInfo.codeHashDebug) {
+                return true;
+            }
+        }
+        return false;
+    }
     async saveToFile(rootPath) {
         const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
         const artifact = {
@@ -192,6 +205,7 @@ class ProjectArtifact {
         }
     }
 }
+exports.ProjectArtifact = ProjectArtifact;
 ProjectArtifact.artifactFileName = '.project.json';
 class Project {
     static buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions) {
@@ -1002,7 +1016,8 @@ function subscribeEventsFromContract(options, address, eventIndex, decodeFunc, f
     const opt = {
         pollingInterval: options.pollingInterval,
         messageCallback: messageCallback,
-        errorCallback: errorCallback
+        errorCallback: errorCallback,
+        onEventCountChanged: options.onEventCountChanged
     };
     return (0, events_1.subscribeToEvents)(opt, address, fromCount);
 }
@@ -1103,7 +1118,8 @@ function subscribeContractEvents(contract, instance, options, fromCount) {
     const opt = {
         pollingInterval: options.pollingInterval,
         messageCallback: messageCallback,
-        errorCallback: errorCallback
+        errorCallback: errorCallback,
+        onEventCountChanged: options.onEventCountChanged
     };
     return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
 }
@@ -1147,3 +1163,17 @@ async function getContractEventsCurrentCount(contractAddress) {
     });
 }
 exports.getContractEventsCurrentCount = getContractEventsCurrentCount;
+// This function only works in the simple case where a single non-subcontract is created in the tx
+const getContractIdFromTxId = async (nodeProvider, txId, groupIndex) => {
+    const txDetails = await nodeProvider.transactions.getTransactionsDetailsTxid(txId, {
+        fromGroup: groupIndex,
+        toGroup: groupIndex
+    });
+    const outputIndex = txDetails.unsigned.fixedOutputs.length;
+    const hex = txId + outputIndex.toString(16).padStart(8, '0');
+    const hashHex = (0, utils_1.binToHex)(blake.blake2b((0, utils_1.hexToBinUnsafe)(hex), undefined, 32));
+    return hashHex.slice(0, 62) + groupIndex.toString(16).padStart(2, '0');
+};
+exports.getContractIdFromTxId = getContractIdFromTxId;
+// This function only works in the simple case where a single non-subcontract is created in the tx
+exports.getTokenIdFromTxId = exports.getContractIdFromTxId;

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

@@ -1,11 +1,15 @@
 import { node } from '../api';
 import { Subscription, SubscribeOptions } from '../utils';
+export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
+    onEventCountChanged?: (eventCount: number) => Promise<void>;
+}
 export declare class EventSubscription extends Subscription<node.ContractEvent> {
     readonly contractAddress: string;
     private fromCount;
-    constructor(options: SubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number);
+    private onEventCountChanged?;
+    constructor(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number);
     startPolling(): void;
     currentEventCount(): number;
     polling(): Promise<void>;
 }
-export declare function subscribeToEvents(options: SubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number): EventSubscription;
+export declare function subscribeToEvents(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number): EventSubscription;

package/dist/src/contract/events.js

@@ -25,6 +25,7 @@ class EventSubscription extends utils_1.Subscription {
         super(options);
         this.contractAddress = contractAddress;
         this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount;
+        this.onEventCountChanged = options.onEventCountChanged;
         this.startPolling();
     }
     startPolling() {
@@ -51,6 +52,9 @@ class EventSubscription extends utils_1.Subscription {
             const promises = events.events.map((event) => this.messageCallback(event));
             await Promise.all(promises);
             this.fromCount = events.nextStart;
+            if (this.onEventCountChanged !== undefined) {
+                await this.onEventCountChanged(this.fromCount);
+            }
             await this.polling();
         }
         catch (err) {

package/dist/src/token/nft.d.ts

@@ -1,24 +1,9 @@
 import 'cross-fetch/polyfill';
-export interface NFTMetadata {
-    name: string;
-    description?: string;
-    image: string;
-    attributes?: [
-        {
-            trait_type: string;
-            value: string | number | boolean;
-        }
-    ];
-}
-export interface NFTCollectionMetadata {
-    name: string;
-    description: string;
-    image: string;
-}
-export declare const validNFTMetadataFields: string[];
-export declare const validNFTMetadataAttributesFields: string[];
-export declare const validNFTMetadataAttributeTypes: string[];
-export declare const validNFTCollectionMetadataFields: string[];
-export declare function validateNFTMetadata(metadata: any): NFTMetadata;
-export declare function validateNFTCollectionMetadata(metadata: any): NFTCollectionMetadata;
-export declare function validateEnumerableNFTBaseUri(nftBaseUri: string, maxSupply: number): Promise<NFTMetadata[]>;
+import { NFTCollectionUriMetaData, NFTTokenUriMetaData } from '../api';
+export declare const validNFTTokenUriMetaDataFields: string[];
+export declare const validNFTTokenUriMetaDataAttributesFields: string[];
+export declare const validNFTUriMetaDataAttributeTypes: string[];
+export declare const validNFTCollectionUriMetaDataFields: string[];
+export declare function validateNFTTokenUriMetaData(metadata: any): NFTTokenUriMetaData;
+export declare function validateNFTCollectionUriMetaData(metadata: any): NFTCollectionUriMetaData;
+export declare function validateNFTBaseUri(nftBaseUri: string, maxSupply: number): Promise<NFTTokenUriMetaData[]>;

package/dist/src/token/nft.js

@@ -17,31 +17,31 @@ 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.validateEnumerableNFTBaseUri = exports.validateNFTCollectionMetadata = exports.validateNFTMetadata = exports.validNFTCollectionMetadataFields = exports.validNFTMetadataAttributeTypes = exports.validNFTMetadataAttributesFields = exports.validNFTMetadataFields = void 0;
+exports.validateNFTBaseUri = exports.validateNFTCollectionUriMetaData = exports.validateNFTTokenUriMetaData = exports.validNFTCollectionUriMetaDataFields = exports.validNFTUriMetaDataAttributeTypes = exports.validNFTTokenUriMetaDataAttributesFields = exports.validNFTTokenUriMetaDataFields = void 0;
 // JSON Schema for the NFT metadata, which is pointed to by the value
 // returned from the `getTokenUri` method of the NFT contract
 require("cross-fetch/polyfill");
-exports.validNFTMetadataFields = ['name', 'description', 'image', 'attributes'];
-exports.validNFTMetadataAttributesFields = ['trait_type', 'value'];
-exports.validNFTMetadataAttributeTypes = ['string', 'number', 'boolean'];
-exports.validNFTCollectionMetadataFields = ['name', 'description', 'image'];
-function validateNFTMetadata(metadata) {
+exports.validNFTTokenUriMetaDataFields = ['name', 'description', 'image', 'attributes'];
+exports.validNFTTokenUriMetaDataAttributesFields = ['trait_type', 'value'];
+exports.validNFTUriMetaDataAttributeTypes = ['string', 'number', 'boolean'];
+exports.validNFTCollectionUriMetaDataFields = ['name', 'description', 'image'];
+function validateNFTTokenUriMetaData(metadata) {
     Object.keys(metadata).forEach((key) => {
-        if (!exports.validNFTMetadataFields.includes(key)) {
-            throw new Error(`Invalid field ${key}, only ${exports.validNFTMetadataFields} are allowed`);
+        if (!exports.validNFTTokenUriMetaDataFields.includes(key)) {
+            throw new Error(`Invalid field ${key}, only ${exports.validNFTTokenUriMetaDataFields} are allowed`);
         }
     });
     const name = validateNonEmptyString(metadata, 'name');
     const description = validateNonEmptyStringIfExists(metadata, 'description');
     const image = validateNonEmptyString(metadata, 'image');
-    const attributes = validateNFTMetadataAttributes(metadata['attributes']);
+    const attributes = validateNFTTokenUriMetaDataAttributes(metadata['attributes']);
     return { name, description, image, attributes };
 }
-exports.validateNFTMetadata = validateNFTMetadata;
-function validateNFTCollectionMetadata(metadata) {
+exports.validateNFTTokenUriMetaData = validateNFTTokenUriMetaData;
+function validateNFTCollectionUriMetaData(metadata) {
     Object.keys(metadata).forEach((key) => {
-        if (!exports.validNFTCollectionMetadataFields.includes(key)) {
-            throw new Error(`Invalid field ${key}, only ${exports.validNFTCollectionMetadataFields} are allowed`);
+        if (!exports.validNFTCollectionUriMetaDataFields.includes(key)) {
+            throw new Error(`Invalid field ${key}, only ${exports.validNFTCollectionUriMetaDataFields} are allowed`);
         }
     });
     const name = validateNonEmptyString(metadata, 'name');
@@ -49,13 +49,13 @@ function validateNFTCollectionMetadata(metadata) {
     const image = validateNonEmptyString(metadata, 'image');
     return { name, description, image };
 }
-exports.validateNFTCollectionMetadata = validateNFTCollectionMetadata;
-async function validateEnumerableNFTBaseUri(nftBaseUri, maxSupply) {
+exports.validateNFTCollectionUriMetaData = validateNFTCollectionUriMetaData;
+async function validateNFTBaseUri(nftBaseUri, maxSupply) {
     if (isInteger(maxSupply) && maxSupply > 0) {
         const nftMetadataz = [];
         for (let i = 0; i < maxSupply; i++) {
             const nftMetadata = await fetchNFTMetadata(nftBaseUri, i);
-            const validatedNFTMetadata = validateNFTMetadata(nftMetadata);
+            const validatedNFTMetadata = validateNFTTokenUriMetaData(nftMetadata);
             nftMetadataz.push(validatedNFTMetadata);
         }
         return nftMetadataz;
@@ -64,8 +64,8 @@ async function validateEnumerableNFTBaseUri(nftBaseUri, maxSupply) {
         throw new Error('maxSupply should be a positive integer');
     }
 }
-exports.validateEnumerableNFTBaseUri = validateEnumerableNFTBaseUri;
-function validateNFTMetadataAttributes(attributes) {
+exports.validateNFTBaseUri = validateNFTBaseUri;
+function validateNFTTokenUriMetaDataAttributes(attributes) {
     if (!!attributes) {
         if (!Array.isArray(attributes)) {
             throw new Error(`Field 'attributes' should be an array`);
@@ -75,8 +75,8 @@ function validateNFTMetadataAttributes(attributes) {
                 throw new Error(`Field 'attributes' should be an array of objects`);
             }
             Object.keys(item).forEach((key) => {
-                if (!exports.validNFTMetadataAttributesFields.includes(key)) {
-                    throw new Error(`Invalid field ${key} for attributes, only ${exports.validNFTMetadataAttributesFields} are allowed`);
+                if (!exports.validNFTTokenUriMetaDataAttributesFields.includes(key)) {
+                    throw new Error(`Invalid field ${key} for attributes, only ${exports.validNFTTokenUriMetaDataAttributesFields} are allowed`);
                 }
             });
             validateNonEmptyString(item, 'trait_type');

package/dist/src/transaction/status.d.ts

@@ -5,7 +5,8 @@ export declare class TxStatusSubscription extends Subscription<TxStatus> {
     readonly txId: string;
     readonly fromGroup?: number;
     readonly toGroup?: number;
-    constructor(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number);
+    readonly confirmations: number;
+    constructor(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number, confirmations?: number);
     polling(): Promise<void>;
 }
-export declare function subscribeToTxStatus(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number): TxStatusSubscription;
+export declare function subscribeToTxStatus(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number, confirmations?: number): TxStatusSubscription;

package/dist/src/transaction/status.js

@@ -21,11 +21,12 @@ exports.subscribeToTxStatus = exports.TxStatusSubscription = void 0;
 const __1 = require("..");
 const utils_1 = require("../utils");
 class TxStatusSubscription extends utils_1.Subscription {
-    constructor(options, txId, fromGroup, toGroup) {
+    constructor(options, txId, fromGroup, toGroup, confirmations) {
         super(options);
         this.txId = txId;
         this.fromGroup = fromGroup;
         this.toGroup = toGroup;
+        this.confirmations = confirmations ?? 1;
         this.startPolling();
     }
     async polling() {
@@ -36,6 +37,9 @@ class TxStatusSubscription extends utils_1.Subscription {
                 toGroup: this.toGroup
             });
             await this.messageCallback(txStatus);
+            if (txStatus.type === 'Confirmed' && txStatus.chainConfirmations >= this.confirmations) {
+                this.unsubscribe();
+            }
         }
         catch (err) {
             await this.errorCallback(err, this);
@@ -43,7 +47,7 @@ class TxStatusSubscription extends utils_1.Subscription {
     }
 }
 exports.TxStatusSubscription = TxStatusSubscription;
-function subscribeToTxStatus(options, txId, fromGroup, toGroup) {
-    return new TxStatusSubscription(options, txId, fromGroup, toGroup);
+function subscribeToTxStatus(options, txId, fromGroup, toGroup, confirmations) {
+    return new TxStatusSubscription(options, txId, fromGroup, toGroup, confirmations);
 }
 exports.subscribeToTxStatus = subscribeToTxStatus;

package/dist/src/utils/subscription.d.ts

@@ -16,6 +16,7 @@ export declare abstract class Subscription<Message> {
     constructor(options: SubscribeOptions<Message>);
     startPolling(): void;
     unsubscribe(): void;
+    isCancelled(): boolean;
     abstract polling(): Promise<void>;
 }
 export {};

package/dist/src/utils/subscription.js

@@ -47,5 +47,8 @@ class Subscription {
             clearTimeout(this.task);
         }
     }
+    isCancelled() {
+        return this.cancelled;
+    }
 }
 exports.Subscription = Subscription;

package/package.json

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

package/src/api/types.ts

@@ -286,3 +286,21 @@ export interface NFTCollectionMetaData {
   collectionUri: string
   totalSupply: Number256
 }
+
+export interface NFTTokenUriMetaData {
+  name: string
+  description?: string
+  image: string
+  attributes?: [
+    {
+      trait_type: string
+      value: string | number | boolean
+    }
+  ]
+}
+
+export interface NFTCollectionUriMetaData {
+  name: string
+  description: string
+  image: string
+}

package/src/contract/contract.ts

@@ -47,19 +47,20 @@ import {
   bs58,
   binToHex,
   contractIdFromAddress,
-  SubscribeOptions,
   Subscription,
   assertType,
   Eq,
   Optional,
   groupOfAddress,
   addressFromContractId,
-  WebCrypto
+  WebCrypto,
+  hexToBinUnsafe
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
-import { EventSubscription, subscribeToEvents } from './events'
+import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { ONE_ALPH } from '../constants'
+import * as blake from 'blakejs'
 
 const crypto = new WebCrypto()
 
@@ -187,7 +188,7 @@ type CodeInfo = {
   warnings: string[]
 }
 
-class ProjectArtifact {
+export class ProjectArtifact {
   static readonly artifactFileName = '.project.json'
 
   fullNodeVersion: string
@@ -212,6 +213,19 @@ class ProjectArtifact {
     this.infos = infos
   }
 
+  static isCodeChanged(current: ProjectArtifact, previous: ProjectArtifact): boolean {
+    if (current.infos.size !== previous.infos.size) {
+      return true
+    }
+    for (const [name, codeInfo] of current.infos) {
+      const prevCodeInfo = previous.infos.get(name)
+      if (prevCodeInfo?.codeHashDebug !== codeInfo.codeHashDebug) {
+        return true
+      }
+    }
+    return false
+  }
+
   async saveToFile(rootPath: string): Promise<void> {
     const filepath = path.join(rootPath, ProjectArtifact.artifactFileName)
     const artifact = {
@@ -1527,7 +1541,7 @@ export function decodeContractDestroyedEvent(
 }
 
 export function subscribeEventsFromContract<T extends Fields, M extends ContractEvent<T>>(
-  options: SubscribeOptions<M>,
+  options: EventSubscribeOptions<M>,
   address: string,
   eventIndex: number,
   decodeFunc: (event: node.ContractEvent) => M,
@@ -1543,10 +1557,11 @@ export function subscribeEventsFromContract<T extends Fields, M extends Contract
   const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
     return options.errorCallback(err, subscription as unknown as Subscription<M>)
   }
-  const opt: SubscribeOptions<node.ContractEvent> = {
+  const opt: EventSubscribeOptions<node.ContractEvent> = {
     pollingInterval: options.pollingInterval,
     messageCallback: messageCallback,
-    errorCallback: errorCallback
+    errorCallback: errorCallback,
+    onEventCountChanged: options.onEventCountChanged
   }
   return subscribeToEvents(opt, address, fromCount)
 }
@@ -1607,7 +1622,7 @@ export async function fetchContractState<F extends Fields, I extends ContractIns
 }
 
 export function subscribeContractCreatedEvent(
-  options: SubscribeOptions<ContractCreatedEvent>,
+  options: EventSubscribeOptions<ContractCreatedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
@@ -1625,7 +1640,7 @@ export function subscribeContractCreatedEvent(
 }
 
 export function subscribeContractDestroyedEvent(
-  options: SubscribeOptions<ContractDestroyedEvent>,
+  options: EventSubscribeOptions<ContractDestroyedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
@@ -1671,7 +1686,7 @@ export function decodeEvent<F extends Fields, M extends ContractEvent<F>>(
 export function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(
   contract: Contract,
   instance: ContractInstance,
-  options: SubscribeOptions<M>,
+  options: EventSubscribeOptions<M>,
   eventName: string,
   fromCount?: number
 ): EventSubscription {
@@ -1688,7 +1703,7 @@ export function subscribeContractEvent<F extends Fields, M extends ContractEvent
 export function subscribeContractEvents(
   contract: Contract,
   instance: ContractInstance,
-  options: SubscribeOptions<ContractEvent<any>>,
+  options: EventSubscribeOptions<ContractEvent<any>>,
   fromCount?: number
 ): EventSubscription {
   const messageCallback = (event: node.ContractEvent): Promise<void> => {
@@ -1700,10 +1715,11 @@ export function subscribeContractEvents(
   const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
     return options.errorCallback(err, subscription as unknown as Subscription<ContractEvent<any>>)
   }
-  const opt: SubscribeOptions<node.ContractEvent> = {
+  const opt: EventSubscribeOptions<node.ContractEvent> = {
     pollingInterval: options.pollingInterval,
     messageCallback: messageCallback,
-    errorCallback: errorCallback
+    errorCallback: errorCallback,
+    onEventCountChanged: options.onEventCountChanged
   }
   return subscribeToEvents(opt, instance.address, fromCount)
 }
@@ -1772,3 +1788,22 @@ export async function getContractEventsCurrentCount(contractAddress: Address): P
       throw error
     })
 }
+
+// This function only works in the simple case where a single non-subcontract is created in the tx
+export const getContractIdFromTxId = async (
+  nodeProvider: NodeProvider,
+  txId: string,
+  groupIndex: number
+): Promise<HexString> => {
+  const txDetails = await nodeProvider.transactions.getTransactionsDetailsTxid(txId, {
+    fromGroup: groupIndex,
+    toGroup: groupIndex
+  })
+  const outputIndex = txDetails.unsigned.fixedOutputs.length
+  const hex = txId + outputIndex.toString(16).padStart(8, '0')
+  const hashHex = binToHex(blake.blake2b(hexToBinUnsafe(hex), undefined, 32))
+  return hashHex.slice(0, 62) + groupIndex.toString(16).padStart(2, '0')
+}
+
+// This function only works in the simple case where a single non-subcontract is created in the tx
+export const getTokenIdFromTxId = getContractIdFromTxId

package/src/contract/events.ts

@@ -20,14 +20,20 @@ import { web3 } from '..'
 import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
+export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
+  onEventCountChanged?: (eventCount: number) => Promise<void>
+}
+
 export class EventSubscription extends Subscription<node.ContractEvent> {
   readonly contractAddress: string
   private fromCount: number
+  private onEventCountChanged?: (eventCount: number) => Promise<void>
 
-  constructor(options: SubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
+  constructor(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
     super(options)
     this.contractAddress = contractAddress
     this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
+    this.onEventCountChanged = options.onEventCountChanged
 
     this.startPolling()
   }
@@ -60,6 +66,11 @@ export class EventSubscription extends Subscription<node.ContractEvent> {
       const promises = events.events.map((event) => this.messageCallback(event))
       await Promise.all(promises)
       this.fromCount = events.nextStart
+
+      if (this.onEventCountChanged !== undefined) {
+        await this.onEventCountChanged(this.fromCount)
+      }
+
       await this.polling()
     } catch (err) {
       await this.errorCallback(err, this)
@@ -68,7 +79,7 @@ export class EventSubscription extends Subscription<node.ContractEvent> {
 }
 
 export function subscribeToEvents(
-  options: SubscribeOptions<node.ContractEvent>,
+  options: EventSubscribeOptions<node.ContractEvent>,
   contractAddress: string,
   fromCount?: number
 ): EventSubscription {