@alephium/web3 0.8.2-test.3 → 0.9.0-rc.1

package/dist/src/api/api-alephium.d.ts

@@ -334,6 +334,7 @@ export interface CompileContractResult {
     functions: FunctionSig[];
     events: EventSig[];
     warnings: string[];
+    stdInterfaceId?: string;
 }
 export interface CompileProjectResult {
     contracts: CompileContractResult[];
@@ -462,7 +463,7 @@ export interface Destination {
     /** @format hex-string */
     message?: string;
 }
-export declare type DiscoveryAction = Reachable | Unreachable;
+export type DiscoveryAction = Reachable | Unreachable;
 export interface EventSig {
     name: string;
     fieldNames: string[];
@@ -540,7 +541,7 @@ export interface MinerAddresses {
 export interface MinerAddressesInfo {
     addresses: AddressInfo[];
 }
-export declare type MisbehaviorAction = Ban | Unban;
+export type MisbehaviorAction = Ban | Unban;
 export interface MultipleCallContract {
     calls: CallContract[];
 }
@@ -564,7 +565,7 @@ export interface NotFound {
     detail: string;
     resource: string;
 }
-export declare type Output = AssetOutput | ContractOutput;
+export type Output = AssetOutput | ContractOutput;
 export interface OutputRef {
     /** @format int32 */
     hint: number;
@@ -586,7 +587,7 @@ export interface PeerMisbehavior {
     peer: string;
     status: PeerStatus;
 }
-export declare type PeerStatus = Banned | Penalty;
+export type PeerStatus = Banned | Penalty;
 export interface Penalty {
     /** @format int32 */
     value: number;
@@ -758,7 +759,7 @@ export interface TransferResults {
 export interface TxNotFound {
     type: string;
 }
-export declare type TxStatus = Confirmed | MemPooled | TxNotFound;
+export type TxStatus = Confirmed | MemPooled | TxNotFound;
 export interface UTXO {
     ref: OutputRef;
     /** @format uint256 */
@@ -798,7 +799,7 @@ export interface UnsignedTx {
     inputs: AssetInput[];
     fixedOutputs: FixedAssetOutput[];
 }
-export declare type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
+export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
 export interface ValAddress {
     /** @format address */
     value: string;
@@ -868,8 +869,8 @@ export interface WalletUnlock {
     mnemonicPassphrase?: string;
 }
 import 'cross-fetch/polyfill';
-export declare type QueryParamsType = Record<string | number, any>;
-export declare type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
 export interface FullRequestParams extends Omit<RequestInit, 'body'> {
     /** set parameter to `true` for call `securityWorker` for this request */
     secure?: boolean;
@@ -888,7 +889,7 @@ export interface FullRequestParams extends Omit<RequestInit, 'body'> {
     /** request cancellation token */
     cancelToken?: CancelToken;
 }
-export declare type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
 export interface ApiConfig<SecurityDataType = unknown> {
     baseUrl?: string;
     baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
@@ -899,7 +900,7 @@ export interface HttpResponse<D extends unknown, E extends unknown = unknown> ex
     data: D;
     error: E;
 }
-declare type CancelToken = Symbol | string | number;
+type CancelToken = Symbol | string | number;
 export declare enum ContentType {
     Json = "application/json",
     FormData = "multipart/form-data",
@@ -928,7 +929,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 2.0.1
+ * @version 2.1.0
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/dist/src/api/api-alephium.js

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 2.0.1
+ * @version 2.1.0
  * @baseUrl ../
  */
 class Api extends HttpClient {

package/dist/src/api/api-explorer.d.ts

@@ -156,7 +156,7 @@ export interface NotFound {
     detail: string;
     resource: string;
 }
-export declare type Output = AssetOutput | ContractOutput;
+export type Output = AssetOutput | ContractOutput;
 export interface OutputRef {
     /** @format int32 */
     hint: number;
@@ -261,11 +261,11 @@ export interface Transaction {
     scriptExecutionOk: boolean;
     coinbase: boolean;
 }
-export declare type TransactionLike = AcceptedTransaction | PendingTransaction;
+export type TransactionLike = AcceptedTransaction | PendingTransaction;
 export interface Unauthorized {
     detail: string;
 }
-export declare type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
+export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
 export interface ValAddress {
     /** @format address */
     value: string;
@@ -295,8 +295,8 @@ export interface ValU256 {
     type: string;
 }
 import 'cross-fetch/polyfill';
-export declare type QueryParamsType = Record<string | number, any>;
-export declare type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
 export interface FullRequestParams extends Omit<RequestInit, 'body'> {
     /** set parameter to `true` for call `securityWorker` for this request */
     secure?: boolean;
@@ -315,7 +315,7 @@ export interface FullRequestParams extends Omit<RequestInit, 'body'> {
     /** request cancellation token */
     cancelToken?: CancelToken;
 }
-export declare type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
 export interface ApiConfig<SecurityDataType = unknown> {
     baseUrl?: string;
     baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
@@ -326,7 +326,7 @@ export interface HttpResponse<D extends unknown, E extends unknown = unknown> ex
     data: D;
     error: E;
 }
-declare type CancelToken = Symbol | string | number;
+type CancelToken = Symbol | string | number;
 export declare enum ContentType {
     Json = "application/json",
     FormData = "multipart/form-data",

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

@@ -1,7 +1,20 @@
 import { ApiRequestArguments, ApiRequestHandler, TokenMetaData } from './types';
 import { Api as NodeApi } from './api-alephium';
 import { HexString } from '../contract';
-export declare class NodeProvider {
+interface NodeProviderApis {
+    wallets: NodeApi<string>['wallets'];
+    infos: NodeApi<string>['infos'];
+    blockflow: NodeApi<string>['blockflow'];
+    addresses: NodeApi<string>['addresses'];
+    transactions: NodeApi<string>['transactions'];
+    mempool: NodeApi<string>['mempool'];
+    contracts: NodeApi<string>['contracts'];
+    multisig: NodeApi<string>['multisig'];
+    utils: NodeApi<string>['utils'];
+    miners: NodeApi<string>['miners'];
+    events: NodeApi<string>['events'];
+}
+export declare class NodeProvider implements NodeProviderApis {
     readonly wallets: NodeApi<string>['wallets'];
     readonly infos: NodeApi<string>['infos'];
     readonly blockflow: NodeApi<string>['blockflow'];
@@ -20,4 +33,6 @@ export declare class NodeProvider {
     static Proxy(nodeProvider: NodeProvider): NodeProvider;
     static Remote(handler: ApiRequestHandler): NodeProvider;
     fetchStdTokenMetaData: (tokenId: HexString) => Promise<TokenMetaData>;
+    guessStdInterfaceId: (tokenId: HexString) => Promise<HexString | undefined>;
 }
+export {};

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

@@ -39,15 +39,35 @@ class NodeProvider {
         };
         // Only use this when the token is following the standard token interface
         this.fetchStdTokenMetaData = async (tokenId) => {
-            return fetchStdTokenMetaData(this.contracts, tokenId);
+            const group = 0;
+            const address = (0, utils_2.addressFromTokenId)(tokenId);
+            const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }));
+            const result = await this.contracts.postContractsMulticallContract({
+                calls: calls
+            });
+            return {
+                symbol: result.results[0].returns[0].value,
+                name: result.results[1].returns[0].value,
+                decimals: Number(result.results[2].returns[0].value),
+                totalSupply: BigInt(result.results[3].returns[0].value)
+            };
+        };
+        this.guessStdInterfaceId = async (tokenId) => {
+            const address = (0, utils_2.addressFromTokenId)(tokenId);
+            const group = (0, utils_2.groupOfAddress)(address);
+            const rawState = await this.contracts.getContractsAddressState((0, utils_2.addressFromTokenId)(tokenId), { group });
+            const lastImmField = rawState.immFields.slice(-1).pop()?.value;
+            const interfaceIdPrefix = '414c5048'; // the hex of 'ALPH'
+            if (typeof lastImmField === 'string' && lastImmField.startsWith(interfaceIdPrefix)) {
+                return lastImmField.slice(8);
+            }
+            else {
+                return undefined;
+            }
         };
         let nodeApi;
         if (typeof param0 === 'string') {
-            const api = initializeNodeApi(param0, apiKey, customFetch);
-            nodeApi = {
-                ...api,
-                fetchStdTokenMetaData: async (tokenId) => fetchStdTokenMetaData(api.contracts, tokenId)
-            };
+            nodeApi = initializeNodeApi(param0, apiKey, customFetch);
         }
         else if (typeof param0 === 'function') {
             nodeApi = new NodeProvider('https://1.2.3.4:0');
@@ -77,17 +97,3 @@ class NodeProvider {
     }
 }
 exports.NodeProvider = NodeProvider;
-async function fetchStdTokenMetaData(contractAPI, tokenId) {
-    const group = 0;
-    const address = (0, utils_2.addressFromTokenId)(tokenId);
-    const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }));
-    const result = await contractAPI.postContractsMulticallContract({
-        calls: calls
-    });
-    return {
-        symbol: result.results[0].returns[0].value,
-        name: result.results[1].returns[0].value,
-        decimals: Number(result.results[2].returns[0].value),
-        totalSupply: BigInt(result.results[3].returns[0].value)
-    };
-}

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

@@ -1,7 +1,7 @@
 import * as node from './api-alephium';
-export declare type Number256 = bigint | string;
-export declare type Val = Number256 | boolean | string | Val[];
-export declare type NamedVals = Record<string, Val>;
+export type Number256 = bigint | string;
+export type Val = Number256 | boolean | string | Val[];
+export type NamedVals = Record<string, Val>;
 export interface Token {
     id: string;
     amount: Number256;
@@ -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[], optionalNames?: string[], optionalTypes?: string[]): NamedVals;
+export declare function fromApiVals(vals: node.Val[], names: string[], types: string[], systemEvent?: boolean): 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;
@@ -27,7 +27,7 @@ export interface ApiRequestArguments {
     method: string;
     params: any[];
 }
-export declare type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>;
+export 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>;
 export interface TokenMetaData {

package/dist/src/api/types.js

@@ -137,7 +137,7 @@ function toApiVal(v, tpe) {
     }
 }
 exports.toApiVal = toApiVal;
-function _fromApiVal(vals, valIndex, tpe) {
+function _fromApiVal(vals, valIndex, tpe, systemEvent = false) {
     if (vals.length === 0) {
         throw new Error('Not enough Vals');
     }
@@ -148,7 +148,7 @@ function _fromApiVal(vals, valIndex, tpe) {
     else if ((tpe === 'U256' || tpe === 'I256') && firstVal.type === tpe) {
         return [fromApiNumber256(firstVal.value), valIndex + 1];
     }
-    else if ((tpe === 'ByteVec' || tpe === 'Address') && firstVal.type === tpe) {
+    else if ((tpe === 'ByteVec' || tpe === 'Address') && (firstVal.type === tpe || systemEvent)) {
         return [firstVal.value, valIndex + 1];
     }
     else {
@@ -165,20 +165,16 @@ function _fromApiVal(vals, valIndex, tpe) {
         }
     }
 }
-function fromApiVals(vals, names, types, optionalNames = [], optionalTypes = []) {
+function fromApiVals(vals, names, types, systemEvent = false) {
     let valIndex = 0;
     const result = {};
     types.forEach((currentType, index) => {
         const currentName = names[`${index}`];
-        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType);
+        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType, systemEvent);
         valIndex = nextIndex;
         result[`${currentName}`] = val;
     });
-    if (valIndex === vals.length) {
-        return result;
-    }
-    const optionalFields = fromApiVals(vals.slice(valIndex), optionalNames, optionalTypes);
-    return { ...result, ...optionalFields };
+    return result;
 }
 exports.fromApiVals = fromApiVals;
 function fromApiArray(vals, types) {

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

@@ -2,19 +2,20 @@ import { NamedVals, node, Number256, Token } from '../api';
 import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
 import { SubscribeOptions, Optional } from '../utils';
 import { EventSubscription } from './events';
-export declare type FieldsSig = node.FieldsSig;
-export declare type EventSig = node.EventSig;
-export declare type FunctionSig = node.FunctionSig;
-export declare type Fields = NamedVals;
-export declare type Arguments = NamedVals;
-export declare type HexString = string;
+export type FieldsSig = node.FieldsSig;
+export type EventSig = node.EventSig;
+export type FunctionSig = node.FunctionSig;
+export type Fields = NamedVals;
+export type Arguments = NamedVals;
+export type HexString = string;
+export declare const StdIdFieldName = "__stdInterfaceId";
 declare enum SourceKind {
     Contract = 0,
     Script = 1,
     AbstractContract = 2,
     Interface = 3
 }
-export declare type CompilerOptions = node.CompilerOptions & {
+export type CompilerOptions = node.CompilerOptions & {
     errorOnWarnings: boolean;
 };
 export declare const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions;
@@ -41,7 +42,7 @@ declare class Compiled<T extends Artifact> {
     warnings: string[];
     constructor(sourceInfo: SourceInfo, artifact: T, warnings: string[]);
 }
-declare type CodeInfo = {
+type CodeInfo = {
     sourceFile: string;
     sourceCodeHash: string;
     bytecodeDebugPatch: string;
@@ -105,9 +106,10 @@ export declare class Contract extends Artifact {
     readonly codeHash: string;
     readonly fieldsSig: FieldsSig;
     readonly eventsSig: EventSig[];
+    readonly stdInterfaceId?: HexString;
     readonly bytecodeDebug: string;
     readonly codeHashDebug: string;
-    constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
+    constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], stdInterfaceId?: HexString);
     static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string): Contract;
     static fromCompileResult(result: node.CompileContractResult): Contract;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string): Promise<Contract>;
@@ -123,9 +125,9 @@ export declare class Contract extends Artifact {
     fromApiContractState(state: node.ContractState): ContractState<Fields>;
     static fromApiContractState(state: node.ContractState): ContractState;
     static ContractCreatedEventIndex: number;
-    static ContractCreatedEvent: SystemEventSig;
+    static ContractCreatedEvent: EventSig;
     static ContractDestroyedEventIndex: number;
-    static ContractDestroyedEvent: SystemEventSig;
+    static ContractDestroyedEvent: EventSig;
     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>;
@@ -185,7 +187,7 @@ export interface ContractEvent<T extends Fields = Fields> {
     name: string;
     fields: T;
 }
-export declare type DebugMessage = node.DebugMessage;
+export type DebugMessage = node.DebugMessage;
 export interface TestContractResult<R> {
     contractId: string;
     contractAddress: string;
@@ -218,7 +220,7 @@ export interface DeployContractParams<P extends Fields = Fields> {
     gasAmount?: number;
     gasPrice?: Number256;
 }
-export declare type DeployContractResult<T> = SignDeployContractTxResult & {
+export type DeployContractResult<T> = SignDeployContractTxResult & {
     instance: T;
 };
 export declare abstract class ContractFactory<I, F extends Fields = Fields> {
@@ -260,20 +262,22 @@ export interface CallContractResult<R> {
 }
 export declare const CreateContractEventAddress: string;
 export declare const DestroyContractEventAddress: string;
-export interface SystemEventSig extends EventSig {
-    optionalFieldNames?: string[];
-    optionalFieldTypes?: string[];
-}
-export declare type ContractCreatedEvent = ContractEvent<{
+export type ContractCreatedEventFields = {
     address: Address;
     parentAddress?: Address;
-}>;
-export declare type ContractDestroyedEvent = ContractEvent<{
+    stdInterfaceIdGuessed?: HexString;
+};
+export type ContractDestroyedEventFields = {
     address: Address;
-}>;
+};
+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 addStdIdToFields<F extends Fields>(contract: Contract, fields: F): F | (F & {
+    __stdInterfaceId: HexString;
+});
 export declare function testMethod<I, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R>>;
 export declare abstract class ContractInstance {
     readonly address: Address;