@alephium/web3 0.5.0-rc.2 → 0.5.0-rc.21

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

@@ -1,44 +1,5 @@
-import { Api as NodeApi } from './api-alephium';
-export interface ApiRequestArguments {
-    path: string;
-    method: string;
-    params: any[];
-}
-export declare type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>;
-export declare class NodeProvider {
-    readonly wallets: NodeApi<string>['wallets'];
-    readonly infos: NodeApi<string>['infos'];
-    readonly blockflow: NodeApi<string>['blockflow'];
-    readonly addresses: NodeApi<string>['addresses'];
-    readonly transactions: NodeApi<string>['transactions'];
-    readonly contracts: NodeApi<string>['contracts'];
-    readonly multisig: NodeApi<string>['multisig'];
-    readonly utils: NodeApi<string>['utils'];
-    readonly miners: NodeApi<string>['miners'];
-    readonly events: NodeApi<string>['events'];
-    constructor(baseUrl: string, apiKey?: string);
-    constructor(provider: NodeProvider);
-    constructor(handler: ApiRequestHandler);
-    request: (args: ApiRequestArguments) => Promise<any>;
-    static Proxy(nodeProvider: NodeProvider): NodeProvider;
-    static Remote(handler: ApiRequestHandler): NodeProvider;
-}
-export declare class ExplorerProvider {
-    readonly blocks: any;
-    readonly transactions: any;
-    readonly addresses: any;
-    readonly infos: any;
-    readonly unconfirmedTransactions: any;
-    readonly tokens: any;
-    readonly charts: any;
-    readonly utils: any;
-    constructor(baseUrl: string, apiKey?: string);
-    constructor(provider: ExplorerProvider);
-    constructor(handler: ApiRequestHandler);
-    request: (args: ApiRequestArguments) => Promise<any>;
-    static Proxy(explorerProvider: ExplorerProvider): ExplorerProvider;
-    static Remote(handler: ApiRequestHandler): ExplorerProvider;
-}
+export * from './node-provider';
+export * from './explorer-provider';
 export * as node from './api-alephium';
 export * as explorer from './api-explorer';
 export * from './types';

package/dist/src/api/index.js

