@alephium/web3 0.25.2 → 0.27.0

package/src/api/api-explorer.ts

@@ -136,6 +136,15 @@ export interface ExplorerInfo {
   lastFinalizedInputTime: number
 }
 
+export interface FungibleTokenMetadata {
+  /** @format 32-byte-hash */
+  id: string
+  symbol: string
+  name: string
+  /** @format uint256 */
+  decimals: string
+}
+
 export interface Hashrate {
   /** @format int64 */
   timestamp: number
@@ -193,6 +202,22 @@ export interface MempoolTransaction {
   lastSeen: number
 }
 
+export interface NFTCollectionMetadata {
+  /** @format address */
+  address: string
+  collectionUri: string
+}
+
+export interface NFTMetadata {
+  /** @format 32-byte-hash */
+  id: string
+  tokenUri: string
+  /** @format 32-byte-hash */
+  collectionId: string
+  /** @format uint256 */
+  nftIndex: string
+}
+
 export interface NotFound {
   detail: string
   resource: string
@@ -284,6 +309,19 @@ export interface Token {
   amount: string
 }
 
+export interface TokenInfo {
+  /** @format 32-byte-hash */
+  token: string
+  /** Raw interface id, e.g. 0001 */
+  stdInterfaceId?: TokenStdInterfaceId | string
+}
+
+export enum TokenStdInterfaceId {
+  Fungible = 'fungible',
+  NonFungible = 'non-fungible',
+  NonStandard = 'non-standard'
+}
+
 export interface TokenSupply {
   /** @format int64 */
   timestamp: number
@@ -358,6 +396,14 @@ export interface ValU256 {
   type: string
 }
 
+export enum MaxSizeTokens {
+  Value80 = 80
+}
+
+export enum MaxSizeAddresses {
+  Value80 = 80
+}
+
 import 'cross-fetch/polyfill'
 import { convertHttpResponse } from './utils'
 
@@ -845,6 +891,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @tags Addresses
      * @name GetAddressesAddressTokens
      * @request GET:/addresses/{address}/tokens
+     * @deprecated
      */
     getAddressesAddressTokens: (
       address: string,
@@ -1223,7 +1270,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
   }
   tokens = {
     /**
-     * @description List tokens
+     * @description List token information
      *
      * @tags Tokens
      * @name GetTokens
@@ -1241,10 +1288,15 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
          * @format int32
          */
         limit?: number
+        /**
+         * fungible, non-fungible, non-standard or any interface id in hex-string format, e.g: 0001
+         * @format string
+         */
+        'interface-id'?: TokenStdInterfaceId | string
       },
       params: RequestParams = {}
     ) =>
-      this.request<string[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+      this.request<TokenInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/tokens`,
         method: 'GET',
         query: query,
@@ -1252,6 +1304,23 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description list given tokens information
+     *
+     * @tags Tokens
+     * @name PostTokens
+     * @request POST:/tokens
+     */
+    postTokens: (data?: string[], params: RequestParams = {}) =>
+      this.request<TokenInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description List token transactions
      *
@@ -1281,6 +1350,63 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         query: query,
         format: 'json',
         ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Return metadata for the given fungible tokens, if metadata doesn't exist or token isn't a fungible, it won't be in the output list
+     *
+     * @tags Tokens
+     * @name PostTokensFungibleMetadata
+     * @request POST:/tokens/fungible-metadata
+     */
+    postTokensFungibleMetadata: (data?: string[], params: RequestParams = {}) =>
+      this.request<
+        FungibleTokenMetadata[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/tokens/fungible-metadata`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        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
+     *
+     * @tags Tokens
+     * @name PostTokensNftMetadata
+     * @request POST:/tokens/nft-metadata
+     */
+    postTokensNftMetadata: (data?: string[], params: RequestParams = {}) =>
+      this.request<NFTMetadata[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/nft-metadata`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Return metadata for the given nft collection addresses, if metadata doesn't exist or address isn't a nft collection, it won't be in the output list
+     *
+     * @tags Tokens
+     * @name PostTokensNftCollectionMetadata
+     * @request POST:/tokens/nft-collection-metadata
+     */
+    postTokensNftCollectionMetadata: (data?: string[], params: RequestParams = {}) =>
+      this.request<
+        NFTCollectionMetadata[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/tokens/nft-collection-metadata`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
       }).then(convertHttpResponse)
   }
   charts = {
@@ -1467,12 +1593,12 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @description Get contract parent address if exist
      *
      * @tags Contracts
-     * @name GetContractsContractParent
-     * @request GET:/contracts/{contract}/parent
+     * @name GetContractsContractAddressParent
+     * @request GET:/contracts/{contract_address}/parent
      */
-    getContractsContractParent: (contract: string, params: RequestParams = {}) =>
+    getContractsContractAddressParent: (contractAddress: string, params: RequestParams = {}) =>
       this.request<ContractParent, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/contracts/${contract}/parent`,
+        path: `/contracts/${contractAddress}/parent`,
         method: 'GET',
         format: 'json',
         ...params
@@ -1482,11 +1608,11 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @description Get sub contract addresses
      *
      * @tags Contracts
-     * @name GetContractsContractSubContracts
-     * @request GET:/contracts/{contract}/sub-contracts
+     * @name GetContractsContractAddressSubContracts
+     * @request GET:/contracts/{contract_address}/sub-contracts
      */
-    getContractsContractSubContracts: (
-      contract: string,
+    getContractsContractAddressSubContracts: (
+      contractAddress: string,
       query?: {
         /**
          * Page number
@@ -1502,7 +1628,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       params: RequestParams = {}
     ) =>
       this.request<SubContracts, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/contracts/${contract}/sub-contracts`,
+        path: `/contracts/${contractAddress}/sub-contracts`,
         method: 'GET',
         query: query,
         format: 'json',

package/src/utils/exchange.ts

@@ -37,16 +37,35 @@ export function validateExchangeAddress(address: string) {
   }
 }
 
-export function isDepositALPHTransaction(tx: Transaction, exchangeAddress: string): boolean {
-  return isDepositTransaction(tx, exchangeAddress) && checkALPHOutput(tx)
+export function isSimpleALPHTransferTx(tx: Transaction): boolean {
+  return isSimpleTransferTx(tx) && checkALPHOutput(tx)
 }
 
-export function isDepositTokenTransaction(tx: Transaction, exchangeAddress: string): boolean {
-  return isDepositTransaction(tx, exchangeAddress) && checkTokenOutput(tx, exchangeAddress)
+export function isSimpleTransferTokenTx(tx: Transaction): boolean {
+  const isTransferTx = isSimpleTransferTx(tx)
+  if (isTransferTx) {
+    const senderAddress = getSenderAddress(tx)
+    const targetAddress = tx.unsigned.fixedOutputs.find((o) => o.address !== senderAddress)!.address
+    return checkTokenOutput(tx, targetAddress)
+  }
+  return false
+}
+
+// we assume that the tx is a simple transfer tx, i.e. isSimpleTransferALPHTx(tx) == true
+export function getALPHDepositInfo(tx: Transaction): { targetAddress: Address; depositAmount: bigint } {
+  const senderAddress = getSenderAddress(tx)
+  const targetAddress = tx.unsigned.fixedOutputs.find((o) => o.address !== senderAddress)!.address
+  let depositAmount = 0n
+  tx.unsigned.fixedOutputs.forEach((o) => {
+    if (o.address === targetAddress) {
+      depositAmount += BigInt(o.attoAlphAmount)
+    }
+  })
+  return { targetAddress, depositAmount }
 }
 
-// we assume that the tx is deposit transaction
-export function getDepositAddress(tx: Transaction): Address {
+// we assume that the tx is a simple transfer tx, i.e. isSimpleTransferALPHTx(tx) == true
+export function getSenderAddress(tx: Transaction): Address {
   return getAddressFromUnlockScript(tx.unsigned.inputs[0].unlockScript)
 }
 
@@ -77,31 +96,17 @@ export function getAddressFromUnlockScript(unlockScript: string): Address {
   }
 }
 
-function getFromAddress(tx: Transaction): Address | undefined {
+function getSenderAddressAnyTx(tx: Transaction): Address | undefined {
   try {
     const inputAddresses = tx.unsigned.inputs.map((i) => getAddressFromUnlockScript(i.unlockScript))
     // we have checked that the inputs is not empty
-    const from = inputAddresses[0]
-    return inputAddresses.slice(1).every((addr) => addr === from) ? from : undefined
+    const sender = inputAddresses[0]
+    return inputAddresses.slice(1).every((addr) => addr === sender) ? sender : undefined
   } catch (_) {
     return undefined
   }
 }
 
-function checkOutputAddress(tx: Transaction, from: Address, to: Address): boolean {
-  let fromCount = 0
-  let toCount = 0
-  tx.unsigned.fixedOutputs.forEach((o) => {
-    if (o.address === from) {
-      fromCount += 1
-    } else if (o.address === to) {
-      toCount += 1
-    }
-  })
-  const outputCount = tx.unsigned.fixedOutputs.length
-  return toCount === 1 && fromCount === outputCount - 1
-}
-
 function checkALPHOutput(tx: Transaction): boolean {
   const outputs = tx.unsigned.fixedOutputs
   return outputs.every((o) => o.tokens.length === 0)
@@ -109,11 +114,17 @@ function checkALPHOutput(tx: Transaction): boolean {
 
 function checkTokenOutput(tx: Transaction, to: Address): boolean {
   // we have checked the output address
-  const output = tx.unsigned.fixedOutputs.find((o) => o.address === to)!
-  return output.attoAlphAmount === DUST_AMOUNT.toString() && output.tokens.length === 1
+  const outputs = tx.unsigned.fixedOutputs.filter((o) => o.address === to)
+  if (outputs[0].tokens.length === 0) {
+    return false
+  }
+  const tokenId = outputs[0].tokens[0].id
+  return outputs.every(
+    (o) => BigInt(o.attoAlphAmount) === DUST_AMOUNT && o.tokens.length === 1 && o.tokens[0].id === tokenId
+  )
 }
 
-function isDepositTransaction(tx: Transaction, exchangeAddress: string): boolean {
+function isSimpleTransferTx(tx: Transaction): boolean {
   if (
     tx.contractInputs.length !== 0 ||
     tx.generatedOutputs.length !== 0 ||
@@ -122,9 +133,18 @@ function isDepositTransaction(tx: Transaction, exchangeAddress: string): boolean
   ) {
     return false
   }
-  const from = getFromAddress(tx)
-  if (from === undefined || from === exchangeAddress) {
+  const sender = getSenderAddressAnyTx(tx)
+  if (sender === undefined) {
     return false
   }
-  return checkOutputAddress(tx, from, exchangeAddress)
+  const outputAddresses: Address[] = []
+  tx.unsigned.fixedOutputs.forEach((o) => {
+    if (!outputAddresses.includes(o.address)) {
+      outputAddresses.push(o.address)
+    }
+  })
+  return (
+    (outputAddresses.length === 1 && outputAddresses[0] !== sender) ||
+    (outputAddresses.length === 2 && outputAddresses.includes(sender))
+  )
 }

package/src/utils/index.ts

@@ -26,7 +26,8 @@ export * from './sign'
 export * from './number'
 export {
   validateExchangeAddress,
-  isDepositALPHTransaction,
-  isDepositTokenTransaction,
-  getDepositAddress
+  isSimpleALPHTransferTx,
+  isSimpleTransferTokenTx,
+  getSenderAddress,
+  getALPHDepositInfo
 } from './exchange'