@alephium/web3 0.4.0 → 0.5.0-rc.1

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

@@ -425,7 +425,8 @@ export interface ContractState {
     codeHash: string;
     /** @format 32-byte-hash */
     initialStateHash?: string;
-    fields: Val[];
+    immFields: Val[];
+    mutFields: Val[];
     asset: AssetState;
 }
 export interface DebugMessage {
@@ -663,7 +664,8 @@ export interface TestContract {
     address?: string;
     /** @format contract */
     bytecode: string;
-    initialFields?: Val[];
+    initialImmFields?: Val[];
+    initialMutFields?: Val[];
     initialAsset?: AssetState;
     /** @format int32 */
     methodIndex?: number;
@@ -908,7 +910,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 1.6.4
+ * @version 1.7.0
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

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

@@ -149,7 +149,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 1.6.4
+ * @version 1.7.0
  * @baseUrl ../
  */
 class Api extends HttpClient {

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

@@ -21,3 +21,4 @@ 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 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

@@ -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.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.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) {
@@ -233,3 +233,11 @@ function foldVals(vals, dims) {
         return result;
     }
 }
+function typeLength(tpe) {
+    if (tpe === 'U256' || tpe === 'I256' || tpe === 'Bool' || tpe === 'ByteVec' || tpe === 'Address') {
+        return 1;
+    }
+    const [, dims] = decodeArrayType(tpe);
+    return dims.reduce((a, b) => a * b);
+}
+exports.typeLength = typeLength;

package/dist/src/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const TOTAL_NUMBER_OF_GROUPS = 4;
 export declare const MIN_UTXO_SET_AMOUNT: bigint;
 export declare const ALPH_TOKEN_ID: string;
+export declare const ONE_ALPH: bigint;

package/dist/src/constants.js

@@ -17,7 +17,8 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALPH_TOKEN_ID = exports.MIN_UTXO_SET_AMOUNT = exports.TOTAL_NUMBER_OF_GROUPS = void 0;
+exports.ONE_ALPH = exports.ALPH_TOKEN_ID = exports.MIN_UTXO_SET_AMOUNT = exports.TOTAL_NUMBER_OF_GROUPS = void 0;
 exports.TOTAL_NUMBER_OF_GROUPS = 4;
 exports.MIN_UTXO_SET_AMOUNT = BigInt(1000000000000);
 exports.ALPH_TOKEN_ID = ''.padStart(64, '0');
+exports.ONE_ALPH = 10n ** 18n;

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

@@ -1,10 +1,13 @@
-import { NamedVals, node, Number256, Token, Val } from '../api';
-import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerProvider, SignExecuteScriptTxResult, SignDeployContractTxResult } from '../signer';
+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;
 declare enum SourceKind {
     Contract = 0,
     Script = 1,
@@ -108,28 +111,28 @@ export declare class Contract extends Artifact {
     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>;
-    fetchState(address: string, group: number): Promise<ContractState>;
     toString(): string;
-    toState(fields: Fields, asset: Asset, address?: string): ContractState;
+    toState<T extends Fields>(fields: T, asset: Asset, address?: string): ContractState<T>;
     static randomAddress(): string;
-    private _printDebugMessages;
-    private _test;
-    testPublicMethod(funcName: string, params: TestContractParams, printDebugMessages?: boolean): Promise<TestContractResult>;
-    testPrivateMethod(funcName: string, params: TestContractParams, printDebugMessages?: boolean): Promise<TestContractResult>;
+    printDebugMessages(funcName: string, messages: DebugMessage[]): void;
     toApiFields(fields?: Fields): node.Val[];
     toApiArgs(funcName: string, args?: Arguments): node.Val[];
     getMethodIndex(funcName: string): number;
     toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
-    toTestContract(funcName: string, params: TestContractParams): node.TestContract;
-    fromApiContractState(state: node.ContractState): ContractState;
+    toApiTestContractParams(funcName: string, params: TestContractParams): node.TestContract;
+    fromApiContractState(state: node.ContractState): ContractState<Fields>;
     static fromApiContractState(state: node.ContractState): ContractState;
+    static ContractCreatedEventIndex: number;
     static ContractCreatedEvent: EventSig;
+    static ContractDestroyedEventIndex: number;
     static ContractDestroyedEvent: EventSig;
-    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): ContractEventByTxId;
-    fromTestContractResult(methodIndex: number, result: node.TestContractResult): TestContractResult;
-    txParamsForDeployment(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<SignDeployContractTxParams>;
-    deploy(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<SignDeployContractTxResult>;
+    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>;
     buildByteCodeToDeploy(initialFields: Fields): string;
+    static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string): ContractEvent[];
+    toApiCallContract<T extends Arguments>(params: CallContractParams<T>, groupIndex: number, contractAddress: string, methodIndex: number): node.CallContract;
+    fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number): CallContractResult<unknown>;
 }
 export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
@@ -140,8 +143,7 @@ export declare class Script extends Artifact {
     static fromJson(artifact: any, bytecodeDebugPatch?: string): Script;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string): Promise<Script>;
     toString(): string;
-    txParamsForExecution(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<SignExecuteScriptTxParams>;
-    execute(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<SignExecuteScriptTxResult>;
+    txParamsForExecution<P extends Fields>(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<SignExecuteScriptTxParams>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
 export interface Asset {
@@ -152,47 +154,45 @@ export interface InputAsset {
     address: string;
     asset: Asset;
 }
-export interface ContractState {
+export interface ContractState<T extends Fields = Fields> {
     address: string;
     contractId: string;
     bytecode: string;
     initialStateHash?: string;
     codeHash: string;
-    fields: Fields;
+    fields: T;
     fieldsSig: FieldsSig;
     asset: Asset;
 }
-export interface TestContractParams {
+export declare function toApiVals(fields: Fields, names: string[], types: string[]): node.Val[];
+export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments> {
     group?: number;
     address?: string;
-    initialFields?: Fields;
+    blockHash?: string;
+    txId?: string;
+    initialFields: F;
     initialAsset?: Asset;
-    testMethodIndex?: number;
-    testArgs?: Arguments;
+    testArgs: A;
     existingContracts?: ContractState[];
     inputAssets?: InputAsset[];
 }
-export interface ContractEvent {
-    blockHash: string;
+export interface ContractEvent<T extends Fields = Fields> {
     txId: string;
-    name: string;
-    fields: Fields;
-}
-export interface ContractEventByTxId {
     blockHash: string;
     contractAddress: string;
+    eventIndex: number;
     name: string;
-    fields: Fields;
+    fields: T;
 }
 export declare type DebugMessage = node.DebugMessage;
-export interface TestContractResult {
+export interface TestContractResult<R> {
     contractId: string;
     contractAddress: string;
-    returns: Val[];
+    returns: R;
     gasUsed: number;
     contracts: ContractState[];
     txOutputs: Output[];
-    events: ContractEventByTxId[];
+    events: ContractEvent[];
     debugMessages: DebugMessage[];
 }
 export declare type Output = AssetOutput | ContractOutput;
@@ -208,35 +208,76 @@ export interface ContractOutput {
     alphAmount: Number256;
     tokens?: Token[];
 }
-export interface DeployContractTransaction {
-    fromGroup: number;
-    toGroup: number;
-    unsignedTx: string;
-    txId: string;
-    contractAddress: string;
-    contractId: string;
-}
-export interface BuildDeployContractTx {
-    signerAddress: string;
-    initialFields?: Fields;
+export declare function randomTxId(): string;
+export interface DeployContractParams<P extends Fields = Fields> {
+    initialFields: P;
     initialAttoAlphAmount?: Number256;
     initialTokenAmounts?: Token[];
     issueTokenAmount?: Number256;
     gasAmount?: number;
     gasPrice?: Number256;
 }
-export interface BuildExecuteScriptTx {
-    signerAddress: string;
-    initialFields?: Fields;
+export declare type DeployContractResult<T> = SignDeployContractTxResult & {
+    instance: T;
+};
+export declare abstract class ContractFactory<I, F extends Fields = Fields> {
+    readonly contract: Contract;
+    constructor(contract: Contract);
+    abstract at(address: string): I;
+    deploy(signer: SignerProvider, deployParams: DeployContractParams<F>): Promise<DeployContractResult<I>>;
+    stateForTest(initFields: F, asset?: Asset, address?: string): ContractState<F>;
+}
+export interface ExecuteScriptParams<P extends Fields = Fields> {
+    initialFields: P;
     attoAlphAmount?: Number256;
     tokens?: Token[];
     gasAmount?: number;
     gasPrice?: Number256;
 }
-export interface BuildScriptTxResult {
-    fromGroup: number;
-    toGroup: number;
+export interface ExecuteScriptResult {
+    groupIndex: number;
     unsignedTx: string;
     txId: string;
+    signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export interface CallContractParams<T extends Arguments = Arguments> {
+    args: T;
+    worldStateBlockHash?: string;
+    txId?: string;
+    existingContracts?: string[];
+    inputAssets?: node.TestInputAsset[];
+}
+export interface CallContractResult<R> {
+    returns: R;
+    gasUsed: number;
+    contracts: ContractState[];
+    txInputs: string[];
+    txOutputs: Output[];
+    events: ContractEvent[];
+}
+export declare type ContractCreatedEvent = ContractEvent<{
+    address: HexString;
+}>;
+export declare type ContractDestroyedEvent = ContractEvent<{
+    address: HexString;
+}>;
+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 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;
+    readonly contractId: string;
+    readonly groupIndex: number;
+    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 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 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 {};