@@ -32,6 +32,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+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);
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -39,123 +42,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 });
-exports.explorer = exports.node = exports.ExplorerProvider = exports.NodeProvider = void 0;
-const api_alephium_1 = require("./api-alephium");
-const api_explorer_1 = require("./api-explorer");
-function forwardRequests(api, handler) {
-    // Update class properties to forward requests
-    for (const [path, pathObject] of Object.entries(api)) {
-        for (const method of Object.keys(pathObject)) {
-            pathObject[`${method}`] = async (...params) => {
-                return handler({ path, method, params });
-            };
-        }
-    }
-}
-async function request(provider, args) {
-    const call = provider[`${args.path}`][`${args.method}`];
-    return call(...args.params);
-}
-function initializeNodeApi(baseUrl, apiKey) {
-    const nodeApi = new api_alephium_1.Api({
-        baseUrl: baseUrl,
-        baseApiParams: { secure: true },
-        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-    });
-    nodeApi.setSecurityData(apiKey ?? null);
-    return nodeApi;
-}
-class NodeProvider {
-    constructor(param0, apiKey) {
-        this.request = (args) => {
-            return request(this, args);
-        };
-        let nodeApi;
-        if (typeof param0 === 'string') {
-            nodeApi = initializeNodeApi(param0, apiKey);
-        }
-        else if (typeof param0 === 'function') {
-            nodeApi = new NodeProvider('https://1.2.3.4:0');
-            forwardRequests(nodeApi, param0);
-        }
-        else {
-            nodeApi = param0;
-        }
-        this.wallets = { ...nodeApi.wallets };
-        this.infos = { ...nodeApi.infos };
-        this.blockflow = { ...nodeApi.blockflow };
-        this.addresses = { ...nodeApi.addresses };
-        this.transactions = { ...nodeApi.transactions };
-        this.contracts = { ...nodeApi.contracts };
-        this.multisig = { ...nodeApi.multisig };
-        this.utils = { ...nodeApi.utils };
-        this.miners = { ...nodeApi.miners };
-        this.events = { ...nodeApi.events };
-    }
-    // This can prevent the proxied node provider from being modified
-    static Proxy(nodeProvider) {
-        return new NodeProvider(nodeProvider);
-    }
-    static Remote(handler) {
-        return new NodeProvider(handler);
-    }
-}
-exports.NodeProvider = NodeProvider;
-function initializeExplorerApi(baseUrl, apiKey) {
-    const explorerApi = new api_explorer_1.Api({
-        baseUrl: baseUrl,
-        baseApiParams: { secure: true },
-        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-    });
-    explorerApi.setSecurityData(apiKey ?? null);
-    return explorerApi;
-}
-class ExplorerProvider {
-    constructor(param0, apiKey) {
-        this.blocks = api_explorer_1.Api['blocks'];
-        this.transactions = api_explorer_1.Api['transactions'];
-        this.addresses = api_explorer_1.Api['addresses'];
-        this.infos = api_explorer_1.Api['infos'];
-        this.unconfirmedTransactions = api_explorer_1.Api['unconfirmedTransactions'];
-        this.tokens = api_explorer_1.Api['tokens'];
-        this.charts = api_explorer_1.Api['charts'];
-        this.utils = api_explorer_1.Api['utils'];
-        this.request = (args) => {
-            return request(this, args);
-        };
-        let explorerApi;
-        if (typeof param0 === 'string') {
-            explorerApi = initializeExplorerApi(param0, apiKey);
-        }
-        else if (typeof param0 === 'function') {
-            explorerApi = new ExplorerProvider('https://1.2.3.4:0');
-            forwardRequests(explorerApi, param0);
-        }
-        else {
-            explorerApi = param0;
-        }
-        this.blocks = { ...explorerApi.blocks };
-        this.transactions = { ...explorerApi.transactions };
-        this.addresses = { ...explorerApi.addresses };
-        this.infos = { ...explorerApi.infos };
-        this.unconfirmedTransactions = { ...explorerApi.unconfirmedTransactions };
-        this.tokens = { ...explorerApi.tokens };
-        this.charts = { ...explorerApi.charts };
-        this.utils = { ...explorerApi.utils };
-    }
-    // This can prevent the proxied explorer provider from being modified
-    static Proxy(explorerProvider) {
-        return new ExplorerProvider(explorerProvider);
-    }
-    static Remote(handler) {
-        return new ExplorerProvider(handler);
-    }
-}
-exports.ExplorerProvider = ExplorerProvider;
+exports.explorer = exports.node = void 0;
+__exportStar(require("./node-provider"), exports);
+__exportStar(require("./explorer-provider"), exports);
 exports.node = __importStar(require("./api-alephium"));
 exports.explorer = __importStar(require("./api-explorer"));
 __exportStar(require("./types"), exports);

package/dist/src/api/node-provider.d.ts

@@ -0,0 +1,21 @@
+import { ApiRequestArguments, ApiRequestHandler } from './types';
+import { Api as NodeApi } from './api-alephium';
+export declare class NodeProvider {
+    readonly wallets: NodeApi<string>['wallets'];
+    readonly infos: NodeApi<string>['infos'];
+    readonly blockflow: NodeApi<string>['blockflow'];
+    readonly addresses: NodeApi<string>['addresses'];
+    readonly transactions: NodeApi<string>['transactions'];
+    readonly mempool: NodeApi<string>['mempool'];
+    readonly contracts: NodeApi<string>['contracts'];
+    readonly multisig: NodeApi<string>['multisig'];
+    readonly utils: NodeApi<string>['utils'];
+    readonly miners: NodeApi<string>['miners'];
+    readonly events: NodeApi<string>['events'];
+    constructor(baseUrl: string, apiKey?: string);
+    constructor(provider: NodeProvider);
+    constructor(handler: ApiRequestHandler);
+    request: (args: ApiRequestArguments) => Promise<any>;
+    static Proxy(nodeProvider: NodeProvider): NodeProvider;
+    static Remote(handler: ApiRequestHandler): NodeProvider;
+}

