Remove all Buffers with Uint8Arrays

rkalis · rkalis · commit 35e9a189e1d4 · 2020-08-26T16:42:23.000+02:00
diff --git a/packages/cashc/src/ast/AST.ts b/packages/cashc/src/ast/AST.ts
@@ -315,7 +315,7 @@ export class StringLiteralNode extends LiteralNode {
 
 export class HexLiteralNode extends LiteralNode {
   constructor(
-    public value: Buffer,
+    public value: Uint8Array,
   ) {
     super();
     this.type = new BytesType(value.byteLength);
diff --git a/packages/cashc/src/ast/AstBuilder.ts b/packages/cashc/src/ast/AstBuilder.ts
@@ -1,3 +1,4 @@
+import { hexToBin } from '@bitauth/libauth';
 import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
 import { ParseTree } from 'antlr4ts/tree/ParseTree';
 import { TerminalNode } from 'antlr4ts/tree/TerminalNode';
@@ -325,7 +326,7 @@ export default class AstBuilder
 
   createHexLiteral(ctx: LiteralContext): HexLiteralNode {
     const hexString = (ctx.HexLiteral() as TerminalNode).text;
-    const hexValue = Buffer.from(hexString.substring(2), 'hex');
+    const hexValue = hexToBin(hexString.substring(2));
     const hexLiteral = new HexLiteralNode(hexValue);
     hexLiteral.location = Location.fromCtx(ctx);
     return hexLiteral;
diff --git a/packages/cashc/src/cashc-cli.ts b/packages/cashc/src/cashc-cli.ts
@@ -1,5 +1,5 @@
 #! /usr/bin/env node
-import { binToHex } from '@bitauth/libauth';
+import { binToHex, hexToBin } from '@bitauth/libauth';
 import { program } from 'commander';
 import fs from 'fs';
 import path from 'path';
@@ -49,7 +49,7 @@ function run(): void {
         } else if (arg === 'false') {
           script.unshift(Data.encodeBool(false));
         } else if (arg.startsWith('0x')) {
-          script.unshift(Buffer.from(arg.substring(2), 'hex'));
+          script.unshift(hexToBin(arg.substring(2)));
         } else if (!Number.isNaN(Number(arg))) {
           script.unshift(Data.encodeInt(Number(arg)));
         } else {
diff --git a/packages/cashc/src/generation/GenerateTargetTraversal.ts b/packages/cashc/src/generation/GenerateTargetTraversal.ts
@@ -1,3 +1,4 @@
+import { hexToBin } from '@bitauth/libauth';
 import {
   ContractNode,
   ParameterNode,
@@ -442,35 +443,35 @@ export default class GenerateTargetTraversal extends AstTraversal {
       // <output amount>
       this.visit(node.parameters[0]);
       // <VarInt 25 bytes> OP_DUP OP_HASH160 OP_PUSH<20>
-      this.emit(Buffer.from('1976a914', 'hex'));
+      this.emit(hexToBin('1976a914'));
       this.emit(Op.OP_CAT);
       // <pkh>
       this.visit(node.parameters[1]);
       this.emit(Op.OP_CAT);
       // OP_EQUAL OP_CHECKSIG
-      this.emit(Buffer.from('88ac', 'hex'));
+      this.emit(hexToBin('88ac'));
       this.emit(Op.OP_CAT);
       this.popFromStack(2);
     } else if (node.identifier.name === Class.OUTPUT_P2SH) {
       // <output amount>
       this.visit(node.parameters[0]);
       // <VarInt 23 bytes> OP_HASH160 OP_PUSH<20>
-      this.emit(Buffer.from('17a914', 'hex'));
+      this.emit(hexToBin('17a914'));
       this.emit(Op.OP_CAT);
       // <script hash>
       this.visit(node.parameters[1]);
       this.emit(Op.OP_CAT);
       // OP_EQUAL
-      this.emit(Buffer.from('87', 'hex'));
+      this.emit(hexToBin('87'));
       this.emit(Op.OP_CAT);
       this.popFromStack(2);
     } else if (node.identifier.name === Class.OUTPUT_NULLDATA) {
       // Total script = bytes8(0) <VarInt> OP_RETURN (<VarInt> <chunk>)+
       // <output amount (0)>
-      this.emit(Buffer.from('0000000000000000', 'hex'));
+      this.emit(hexToBin('0000000000000000'));
       this.pushToStack('(value)');
       // OP_RETURN
-      this.emit(Buffer.from('6a', 'hex'));
+      this.emit(hexToBin('6a'));
       this.pushToStack('(value)');
       const { elements } = node.parameters[0] as ArrayNode;
       // <VarInt data chunk size (dynamic)>
@@ -481,7 +482,7 @@ export default class GenerateTargetTraversal extends AstTraversal {
         if (el instanceof HexLiteralNode) {
           // If the argument is a literal, we know its size
           if (el.value.byteLength > 75) {
-            this.emit(Buffer.from('4c', 'hex'));
+            this.emit(hexToBin('4c'));
             this.emit(Op.OP_SWAP);
             this.emit(Op.OP_CAT);
           }
@@ -491,7 +492,7 @@ export default class GenerateTargetTraversal extends AstTraversal {
           this.emit(Data.encodeInt(75));
           this.emit(Op.OP_GREATERTHAN);
           this.emit(Op.OP_IF);
-          this.emit(Buffer.from('4c', 'hex'));
+          this.emit(hexToBin('4c'));
           this.emit(Op.OP_SWAP);
           this.emit(Op.OP_CAT);
           this.emit(Op.OP_ENDIF);
diff --git a/packages/cashc/src/generation/ReplaceBytecodeNop.ts b/packages/cashc/src/generation/ReplaceBytecodeNop.ts
@@ -12,7 +12,7 @@ export default class ReplaceBytecodeNop {
     // Retrieve size of current cut
     script.splice(index, 1);
     let oldCut = script[index];
-    if (oldCut instanceof Buffer) {
+    if (oldCut instanceof Uint8Array) {
       oldCut = Data.decodeInt(oldCut);
     } else if (oldCut === Op.OP_0) {
       oldCut = 0;
diff --git a/packages/cashc/src/generation/Script.ts b/packages/cashc/src/generation/Script.ts
@@ -6,7 +6,7 @@ import { Data } from '../util';
 
 export const Op = OpcodesBCH;
 export type Op = number;
-export type OpOrData = Op | Buffer;
+export type OpOrData = Op | Uint8Array;
 export type Script = OpOrData[];
 
 export class toOps {
diff --git a/packages/cashc/src/print/OutputSourceCodeTraversal.ts b/packages/cashc/src/print/OutputSourceCodeTraversal.ts
@@ -1,3 +1,4 @@
+import { binToHex } from '@bitauth/libauth';
 import { SymbolTable } from '../ast/SymbolTable';
 import {
   Node,
@@ -237,7 +238,7 @@ export default class OutputSourceCodeTraversal extends AstTraversal {
   }
 
   visitHexLiteral(node: HexLiteralNode): Node {
-    this.addOutput(`0x${node.value.toString('hex')}`);
+    this.addOutput(`0x${binToHex(node.value)}`);
     return node;
   }
 }
diff --git a/packages/cashc/src/util.ts b/packages/cashc/src/util.ts
@@ -8,6 +8,8 @@ import {
   disassembleBytecodeBCH,
   AuthenticationInstructions,
   hexToBin,
+  utf8ToBin,
+  binToUtf8,
 } from '@bitauth/libauth';
 import { ANTLRInputStream, CommonTokenStream } from 'antlr4ts';
 import fs from 'fs';
@@ -25,11 +27,11 @@ import ReplaceBytecodeNop from './generation/ReplaceBytecodeNop';
 import VerifyCovenantTraversal from './semantic/VerifyCovenantTraversal';
 
 export const Data = {
-  encodeBool(bool: boolean): Buffer {
+  encodeBool(bool: boolean): Uint8Array {
     return bool ? this.encodeInt(1) : this.encodeInt(0);
   },
 
-  decodeBool(encodedBool: Buffer): boolean {
+  decodeBool(encodedBool: Uint8Array): boolean {
     // Any encoding of 0 is false, else true
     for (let i = 0; i < encodedBool.byteLength; i += 1) {
       if (encodedBool[i] !== 0) {
@@ -41,11 +43,11 @@ export const Data = {
     return false;
   },
 
-  encodeInt(int: number): Buffer {
-    return Buffer.from(bigIntToScriptNumber(BigInt(int)));
+  encodeInt(int: number): Uint8Array {
+    return bigIntToScriptNumber(BigInt(int));
   },
 
-  decodeInt(encodedInt: Buffer, maxLength?: number): number {
+  decodeInt(encodedInt: Uint8Array, maxLength?: number): number {
     const options = { maximumScriptNumberByteLength: maxLength };
     const result = parseBytesAsScriptNumber(encodedInt, options);
 
@@ -56,12 +58,12 @@ export const Data = {
     return Number(result);
   },
 
-  encodeString(str: string): Buffer {
-    return Buffer.from(str, 'ascii');
+  encodeString(str: string): Uint8Array {
+    return utf8ToBin(str);
   },
 
-  decodeString(encodedString: Buffer): string {
-    return encodedString.toString('ascii');
+  decodeString(encodedString: Uint8Array): string {
+    return binToUtf8(encodedString);
   },
 
   scriptToAsm(script: Script): string {
@@ -75,7 +77,7 @@ export const Data = {
   scriptToBytecode(script: Script): Uint8Array {
     // Convert the script elements to AuthenticationInstructions
     const instructions = script.map((opOrData) => {
-      if (opOrData instanceof Buffer) {
+      if (opOrData instanceof Uint8Array) {
         return parseBytecode(encodeDataPush(opOrData))[0];
       } else {
         return { opcode: opOrData };
@@ -93,7 +95,7 @@ export const Data = {
     // Convert the AuthenticationInstructions to script elements
     const script = instructions.map((instruction) => {
       if ('data' in instruction) {
-        return Buffer.from(instruction.data);
+        return instruction.data;
       } else {
         return instruction.opcode;
       }
diff --git a/packages/cashc/test/ast/fixtures.ts b/packages/cashc/test/ast/fixtures.ts
@@ -1,3 +1,4 @@
+import { hexToBin } from '@bitauth/libauth';
 import { BytesType, PrimitiveType } from '../../src';
 import {
   SourceFileNode,
@@ -447,7 +448,7 @@ export const fixtures: Fixture[] = [
               new BinaryOpNode(
                 new IdentifierNode(PreimageField.BYTECODE),
                 BinaryOperator.EQ,
-                new HexLiteralNode(Buffer.from('00', 'hex')),
+                new HexLiteralNode(hexToBin('00')),
               ),
             ),
             new RequireNode(
@@ -675,7 +676,7 @@ export const fixtures: Fixture[] = [
               new InstantiationNode(
                 new IdentifierNode(Class.OUTPUT_NULLDATA),
                 [new ArrayNode([
-                  new HexLiteralNode(Buffer.from('6d02', 'hex')),
+                  new HexLiteralNode(hexToBin('6d02')),
                   new CastNode(
                     new BytesType(),
                     new StringLiteralNode('A contract may not injure a human being or, through inaction, allow a human being to come to harm.', '\''),
diff --git a/packages/cashc/test/fixture/cast_hash_checksig.cash b/packages/cashc/test/fixture/cast_hash_checksig.cash
@@ -1,6 +1,6 @@
 contract CastHashChecksig() {
     function hello(pubkey pk, sig s) {
-        require((ripemd160(bytes(pk)) == hash160(0x0) == !true));
+        require((ripemd160(bytes(pk)) == hash160(0x) == !true));
         require(checkSig(s, pk));
     }
 }
diff --git a/packages/cashc/test/test-util.ts b/packages/cashc/test/test-util.ts
@@ -1,3 +1,4 @@
+import { hexToBin } from '@bitauth/libauth';
 import { ParseTree } from 'antlr4ts/tree/ParseTree';
 import { CommonTokenStream, ParserRuleContext } from 'antlr4ts';
 import { TerminalNode } from 'antlr4ts/tree/TerminalNode';
@@ -19,7 +20,7 @@ export function literalToNode(literal: boolean | number | string): LiteralNode {
   } else if (typeof literal === 'number') {
     return new IntLiteralNode(literal);
   } else if (literal.startsWith('0x')) {
-    return new HexLiteralNode(Buffer.from(literal.slice(2), 'hex'));
+    return new HexLiteralNode(hexToBin(literal.slice(2)));
   } else {
     return new StringLiteralNode(literal, '"');
   }
diff --git a/packages/cashscript/src/Contract.ts b/packages/cashscript/src/Contract.ts
@@ -49,7 +49,7 @@ export class Contract {
     }
 
     this.redeemScript = [
-      ...encodedParameters as Buffer[],
+      ...encodedParameters as Uint8Array[],
       ...Data.asmToScript(this.artifact.bytecode),
     ];
 
diff --git a/packages/cashscript/src/Parameter.ts b/packages/cashscript/src/Parameter.ts
@@ -1,3 +1,4 @@
+import { hexToBin } from '@bitauth/libauth';
 import {
   PrimitiveType,
   Data,
@@ -7,9 +8,12 @@ import {
 import { TypeError } from './Errors';
 import SignatureTemplate from './SignatureTemplate';
 
-export type Parameter = number | boolean | string | Buffer | SignatureTemplate;
+export type Parameter = number | boolean | string | Uint8Array | SignatureTemplate;
 
-export function encodeParameter(parameter: Parameter, typeStr: string): Buffer | SignatureTemplate {
+export function encodeParameter(
+  parameter: Parameter,
+  typeStr: string,
+): Uint8Array | SignatureTemplate {
   const type = parseType(typeStr);
   if (type === PrimitiveType.BOOL) {
     if (typeof parameter !== 'boolean') {
@@ -28,15 +32,15 @@ export function encodeParameter(parameter: Parameter, typeStr: string): Buffer |
     return Data.encodeString(parameter);
   } else {
     if (type === PrimitiveType.SIG && parameter instanceof SignatureTemplate) return parameter;
-    // Convert string to Buffer
+    // Convert string to Uint8Array
     if (typeof parameter === 'string') {
       if (parameter.startsWith('0x')) {
         parameter = parameter.slice(2);
       }
-      parameter = Buffer.from(parameter, 'hex');
+      parameter = hexToBin(parameter);
     }
 
-    if (!(parameter instanceof Buffer)) throw Error(); // Shouldn't happen
+    if (!(parameter instanceof Uint8Array)) throw Error(); // Shouldn't happen
 
     // Bounded bytes types require a correctly sized parameter
     if (type instanceof BytesType && type.bound && parameter.byteLength !== type.bound) {
diff --git a/packages/cashscript/src/Transaction.ts b/packages/cashscript/src/Transaction.ts
@@ -1,7 +1,6 @@
 import {
   bigIntToBinUint64LE,
   hexToBin,
-  instantiateSha256,
   binToHex,
   encodeTransaction,
   addressContentsToLockingBytecode,
@@ -30,6 +29,7 @@ import {
   sha256,
   addressToLockScript,
   createSighashPreimage,
+  placeholder,
 } from './util';
 import { P2SH_OUTPUT_SIZE, DUST_LIMIT } from './constants';
 import NetworkProvider from './network/NetworkProvider';
@@ -52,7 +52,7 @@ export class Transaction {
     private provider: NetworkProvider,
     private redeemScript: Script,
     private abiFunction: AbiFunction,
-    private parameters: (Buffer | SignatureTemplate)[],
+    private parameters: (Uint8Array | SignatureTemplate)[],
     private selector?: number,
   ) {}
 
@@ -176,7 +176,7 @@ export class Transaction {
 
         const signature = utxo.template.generateSignature(sighash, secp256k1);
 
-        const inputScript = Data.scriptToBytecode([Buffer.from(signature), Buffer.from(pubkey)]);
+        const inputScript = Data.scriptToBytecode([signature, pubkey]);
         inputScripts.push(inputScript);
 
         return;
@@ -192,7 +192,7 @@ export class Transaction {
         const preimage = createSighashPreimage(transaction, utxo, i, bytecode, p.getHashType());
         const sighash = sha256(sha256(preimage));
 
-        return Buffer.from(p.generateSignature(sighash, secp256k1));
+        return p.generateSignature(sighash, secp256k1);
       });
 
       const preimage = this.abiFunction.covenant
@@ -248,16 +248,21 @@ export class Transaction {
       throw Error('Attempted to build a transaction without outputs');
     }
 
-    // Use a placeholder script with 65-length Buffer in the place of signatures
-    // and a correctly sized preimage Buffer if the function is a covenant
-    // for correct size calculation of inputs
+    // Replace all SignatureTemplate with 65-length placeholder Uint8Arrays
+    const placeholderParameters = this.parameters.map(p => (
+      p instanceof SignatureTemplate ? placeholder(65) : p
+    ));
+
+    // Create a placeholder preimage of the correct size
     const placeholderPreimage = this.abiFunction.covenant
-      ? Buffer.alloc(getPreimageSize(Data.scriptToBytecode(this.redeemScript)), 0)
+      ? placeholder(getPreimageSize(Data.scriptToBytecode(this.redeemScript)))
       : undefined;
 
+    // Create a placeholder input script for size calculation using the placeholder
+    // parameters and correctly sized placeholder preimage
     const placeholderScript = createInputScript(
       this.redeemScript,
-      this.parameters.map(p => (p instanceof SignatureTemplate ? Buffer.alloc(65, 0) : p)),
+      placeholderParameters,
       this.selector,
       placeholderPreimage,
     );
diff --git a/packages/cashscript/src/interfaces.ts b/packages/cashscript/src/interfaces.ts
@@ -20,7 +20,7 @@ export interface Recipient {
 }
 
 export interface Output {
-  to: string | Buffer;
+  to: string | Uint8Array;
   amount: number;
 }
 
diff --git a/packages/cashscript/src/network/ElectrumNetworkProvider.ts b/packages/cashscript/src/network/ElectrumNetworkProvider.ts
@@ -76,7 +76,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
 
   async connectCluster(): Promise<boolean[]> {
     try {
-      return this.electrum.startup();
+      return await this.electrum.startup();
     } catch (e) {
       return [];
     }
diff --git a/packages/cashscript/src/util.ts b/packages/cashscript/src/util.ts
diff --git a/packages/cashscript/test/Contract.test.ts b/packages/cashscript/test/Contract.test.ts
diff --git a/packages/cashscript/test/e2e/P2PKH.test.ts b/packages/cashscript/test/e2e/P2PKH.test.ts
diff --git a/packages/cashscript/test/e2e/misc.test.ts b/packages/cashscript/test/e2e/misc.test.ts
diff --git a/packages/cashscript/test/test-util.ts b/packages/cashscript/test/test-util.ts
diff --git a/packages/cashscript/test/util.test.ts b/packages/cashscript/test/util.test.ts

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+import { binToHex } from '@bitauth/libauth';`
`1`	`2`	`import { SymbolTable } from '../ast/SymbolTable';`
`2`	`3`	`import {`
`3`	`4`	`Node,`
`@@ -237,7 +238,7 @@ export default class OutputSourceCodeTraversal extends AstTraversal {`
`237`	`238`	`}`
`238`	`239`
`239`	`240`	`visitHexLiteral(node: HexLiteralNode): Node {`
`240`		- this.addOutput(`0x${node.value.toString('hex')}`);
	`241`	+ this.addOutput(`0x${binToHex(node.value)}`);
`241`	`242`	`return node;`
`242`	`243`	`}`
`243`	`244`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`contract CastHashChecksig() {`
`2`	`2`	`function hello(pubkey pk, sig s) {`
`3`		`- require((ripemd160(bytes(pk)) == hash160(0x0) == !true));`
	`3`	`+ require((ripemd160(bytes(pk)) == hash160(0x) == !true));`
`4`	`4`	`require(checkSig(s, pk));`
`5`	`5`	`}`
`6`	`6`	`}`