@alephium/web3 0.5.0-rc.0 → 0.5.0-rc.10

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

@@ -145,9 +145,11 @@ export interface BrokerInfo {
     };
 }
 export interface BuildDeployContractTx {
-    /** @format public-key */
+    /** @format hex-string */
     fromPublicKey: string;
     /** @format hex-string */
+    fromPublicKeyType?: string;
+    /** @format hex-string */
     bytecode: string;
     /** @format uint256 */
     initialAttoAlphAmount?: string;
@@ -177,9 +179,11 @@ export interface BuildDeployContractTxResult {
     contractAddress: string;
 }
 export interface BuildExecuteScriptTx {
-    /** @format public-key */
+    /** @format hex-string */
     fromPublicKey: string;
     /** @format hex-string */
+    fromPublicKeyType?: string;
+    /** @format hex-string */
     bytecode: string;
     /** @format uint256 */
     attoAlphAmount?: string;
@@ -249,8 +253,10 @@ export interface BuildSweepAddressTransactionsResult {
     toGroup: number;
 }
 export interface BuildTransaction {
-    /** @format public-key */
+    /** @format hex-string */
     fromPublicKey: string;
+    /** @format hex-string */
+    fromPublicKeyType?: string;
     destinations: Destination[];
     utxos?: OutputRef[];
     /** @format gas */
@@ -519,6 +525,13 @@ export interface InternalServerError {
 export interface MemPooled {
     type: string;
 }
+export interface MempoolTransactions {
+    /** @format int32 */
+    fromGroup: number;
+    /** @format int32 */
+    toGroup: number;
+    transactions: TransactionTemplate[];
+}
 export interface MinerAddresses {
     addresses: string[];
 }
@@ -756,13 +769,6 @@ export interface Unban {
     peers: string[];
     type: string;
 }
-export interface UnconfirmedTransactions {
-    /** @format int32 */
-    fromGroup: number;
-    /** @format int32 */
-    toGroup: number;
-    unconfirmedTransactions: TransactionTemplate[];
-}
 export interface Unreachable {
     peers: string[];
     type: string;
@@ -910,7 +916,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 1.7.0
+ * @version 1.7.1
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -1323,15 +1329,6 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getAddressesAddressGroup: (address: string, params?: RequestParams) => Promise<Group>;
     };
     transactions: {
-        /**
-         * No description
-         *
-         * @tags Transactions
-         * @name GetTransactionsUnconfirmed
-         * @summary List unconfirmed transactions
-         * @request GET:/transactions/unconfirmed
-         */
-        getTransactionsUnconfirmed: (params?: RequestParams) => Promise<UnconfirmedTransactions[]>;
         /**
          * No description
          *
@@ -1394,6 +1391,46 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             toGroup?: number;
         }, params?: RequestParams) => Promise<Confirmed | MemPooled | TxNotFound>;
     };
+    mempool: {
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name GetMempoolTransactions
+         * @summary List mempool transactions
+         * @request GET:/mempool/transactions
+         */
+        getMempoolTransactions: (params?: RequestParams) => Promise<MempoolTransactions[]>;
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name DeleteMempoolTransactions
+         * @summary Remove all transactions from mempool
+         * @request DELETE:/mempool/transactions
+         */
+        deleteMempoolTransactions: (params?: RequestParams) => Promise<void>;
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name PutMempoolTransactionsRebroadcast
+         * @summary Rebroadcase a mempool transaction to the network
+         * @request PUT:/mempool/transactions/rebroadcast
+         */
+        putMempoolTransactionsRebroadcast: (query: {
+            txId: string;
+        }, params?: RequestParams) => Promise<void>;
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name PutMempoolTransactionsValidate
+         * @summary Validate all mempool transactions and remove invalid ones
+         * @request PUT:/mempool/transactions/validate
+         */
+        putMempoolTransactionsValidate: (params?: RequestParams) => Promise<void>;
+    };
     contracts: {
         /**
          * No description

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

@@ -149,7 +149,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 1.7.0
+ * @version 1.7.1
  * @baseUrl ../
  */
 class Api extends HttpClient {
@@ -778,20 +778,6 @@ class Api extends HttpClient {
             }).then(utils_1.convertHttpResponse)
         };
         this.transactions = {
-            /**
-             * No description
-             *
-             * @tags Transactions
-             * @name GetTransactionsUnconfirmed
-             * @summary List unconfirmed transactions
-             * @request GET:/transactions/unconfirmed
-             */
-            getTransactionsUnconfirmed: (params = {}) => this.request({
-                path: `/transactions/unconfirmed`,
-                method: 'GET',
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *
@@ -887,6 +873,62 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
+        this.mempool = {
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name GetMempoolTransactions
+             * @summary List mempool transactions
+             * @request GET:/mempool/transactions
+             */
+            getMempoolTransactions: (params = {}) => this.request({
+                path: `/mempool/transactions`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name DeleteMempoolTransactions
+             * @summary Remove all transactions from mempool
+             * @request DELETE:/mempool/transactions
+             */
+            deleteMempoolTransactions: (params = {}) => this.request({
+                path: `/mempool/transactions`,
+                method: 'DELETE',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name PutMempoolTransactionsRebroadcast
+             * @summary Rebroadcase a mempool transaction to the network
+             * @request PUT:/mempool/transactions/rebroadcast
+             */
+            putMempoolTransactionsRebroadcast: (query, params = {}) => this.request({
+                path: `/mempool/transactions/rebroadcast`,
+                method: 'PUT',
+                query: query,
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name PutMempoolTransactionsValidate
+             * @summary Validate all mempool transactions and remove invalid ones
+             * @request PUT:/mempool/transactions/validate
+             */
+            putMempoolTransactionsValidate: (params = {}) => this.request({
+                path: `/mempool/transactions/validate`,
+                method: 'PUT',
+                ...params
+            }).then(utils_1.convertHttpResponse)
+        };
         this.contracts = {
             /**
              * No description

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

@@ -11,6 +11,7 @@ export declare class NodeProvider {
     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'];

package/dist/src/api/index.js

@@ -90,6 +90,7 @@ class NodeProvider {
         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 };

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/constants.d.ts

@@ -2,3 +2,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;
+export declare const DUST_AMOUNT: bigint;

package/dist/src/constants.js

@@ -17,8 +17,9 @@ 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.ONE_ALPH = exports.ALPH_TOKEN_ID = exports.MIN_UTXO_SET_AMOUNT = exports.TOTAL_NUMBER_OF_GROUPS = void 0;
+exports.DUST_AMOUNT = 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;
+exports.DUST_AMOUNT = 10n ** 15n;

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

@@ -1,6 +1,6 @@
-import { NamedVals, node, Number256, Token, Val } from '../api';
-import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider } from '../signer';
-import { SubscribeOptions } from '../utils';
+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;
@@ -123,16 +123,16 @@ 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(methodIndex: number, result: node.TestContractResult, txId: string): TestContractResult;
+    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;
+    fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number): CallContractResult<unknown>;
 }
 export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
@@ -185,10 +185,10 @@ export interface ContractEvent<T extends 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[];
@@ -220,11 +220,12 @@ export interface DeployContractParams<P extends Fields = Fields> {
 export declare type DeployContractResult<T> = SignDeployContractTxResult & {
     instance: T;
 };
-export declare abstract class ContractFactory<T, P extends Fields = Fields> {
+export declare abstract class ContractFactory<I, F extends Fields = Fields> {
     readonly contract: Contract;
     constructor(contract: Contract);
-    deploy(signer: SignerProvider, deployParams: DeployContractParams<P>): Promise<DeployContractResult<T>>;
-    abstract at(address: string): T;
+    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;
@@ -248,21 +249,40 @@ export interface CallContractParams<T extends Arguments = Arguments> {
     existingContracts?: string[];
     inputAssets?: node.TestInputAsset[];
 }
-export interface CallContractResult {
-    returns: Val[];
+export interface CallContractResult<R> {
+    returns: R;
     gasUsed: number;
     contracts: ContractState[];
     txInputs: string[];
     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'>;
-export declare function subscribeEventsFromContract<T extends Fields>(options: SubscribeOptions<ContractEvent<T>>, address: string, eventIndex: number, decodeFunc: (event: node.ContractEvent) => ContractEvent<T>, fromCount?: number): EventSubscription;
+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 {};