package/dist/src/api/node-provider.js

@@ -0,0 +1,68 @@
+"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.NodeProvider = void 0;
+const types_1 = require("./types");
+const api_alephium_1 = require("./api-alephium");
+function initializeNodeApi(baseUrl, apiKey) {
+    const nodeApi = new api_alephium_1.Api({
+        baseUrl: baseUrl,
+        baseApiParams: { secure: true },
+        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+    });
+    nodeApi.setSecurityData(apiKey ?? null);
+    return nodeApi;
+}
+class NodeProvider {
+    constructor(param0, apiKey) {
+        this.request = (args) => {
+            return (0, types_1.request)(this, args);
+        };
+        let nodeApi;
+        if (typeof param0 === 'string') {
+            nodeApi = initializeNodeApi(param0, apiKey);
+        }
+        else if (typeof param0 === 'function') {
+            nodeApi = new NodeProvider('https://1.2.3.4:0');
+            (0, types_1.forwardRequests)(nodeApi, param0);
+        }
+        else {
+            nodeApi = param0;
+        }
+        this.wallets = { ...nodeApi.wallets };
+        this.infos = { ...nodeApi.infos };
+        this.blockflow = { ...nodeApi.blockflow };
+        this.addresses = { ...nodeApi.addresses };
+        this.transactions = { ...nodeApi.transactions };
+        this.mempool = { ...nodeApi.mempool };
+        this.contracts = { ...nodeApi.contracts };
+        this.multisig = { ...nodeApi.multisig };
+        this.utils = { ...nodeApi.utils };
+        this.miners = { ...nodeApi.miners };
+        this.events = { ...nodeApi.events };
+    }
+    // This can prevent the proxied node provider from being modified
+    static Proxy(nodeProvider) {
+        return new NodeProvider(nodeProvider);
+    }
+    static Remote(handler) {
+        return new NodeProvider(handler);
+    }
+}
+exports.NodeProvider = NodeProvider;

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

@@ -1,5 +1,5 @@
 import * as node from './api-alephium';
-export declare type Number256 = bigint;
+export declare type Number256 = bigint | string;
 export declare type Val = Number256 | boolean | string | Val[];
 export declare type NamedVals = Record<string, Val>;
 export interface Token {
@@ -18,7 +18,15 @@ export declare function toApiByteVec(v: Val): string;
 export declare function toApiAddress(v: Val): string;
 export declare function toApiArray(tpe: string, v: Val): node.Val;
 export declare function toApiVal(v: Val, tpe: string): node.Val;
-export declare function fromApiVals(vals: node.Val[], names: string[], types: string[]): NamedVals;
+export declare function fromApiVals(vals: node.Val[], names: string[], types: string[], optionalNames?: string[], optionalTypes?: string[]): NamedVals;
 export declare function fromApiArray(vals: node.Val[], types: string[]): Val[];
 export declare function fromApiVal(v: node.Val, tpe: string): Val;
 export declare function typeLength(tpe: string): number;
+export interface ApiRequestArguments {
+    path: string;
+    method: string;
+    params: any[];
+}
+export declare type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>;
+export declare function forwardRequests(api: Record<string, any>, handler: ApiRequestHandler): void;
+export declare function request(provider: Record<string, any>, args: ApiRequestArguments): Promise<any>;

package/dist/src/api/types.js

@@ -17,7 +17,7 @@ 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.typeLength = exports.fromApiVal = exports.fromApiArray = exports.fromApiVals = exports.toApiVal = exports.toApiArray = exports.toApiAddress = exports.toApiByteVec = exports.fromApiNumber256 = exports.toApiNumber256Optional = exports.toApiNumber256 = exports.toApiBoolean = exports.fromApiTokens = exports.fromApiToken = exports.toApiTokens = exports.toApiToken = void 0;
+exports.request = exports.forwardRequests = exports.typeLength = exports.fromApiVal = exports.fromApiArray = exports.fromApiVals = exports.toApiVal = exports.toApiArray = exports.toApiAddress = exports.toApiByteVec = exports.fromApiNumber256 = exports.toApiNumber256Optional = exports.toApiNumber256 = exports.toApiBoolean = exports.fromApiTokens = exports.fromApiToken = exports.toApiTokens = exports.toApiToken = void 0;
 const utils_1 = require("../utils");
 utils_1.assertType;
 function toApiToken(token) {
@@ -165,7 +165,7 @@ function _fromApiVal(vals, valIndex, tpe) {
         }
     }
 }
