@alephium/web3 0.5.0-rc.4 → 0.5.0-rc.6

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

@@ -18,7 +18,7 @@ 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;

package/dist/src/api/types.js

@@ -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) {

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,16 @@ export interface CallContractResult<R> {
     txOutputs: Output[];
     events: ContractEvent[];
 }
+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'>;

package/dist/src/contract/contract.js

@@ -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) {
@@ -678,7 +683,9 @@ Contract.ContractCreatedEventIndex = -1;
 Contract.ContractCreatedEvent = {
     name: 'ContractCreated',
     fieldNames: ['address'],
-    fieldTypes: ['Address']
+    fieldTypes: ['Address'],
+    optionalFieldNames: ['parentAddress'],
+    optionalFieldTypes: ['Address']
 };
 Contract.ContractDestroyedEventIndex = -2;
 Contract.ContractDestroyedEvent = {
@@ -758,6 +765,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 +882,28 @@ class ContractFactory {
     }
 }
 exports.ContractFactory = ContractFactory;
-function decodeFields(event, eventSig, eventIndex) {
+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,

package/package.json

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

package/src/api/types.ts

@@ -162,7 +162,13 @@ function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result:
   }
 }
 
-export function fromApiVals(vals: node.Val[], names: string[], types: string[]): NamedVals {
+export function fromApiVals(
+  vals: node.Val[],
+  names: string[],
+  types: string[],
+  optionalNames: string[] = [],
+  optionalTypes: string[] = []
+): NamedVals {
   let valIndex = 0
   const result: NamedVals = {}
   types.forEach((currentType, index) => {
@@ -171,7 +177,11 @@ export function fromApiVals(vals: node.Val[], names: string[], types: string[]):
     valIndex = nextIndex
     result[`${currentName}`] = val
   })
-  return result
+  if (valIndex === vals.length) {
+    return result
+  }
+  const optionalFields = fromApiVals(vals.slice(valIndex), optionalNames, optionalTypes)
+  return { ...result, ...optionalFields }
 }
 
 export function fromApiArray(vals: node.Val[], types: string[]): Val[] {

package/src/contract/contract.ts

@@ -848,38 +848,45 @@ export class Contract extends Artifact {
   }
 
   static ContractCreatedEventIndex = -1
-  static ContractCreatedEvent: EventSig = {
+  static ContractCreatedEvent: SystemEventSig = {
     name: 'ContractCreated',
     fieldNames: ['address'],
-    fieldTypes: ['Address']
+    fieldTypes: ['Address'],
+    optionalFieldNames: ['parentAddress'],
+    optionalFieldTypes: ['Address']
   }
 
   static ContractDestroyedEventIndex = -2
-  static ContractDestroyedEvent: EventSig = {
+  static ContractDestroyedEvent: SystemEventSig = {
     name: 'ContractDestroyed',
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
 
   static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string): ContractEvent {
-    let eventSig: EventSig
+    let fields: Fields
+    let name: string
 
     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
     }
   }
 
@@ -1095,6 +1102,16 @@ function fromApiEventFields(vals: node.Val[], eventSig: node.EventSig): Fields {
   return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes)
 }
 
+function fromApiSystemEventFields(vals: node.Val[], systemEventSig: SystemEventSig): Fields {
+  return fromApiVals(
+    vals,
+    systemEventSig.fieldNames,
+    systemEventSig.fieldTypes,
+    systemEventSig.optionalFieldNames ?? [],
+    systemEventSig.optionalFieldTypes ?? []
+  )
+}
+
 export interface Asset {
   alphAmount: Number256
   tokens?: Token[]
@@ -1339,37 +1356,45 @@ export interface CallContractResult<R> {
   events: ContractEvent[]
 }
 
-export type ContractCreatedEvent = ContractEvent<{ address: HexString }>
-export type ContractDestroyedEvent = ContractEvent<{ address: HexString }>
+export interface SystemEventSig extends EventSig {
+  optionalFieldNames?: string[]
+  optionalFieldTypes?: string[]
+}
+
+export type ContractCreatedEvent = ContractEvent<{ address: Address; parentAddress?: Address }>
+export type ContractDestroyedEvent = ContractEvent<{ address: Address }>
 
-function decodeFields(event: node.ContractEvent, eventSig: EventSig, eventIndex: number): Fields {
+function decodeSystemEvent(event: node.ContractEvent, systemEventSig: SystemEventSig, eventIndex: number): Fields {
   if (event.eventIndex !== eventIndex) {
     throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`)
   }
-  return fromApiVals(event.fields, eventSig.fieldNames, eventSig.fieldTypes)
+  return fromApiSystemEventFields(event.fields, systemEventSig)
 }
 
 export function decodeContractCreatedEvent(event: node.ContractEvent): Omit<ContractCreatedEvent, 'contractAddress'> {
-  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'] as HexString }
+    fields: {
+      address: fields['address'] as Address,
+      parentAddress: fields['parentAddress'] === undefined ? undefined : (fields['parentAddress'] as Address)
+    }
   }
 }
 
 export function decodeContractDestroyedEvent(
   event: node.ContractEvent
 ): Omit<ContractDestroyedEvent, 'contractAddress'> {
-  const fields = decodeFields(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex)
+  const fields = decodeSystemEvent(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex)
   return {
     blockHash: event.blockHash,
     txId: event.txId,
     eventIndex: event.eventIndex,
     name: Contract.ContractDestroyedEvent.name,
-    fields: { address: fields['address'] as HexString }
+    fields: { address: fields['address'] as Address }
   }
 }