@alephium/web3 0.21.2 → 0.23.0

package/dist/src/api/node-provider.js

@@ -57,10 +57,46 @@ class NodeProvider {
         this.fetchNFTMetaData = async (tokenId) => {
             const address = (0, utils_1.addressFromTokenId)(tokenId);
             const group = (0, utils_1.groupOfAddress)(address);
-            const result = await this.contracts.postContractsCallContract({ methodIndex: 0, group, address });
-            return {
-                tokenUri: (0, utils_1.hexToString)((0, contract_1.tryGetCallResult)(result).returns[0].value)
-            };
+            const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }));
+            const result = await this.contracts.postContractsMulticallContract({
+                calls: calls
+            });
+            const tokenUri = (0, utils_1.hexToString)((0, contract_1.tryGetCallResult)(result.results[0]).returns[0].value);
+            const collectionIndexResult = result.results[1];
+            if (collectionIndexResult.type === 'CallContractSucceeded') {
+                const successfulCollectionIndexResult = result.results[1];
+                const contractIdReturnResult = successfulCollectionIndexResult.returns[0];
+                if (contractIdReturnResult === undefined) {
+                    throw new Error('Deprecated NFT contract');
+                }
+                const collectionId = successfulCollectionIndexResult.returns[0].value;
+                if (collectionId === undefined || !(0, utils_1.isHexString)(collectionId) || collectionId.length !== 64) {
+                    throw new Error('Deprecated NFT contract');
+                }
+                const nftIndexReturnResult = successfulCollectionIndexResult.returns[1];
+                if (nftIndexReturnResult === undefined) {
+                    throw new Error('Deprecated NFT contract');
+                }
+                const nftIndex = (0, utils_1.toNonNegativeBigInt)(nftIndexReturnResult.value);
+                if (nftIndex === undefined) {
+                    throw new Error('Deprecated NFT contract');
+                }
+                // If there are more return values, it is also a deprecated NFT contract
+                const thirdResult = successfulCollectionIndexResult.returns[2];
+                if (thirdResult !== undefined) {
+                    throw new Error('Deprecated NFT contract');
+                }
+                return { tokenUri, collectionId, nftIndex };
+            }
+            else {
+                const failedCollectionIndexResult = result.results[1];
+                if (failedCollectionIndexResult.error.startsWith('VM execution error: InvalidMethodIndex')) {
+                    throw new Error('Deprecated NFT contract');
+                }
+                else {
+                    throw new Error(`Failed to call contract, error: ${failedCollectionIndexResult.error}`);
+                }
+            }
         };
         // Only use this when the contract follows the NFT collection interface, check `guessFollowsNFTCollectionStd` first
         this.fetchNFTCollectionMetaData = async (contractId) => {

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

@@ -38,13 +38,15 @@ export declare enum StdInterfaceIds {
     NFTCollectionWithRoyalty = "000201"
 }
 export interface FungibleTokenMetaData {
-    name: string;
     symbol: string;
+    name: string;
     decimals: number;
     totalSupply: Number256;
 }
 export interface NFTMetaData {
     tokenUri: string;
+    collectionId: string;
+    nftIndex: Number256;
 }
 export interface NFTCollectionMetaData {
     collectionUri: string;

package/dist/src/contract/contract.js

@@ -556,9 +556,9 @@ class Contract extends Artifact {
         const fields = this.stdInterfaceId === undefined
             ? this.fieldsSig
             : {
-                names: this.fieldsSig.names.slice(-1),
-                types: this.fieldsSig.types.slice(-1),
-                isMutable: this.fieldsSig.isMutable.slice(-1)
+                names: this.fieldsSig.names.slice(0, -1),
+                types: this.fieldsSig.types.slice(0, -1),
+                isMutable: this.fieldsSig.isMutable.slice(0, -1)
             };
         return fields.names.reduce((acc, key, index) => {
             acc[`${key}`] = (0, api_1.getDefaultValue)(fields.types[`${index}`]);

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

@@ -0,0 +1,7 @@
+import { Transaction } from '../api/api-alephium';
+import { Address } from '../signer';
+export declare function isExchangeAddress(address: string): boolean;
+export declare function isDepositALPHTransaction(tx: Transaction, exchangeAddress: string): boolean;
+export declare function isDepositTokenTransaction(tx: Transaction, exchangeAddress: string): boolean;
+export declare function getDepositAddress(tx: Transaction): Address;
+export declare function getAddressFromUnlockScript(unlockScript: string): Address;

package/dist/src/utils/exchange.js

@@ -0,0 +1,119 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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.getAddressFromUnlockScript = exports.getDepositAddress = exports.isDepositTokenTransaction = exports.isDepositALPHTransaction = exports.isExchangeAddress = void 0;
+const __1 = require("..");
+function isExchangeAddress(address) {
+    const decoded = __1.bs58.decode(address);
+    if (decoded.length === 0)
+        throw new Error('Address is empty');
+    const addressType = decoded[0];
+    return (addressType === __1.AddressType.P2PKH || addressType === __1.AddressType.P2SH) && decoded.length === 33;
+}
+exports.isExchangeAddress = isExchangeAddress;
+function isDepositALPHTransaction(tx, exchangeAddress) {
+    return isDepositTransaction(tx, exchangeAddress) && checkALPHOutput(tx);
+}
+exports.isDepositALPHTransaction = isDepositALPHTransaction;
+function isDepositTokenTransaction(tx, exchangeAddress) {
+    return isDepositTransaction(tx, exchangeAddress) && checkTokenOutput(tx, exchangeAddress);
+}
+exports.isDepositTokenTransaction = isDepositTokenTransaction;
+// we assume that the tx is deposit transaction
+function getDepositAddress(tx) {
+    return getAddressFromUnlockScript(tx.unsigned.inputs[0].unlockScript);
+}
+exports.getDepositAddress = getDepositAddress;
+var UnlockScriptType;
+(function (UnlockScriptType) {
+    UnlockScriptType[UnlockScriptType["P2PKH"] = 0] = "P2PKH";
+    UnlockScriptType[UnlockScriptType["P2MPKH"] = 1] = "P2MPKH";
+    UnlockScriptType[UnlockScriptType["P2SH"] = 2] = "P2SH";
+})(UnlockScriptType || (UnlockScriptType = {}));
+function getAddressFromUnlockScript(unlockScript) {
+    const decoded = (0, __1.hexToBinUnsafe)(unlockScript);
+    if (decoded.length === 0)
+        throw new Error('UnlockScript is empty');
+    const unlockScriptType = decoded[0];
+    const unlockScriptBody = decoded.slice(1);
+    if (unlockScriptType === UnlockScriptType.P2PKH) {
+        return (0, __1.addressFromPublicKey)((0, __1.binToHex)(unlockScriptBody));
+    }
+    else if (unlockScriptType === UnlockScriptType.P2MPKH) {
+        throw new Error('Naive multi-sig address is not supported for exchanges as it will be replaced by P2SH');
+    }
+    else if (unlockScriptType === UnlockScriptType.P2SH) {
+        // FIXEME: for now we assume that the params is empty, so we need to
+        // remove the last byte from the `unlockScriptBody`, we can decode
+        // the unlock script once the codec PR is merged
+        const script = unlockScriptBody.slice(0, -1);
+        return (0, __1.addressFromScript)(script);
+    }
+    else {
+        throw new Error('Invalid unlock script type');
+    }
+}
+exports.getAddressFromUnlockScript = getAddressFromUnlockScript;
+function getFromAddress(tx) {
+    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;
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+function checkOutputAddress(tx, from, to) {
+    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) {
+    const outputs = tx.unsigned.fixedOutputs;
+    return outputs.every((o) => o.tokens.length === 0);
+}
+function checkTokenOutput(tx, to) {
+    // we have checked the output address
+    const output = tx.unsigned.fixedOutputs.find((o) => o.address === to);
+    return output.attoAlphAmount === __1.DUST_AMOUNT.toString() && output.tokens.length === 1;
+}
+function isDepositTransaction(tx, exchangeAddress) {
+    if (tx.contractInputs.length !== 0 ||
+        tx.generatedOutputs.length !== 0 ||
+        tx.unsigned.inputs.length === 0 ||
+        tx.unsigned.scriptOpt !== undefined) {
+        return false;
+    }
+    const from = getFromAddress(tx);
+    if (from === undefined) {
+        return false;
+    }
+    return checkOutputAddress(tx, from, exchangeAddress);
+}

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

@@ -6,3 +6,4 @@ export * from './utils';
 export * from './subscription';
 export * from './sign';
 export * from './number';
+export { isExchangeAddress, isDepositALPHTransaction, isDepositTokenTransaction, getDepositAddress } from './exchange';

package/dist/src/utils/index.js

@@ -31,6 +31,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDepositAddress = exports.isDepositTokenTransaction = exports.isDepositALPHTransaction = exports.isExchangeAddress = void 0;
 __exportStar(require("./webcrypto"), exports);
 __exportStar(require("./address"), exports);
 __exportStar(require("./bs58"), exports);
@@ -39,3 +40,8 @@ __exportStar(require("./utils"), exports);
 __exportStar(require("./subscription"), exports);
 __exportStar(require("./sign"), exports);
 __exportStar(require("./number"), exports);
+var exchange_1 = require("./exchange");
+Object.defineProperty(exports, "isExchangeAddress", { enumerable: true, get: function () { return exchange_1.isExchangeAddress; } });
+Object.defineProperty(exports, "isDepositALPHTransaction", { enumerable: true, get: function () { return exchange_1.isDepositALPHTransaction; } });
+Object.defineProperty(exports, "isDepositTokenTransaction", { enumerable: true, get: function () { return exchange_1.isDepositTokenTransaction; } });
+Object.defineProperty(exports, "getDepositAddress", { enumerable: true, get: function () { return exchange_1.getDepositAddress; } });

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

@@ -12,6 +12,13 @@ export declare function encodeHexSignature(rHex: string, sHex: string): string;
 export declare function signatureDecode(ec: EC, signature: string): SignatureInput;
 export declare function xorByte(intValue: number): number;
 export declare function isHexString(input: string): boolean;
+export declare function toNonNegativeBigInt(input: string): bigint | undefined;
+export declare enum AddressType {
+    P2PKH = 0,
+    P2MPKH = 1,
+    P2SH = 2,
+    P2C = 3
+}
 export declare function groupOfAddress(address: string): number;
 export declare function contractIdFromAddress(address: string): Uint8Array;
 export declare function tokenIdFromAddress(address: string): Uint8Array;
@@ -20,6 +27,7 @@ export declare function binToHex(bin: Uint8Array): string;
 export declare function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number;
 export declare function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string;
 export declare function addressFromPublicKey(publicKey: string, _keyType?: KeyType): string;
+export declare function addressFromScript(script: Uint8Array): string;
 export declare function addressFromContractId(contractId: string): string;
 export declare function addressFromTokenId(tokenId: string): string;
 export declare function contractIdFromTx(txId: string, outputIndex: number): string;

package/dist/src/utils/utils.js

@@ -20,7 +20,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertType = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.binToHex = exports.hexToBinUnsafe = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isHexString = exports.xorByte = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = void 0;
+exports.assertType = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.binToHex = exports.hexToBinUnsafe = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.AddressType = exports.toNonNegativeBigInt = exports.isHexString = exports.xorByte = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = void 0;
 const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
 const blakejs_1 = __importDefault(require("blakejs"));
@@ -72,13 +72,23 @@ function isHexString(input) {
     return input.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(input);
 }
 exports.isHexString = isHexString;
+function toNonNegativeBigInt(input) {
+    try {
+        const bigIntValue = BigInt(input);
+        return bigIntValue < 0n ? undefined : bigIntValue;
+    }
+    catch {
+        return undefined;
+    }
+}
+exports.toNonNegativeBigInt = toNonNegativeBigInt;
 var AddressType;
 (function (AddressType) {
     AddressType[AddressType["P2PKH"] = 0] = "P2PKH";
     AddressType[AddressType["P2MPKH"] = 1] = "P2MPKH";
     AddressType[AddressType["P2SH"] = 2] = "P2SH";
     AddressType[AddressType["P2C"] = 3] = "P2C";
-})(AddressType || (AddressType = {}));
+})(AddressType = exports.AddressType || (exports.AddressType = {}));
 function groupOfAddress(address) {
     const decoded = bs58_1.default.decode(address);
     if (decoded.length == 0)
@@ -179,12 +189,16 @@ function addressFromPublicKey(publicKey, _keyType) {
     }
     else {
         const lockupScript = buffer_1.Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex');
-        const lockupScriptHash = blakejs_1.default.blake2b(lockupScript, undefined, 32);
-        const addressType = buffer_1.Buffer.from([AddressType.P2SH]);
-        return bs58_1.default.encode(buffer_1.Buffer.concat([addressType, lockupScriptHash]));
+        return addressFromScript(lockupScript);
     }
 }
 exports.addressFromPublicKey = addressFromPublicKey;
+function addressFromScript(script) {
+    const scriptHash = blakejs_1.default.blake2b(script, undefined, 32);
+    const addressType = buffer_1.Buffer.from([AddressType.P2SH]);
+    return bs58_1.default.encode(buffer_1.Buffer.concat([addressType, scriptHash]));
+}
+exports.addressFromScript = addressFromScript;
 function addressFromContractId(contractId) {
     const addressType = buffer_1.Buffer.from([AddressType.P2C]);
     const hash = buffer_1.Buffer.from(hexToBinUnsafe(contractId));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.21.2",
+  "version": "0.23.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -82,7 +82,7 @@
     "webpack-cli": "^4.10.0"
   },
   "engines": {
-    "node": ">=16.0.0",
+    "node": ">=14.0.0",
     "npm": ">=7.0.0"
   },
   "scripts": {

package/src/api/node-provider.ts

@@ -26,9 +26,16 @@ import {
   NFTCollectionMetaData,
   StdInterfaceIds
 } from './types'
-import { Api as NodeApi } from './api-alephium'
+import { Api as NodeApi, CallContractFailed, CallContractSucceeded } from './api-alephium'
 import { HexString, tryGetCallResult } from '../contract'
-import { addressFromContractId, addressFromTokenId, groupOfAddress, hexToString } from '../utils'
+import {
+  addressFromContractId,
+  addressFromTokenId,
+  groupOfAddress,
+  hexToString,
+  isHexString,
+  toNonNegativeBigInt
+} from '../utils'
 
 function initializeNodeApi(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): NodeApi<string> {
   const nodeApi = new NodeApi<string>({
@@ -129,9 +136,46 @@ export class NodeProvider implements NodeProviderApis {
   fetchNFTMetaData = async (tokenId: HexString): Promise<NFTMetaData> => {
     const address = addressFromTokenId(tokenId)
     const group = groupOfAddress(address)
-    const result = await this.contracts.postContractsCallContract({ methodIndex: 0, group, address })
-    return {
-      tokenUri: hexToString(tryGetCallResult(result).returns[0].value as any as string)
+    const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }))
+    const result = await this.contracts.postContractsMulticallContract({
+      calls: calls
+    })
+    const tokenUri = hexToString(tryGetCallResult(result.results[0]).returns[0].value as any as string)
+    const collectionIndexResult = result.results[1]
+    if (collectionIndexResult.type === 'CallContractSucceeded') {
+      const successfulCollectionIndexResult = result.results[1] as CallContractSucceeded
+      const contractIdReturnResult = successfulCollectionIndexResult.returns[0]
+      if (contractIdReturnResult === undefined) {
+        throw new Error('Deprecated NFT contract')
+      }
+      const collectionId = successfulCollectionIndexResult.returns[0].value as any as string
+      if (collectionId === undefined || !isHexString(collectionId) || collectionId.length !== 64) {
+        throw new Error('Deprecated NFT contract')
+      }
+
+      const nftIndexReturnResult = successfulCollectionIndexResult.returns[1]
+      if (nftIndexReturnResult === undefined) {
+        throw new Error('Deprecated NFT contract')
+      }
+      const nftIndex = toNonNegativeBigInt(nftIndexReturnResult.value as any as string)
+      if (nftIndex === undefined) {
+        throw new Error('Deprecated NFT contract')
+      }
+
+      // If there are more return values, it is also a deprecated NFT contract
+      const thirdResult = successfulCollectionIndexResult.returns[2]
+      if (thirdResult !== undefined) {
+        throw new Error('Deprecated NFT contract')
+      }
+
+      return { tokenUri, collectionId, nftIndex }
+    } else {
+      const failedCollectionIndexResult = result.results[1] as CallContractFailed
+      if (failedCollectionIndexResult.error.startsWith('VM execution error: InvalidMethodIndex')) {
+        throw new Error('Deprecated NFT contract')
+      } else {
+        throw new Error(`Failed to call contract, error: ${failedCollectionIndexResult.error}`)
+      }
     }
   }
 

package/src/api/types.ts

@@ -291,14 +291,16 @@ export enum StdInterfaceIds {
 }
 
 export interface FungibleTokenMetaData {
-  name: string
   symbol: string
+  name: string
   decimals: number
   totalSupply: Number256
 }
 
 export interface NFTMetaData {
   tokenUri: string
+  collectionId: string
+  nftIndex: Number256
 }
 
 export interface NFTCollectionMetaData {

package/src/contract/contract.ts

@@ -850,9 +850,9 @@ export class Contract extends Artifact {
       this.stdInterfaceId === undefined
         ? this.fieldsSig
         : {
-            names: this.fieldsSig.names.slice(-1),
-            types: this.fieldsSig.types.slice(-1),
-            isMutable: this.fieldsSig.isMutable.slice(-1)
+            names: this.fieldsSig.names.slice(0, -1),
+            types: this.fieldsSig.types.slice(0, -1),
+            isMutable: this.fieldsSig.isMutable.slice(0, -1)
           }
     return fields.names.reduce((acc, key, index) => {
       acc[`${key}`] = getDefaultValue(fields.types[`${index}`])

package/src/utils/exchange.ts

@@ -0,0 +1,120 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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/>.
+*/
+
+import { AddressType, DUST_AMOUNT, addressFromPublicKey, addressFromScript, binToHex, bs58, hexToBinUnsafe } from '..'
+import { Transaction } from '../api/api-alephium'
+import { Address } from '../signer'
+
+export function isExchangeAddress(address: string): boolean {
+  const decoded = bs58.decode(address)
+  if (decoded.length === 0) throw new Error('Address is empty')
+  const addressType = decoded[0]
+  return (addressType === AddressType.P2PKH || addressType === AddressType.P2SH) && decoded.length === 33
+}
+
+export function isDepositALPHTransaction(tx: Transaction, exchangeAddress: string): boolean {
+  return isDepositTransaction(tx, exchangeAddress) && checkALPHOutput(tx)
+}
+
+export function isDepositTokenTransaction(tx: Transaction, exchangeAddress: string): boolean {
+  return isDepositTransaction(tx, exchangeAddress) && checkTokenOutput(tx, exchangeAddress)
+}
+
+// we assume that the tx is deposit transaction
+export function getDepositAddress(tx: Transaction): Address {
+  return getAddressFromUnlockScript(tx.unsigned.inputs[0].unlockScript)
+}
+
+enum UnlockScriptType {
+  P2PKH = 0x00,
+  P2MPKH = 0x01,
+  P2SH = 0x02
+}
+
+export function getAddressFromUnlockScript(unlockScript: string): Address {
+  const decoded = hexToBinUnsafe(unlockScript)
+  if (decoded.length === 0) throw new Error('UnlockScript is empty')
+  const unlockScriptType = decoded[0]
+  const unlockScriptBody = decoded.slice(1)
+
+  if (unlockScriptType === UnlockScriptType.P2PKH) {
+    return addressFromPublicKey(binToHex(unlockScriptBody))
+  } else if (unlockScriptType === UnlockScriptType.P2MPKH) {
+    throw new Error('Naive multi-sig address is not supported for exchanges as it will be replaced by P2SH')
+  } else if (unlockScriptType === UnlockScriptType.P2SH) {
+    // FIXEME: for now we assume that the params is empty, so we need to
+    // remove the last byte from the `unlockScriptBody`, we can decode
+    // the unlock script once the codec PR is merged
+    const script = unlockScriptBody.slice(0, -1)
+    return addressFromScript(script)
+  } else {
+    throw new Error('Invalid unlock script type')
+  }
+}
+
+function getFromAddress(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
+  } 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)
+}
+
+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
+}
+
+function isDepositTransaction(tx: Transaction, exchangeAddress: string): boolean {
+  if (
+    tx.contractInputs.length !== 0 ||
+    tx.generatedOutputs.length !== 0 ||
+    tx.unsigned.inputs.length === 0 ||
+    tx.unsigned.scriptOpt !== undefined
+  ) {
+    return false
+  }
+  const from = getFromAddress(tx)
+  if (from === undefined) {
+    return false
+  }
+  return checkOutputAddress(tx, from, exchangeAddress)
+}

package/src/utils/index.ts

@@ -24,3 +24,4 @@ export * from './utils'
 export * from './subscription'
 export * from './sign'
 export * from './number'
+export { isExchangeAddress, isDepositALPHTransaction, isDepositTokenTransaction, getDepositAddress } from './exchange'

package/src/utils/utils.ts

@@ -75,7 +75,16 @@ export function isHexString(input: string): boolean {
   return input.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(input)
 }
 
-enum AddressType {
+export function toNonNegativeBigInt(input: string): bigint | undefined {
+  try {
+    const bigIntValue = BigInt(input)
+    return bigIntValue < 0n ? undefined : bigIntValue
+  } catch {
+    return undefined
+  }
+}
+
+export enum AddressType {
   P2PKH = 0x00,
   P2MPKH = 0x01,
   P2SH = 0x02,
@@ -187,12 +196,16 @@ export function addressFromPublicKey(publicKey: string, _keyType?: KeyType): str
     return bs58.encode(bytes)
   } else {
     const lockupScript = Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex')
-    const lockupScriptHash = blake.blake2b(lockupScript, undefined, 32)
-    const addressType = Buffer.from([AddressType.P2SH])
-    return bs58.encode(Buffer.concat([addressType, lockupScriptHash]))
+    return addressFromScript(lockupScript)
   }
 }
 
+export function addressFromScript(script: Uint8Array): string {
+  const scriptHash = blake.blake2b(script, undefined, 32)
+  const addressType = Buffer.from([AddressType.P2SH])
+  return bs58.encode(Buffer.concat([addressType, scriptHash]))
+}
+
 export function addressFromContractId(contractId: string): string {
   const addressType = Buffer.from([AddressType.P2C])
   const hash = Buffer.from(hexToBinUnsafe(contractId))

package/std/nft_collection_interface.ral

@@ -26,4 +26,7 @@ Interface INFTCollection {
    pub fn totalSupply() -> U256
 
    pub fn nftByIndex(index: U256) -> INFT
+
+   // Validates that the NFT is part of the collection, otherwise throws exception.
+   pub fn validateNFT(nftId: ByteVec, nftIndex: U256) -> ()
 }

package/std/nft_interface.ral

@@ -22,4 +22,7 @@ Interface INFT {
    //     }
    // }
    pub fn getTokenUri() -> ByteVec
+
+   // Returns collection id and index of the NFT in the collection.
+   pub fn getCollectionIndex() -> (ByteVec, U256)
 }