@alephium/web3 0.44.0 → 1.0.0

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

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 2.14.0
+ * @version 3.1.0
  * @baseUrl ../
  */
 class Api extends HttpClient {
@@ -675,6 +675,20 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Blockflow
+             * @name GetBlockflowMainChainBlockByGhostUncleGhostUncleHash
+             * @summary Get a mainchain block by ghost uncle hash
+             * @request GET:/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}
+             */
+            getBlockflowMainChainBlockByGhostUncleGhostUncleHash: (ghostUncleHash, params = {}) => this.request({
+                path: `/blockflow/main-chain-block-by-ghost-uncle/${ghostUncleHash}`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *

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

@@ -78,6 +78,21 @@ export interface BlockEntryLite {
     /** @format bigint */
     hashRate: string;
 }
+export interface ContractLiveness {
+    /** @format address */
+    parent?: string;
+    creation: ContractLivenessLocation;
+    destruction?: ContractLivenessLocation;
+    interfaceId?: StdInterfaceId;
+}
+export interface ContractLivenessLocation {
+    /** @format block-hash */
+    blockHash: string;
+    /** @format 32-byte-hash */
+    txHash: string;
+    /** @format int64 */
+    timestamp: number;
+}
 export interface ContractOutput {
     /** @format int32 */
     hint: number;
@@ -117,6 +132,9 @@ export interface ExplorerInfo {
     /** @format int64 */
     lastFinalizedInputTime: number;
 }
+export interface FungibleToken {
+    type: string;
+}
 export interface FungibleTokenMetadata {
     /** @format 32-byte-hash */
     id: string;
@@ -176,11 +194,20 @@ export interface MempoolTransaction {
     /** @format int64 */
     lastSeen: number;
 }
+export interface NFT {
+    type: string;
+}
+export interface NFTCollection {
+    type: string;
+}
 export interface NFTCollectionMetadata {
     /** @format address */
     address: string;
     collectionUri: string;
 }
+export interface NFTCollectionWithRoyalty {
+    type: string;
+}
 export interface NFTMetadata {
     /** @format 32-byte-hash */
     id: string;
@@ -190,6 +217,9 @@ export interface NFTMetadata {
     /** @format uint256 */
     nftIndex: string;
 }
+export interface NonStandard {
+    type: string;
+}
 export interface NotFound {
     detail: string;
     resource: string;
@@ -254,6 +284,7 @@ export interface PerChainTimedCount {
 export interface ServiceUnavailable {
     detail: string;
 }
+export type StdInterfaceId = FungibleToken | NFT | NFTCollection | NFTCollectionWithRoyalty | NonStandard | Unknown;
 export interface SubContracts {
     subContracts?: string[];
 }
@@ -324,6 +355,10 @@ export type TransactionLike = AcceptedTransaction | PendingTransaction;
 export interface Unauthorized {
     detail: string;
 }
+export interface Unknown {
+    id: string;
+    type: string;
+}
 export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
 export interface ValAddress {
     /** @format address */
@@ -633,6 +668,14 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/addresses/{address}/tokens/{token_id}/balance
          */
         getAddressesAddressTokensTokenIdBalance: (address: string, tokenId: string, params?: RequestParams) => Promise<AddressTokenBalance>;
+        /**
+         * @description Get public key of p2pkh addresses, the address needs to have at least one input.
+         *
+         * @tags Addresses
+         * @name GetAddressesAddressPublicKey
+         * @request GET:/addresses/{address}/public-key
+         */
+        getAddressesAddressPublicKey: (address: string, params?: RequestParams) => Promise<string>;
         /**
          * @description Get address tokens with balance
          *
@@ -1037,6 +1080,14 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         }, params?: RequestParams) => Promise<Event[]>;
     };
     contracts: {
+        /**
+         * @description Get contract liveness
+         *
+         * @tags Contracts
+         * @name GetContractsContractAddressCurrentLiveness
+         * @request GET:/contracts/{contract_address}/current-liveness
+         */
+        getContractsContractAddressCurrentLiveness: (contractAddress: string, params?: RequestParams) => Promise<ContractLiveness>;
         /**
          * @description Get contract parent address if exist
          *

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

@@ -377,6 +377,19 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Get public key of p2pkh addresses, the address needs to have at least one input.
+             *
+             * @tags Addresses
+             * @name GetAddressesAddressPublicKey
+             * @request GET:/addresses/{address}/public-key
+             */
+            getAddressesAddressPublicKey: (address, params = {}) => this.request({
+                path: `/addresses/${address}/public-key`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * @description Get address tokens with balance
              *
@@ -781,6 +794,19 @@ class Api extends HttpClient {
             }).then(utils_1.convertHttpResponse)
         };
         this.contracts = {
+            /**
+             * @description Get contract liveness
+             *
+             * @tags Contracts
+             * @name GetContractsContractAddressCurrentLiveness
+             * @request GET:/contracts/{contract_address}/current-liveness
+             */
+            getContractsContractAddressCurrentLiveness: (contractAddress, params = {}) => this.request({
+                path: `/contracts/${contractAddress}/current-liveness`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * @description Get contract parent address if exist
              *

package/dist/src/block/block.d.ts

@@ -1,28 +1,27 @@
 import { Subscription, SubscribeOptions } from '../utils/subscription';
 import * as node from '../api/api-alephium';
 import { NodeProvider } from '../api';
-export type ReorgCallback = (orphanBlocks: node.BlockEntry[], newBlocks: node.BlockEntry[]) => Promise<void> | void;
-export interface BlockSubscribeOptions extends SubscribeOptions<node.BlockEntry> {
+export type ReorgCallback = (fromGroup: number, toGroup: number, orphanBlocks: node.BlockEntry[], newBlocks: node.BlockEntry[]) => Promise<void> | void;
+export interface BlockSubscribeOptions extends SubscribeOptions<node.BlockEntry[]> {
     reorgCallback?: ReorgCallback;
 }
-export declare abstract class BlockSubscriptionBase extends Subscription<node.BlockEntry> {
+export declare abstract class BlockSubscriptionBase extends Subscription<node.BlockEntry[]> {
     abstract readonly reorgCallback?: ReorgCallback;
-    abstract readonly fromGroup: number;
-    abstract readonly toGroup: number;
-    abstract getHashesAtHeight(height: number): Promise<string[]>;
+    abstract getHashesAtHeight(fromGroup: number, toGroup: number, height: number): Promise<string[]>;
     abstract getBlockByHash(hash: string): Promise<node.BlockEntry>;
     protected getParentHash(block: node.BlockEntry): string;
-    protected handleReorg(blockHash: string, blockHeight: number): Promise<void>;
+    protected handleReorg(fromGroup: number, toGroup: number, orphanBlockHash: string, newBlockHash: string): Promise<void>;
 }
 export declare class BlockSubscription extends BlockSubscriptionBase {
     readonly nodeProvider: NodeProvider;
-    readonly fromGroup: number;
-    readonly toGroup: number;
     readonly reorgCallback?: ReorgCallback;
-    private currentBlockHeight;
-    private parentBlockHash;
-    constructor(options: BlockSubscribeOptions, fromGroup: number, toGroup: number, fromBlockHeight: number, nodeProvider?: NodeProvider | undefined);
-    getHashesAtHeight(height: number): Promise<string[]>;
+    private fromTimeStamp;
+    private parents;
+    private cache;
+    constructor(options: BlockSubscribeOptions, fromTimeStamp: number, nodeProvider?: NodeProvider | undefined);
+    getHashesAtHeight(fromGroup: number, toGroup: number, height: number): Promise<string[]>;
     getBlockByHash(hash: string): Promise<node.BlockEntry>;
+    private getMissingBlocksAndHandleReorg;
+    private handleBlocks;
     polling(): Promise<void>;
 }

package/dist/src/block/block.js

@@ -43,88 +43,129 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockSubscription = exports.BlockSubscriptionBase = void 0;
 const subscription_1 = require("../utils/subscription");
 const web3 = __importStar(require("../global"));
+const constants_1 = require("../constants");
+const DEFAULT_INTERVAL = 60 * 1000; // 60 seconds
+const EXPIRE_DURATION = 20 * 1000; // 20 seconds
 class BlockSubscriptionBase extends subscription_1.Subscription {
     getParentHash(block) {
-        const index = Math.floor(block.deps.length / 2) + this.toGroup;
+        const index = Math.floor(block.deps.length / 2) + block.chainTo;
         return block.deps[index];
     }
-    async handleReorg(blockHash, blockHeight) {
-        console.info(`reorg occur, hash: ${blockHash}, height: ${blockHeight}`);
+    async handleReorg(fromGroup, toGroup, orphanBlockHash, newBlockHash) {
+        console.info(`reorg occur in chain ${fromGroup} -> ${toGroup}, orphan hash: ${orphanBlockHash}, new hash: ${newBlockHash}`);
         if (this.reorgCallback === undefined)
             return;
-        const orphans = [];
-        const newHashes = [];
-        let fromHash = blockHash;
-        let fromHeight = blockHeight;
+        const orphanBlocks = [];
+        let fromHash = orphanBlockHash;
+        let canonicalHash = undefined;
         while (true) {
-            const hashes = await this.getHashesAtHeight(fromHeight);
-            const canonicalHash = hashes[0];
-            if (canonicalHash !== fromHash) {
-                orphans.push(fromHash);
-                newHashes.push(canonicalHash);
-                const block = await this.getBlockByHash(fromHash);
-                fromHash = this.getParentHash(block);
-                fromHeight -= 1;
-            }
-            else {
+            const orphanBlock = await this.getBlockByHash(fromHash);
+            orphanBlocks.push(orphanBlock);
+            const hashes = await this.getHashesAtHeight(fromGroup, toGroup, orphanBlock.height - 1);
+            const parentHash = this.getParentHash(orphanBlock);
+            if (hashes[0] === parentHash) {
+                canonicalHash = hashes[0];
                 break;
             }
-        }
-        const orphanBlocks = [];
-        for (const hash of orphans.reverse()) {
-            const block = await this.getBlockByHash(hash);
-            orphanBlocks.push(block);
+            fromHash = parentHash;
         }
         const newBlocks = [];
-        for (const hash of newHashes.reverse()) {
-            const block = await this.getBlockByHash(hash);
-            newBlocks.push(block);
+        fromHash = newBlockHash;
+        while (fromHash !== canonicalHash) {
+            const newBlock = await this.getBlockByHash(fromHash);
+            newBlocks.push(newBlock);
+            fromHash = this.getParentHash(newBlock);
         }
-        console.info(`orphan hashes: ${orphanBlocks.map((b) => b.hash)}, new hashes: ${newBlocks.map((b) => b.hash)}`);
-        await this.reorgCallback(orphanBlocks, newBlocks);
+        const orphans = orphanBlocks.reverse();
+        const news = newBlocks.reverse();
+        console.info(`orphan hashes: ${orphans.map((b) => b.hash)}, new hashes: ${news.map((b) => b.hash)}`);
+        await this.reorgCallback(fromGroup, toGroup, orphans, news);
     }
 }
 exports.BlockSubscriptionBase = BlockSubscriptionBase;
 class BlockSubscription extends BlockSubscriptionBase {
-    constructor(options, fromGroup, toGroup, fromBlockHeight, nodeProvider = undefined) {
+    constructor(options, fromTimeStamp, nodeProvider = undefined) {
         super(options);
         this.nodeProvider = nodeProvider ?? web3.getCurrentNodeProvider();
-        this.fromGroup = fromGroup;
-        this.toGroup = toGroup;
         this.reorgCallback = options.reorgCallback;
-        this.currentBlockHeight = fromBlockHeight;
-        this.parentBlockHash = undefined;
+        this.fromTimeStamp = fromTimeStamp;
+        this.parents = new Array(constants_1.TOTAL_NUMBER_OF_CHAINS).fill(undefined);
+        this.cache = new Map();
     }
-    async getHashesAtHeight(height) {
-        const result = await this.nodeProvider.blockflow.getBlockflowHashes({
-            fromGroup: this.fromGroup,
-            toGroup: this.toGroup,
-            height
-        });
+    async getHashesAtHeight(fromGroup, toGroup, height) {
+        const result = await this.nodeProvider.blockflow.getBlockflowHashes({ fromGroup, toGroup, height });
         return result.headers;
     }
     async getBlockByHash(hash) {
         return await this.nodeProvider.blockflow.getBlockflowBlocksBlockHash(hash);
     }
-    async polling() {
+    async getMissingBlocksAndHandleReorg(fromHash, fromHeight, toBlock) {
+        const blocks = [];
+        let lastBlock = toBlock;
+        while (lastBlock.height - 1 > fromHeight) {
+            const parentHash = this.getParentHash(lastBlock);
+            const block = await this.getBlockByHash(parentHash);
+            blocks.push(block);
+            lastBlock = block;
+        }
+        const parentHash = this.getParentHash(lastBlock);
+        if (parentHash !== fromHash) {
+            await this.handleReorg(toBlock.chainFrom, toBlock.chainTo, fromHash, parentHash);
+        }
+        return blocks.reverse();
+    }
+    async handleBlocks(blocks, now) {
+        const allBlocks = [];
+        for (let index = 0; index < blocks.length; index += 1) {
+            const blocksPerChain = blocks[index].filter((b) => !this.cache.has(b.hash));
+            if (blocksPerChain.length === 0)
+                continue;
+            allBlocks.push(...blocksPerChain);
+            const parent = this.parents[index];
+            if (parent !== undefined) {
+                const missingBlocks = await this.getMissingBlocksAndHandleReorg(parent.hash, parent.height, blocksPerChain[0]);
+                allBlocks.push(...missingBlocks);
+            }
+            const latestBlock = blocksPerChain[blocksPerChain.length - 1];
+            this.parents[index] = { hash: latestBlock.hash, height: latestBlock.height };
+        }
+        const sortedBlocks = allBlocks.sort((a, b) => a.timestamp - b.timestamp);
         try {
-            const chainInfo = await this.nodeProvider.blockflow.getBlockflowChainInfo({
-                fromGroup: this.fromGroup,
-                toGroup: this.toGroup
+            await this.messageCallback(sortedBlocks);
+        }
+        finally {
+            const threshold = now - EXPIRE_DURATION;
+            Array.from(this.cache.entries()).forEach(([hash, ts]) => {
+                if (ts < threshold)
+                    this.cache.delete(hash);
             });
-            while (this.currentBlockHeight <= chainInfo.currentHeight) {
-                const hashes = await this.getHashesAtHeight(this.currentBlockHeight);
-                const block = await this.getBlockByHash(hashes[0]);
-                if (this.parentBlockHash !== undefined && this.getParentHash(block) !== this.parentBlockHash) {
-                    await this.handleReorg(this.parentBlockHash, this.currentBlockHeight - 1);
-                }
-                await this.messageCallback(block);
-                this.currentBlockHeight += 1;
-                this.parentBlockHash = hashes[0];
+            const index = sortedBlocks.findIndex((b) => b.timestamp >= threshold);
+            if (index !== -1) {
+                sortedBlocks.slice(index).forEach((b) => this.cache.set(b.hash, b.timestamp));
             }
         }
-        catch (err) {
-            await this.errorCallback(err, this);
+    }
+    async polling() {
+        const now = Date.now();
+        if (this.fromTimeStamp >= now)
+            return;
+        while (this.fromTimeStamp < now) {
+            if (this.isCancelled())
+                return;
+            const toTs = Math.min(this.fromTimeStamp + DEFAULT_INTERVAL, now);
+            try {
+                const result = await this.nodeProvider.blockflow.getBlockflowBlocks({ fromTs: this.fromTimeStamp, toTs });
+                await this.handleBlocks(result.blocks, now);
+            }
+            catch (err) {
+                await this.errorCallback(err, this);
+            }
+            if (this.fromTimeStamp + EXPIRE_DURATION < now) {
+                this.fromTimeStamp = Math.min(toTs + 1, now - EXPIRE_DURATION);
+            }
+            else {
+                return;
+            }
         }
     }
 }

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@alephium/web3",
-  "version": "0.44.0",
+  "version": "1.0.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
   "browser": "dist/alephium-web3.min.js",
   "types": "dist/src/index.d.ts",
   "exports": {
-    "node": "./dist/src/index.js",
-    "default": "./dist/alephium-web3.min.js"
+    "node": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "default": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/alephium-web3.min.js"
+    }
   },
   "typesVersions": {
     "*": {
@@ -27,8 +33,8 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "2.14.0",
-    "explorer_backend_version": "1.17.0"
+    "alephium_version": "3.1.0",
+    "explorer_backend_version": "1.19.3"
   },
   "type": "commonjs",
   "dependencies": {

package/src/address/address.ts

@@ -28,6 +28,7 @@ import { MultiSig, lockupScriptCodec } from '../codec/lockup-script-codec'
 import { compactSignedIntCodec } from '../codec'
 
 const ec = new EC('secp256k1')
+const PublicKeyHashSize = 32
 
 export enum AddressType {
   P2PKH = 0x00,
@@ -59,10 +60,13 @@ function decodeAndValidateAddress(address: string): Uint8Array {
     }
     const n = multisig.publicKeyHashes.value.length
     const m = compactSignedIntCodec.toI32(multisig.m)
-    if (n < m) {
+    if (n < m || m <= 0) {
       throw new Error(`Invalid multisig address, n: ${n}, m: ${m}`)
     }
-    return decoded
+    const encodedNSize = compactSignedIntCodec.encodeI32(n).length
+    const encodedMSize = multisig.m.rest.length + 1
+    const size = encodedNSize + PublicKeyHashSize * n + encodedMSize + 1 // 1 for the P2MPKH prefix
+    if (decoded.length === size) return decoded
   } else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {
     // [type, ...hash]
     if (decoded.length === 33) return decoded