@alephium/web3 0.42.0 → 0.43.0

package/src/codec/method-codec.ts

@@ -15,7 +15,6 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
@@ -95,16 +94,16 @@ export class MethodCodec implements Codec<DecodedMethod> {
       type: instrsCodec.parser
     })
 
-  encode(input: DecodedMethod): Buffer {
+  encode(input: DecodedMethod): Uint8Array {
     const result = [input.isPublic, input.assetModifier]
     result.push(...compactUnsignedIntCodec.encode(input.argsLength))
     result.push(...compactUnsignedIntCodec.encode(input.localsLength))
     result.push(...compactUnsignedIntCodec.encode(input.returnLength))
     result.push(...instrsCodec.encode(input.instrs.value))
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): DecodedMethod {
+  decode(input: Uint8Array): DecodedMethod {
     return this.parser.parse(input)
   }
 

package/src/codec/option-codec.ts

@@ -15,7 +15,6 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { Codec } from './codec'
 
@@ -35,15 +34,15 @@ export class OptionCodec<T> implements Codec<Option<T>> {
     })
   ) {}
 
-  encode(input: Option<T>): Buffer {
+  encode(input: Option<T>): Uint8Array {
     const result = [input.option]
     if (input.option === 1) {
       result.push(...this.childCodec.encode(input.value!))
     }
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): Option<T> {
+  decode(input: Uint8Array): Option<T> {
     const result = this.parser.parse(input)
     return {
       ...result,
@@ -51,7 +50,7 @@ export class OptionCodec<T> implements Codec<Option<T>> {
     }
   }
 
-  fromBuffer(input?: Buffer): Option<T> {
+  fromBytes(input?: Uint8Array): Option<T> {
     return {
       option: input ? 1 : 0,
       value: input ? this.childCodec.decode(input) : undefined

package/src/codec/script-codec.ts

@@ -16,7 +16,6 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
 import { Codec } from './codec'
@@ -37,22 +36,21 @@ export class ScriptCodec implements Codec<DecodedScript> {
     type: methodsCodec.parser
   })
 
-  encode(input: DecodedScript): Buffer {
-    const script = methodsCodec.encode(input.methods.value)
-    return Buffer.from(script)
+  encode(input: DecodedScript): Uint8Array {
+    return methodsCodec.encode(input.methods.value)
   }
 
-  decode(input: Buffer): DecodedScript {
+  decode(input: Uint8Array): DecodedScript {
     return this.parser.parse(input)
   }
 
-  decodeScript(input: Buffer): Script {
+  decodeScript(input: Uint8Array): Script {
     const decodedTxScript = this.decode(input)
     const methods = decodedTxScript.methods.value.map((decodedMethod) => MethodCodec.toMethod(decodedMethod))
     return { methods }
   }
 
-  encodeScript(inputTxScript: Script): Buffer {
+  encodeScript(inputTxScript: Script): Uint8Array {
     const methodLength = compactUnsignedIntCodec.fromU32(inputTxScript.methods.length)
     const decodedMethods = inputTxScript.methods.map((method) => MethodCodec.fromMethod(method))
     return this.encode({ methods: { value: decodedMethods, length: methodLength } })

package/src/codec/signature-codec.ts

@@ -15,23 +15,22 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { ArrayCodec } from './array-codec'
 import { Codec } from './codec'
 
 export interface Signature {
-  value: Buffer
+  value: Uint8Array
 }
 
 export class SignatureCodec implements Codec<Signature> {
   parser = Parser.start().buffer('value', { length: 64 })
 
-  encode(input: Signature): Buffer {
+  encode(input: Signature): Uint8Array {
     return input.value
   }
 
-  decode(input: Buffer): Signature {
+  decode(input: Uint8Array): Signature {
     return this.parser.parse(input)
   }
 }

package/src/codec/signed-int-codec.ts

@@ -18,17 +18,16 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import { Parser } from 'binary-parser'
 import { Codec, assert } from './codec'
 
-import { Buffer } from 'buffer/'
 export class SignedIntCodec implements Codec<number> {
   parser = Parser.start().buffer('value', {
     length: 4
   })
 
-  encode(value: number): Buffer {
-    return Buffer.from([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff])
+  encode(value: number): Uint8Array {
+    return new Uint8Array([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff])
   }
 
-  decode(bytes: Buffer): number {
+  decode(bytes: Uint8Array): number {
     assert(bytes.length === 4, 'Length should be 4')
     return ((bytes[0] & 0xff) << 24) | ((bytes[1] & 0xff) << 16) | ((bytes[2] & 0xff) << 8) | (bytes[3] & 0xff)
   }

package/src/codec/token-codec.ts

@@ -16,14 +16,14 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { ArrayCodec } from './array-codec'
+import { concatBytes } from '../utils'
 
 export interface Token {
-  tokenId: Buffer
+  tokenId: Uint8Array
   amount: DecodedCompactInt
 }
 
@@ -36,13 +36,13 @@ export class TokenCodec implements Codec<Token> {
       type: compactUnsignedIntCodec.parser
     })
 
-  encode(input: Token): Buffer {
+  encode(input: Token): Uint8Array {
     const tokenId = input.tokenId
-    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
-    return Buffer.concat([tokenId, amount])
+    const amount = compactUnsignedIntCodec.encode(input.amount)
+    return concatBytes([tokenId, amount])
   }
 
-  decode(input: Buffer): Token {
+  decode(input: Uint8Array): Token {
     return this.parser.parse(input)
   }
 }

package/src/codec/transaction-codec.ts

@@ -16,7 +16,6 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
 
@@ -27,7 +26,7 @@ import { Either } from './either-codec'
 import { AssetOutput, AssetOutputCodec } from './asset-output-codec'
 import { ContractOutput, ContractOutputCodec } from './contract-output-codec'
 import { FixedAssetOutput, Transaction as ApiTransaction } from '../api/api-alephium'
-import { hexToBinUnsafe } from '../utils'
+import { binToHex, hexToBinUnsafe, concatBytes } from '../utils'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { Codec } from './codec'
 import { Output, outputCodec, outputsCodec } from './output-codec'
@@ -60,27 +59,27 @@ export class TransactionCodec implements Codec<Transaction> {
       type: signaturesCodec.parser
     })
 
-  encode(decodedTx: Transaction): Buffer {
-    return Buffer.concat([
+  encode(decodedTx: Transaction): Uint8Array {
+    return concatBytes([
       unsignedTxCodec.encode(decodedTx.unsigned),
-      Buffer.from([decodedTx.scriptExecutionOk]),
-      Buffer.from([...contractOutputRefsCodec.encode(decodedTx.contractInputs.value)]),
-      Buffer.from([...outputsCodec.encode(decodedTx.generatedOutputs.value)]),
-      Buffer.from([...signaturesCodec.encode(decodedTx.inputSignatures.value)]),
-      Buffer.from([...signaturesCodec.encode(decodedTx.scriptSignatures.value)])
+      new Uint8Array([decodedTx.scriptExecutionOk]),
+      contractOutputRefsCodec.encode(decodedTx.contractInputs.value),
+      outputsCodec.encode(decodedTx.generatedOutputs.value),
+      signaturesCodec.encode(decodedTx.inputSignatures.value),
+      signaturesCodec.encode(decodedTx.scriptSignatures.value)
     ])
   }
 
-  decode(input: Buffer): Transaction {
+  decode(input: Uint8Array): Transaction {
     return this.parser.parse(input)
   }
 
-  encodeApiTransaction(input: ApiTransaction): Buffer {
+  encodeApiTransaction(input: ApiTransaction): Uint8Array {
     const decodedTx = TransactionCodec.fromApiTransaction(input)
     return this.encode(decodedTx)
   }
 
-  decodeApiTransaction(input: Buffer): ApiTransaction {
+  decodeApiTransaction(input: Uint8Array): ApiTransaction {
     const decodedTx = this.parser.parse(input)
     return TransactionCodec.toApiTransaction(decodedTx)
   }
@@ -91,7 +90,7 @@ export class TransactionCodec implements Codec<Transaction> {
     const scriptExecutionOk = !!transaction.scriptExecutionOk
     const contractInputs = transaction.contractInputs.value.map((contractInput) => {
       const hint = contractInput.hint
-      const key = contractInput.key.toString('hex')
+      const key = binToHex(contractInput.key)
       return { hint, key }
     })
     const txIdBytes = hexToBinUnsafe(txId)
@@ -104,8 +103,8 @@ export class TransactionCodec implements Codec<Transaction> {
       }
     })
 
-    const inputSignatures = transaction.inputSignatures.value.map((signature) => signature.value.toString('hex'))
-    const scriptSignatures = transaction.scriptSignatures.value.map((signature) => signature.value.toString('hex'))
+    const inputSignatures = transaction.inputSignatures.value.map((signature) => binToHex(signature.value))
+    const scriptSignatures = transaction.scriptSignatures.value.map((signature) => binToHex(signature.value))
 
     return { unsigned, scriptExecutionOk, contractInputs, generatedOutputs, inputSignatures, scriptSignatures }
   }
@@ -114,7 +113,7 @@ export class TransactionCodec implements Codec<Transaction> {
     const unsigned = UnsignedTxCodec.fromApiUnsignedTx(tx.unsigned)
     const scriptExecutionOk = tx.scriptExecutionOk ? 1 : 0
     const contractInputs: ContractOutputRef[] = tx.contractInputs.map((contractInput) => {
-      return { hint: contractInput.hint, key: Buffer.from(contractInput.key, 'hex') }
+      return { hint: contractInput.hint, key: hexToBinUnsafe(contractInput.key) }
     })
     const generatedOutputs: Either<AssetOutput, ContractOutput>[] = tx.generatedOutputs.map((output) => {
       if (output.type === 'AssetOutput') {
@@ -127,10 +126,10 @@ export class TransactionCodec implements Codec<Transaction> {
     })
 
     const inputSignatures: Signature[] = tx.inputSignatures.map((signature) => {
-      return { value: Buffer.from(signature, 'hex') }
+      return { value: hexToBinUnsafe(signature) }
     })
     const scriptSignatures: Signature[] = tx.scriptSignatures.map((signature) => {
-      return { value: Buffer.from(signature, 'hex') }
+      return { value: hexToBinUnsafe(signature) }
     })
 
     return {

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

@@ -15,27 +15,27 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
 import { Codec } from './codec'
-import { DecodedScript, Script, scriptCodec } from './script-codec'
+import { DecodedScript, scriptCodec } from './script-codec'
 import { ByteString, byteStringCodec } from './bytestring-codec'
 import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
+import { concatBytes } from '../utils'
 
 export interface P2PKH {
-  publicKey: Buffer
+  publicKey: Uint8Array
 }
 
 class P2PKHCodec implements Codec<P2PKH> {
   parser = Parser.start().buffer('publicKey', { length: 33 })
 
-  encode(input: P2PKH): Buffer {
+  encode(input: P2PKH): Uint8Array {
     return input.publicKey
   }
 
-  decode(input: Buffer): P2PKH {
+  decode(input: Uint8Array): P2PKH {
     return this.parser.parse(input)
   }
 }
@@ -57,16 +57,16 @@ class P2MPKHCodec implements Codec<P2MPKH> {
     )
   })
 
-  encode(input: P2MPKH): Buffer {
-    return Buffer.concat([
-      Buffer.from(compactUnsignedIntCodec.encode(input.publicKeys.length)),
+  encode(input: P2MPKH): Uint8Array {
+    return concatBytes([
+      compactUnsignedIntCodec.encode(input.publicKeys.length),
       ...input.publicKeys.value.map((v) => {
-        return Buffer.concat([v.publicKey.publicKey, Buffer.from(compactUnsignedIntCodec.encode(v.index))])
+        return concatBytes([v.publicKey.publicKey, compactUnsignedIntCodec.encode(v.index)])
       })
     ])
   }
 
-  decode(input: Buffer): any {
+  decode(input: Uint8Array): any {
     return this.parser.parse(input)
   }
 }
@@ -90,30 +90,30 @@ class ValCodec implements Codec<Val> {
       }
     })
 
-  encode(input: Val): Buffer {
+  encode(input: Val): Uint8Array {
     const valType = input.type
 
     if (valType === 0x00) {
       // Boolean
-      return Buffer.from([valType, input.val as number])
+      return new Uint8Array([valType, input.val as number])
     } else if (valType === 0x01) {
       // I256
-      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
+      return new Uint8Array([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
     } else if (valType === 0x02) {
       // U256
-      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
+      return new Uint8Array([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
     } else if (valType === 0x03) {
       // ByteVec
-      return Buffer.from([valType, ...byteStringCodec.encode(input.val as ByteString)])
+      return new Uint8Array([valType, ...byteStringCodec.encode(input.val as ByteString)])
     } else if (valType === 0x04) {
       // Address
-      return Buffer.from([valType, ...lockupScriptCodec.encode(input.val as LockupScript)])
+      return new Uint8Array([valType, ...lockupScriptCodec.encode(input.val as LockupScript)])
     } else {
       throw new Error(`ValCodec: unsupported val type: ${valType}`)
     }
   }
 
-  decode(input: Buffer): Val {
+  decode(input: Uint8Array): Val {
     return this.parser.parse(input)
   }
 }
@@ -135,11 +135,11 @@ export class P2SHCodec implements Codec<P2SH> {
       type: valsCodec.parser
     })
 
-  encode(input: P2SH): Buffer {
-    return Buffer.concat([scriptCodec.encode(input.script), valsCodec.encode(input.params.value)])
+  encode(input: P2SH): Uint8Array {
+    return concatBytes([scriptCodec.encode(input.script), valsCodec.encode(input.params.value)])
   }
 
-  decode(input: Buffer): P2SH {
+  decode(input: Uint8Array): P2SH {
     return this.parser.parse(input)
   }
 }
@@ -164,29 +164,28 @@ export class UnlockScriptCodec implements Codec<UnlockScript> {
       }
     })
 
-  encode(input: UnlockScript): Buffer {
+  encode(input: UnlockScript): Uint8Array {
     const scriptType = input.scriptType
     const inputUnLockScript = input.script
-    const inputUnLockScriptType = Buffer.from([scriptType])
 
     if (scriptType === 0) {
       // P2PKH
-      return Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript as P2PKH)])
+      return new Uint8Array([scriptType, ...p2pkhCodec.encode(inputUnLockScript as P2PKH)])
     } else if (scriptType === 1) {
       // P2MPKH
-      return Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript as P2MPKH)])
+      return new Uint8Array([scriptType, ...p2mpkhCodec.encode(inputUnLockScript as P2MPKH)])
     } else if (scriptType === 2) {
       // P2SH
-      return Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script as P2SH)])
+      return new Uint8Array([scriptType, ...p2shCodec.encode(inputUnLockScript as P2SH)])
     } else if (scriptType === 3) {
       // SameAsPrevious
-      return inputUnLockScriptType
+      return new Uint8Array([scriptType])
     } else {
       throw new Error(`TODO: encode unlock script: ${scriptType}`)
     }
   }
 
-  decode(input: Buffer): UnlockScript {
+  decode(input: Uint8Array): UnlockScript {
     return this.parser.parse(input)
   }
 }

package/src/codec/unsigned-tx-codec.ts

@@ -15,10 +15,9 @@ 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 { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium'
-import { binToHex, hexToBinUnsafe } from '../utils'
+import { binToHex, concatBytes, hexToBinUnsafe } from '../utils'
 import { DecodedScript, scriptCodec, statefulScriptCodecOpt } from './script-codec'
 import { Option } from './option-codec'
 import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
@@ -58,9 +57,9 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
       type: assetOutputsCodec.parser
     })
 
-  encode(decodedUnsignedTx: UnsignedTx): Buffer {
-    return Buffer.concat([
-      Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
+  encode(decodedUnsignedTx: UnsignedTx): Uint8Array {
+    return concatBytes([
+      new Uint8Array([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
       statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
       compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
       compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
@@ -69,16 +68,16 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
     ])
   }
 
-  decode(input: Buffer): UnsignedTx {
+  decode(input: Uint8Array): UnsignedTx {
     return this.parser.parse(input)
   }
 
-  encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer {
+  encodeApiUnsignedTx(input: ApiUnsignedTx): Uint8Array {
     const decoded = UnsignedTxCodec.fromApiUnsignedTx(input)
     return this.encode(decoded)
   }
 
-  decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx {
+  decodeApiUnsignedTx(input: Uint8Array): ApiUnsignedTx {
     const decoded = this.parser.parse(input)
     return UnsignedTxCodec.toApiUnsignedTx(decoded)
   }
@@ -98,7 +97,7 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
     const fixedOutputs = AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value)
     let scriptOpt: string | undefined = undefined
     if (unsigned.statefulScript.option === 1) {
-      scriptOpt = scriptCodec.encode(unsigned.statefulScript.value!).toString('hex')
+      scriptOpt = binToHex(scriptCodec.encode(unsigned.statefulScript.value!))
     }
 
     return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs }
@@ -113,8 +112,8 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
     const inputs = inputsCodec.fromArray(inputsValue)
     const fixedOutputsValue = AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs)
     const fixedOutputs = assetOutputsCodec.fromArray(fixedOutputsValue)
-    const statefulScript = statefulScriptCodecOpt.fromBuffer(
-      unsignedTx.scriptOpt ? Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined
+    const statefulScript = statefulScriptCodecOpt.fromBytes(
+      unsignedTx.scriptOpt ? hexToBinUnsafe(unsignedTx.scriptOpt) : undefined
     )
 
     return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript }

package/src/contract/contract.ts

@@ -16,7 +16,6 @@ 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 { Buffer } from 'buffer/'
 import { promises as fsPromises } from 'fs'
 import {
   fromApiNumber256,
@@ -47,19 +46,16 @@ import * as ralph from './ralph'
 import {
   bs58,
   binToHex,
-  contractIdFromAddress,
   Subscription,
   assertType,
   Eq,
   Optional,
-  groupOfAddress,
   WebCrypto,
   hexToBinUnsafe,
   isDevnet,
-  addressFromContractId,
-  subContractId,
   HexString
 } from '../utils'
+import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId } from '../address'
 import { getCurrentNodeProvider } from '../global'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
@@ -220,7 +216,7 @@ export class Contract extends Artifact {
     this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
     this.codeHashDebug = codeHashDebug
 
-    this.decodedMethods = contract.contractCodec.decodeContract(Buffer.from(bytecode, 'hex')).methods
+    this.decodedMethods = contract.contractCodec.decodeContract(hexToBinUnsafe(bytecode)).methods
   }
 
   publicFunctions(): FunctionSig[] {
@@ -1208,7 +1204,7 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
     fieldLength: immFields + mutFields + 1, // parentContractId
     methods: [loadImmFieldByIndex, loadMutFieldByIndex, storeMutFieldByIndex, destroy]
   }
-  const bytecode = contract.contractCodec.encode(contract.toHalfDecoded(c))
+  const bytecode = contract.contractCodec.encodeContract(c)
   const codeHash = blake.blake2b(bytecode, undefined, 32)
   return { bytecode: binToHex(bytecode), codeHash: binToHex(codeHash) }
 }

package/src/contract/ralph.ts

@@ -16,9 +16,8 @@ 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 { Buffer } from 'buffer/'
 import { Val, decodeArrayType, toApiAddress, toApiBoolean, toApiByteVec, toApiNumber256 } from '../api'
-import { HexString, binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
+import { HexString, binToHex, bs58, concatBytes, hexToBinUnsafe, isHexString } from '../utils'
 import { Fields, FieldsSig, Struct } from './contract'
 import { compactSignedIntCodec, compactUnsignedIntCodec } from '../codec'
 
@@ -151,14 +150,14 @@ export function encodeU256(u256: bigint): Uint8Array {
   }
 }
 
-export function encodeByteVec(bytes: string): Uint8Array {
-  if (!isHexString(bytes)) {
-    throw Error(`Given value ${bytes} is not a valid hex string`)
+export function encodeByteVec(hex: string): Uint8Array {
+  if (!isHexString(hex)) {
+    throw Error(`Given value ${hex} is not a valid hex string`)
   }
 
-  const buffer0 = Buffer.from(bytes, 'hex')
-  const buffer1 = Buffer.from(encodeI256(BigInt(buffer0.length)))
-  return Buffer.concat([buffer1, buffer0])
+  const bytes0 = hexToBinUnsafe(hex)
+  const bytes1 = encodeI256(BigInt(bytes0.length))
+  return concatBytes([bytes1, bytes0])
 }
 
 export function encodeAddress(address: string): Uint8Array {
@@ -254,7 +253,7 @@ function encodeScriptFieldU256(value: bigint): Uint8Array {
 }
 
 export function encodeScriptFieldAsString(tpe: string, value: Val): string {
-  return Buffer.from(encodeScriptField(tpe, value)).toString('hex')
+  return binToHex(encodeScriptField(tpe, value))
 }
 
 export function encodeScriptField(tpe: string, value: Val): Uint8Array {
@@ -378,9 +377,9 @@ export function decodePrimitive(value: Uint8Array, type: string): Val {
     case 'Bool':
       return decodeBool(value)
     case 'I256':
-      return compactSignedIntCodec.decodeI256(Buffer.from(value))
+      return compactSignedIntCodec.decodeI256(value)
     case 'U256':
-      return compactUnsignedIntCodec.decodeU256(Buffer.from(value))
+      return compactUnsignedIntCodec.decodeU256(value)
     case 'ByteVec':
       return binToHex(value)
     case 'Address':

package/src/{utils → exchange}/exchange.ts

@@ -16,19 +16,11 @@ 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,
-  addressFromPublicKey,
-  addressFromScript,
-  binToHex,
-  bs58,
-  hexToBinUnsafe,
-  isHexString
-} from '../utils'
+import { AddressType, addressFromPublicKey, addressFromScript } from '../address'
+import { binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
 import { Transaction } from '../api/api-alephium'
 import { Address } from '../signer'
 import { P2SH, unlockScriptCodec } from '../codec/unlock-script-codec'
-import { Buffer } from 'buffer/'
 import { scriptCodec } from '../codec/script-codec'
 
 export function validateExchangeAddress(address: string) {
@@ -113,7 +105,7 @@ export function getAddressFromUnlockScript(unlockScript: string): Address {
   if (unlockScriptType === UnlockScriptType.P2SH) {
     let p2sh: P2SH
     try {
-      p2sh = unlockScriptCodec.decode(Buffer.from(decoded)).script as P2SH
+      p2sh = unlockScriptCodec.decode(decoded).script as P2SH
     } catch (_) {
       throw new Error(`Invalid p2sh unlock script: ${unlockScript}`)
     }

package/src/exchange/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 { validateExchangeAddress, isALPHTransferTx, getSenderAddress, getALPHDepositInfo } from './exchange'

package/src/index.ts

@@ -33,3 +33,5 @@ export * as codec from './codec'
 export * as utils from './utils'
 export * from './debug'
 export * from './block'
+export * from './address'
+export * from './exchange'