-function fromApiVals(vals, names, types) {
+function fromApiVals(vals, names, types, optionalNames = [], optionalTypes = []) {
     let valIndex = 0;
     const result = {};
     types.forEach((currentType, index) => {
@@ -174,7 +174,11 @@ function fromApiVals(vals, names, types) {
         valIndex = nextIndex;
         result[`${currentName}`] = val;
     });
-    return result;
+    if (valIndex === vals.length) {
+        return result;
+    }
+    const optionalFields = fromApiVals(vals.slice(valIndex), optionalNames, optionalTypes);
+    return { ...result, ...optionalFields };
 }
 exports.fromApiVals = fromApiVals;
 function fromApiArray(vals, types) {
@@ -241,3 +245,19 @@ function typeLength(tpe) {
     return dims.reduce((a, b) => a * b);
 }
 exports.typeLength = typeLength;
+function forwardRequests(api, handler) {
+    // Update class properties to forward requests
+    for (const [path, pathObject] of Object.entries(api)) {
+        for (const method of Object.keys(pathObject)) {
+            pathObject[`${method}`] = async (...params) => {
+                return handler({ path, method, params });
+            };
+        }
+    }
+}
+exports.forwardRequests = forwardRequests;
+async function request(provider, args) {
+    const call = provider[`${args.path}`][`${args.method}`];
+    return call(...args.params);
+}
+exports.request = request;

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

@@ -123,9 +123,9 @@ export declare class Contract extends Artifact {
     fromApiContractState(state: node.ContractState): ContractState<Fields>;
     static fromApiContractState(state: node.ContractState): ContractState;
     static ContractCreatedEventIndex: number;
-    static ContractCreatedEvent: EventSig;
+    static ContractCreatedEvent: SystemEventSig;
     static ContractDestroyedEventIndex: number;
-    static ContractDestroyedEvent: EventSig;
+    static ContractDestroyedEvent: SystemEventSig;
     static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string): ContractEvent;
     fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string): TestContractResult<unknown>;
     txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>): Promise<SignDeployContractTxParams>;
@@ -257,11 +257,18 @@ 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[];
+}
 export declare type ContractCreatedEvent = ContractEvent<{
-    address: HexString;
+    address: Address;
+    parentAddress?: Address;
 }>;
 export declare type ContractDestroyedEvent = ContractEvent<{
-    address: HexString;
+    address: Address;
 }>;
 export declare function decodeContractCreatedEvent(event: node.ContractEvent): Omit<ContractCreatedEvent, 'contractAddress'>;
 export declare function decodeContractDestroyedEvent(event: node.ContractEvent): Omit<ContractDestroyedEvent, 'contractAddress'>;
