@alephium/web3 1.7.3 → 1.8.0

package/dist/src/signer/tx-builder.js

@@ -41,22 +41,103 @@ class TransactionBuilder {
         }
     }
     async buildTransferTx(params, publicKey) {
+        const data = this.buildTransferTxParams(params, publicKey);
+        const response = await this.nodeProvider.transactions.postTransactionsBuild(data);
+        return this.convertTransferTxResult(response);
+    }
+    async buildDeployContractTx(params, publicKey) {
+        const data = this.buildDeployContractTxParams(params, publicKey);
+        const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
+        return this.convertDeployContractTxResult(response);
+    }
+    async buildExecuteScriptTx(params, publicKey) {
+        const data = this.buildExecuteScriptTxParams(params, publicKey);
+        const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
+        return this.convertExecuteScriptTxResult(response);
+    }
+    async buildChainedTx(params, publicKeys) {
+        if (params.length !== publicKeys.length) {
+            throw new Error('The number of build chained transaction parameters must match the number of public keys provided');
+        }
+        const data = params.map((param, index) => {
+            const paramType = param.type;
+            switch (paramType) {
+                case 'Transfer': {
+                    const value = this.buildTransferTxParams(param, publicKeys[index]);
+                    return { type: paramType, value };
+                }
+                case 'DeployContract': {
+                    const value = this.buildDeployContractTxParams(param, publicKeys[index]);
+                    return { type: paramType, value };
+                }
+                case 'ExecuteScript': {
+                    const value = this.buildExecuteScriptTxParams(param, publicKeys[index]);
+                    return { type: paramType, value };
+                }
+                default:
+                    throw new Error(`Unsupported transaction type: ${paramType}`);
+            }
+        });
+        const buildChainedTxsResponse = await this.nodeProvider.transactions.postTransactionsBuildChained(data);
+        const results = buildChainedTxsResponse.map((buildResult) => {
+            const buildResultType = buildResult.type;
+            switch (buildResultType) {
+                case 'Transfer': {
+                    const buildTransferTxResult = buildResult.value;
+                    return {
+                        ...this.convertTransferTxResult(buildTransferTxResult),
+                        type: buildResultType
+                    };
+                }
+                case 'DeployContract': {
+                    const buildDeployContractTxResult = buildResult.value;
+                    return {
+                        ...this.convertDeployContractTxResult(buildDeployContractTxResult),
+                        type: buildResultType
+                    };
+                }
+                case 'ExecuteScript': {
+                    const buildExecuteScriptTxResult = buildResult.value;
+                    return {
+                        ...this.convertExecuteScriptTxResult(buildExecuteScriptTxResult),
+                        type: buildResultType
+                    };
+                }
+                default:
+                    throw new Error(`Unexpected transaction type: ${buildResultType} for ${buildResult.value.txId}`);
+            }
+        });
+        return results;
+    }
+    buildUnsignedTx(params) {
+        const unsignedTxBin = (0, utils_1.hexToBinUnsafe)(params.unsignedTx);
+        const decoded = codec_1.unsignedTxCodec.decode(unsignedTxBin);
+        const txId = (0, utils_1.binToHex)((0, hash_1.blakeHash)(unsignedTxBin));
+        const [fromGroup, toGroup] = (0, transaction_1.groupIndexOfTransaction)(decoded);
+        return {
+            fromGroup: fromGroup,
+            toGroup: toGroup,
+            unsignedTx: params.unsignedTx,
+            txId: txId,
+            gasAmount: decoded.gasAmount,
+            gasPrice: decoded.gasPrice
+        };
+    }
+    buildTransferTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { destinations, gasPrice, ...rest } = params;
-        const data = {
+        return {
             fromPublicKey: publicKey,
             fromPublicKeyType: params.signerKeyType,
             destinations: (0, signer_1.toApiDestinations)(destinations),
             gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
             ...rest
         };
-        const response = await this.nodeProvider.transactions.postTransactionsBuild(data);
-        return { ...response, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
-    async buildDeployContractTx(params, publicKey) {
+    buildDeployContractTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params;
-        const data = {
+        return {
             fromPublicKey: publicKey,
             fromPublicKeyType: params.signerKeyType,
             initialAttoAlphAmount: (0, api_1.toApiNumber256Optional)(initialAttoAlphAmount),
@@ -65,14 +146,11 @@ class TransactionBuilder {
             gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
             ...rest
         };
-        const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
-        const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(response.contractAddress));
-        return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
-    async buildExecuteScriptTx(params, publicKey) {
+    buildExecuteScriptTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { attoAlphAmount, tokens, gasPrice, ...rest } = params;
-        const data = {
+        return {
             fromPublicKey: publicKey,
             fromPublicKeyType: params.signerKeyType,
             attoAlphAmount: (0, api_1.toApiNumber256Optional)(attoAlphAmount),
@@ -80,21 +158,27 @@ class TransactionBuilder {
             gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
             ...rest
         };
-        const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
-        return { ...response, groupIndex: response.fromGroup, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
-    buildUnsignedTx(params) {
-        const unsignedTxBin = (0, utils_1.hexToBinUnsafe)(params.unsignedTx);
-        const decoded = codec_1.unsignedTxCodec.decode(unsignedTxBin);
-        const txId = (0, utils_1.binToHex)((0, hash_1.blakeHash)(unsignedTxBin));
-        const [fromGroup, toGroup] = (0, transaction_1.groupIndexOfTransaction)(decoded);
+    convertTransferTxResult(result) {
         return {
-            fromGroup: fromGroup,
-            toGroup: toGroup,
-            unsignedTx: params.unsignedTx,
-            txId: txId,
-            gasAmount: decoded.gasAmount,
-            gasPrice: decoded.gasPrice
+            ...result,
+            gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
+        };
+    }
+    convertDeployContractTxResult(result) {
+        const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(result.contractAddress));
+        return {
+            ...result,
+            groupIndex: result.fromGroup,
+            contractId,
+            gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
+        };
+    }
+    convertExecuteScriptTxResult(result) {
+        return {
+            ...result,
+            groupIndex: result.fromGroup,
+            gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
         };
     }
 }

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

@@ -91,6 +91,26 @@ export interface SignUnsignedTxResult {
     gasAmount: number;
     gasPrice: Number256;
 }
+export type SignTransferChainedTxParams = SignTransferTxParams & {
+    type: 'Transfer';
+};
+export type SignDeployContractChainedTxParams = SignDeployContractTxParams & {
+    type: 'DeployContract';
+};
+export type SignExecuteScriptChainedTxParams = SignExecuteScriptTxParams & {
+    type: 'ExecuteScript';
+};
+export type SignChainedTxParams = SignTransferChainedTxParams | SignDeployContractChainedTxParams | SignExecuteScriptChainedTxParams;
+export type SignTransferChainedTxResult = SignTransferTxResult & {
+    type: 'Transfer';
+};
+export type SignDeployContractChainedTxResult = SignDeployContractTxResult & {
+    type: 'DeployContract';
+};
+export type SignExecuteScriptChainedTxResult = SignExecuteScriptTxResult & {
+    type: 'ExecuteScript';
+};
+export type SignChainedTxResult = SignTransferChainedTxResult | SignDeployContractChainedTxResult | SignExecuteScriptChainedTxResult;
 export type MessageHasher = 'alephium' | 'sha256' | 'blake2b' | 'identity';
 export interface SignMessageParams {
     signerAddress: string;

package/dist/src/utils/utils.d.ts

@@ -33,4 +33,7 @@ export type Eq<X, Y> = _Eq<{
 }>;
 export declare function assertType<T extends true>(): void;
 export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type Narrow<type> = (unknown extends type ? unknown : never) | (type extends Function ? type : never) | (type extends bigint | boolean | number | string ? type : never) | (type extends [] ? [] : never) | {
+    [K in keyof type]: Narrow<type[K]>;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -33,8 +33,8 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "3.6.2",
-    "explorer_backend_version": "2.0.0"
+    "alephium_version": "3.8.1",
+    "explorer_backend_version": "2.2.3"
   },
   "type": "commonjs",
   "dependencies": {

package/src/api/api-alephium.ts

@@ -189,6 +189,51 @@ export interface BrokerInfo {
   }
 }
 
+/** BuildChainedDeployContractTx */
+export interface BuildChainedDeployContractTx {
+  value: BuildDeployContractTx
+  type: string
+}
+
+/** BuildChainedDeployContractTxResult */
+export interface BuildChainedDeployContractTxResult {
+  value: BuildDeployContractTxResult
+  type: string
+}
+
+/** BuildChainedExecuteScriptTx */
+export interface BuildChainedExecuteScriptTx {
+  value: BuildExecuteScriptTx
+  type: string
+}
+
+/** BuildChainedExecuteScriptTxResult */
+export interface BuildChainedExecuteScriptTxResult {
+  value: BuildExecuteScriptTxResult
+  type: string
+}
+
+/** BuildChainedTransferTx */
+export interface BuildChainedTransferTx {
+  value: BuildTransferTx
+  type: string
+}
+
+/** BuildChainedTransferTxResult */
+export interface BuildChainedTransferTxResult {
+  value: BuildTransferTxResult
+  type: string
+}
+
+/** BuildChainedTx */
+export type BuildChainedTx = BuildChainedDeployContractTx | BuildChainedExecuteScriptTx | BuildChainedTransferTx
+
+/** BuildChainedTxResult */
+export type BuildChainedTxResult =
+  | BuildChainedDeployContractTxResult
+  | BuildChainedExecuteScriptTxResult
+  | BuildChainedTransferTxResult
+
 /** BuildDeployContractTx */
 export interface BuildDeployContractTx {
   /** @format hex-string */
@@ -353,8 +398,8 @@ export interface BuildSweepMultisig {
   targetBlockHash?: string
 }
 
-/** BuildTransaction */
-export interface BuildTransaction {
+/** BuildTransferTx */
+export interface BuildTransferTx {
   /** @format hex-string */
   fromPublicKey: string
   /** @format hex-string */
@@ -369,8 +414,8 @@ export interface BuildTransaction {
   targetBlockHash?: string
 }
 
-/** BuildTransactionResult */
-export interface BuildTransactionResult {
+/** BuildTransferTxResult */
+export interface BuildTransferTxResult {
   unsignedTx: string
   /** @format gas */
   gasAmount: number
@@ -926,6 +971,97 @@ export interface RevealMnemonicResult {
   mnemonic: string
 }
 
+/** RichAssetInput */
+export interface RichAssetInput {
+  /** @format int32 */
+  hint: number
+  /** @format 32-byte-hash */
+  key: string
+  /** @format hex-string */
+  unlockScript: string
+  /** @format uint256 */
+  attoAlphAmount: string
+  /** @format address */
+  address: string
+  tokens: Token[]
+}
+
+/** RichBlockAndEvents */
+export interface RichBlockAndEvents {
+  block: RichBlockEntry
+  events: ContractEventByBlockHash[]
+}
+
+/** RichBlockEntry */
+export interface RichBlockEntry {
+  /** @format block-hash */
+  hash: string
+  /** @format int64 */
+  timestamp: number
+  /** @format int32 */
+  chainFrom: number
+  /** @format int32 */
+  chainTo: number
+  /** @format int32 */
+  height: number
+  deps: string[]
+  transactions: RichTransaction[]
+  /** @format hex-string */
+  nonce: string
+  version: number
+  /** @format 32-byte-hash */
+  depStateHash: string
+  /** @format 32-byte-hash */
+  txsHash: string
+  /** @format hex-string */
+  target: string
+  ghostUncles: GhostUncleBlockEntry[]
+}
+
+/** RichBlocksAndEventsPerTimeStampRange */
+export interface RichBlocksAndEventsPerTimeStampRange {
+  blocksAndEvents: RichBlockAndEvents[][]
+}
+
+/** RichContractInput */
+export interface RichContractInput {
+  /** @format int32 */
+  hint: number
+  /** @format 32-byte-hash */
+  key: string
+  /** @format uint256 */
+  attoAlphAmount: string
+  /** @format address */
+  address: string
+  tokens: Token[]
+}
+
+/** RichTransaction */
+export interface RichTransaction {
+  unsigned: RichUnsignedTx
+  scriptExecutionOk: boolean
+  contractInputs: RichContractInput[]
+  generatedOutputs: Output[]
+  inputSignatures: string[]
+  scriptSignatures: string[]
+}
+
+/** RichUnsignedTx */
+export interface RichUnsignedTx {
+  /** @format 32-byte-hash */
+  txId: string
+  version: number
+  networkId: number
+  /** @format script */
+  scriptOpt?: string
+  /** @format int32 */
+  gasAmount: number
+  /** @format uint256 */
+  gasPrice: string
+  inputs: RichAssetInput[]
+  fixedOutputs: FixedAssetOutput[]
+}
+
 /** Script */
 export interface Script {
   code: string
@@ -1113,6 +1249,8 @@ export interface TransactionTemplate {
   unsigned: UnsignedTx
   inputSignatures: string[]
   scriptSignatures: string[]
+  /** @format int64 */
+  seenAt: number
 }
 
 /** Transfer */
@@ -1512,7 +1650,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 3.6.2
+ * @version 3.8.1
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -2169,6 +2307,40 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * No description
+     *
+     * @tags Blockflow
+     * @name GetBlockflowRichBlocks
+     * @summary Given a time interval, list blocks containing events and transactions with enriched input information when node indexes are enabled.
+     * @request GET:/blockflow/rich-blocks
+     */
+    getBlockflowRichBlocks: (
+      query: {
+        /**
+         * @format int64
+         * @min 0
+         */
+        fromTs: number
+        /**
+         * @format int64
+         * @min 0
+         */
+        toTs?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<
+        RichBlocksAndEventsPerTimeStampRange,
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/blockflow/rich-blocks`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * No description
      *
@@ -2217,6 +2389,24 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * No description
+     *
+     * @tags Blockflow
+     * @name GetBlockflowRichBlocksBlockHash
+     * @summary Get a block containing events and transactions with enriched input information when node indexes are enabled.
+     * @request GET:/blockflow/rich-blocks/{block_hash}
+     */
+    getBlockflowRichBlocksBlockHash: (blockHash: string, params: RequestParams = {}) =>
+      this.request<RichBlockAndEvents, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>(
+        {
+          path: `/blockflow/rich-blocks/${blockHash}`,
+          method: 'GET',
+          format: 'json',
+          ...params
+        }
+      ).then(convertHttpResponse),
+
     /**
      * No description
      *
@@ -2386,12 +2576,12 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      *
      * @tags Transactions
      * @name PostTransactionsBuild
-     * @summary Build an unsigned transaction to a number of recipients
+     * @summary Build an unsigned transfer transaction to a number of recipients
      * @request POST:/transactions/build
      */
-    postTransactionsBuild: (data: BuildTransaction, params: RequestParams = {}) =>
+    postTransactionsBuild: (data: BuildTransferTx, params: RequestParams = {}) =>
       this.request<
-        BuildTransactionResult,
+        BuildTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
       >({
         path: `/transactions/build`,
@@ -2412,7 +2602,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      */
     postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params: RequestParams = {}) =>
       this.request<
-        BuildTransactionResult,
+        BuildTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
       >({
         path: `/transactions/build-multi-addresses`,
@@ -2509,6 +2699,32 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * No description
+     *
+     * @tags Transactions
+     * @name GetTransactionsRichDetailsTxid
+     * @summary Get transaction with enriched input information when node indexes are enabled.
+     * @request GET:/transactions/rich-details/{txId}
+     */
+    getTransactionsRichDetailsTxid: (
+      txId: string,
+      query?: {
+        /** @format int32 */
+        fromGroup?: number
+        /** @format int32 */
+        toGroup?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<RichTransaction, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/transactions/rich-details/${txId}`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * No description
      *
@@ -2585,6 +2801,27 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         query: query,
         format: 'json',
         ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * No description
+     *
+     * @tags Transactions
+     * @name PostTransactionsBuildChained
+     * @summary Build a chain of transactions
+     * @request POST:/transactions/build-chained
+     */
+    postTransactionsBuildChained: (data: BuildChainedTx[], params: RequestParams = {}) =>
+      this.request<
+        BuildChainedTxResult[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/transactions/build-chained`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
       }).then(convertHttpResponse)
   }
   mempool = {
@@ -2952,7 +3189,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      */
     postMultisigBuild: (data: BuildMultisig, params: RequestParams = {}) =>
       this.request<
-        BuildTransactionResult,
+        BuildTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
       >({
         path: `/multisig/build`,

package/src/api/api-explorer.ts

@@ -190,6 +190,7 @@ export interface AssetOutput {
 
 /** NFT */
 export interface NFT {
+  id: string
   type: string
 }
 
@@ -217,6 +218,14 @@ export interface AcceptedTransaction {
   timestamp: number
 }
 
+/** HolderInfo */
+export interface HolderInfo {
+  /** @format address */
+  address: string
+  /** @format uint256 */
+  balance: string
+}
+
 /** TokenSupply */
 export interface TokenSupply {
   /** @format uint256 */
@@ -317,6 +326,8 @@ export enum TokenStdInterfaceId {
 export interface ExplorerInfo {
   releaseVersion: string
   commit: string
+  /** @format int64 */
+  lastHoldersUpdate: number
   /** @format int32 */
   migrationsVersion: number
   /** @format int64 */
@@ -367,6 +378,7 @@ export interface Transaction {
 
 /** FungibleToken */
 export interface FungibleToken {
+  id: string
   type: string
 }
 
@@ -1588,6 +1600,40 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description Get a sorted list of top addresses by {token_id} balance. Updates once per day.
+     *
+     * @tags Tokens
+     * @name GetTokensHoldersTokenTokenId
+     * @request GET:/tokens/holders/token/{token_id}
+     */
+    getTokensHoldersTokenTokenId: (
+      tokenId: string,
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         * @min 1
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         * @min 0
+         * @max 100
+         */
+        limit?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<HolderInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/holders/token/${tokenId}`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description List token transactions
      *
@@ -1676,6 +1722,39 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description Get a sorted list of top addresses by ALPH balance. Updates once per day.
+     *
+     * @tags Tokens
+     * @name GetTokensHoldersAlph
+     * @request GET:/tokens/holders/alph
+     */
+    getTokensHoldersAlph: (
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         * @min 1
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         * @min 0
+         * @max 100
+         */
+        limit?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<HolderInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/holders/alph`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Return metadata for the given nft tokens, if metadata doesn't exist or token isn't a nft, it won't be in the output list
      *