@alephium/web3 0.39.3 → 0.41.0

package/dist/src/utils/address.js

@@ -28,6 +28,9 @@ const blakejs_1 = __importDefault(require("blakejs"));
 const bs58_1 = __importDefault(require("./bs58"));
 const djb2_1 = __importDefault(require("./djb2"));
 const utils_1 = require("./utils");
+const lockup_script_codec_1 = require("../codec/lockup-script-codec");
+const buffer_1 = require("buffer/");
+const codec_1 = require("../codec");
 const ec = new elliptic_1.ec('secp256k1');
 var AddressType;
 (function (AddressType) {
@@ -52,9 +55,19 @@ function decodeAndValidateAddress(address) {
         throw new Error('Address is empty');
     const addressType = decoded[0];
     if (addressType === AddressType.P2MPKH) {
-        // [1, n, ...hashes, m]
-        if ((decoded.length - 3) % 32 === 0)
-            return decoded;
+        let multisig;
+        try {
+            multisig = lockup_script_codec_1.lockupScriptCodec.decode(buffer_1.Buffer.from(decoded)).script;
+        }
+        catch (_) {
+            throw new Error(`Invalid multisig address: ${address}`);
+        }
+        const n = multisig.publicKeyHashes.value.length;
+        const m = codec_1.compactSignedIntCodec.toI32(multisig.m);
+        if (n < m) {
+            throw new Error(`Invalid multisig address, n: ${n}, m: ${m}`);
+        }
+        return decoded;
     }
     else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {
         // [type, ...hash]
@@ -150,27 +163,27 @@ exports.publicKeyFromPrivateKey = publicKeyFromPrivateKey;
 function addressFromPublicKey(publicKey, _keyType) {
     const keyType = _keyType ?? 'default';
     if (keyType === 'default') {
-        const addressType = Buffer.from([AddressType.P2PKH]);
-        const hash = Buffer.from(blakejs_1.default.blake2b(Buffer.from(publicKey, 'hex'), undefined, 32));
-        const bytes = Buffer.concat([addressType, hash]);
+        const addressType = buffer_1.Buffer.from([AddressType.P2PKH]);
+        const hash = buffer_1.Buffer.from(blakejs_1.default.blake2b(buffer_1.Buffer.from(publicKey, 'hex'), undefined, 32));
+        const bytes = buffer_1.Buffer.concat([addressType, hash]);
         return bs58_1.default.encode(bytes);
     }
     else {
-        const lockupScript = Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex');
+        const lockupScript = buffer_1.Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex');
         return addressFromScript(lockupScript);
     }
 }
 exports.addressFromPublicKey = addressFromPublicKey;
 function addressFromScript(script) {
     const scriptHash = blakejs_1.default.blake2b(script, undefined, 32);
-    const addressType = Buffer.from([AddressType.P2SH]);
-    return bs58_1.default.encode(Buffer.concat([addressType, scriptHash]));
+    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.from([AddressType.P2C]);
-    const hash = Buffer.from((0, utils_1.hexToBinUnsafe)(contractId));
-    const bytes = Buffer.concat([addressType, hash]);
+    const addressType = buffer_1.Buffer.from([AddressType.P2C]);
+    const hash = buffer_1.Buffer.from((0, utils_1.hexToBinUnsafe)(contractId));
+    const bytes = buffer_1.Buffer.concat([addressType, hash]);
     return bs58_1.default.encode(bytes);
 }
 exports.addressFromContractId = addressFromContractId;
@@ -181,7 +194,7 @@ function addressFromTokenId(tokenId) {
 exports.addressFromTokenId = addressFromTokenId;
 function contractIdFromTx(txId, outputIndex) {
     const txIdBin = (0, utils_1.hexToBinUnsafe)(txId);
-    const data = Buffer.concat([txIdBin, Buffer.from([outputIndex])]);
+    const data = buffer_1.Buffer.concat([txIdBin, buffer_1.Buffer.from([outputIndex])]);
     const hash = blakejs_1.default.blake2b(data, undefined, 32);
     return (0, utils_1.binToHex)(hash);
 }
@@ -190,10 +203,10 @@ function subContractId(parentContractId, pathInHex, group) {
     if (group < 0 || group >= constants_1.TOTAL_NUMBER_OF_GROUPS) {
         throw new Error(`Invalid group ${group}`);
     }
-    const data = Buffer.concat([(0, utils_1.hexToBinUnsafe)(parentContractId), (0, utils_1.hexToBinUnsafe)(pathInHex)]);
-    const bytes = Buffer.concat([
+    const data = buffer_1.Buffer.concat([(0, utils_1.hexToBinUnsafe)(parentContractId), (0, utils_1.hexToBinUnsafe)(pathInHex)]);
+    const bytes = buffer_1.Buffer.concat([
         blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
-        Buffer.from([group])
+        buffer_1.Buffer.from([group])
     ]);
     return (0, utils_1.binToHex)(bytes);
 }

package/dist/src/utils/exchange.js

@@ -18,11 +18,14 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAddressFromUnlockScript = exports.getSenderAddress = exports.getALPHDepositInfo = exports.isALPHTransferTx = exports.validateExchangeAddress = void 0;
-const __1 = require("..");
+const utils_1 = require("../utils");
+const unlock_script_codec_1 = require("../codec/unlock-script-codec");
+const buffer_1 = require("buffer/");
+const script_codec_1 = require("../codec/script-codec");
 function validateExchangeAddress(address) {
     let decoded;
     try {
-        decoded = __1.bs58.decode(address);
+        decoded = utils_1.bs58.decode(address);
     }
     catch (_) {
         throw new Error('Invalid base58 string');
@@ -30,7 +33,7 @@ function validateExchangeAddress(address) {
     if (decoded.length === 0)
         throw new Error('Address is empty');
     const addressType = decoded[0];
-    if (addressType !== __1.AddressType.P2PKH && addressType !== __1.AddressType.P2SH) {
+    if (addressType !== utils_1.AddressType.P2PKH && addressType !== utils_1.AddressType.P2SH) {
         throw new Error('Invalid address type');
     }
     if (decoded.length !== 33) {
@@ -83,27 +86,34 @@ var UnlockScriptType;
     UnlockScriptType[UnlockScriptType["P2SH"] = 2] = "P2SH";
 })(UnlockScriptType || (UnlockScriptType = {}));
 function getAddressFromUnlockScript(unlockScript) {
-    const decoded = (0, __1.hexToBinUnsafe)(unlockScript);
+    if (!(0, utils_1.isHexString)(unlockScript)) {
+        throw new Error(`Invalid unlock script ${unlockScript}, expected a hex string`);
+    }
+    const decoded = (0, utils_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));
+        if (unlockScriptBody.length !== 33) {
+            throw new Error(`Invalid p2pkh unlock script: ${unlockScript}`);
+        }
+        return (0, utils_1.addressFromPublicKey)((0, utils_1.binToHex)(unlockScriptBody));
     }
-    else if (unlockScriptType === UnlockScriptType.P2MPKH) {
+    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');
+    if (unlockScriptType === UnlockScriptType.P2SH) {
+        let p2sh;
+        try {
+            p2sh = unlock_script_codec_1.unlockScriptCodec.decode(buffer_1.Buffer.from(decoded)).script;
+        }
+        catch (_) {
+            throw new Error(`Invalid p2sh unlock script: ${unlockScript}`);
+        }
+        return (0, utils_1.addressFromScript)(script_codec_1.scriptCodec.encode(p2sh.script));
     }
+    throw new Error('Invalid unlock script type');
 }
 exports.getAddressFromUnlockScript = getAddressFromUnlockScript;
 function checkALPHOutput(tx) {

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

@@ -1,4 +1,4 @@
-import { Number256 } from '..';
+import { Number256 } from '../api/types';
 export declare const isNumeric: (numToCheck: any) => boolean;
 export interface IPrettifyNumberConfig {
     minDecimalPlaces: number;

package/dist/src/utils/sign.js

@@ -42,7 +42,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifySignature = exports.sign = void 0;
 const elliptic_1 = require("elliptic");
-const __1 = require("..");
+const utils_1 = require("../utils");
 const necc = __importStar(require("@noble/secp256k1"));
 const crypto_1 = require("crypto");
 const ec = new elliptic_1.ec('secp256k1');
@@ -63,11 +63,11 @@ function sign(hash, privateKey, _keyType) {
     if (keyType === 'default') {
         const key = ec.keyFromPrivate(privateKey);
         const signature = key.sign(hash);
-        return (0, __1.encodeSignature)(signature);
+        return (0, utils_1.encodeSignature)(signature);
     }
     else {
-        const signature = necc.schnorr.signSync((0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(privateKey));
-        return (0, __1.binToHex)(signature);
+        const signature = necc.schnorr.signSync((0, utils_1.hexToBinUnsafe)(hash), (0, utils_1.hexToBinUnsafe)(privateKey));
+        return (0, utils_1.binToHex)(signature);
     }
 }
 exports.sign = sign;
@@ -76,10 +76,10 @@ function verifySignature(hash, publicKey, signature, _keyType) {
     try {
         if (keyType === 'default') {
             const key = ec.keyFromPublic(publicKey, 'hex');
-            return key.verify(hash, (0, __1.signatureDecode)(ec, signature));
+            return key.verify(hash, (0, utils_1.signatureDecode)(ec, signature));
         }
         else {
-            return necc.schnorr.verifySync((0, __1.hexToBinUnsafe)(signature), (0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(publicKey));
+            return necc.schnorr.verifySync((0, utils_1.hexToBinUnsafe)(signature), (0, utils_1.hexToBinUnsafe)(hash), (0, utils_1.hexToBinUnsafe)(publicKey));
         }
     }
     catch (error) {

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

@@ -1,6 +1,6 @@
 import EventEmitter from 'eventemitter3';
-type MessageCallback<Message> = (message: Message) => Promise<void>;
-type ErrorCallback<Message> = (error: any, subscription: Subscription<Message>) => Promise<void>;
+type MessageCallback<Message> = (message: Message) => Promise<void> | void;
+type ErrorCallback<Message> = (error: any, subscription: Subscription<Message>) => Promise<void> | void;
 export interface SubscribeOptions<Message> {
     pollingInterval: number;
     messageCallback: MessageCallback<Message>;
@@ -14,9 +14,9 @@ export declare abstract class Subscription<Message> {
     protected eventEmitter: EventEmitter;
     protected cancelled: boolean;
     constructor(options: SubscribeOptions<Message>);
-    startPolling(): void;
+    subscribe(): void;
     unsubscribe(): void;
     isCancelled(): boolean;
-    abstract polling(): Promise<void>;
+    protected abstract polling(): Promise<void>;
 }
 export {};

package/dist/src/utils/subscription.js

@@ -31,7 +31,7 @@ class Subscription {
         this.cancelled = false;
         this.eventEmitter = new eventemitter3_1.default();
     }
-    startPolling() {
+    subscribe() {
         this.eventEmitter.on('tick', async () => {
             await this.polling();
             if (!this.cancelled) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@alephium/web3",
-  "version": "0.39.3",
+  "version": "0.41.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": {
-    ".": "./dist/src/index.js",
-    "./test": "./dist/src/test/index.js"
+    "node": "./dist/src/index.js",
+    "default": "./dist/alephium-web3.min.js"
   },
   "typesVersions": {
     "*": {
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "2.11.0",
+    "alephium_version": "2.14.0",
     "explorer_backend_version": "1.17.0"
   },
   "type": "commonjs",
@@ -90,7 +90,7 @@
     "build": "rm -rf dist/* && npx tsc --build . && webpack",
     "test": "jest -i --config ./jest-config.json",
     "update-schemas": "npm run update-schema:alephium && npm run update-schema:explorer",
-    "update-schema:alephium": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/rhone-upgrade/api/src/main/resources/openapi.json",
+    "update-schema:alephium": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/v${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
     "update-schema:explorer": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-explorer.ts -p https://raw.githubusercontent.com/alephium/explorer-backend/v${npm_package_config_explorer_backend_version}/app/src/main/resources/explorer-backend-openapi.json",
     "check-versions": "node scripts/check-versions.js ${npm_package_config_alephium_version} ${npm_package_config_explorer_backend_version}"
   }

package/src/api/api-alephium.ts

@@ -1306,7 +1306,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 2.11.0
+ * @version 2.14.0
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/api/node-provider.ts

@@ -28,7 +28,6 @@ import {
   requestWithLog
 } from './types'
 import { Api as NodeApi, CallContractFailed, CallContractSucceeded } from './api-alephium'
-import { tryGetCallResult } from '../contract'
 import {
   HexString,
   addressFromContractId,
@@ -38,6 +37,7 @@ import {
   isHexString,
   toNonNegativeBigInt
 } from '../utils'
+import * as node from '../api/api-alephium'
 
 function initializeNodeApi(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): NodeApi<string> {
   const nodeApi = new NodeApi<string>({
@@ -253,3 +253,10 @@ export class NodeProvider implements NodeProviderApis {
     }
   }
 }
+
+export function tryGetCallResult(result: node.CallContractResult): node.CallContractSucceeded {
+  if (result.type === 'CallContractFailed') {
+    throw new Error(`Failed to call contract, error: ${(result as node.CallContractFailed).error}`)
+  }
+  return result as node.CallContractSucceeded
+}

package/src/api/utils.ts

@@ -17,7 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import 'cross-fetch/polyfill'
-import { node } from '..'
+import * as node from '../api/api-alephium'
 
 export function convertHttpResponse<T>(response: { status: number; data: T; error?: { detail: string } }): T {
   if (response.error) {

package/src/block/block.ts

@@ -0,0 +1,139 @@
+/*
+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 { Subscription, SubscribeOptions } from '../utils/subscription'
+import * as node from '../api/api-alephium'
+import { NodeProvider } from '../api'
+import * as web3 from '../global'
+
+export type ReorgCallback = (orphanBlocks: node.BlockEntry[], newBlocks: node.BlockEntry[]) => Promise<void> | void
+
+export interface BlockSubscribeOptions extends SubscribeOptions<node.BlockEntry> {
+  reorgCallback?: ReorgCallback
+}
+
+export 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 getBlockByHash(hash: string): Promise<node.BlockEntry>
+
+  protected getParentHash(block: node.BlockEntry): string {
+    const index = Math.floor(block.deps.length / 2) + this.toGroup
+    return block.deps[index]
+  }
+
+  protected async handleReorg(blockHash: string, blockHeight: number) {
+    console.info(`reorg occur, hash: ${blockHash}, height: ${blockHeight}`)
+    if (this.reorgCallback === undefined) return
+
+    const orphans: string[] = []
+    const newHashes: string[] = []
+    let fromHash = blockHash
+    let fromHeight = blockHeight
+    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 {
+        break
+      }
+    }
+
+    const orphanBlocks: node.BlockEntry[] = []
+    for (const hash of orphans.reverse()) {
+      const block = await this.getBlockByHash(hash)
+      orphanBlocks.push(block)
+    }
+
+    const newBlocks: node.BlockEntry[] = []
+    for (const hash of newHashes.reverse()) {
+      const block = await this.getBlockByHash(hash)
+      newBlocks.push(block)
+    }
+    console.info(`orphan hashes: ${orphanBlocks.map((b) => b.hash)}, new hashes: ${newBlocks.map((b) => b.hash)}`)
+    await this.reorgCallback(orphanBlocks, newBlocks)
+  }
+}
+
+export class BlockSubscription extends BlockSubscriptionBase {
+  readonly nodeProvider: NodeProvider
+  readonly fromGroup: number
+  readonly toGroup: number
+  readonly reorgCallback?: ReorgCallback
+  private currentBlockHeight: number
+  private parentBlockHash: string | undefined
+
+  constructor(
+    options: BlockSubscribeOptions,
+    fromGroup: number,
+    toGroup: number,
+    fromBlockHeight: number,
+    nodeProvider: NodeProvider | undefined = undefined
+  ) {
+    super(options)
+    this.nodeProvider = nodeProvider ?? web3.getCurrentNodeProvider()
+    this.fromGroup = fromGroup
+    this.toGroup = toGroup
+    this.reorgCallback = options.reorgCallback
+    this.currentBlockHeight = fromBlockHeight
+    this.parentBlockHash = undefined
+  }
+
+  override async getHashesAtHeight(height: number): Promise<string[]> {
+    const result = await this.nodeProvider.blockflow.getBlockflowHashes({
+      fromGroup: this.fromGroup,
+      toGroup: this.toGroup,
+      height
+    })
+    return result.headers
+  }
+
+  override async getBlockByHash(hash: string): Promise<node.BlockEntry> {
+    return await this.nodeProvider.blockflow.getBlockflowBlocksBlockHash(hash)
+  }
+
+  override async polling(): Promise<void> {
+    try {
+      const chainInfo = await this.nodeProvider.blockflow.getBlockflowChainInfo({
+        fromGroup: this.fromGroup,
+        toGroup: this.toGroup
+      })
+
+      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]
+      }
+    } catch (err) {
+      await this.errorCallback(err, this)
+    }
+  }
+}

package/src/block/index.ts

@@ -0,0 +1,19 @@
+/*
+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/>.
+*/
+
+export { ReorgCallback, BlockSubscribeOptions, BlockSubscription } from './block'

package/src/codec/contract-output-codec.ts

@@ -24,7 +24,7 @@ import { Codec } from './codec'
 import { Token, tokensCodec } from './token-codec'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
-import { binToHex, bs58 } from '..'
+import { binToHex, bs58 } from '../utils'
 import { signedIntCodec } from './signed-int-codec'
 import { lockupScriptCodec } from './lockup-script-codec'
 

package/src/codec/instr-codec.ts

@@ -22,6 +22,7 @@ import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } fro
 import { ByteString, byteStringCodec } from './bytestring-codec'
 import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
 import { Codec } from './codec'
+import { signedIntCodec } from './signed-int-codec'
 
 const byteStringArrayCodec = new ArrayCodec(byteStringCodec)
 
@@ -192,6 +193,7 @@ export const AddModN: Instr = { code: 0x88, value: {} }
 export const U256ToString: Instr = { code: 0x89, value: {} }
 export const I256ToString: Instr = { code: 0x8a, value: {} }
 export const BoolToString: Instr = { code: 0x8b, value: {} }
+export const GroupOfAddress: Instr = { code: 0x8c, value: {} }
 export const LoadMutField = (index: number): Instr => ({ code: 0xa0, value: { index } })
 export const StoreMutField = (index: number): Instr => ({ code: 0xa1, value: { index } })
 export const ApproveAlph: Instr = { code: 0xa2, value: {} }
@@ -246,6 +248,12 @@ export const CreateMapEntry: (immFields: number, mutFields: number) => Instr = (
   immFields: number,
   mutFields: number
 ) => ({ code: 0xd2, value: { immFields, mutFields } })
+export const MethodSelector: (selector: number) => Instr = (selector: number) => {
+  return { code: 0xd3, value: { index: selector } }
+}
+export const CallExternalBySelector: (selector: number) => Instr = (selector: number) => {
+  return { code: 0xd4, value: { index: selector } }
+}
 
 export class InstrCodec implements Codec<Instr> {
   parser = Parser.start()
@@ -393,6 +401,7 @@ export class InstrCodec implements Codec<Instr> {
         [U256ToString.code]: Parser.start(),
         [I256ToString.code]: Parser.start(),
         [BoolToString.code]: Parser.start(),
+        [GroupOfAddress.code]: Parser.start(),
         0xa0: Parser.start().uint8('index'),
         0xa1: Parser.start().uint8('index'),
         [ApproveAlph.code]: Parser.start(),
@@ -443,7 +452,9 @@ export class InstrCodec implements Codec<Instr> {
         [LoadImmFieldByIndex.code]: Parser.start(),
         [PayGasFee.code]: Parser.start(),
         [MinimalContractDeposit.code]: Parser.start(),
-        0xd2: Parser.start().uint8('immFields').uint8('mutFields')
+        0xd2: Parser.start().uint8('immFields').uint8('mutFields'),
+        0xd3: Parser.start().int32('index'),
+        0xd4: Parser.start().int32('index')
       }
     })
 
@@ -465,6 +476,8 @@ export class InstrCodec implements Codec<Instr> {
     } else if (instr.code === 0xd2) {
       const value = instrValue as CreateMapEntryValue
       result.push(value.immFields, value.mutFields)
+    } else if (instr.code === 0xd3 || instr.code === 0xd4) {
+      result.push(...signedIntCodec.encode((instrValue as InstrValueWithIndex).index))
     }
 
     return Buffer.from(result)

package/src/codec/lockup-script-codec.ts

@@ -17,7 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { ArrayCodec, DecodedArray } from './array-codec'
 
@@ -41,7 +41,7 @@ const publicKeyHashCodec = new PublicKeyHashCodec()
 const publicKeyHashesCodec = new ArrayCodec(publicKeyHashCodec)
 const multiSigParser = Parser.start()
   .nest('publicKeyHashes', { type: publicKeyHashesCodec.parser })
-  .nest('m', { type: compactUnsignedIntCodec.parser })
+  .nest('m', { type: compactSignedIntCodec.parser })
 export interface MultiSig {
   publicKeyHashes: DecodedArray<PublicKeyHash>
   m: DecodedCompactInt
@@ -79,7 +79,7 @@ export class LockupScriptCodec implements Codec<LockupScript> {
       result.push(...(input.script as PublicKeyHash).publicKeyHash)
     } else if (input.scriptType === 1) {
       result.push(...publicKeyHashesCodec.encode((input.script as MultiSig).publicKeyHashes.value))
-      result.push(...compactUnsignedIntCodec.encode((input.script as MultiSig).m))
+      result.push(...compactSignedIntCodec.encode((input.script as MultiSig).m))
     } else if (input.scriptType === 2) {
       result.push(...(input.script as P2SH).scriptHash)
     } else if (input.scriptType === 3) {

package/src/codec/method-codec.ts

@@ -33,13 +33,51 @@ export interface DecodedMethod {
 
 export interface Method {
   isPublic: boolean
-  assetModifier: number
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
   argsLength: number
   localsLength: number
   returnLength: number
   instrs: Instr[]
 }
 
+function decodeAssetModifier(encoded: number): {
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
+} {
+  const usePayToContractOnly = (encoded & 4) !== 0
+  switch (encoded & 3) {
+    case 0:
+      return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: false }
+    case 1:
+      return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: true }
+    case 2:
+      return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: true }
+    case 3:
+      return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: false }
+    default:
+      throw new Error(`Invalid asset modifier: ${encoded}`)
+  }
+}
+
+function encodeAssetModifier(arg: {
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
+}): number {
+  const encoded =
+    !arg.usePreapprovedAssets && !arg.useContractAssets
+      ? 0
+      : arg.usePreapprovedAssets && arg.useContractAssets
+      ? 1
+      : !arg.usePreapprovedAssets && arg.useContractAssets
+      ? 2
+      : 3
+  return encoded | (arg.usePayToContractOnly ? 4 : 0)
+}
+
 export class MethodCodec implements Codec<DecodedMethod> {
   parser = Parser.start()
     .uint8('isPublic')
@@ -73,7 +111,7 @@ export class MethodCodec implements Codec<DecodedMethod> {
   static toMethod(decodedMethod: DecodedMethod): Method {
     return {
       isPublic: decodedMethod.isPublic === 1,
-      assetModifier: decodedMethod.assetModifier,
+      ...decodeAssetModifier(decodedMethod.assetModifier),
       argsLength: compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
       localsLength: compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
       returnLength: compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
@@ -84,7 +122,7 @@ export class MethodCodec implements Codec<DecodedMethod> {
   static fromMethod(method: Method): DecodedMethod {
     return {
       isPublic: method.isPublic ? 1 : 0,
-      assetModifier: method.assetModifier,
+      assetModifier: encodeAssetModifier(method),
       argsLength: compactUnsignedIntCodec.fromU32(method.argsLength),
       localsLength: compactUnsignedIntCodec.fromU32(method.localsLength),
       returnLength: compactUnsignedIntCodec.fromU32(method.returnLength),