@@ -274,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"));
@@ -579,24 +579,29 @@ class Contract extends Artifact {
         return contract.fromApiContractState(state);
     }
     static fromApiEvent(event, codeHash, txId) {
-        let eventSig;
+        let fields;
+        let name;
         if (event.eventIndex == Contract.ContractCreatedEventIndex) {
-            eventSig = this.ContractCreatedEvent;
+            fields = fromApiSystemEventFields(event.fields, Contract.ContractCreatedEvent);
+            name = Contract.ContractCreatedEvent.name;
         }
         else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
-            eventSig = this.ContractDestroyedEvent;
+            fields = fromApiSystemEventFields(event.fields, Contract.ContractDestroyedEvent);
+            name = Contract.ContractDestroyedEvent.name;
         }
         else {
             const contract = Project.currentProject.contractByCodeHash(codeHash);
-            eventSig = contract.eventsSig[event.eventIndex];
+            const eventSig = contract.eventsSig[event.eventIndex];
+            fields = fromApiEventFields(event.fields, eventSig);
+            name = eventSig.name;
         }
         return {
             txId: txId,
             blockHash: event.blockHash,
             contractAddress: event.contractAddress,
-            name: eventSig.name,
+            name: name,
             eventIndex: event.eventIndex,
-            fields: fromApiEventFields(event.fields, eventSig)
+            fields: fields
         };
     }
     fromApiTestContractResult(methodName, result, txId) {
@@ -620,8 +625,10 @@ class Contract extends Artifact {
     }
     async txParamsForDeployment(signer, params) {
         const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {});
+        const selectedAccount = await signer.getSelectedAccount();
         const signerParams = {
-            signerAddress: await signer.getSelectedAddress(),
+            signerAddress: selectedAccount.address,
+            signerKeyType: selectedAccount.keyType,
             bytecode: bytecode,
             initialAttoAlphAmount: params?.initialAttoAlphAmount,
             issueTokenAmount: params?.issueTokenAmount,
@@ -678,7 +685,9 @@ Contract.ContractCreatedEventIndex = -1;
 Contract.ContractCreatedEvent = {
     name: 'ContractCreated',
     fieldNames: ['address'],
-    fieldTypes: ['Address']
+    fieldTypes: ['Address'],
+    optionalFieldNames: ['parentAddress'],
+    optionalFieldTypes: ['Address']
 };
 Contract.ContractDestroyedEventIndex = -2;
 Contract.ContractDestroyedEvent = {
@@ -723,8 +732,10 @@ class Script extends Artifact {
         return JSON.stringify(object, null, 2);
     }
     async txParamsForExecution(signer, params) {
+        const selectedAccount = await signer.getSelectedAccount();
         const signerParams = {
-            signerAddress: await signer.getSelectedAddress(),
+            signerAddress: selectedAccount.address,
+            signerKeyType: selectedAccount.keyType,
             bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
             attoAlphAmount: params.attoAlphAmount,
             tokens: params.tokens,
@@ -758,6 +769,9 @@ function fromApiFields(immFields, mutFields, fieldsSig) {
 function fromApiEventFields(vals, eventSig) {
     return (0, api_1.fromApiVals)(vals, eventSig.fieldNames, eventSig.fieldTypes);
 }
+function fromApiSystemEventFields(vals, systemEventSig) {
+    return (0, api_1.fromApiVals)(vals, systemEventSig.fieldNames, systemEventSig.fieldTypes, systemEventSig.optionalFieldNames ?? [], systemEventSig.optionalFieldTypes ?? []);
+}
 function toApiAsset(asset) {
     return {
         attoAlphAmount: (0, api_1.toApiNumber256)(asset.alphAmount),
@@ -872,25 +886,35 @@ class ContractFactory {
     }
 }
 exports.ContractFactory = ContractFactory;
-function decodeFields(event, eventSig, eventIndex) {
+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}`);
     }
-    return (0, api_1.fromApiVals)(event.fields, eventSig.fieldNames, eventSig.fieldTypes);
+    return fromApiSystemEventFields(event.fields, systemEventSig);
 }
 function decodeContractCreatedEvent(event) {
-    const fields = decodeFields(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex);
+    const fields = decodeSystemEvent(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex);
     return {
         blockHash: event.blockHash,
         txId: event.txId,
         eventIndex: event.eventIndex,
         name: Contract.ContractCreatedEvent.name,
-        fields: { address: fields['address'] }
+        fields: {
+            address: fields['address'],
+            parentAddress: fields['parentAddress'] === undefined ? undefined : fields['parentAddress']
+        }
     };
 }
 exports.decodeContractCreatedEvent = decodeContractCreatedEvent;
 function decodeContractDestroyedEvent(event) {
-    const fields = decodeFields(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex);
+    const fields = decodeSystemEvent(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex);
     return {
         blockHash: event.blockHash,
         txId: event.txId,
@@ -951,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);
 }
@@ -993,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);
@@ -1025,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();
@@ -1035,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;