algosdk 2.8.0 → 3.0.0-beta.1

package/src/logicsig.ts

@@ -1,25 +1,31 @@
-import { Buffer } from 'buffer';
-import * as nacl from './nacl/naclWrappers';
-import * as address from './encoding/address';
-import * as encoding from './encoding/encoding';
-import { verifyMultisig } from './multisig';
-import * as utils from './utils/utils';
-import * as txnBuilder from './transaction';
-import { isValidAddress } from './encoding/address';
+import * as nacl from './nacl/naclWrappers.js';
+import { Address, isValidAddress } from './encoding/address.js';
+import * as encoding from './encoding/encoding.js';
+import {
+  NamedMapSchema,
+  ArraySchema,
+  ByteArraySchema,
+  FixedLengthByteArraySchema,
+  OptionalSchema,
+  allOmitEmpty,
+} from './encoding/schema/index.js';
+import {
+  MultisigMetadata,
+  verifyMultisig,
+  addressFromMultisigPreImg,
+  pksFromAddresses,
+} from './multisig.js';
+import * as utils from './utils/utils.js';
 import {
-  EncodedLogicSig,
-  EncodedLogicSigAccount,
   EncodedMultisig,
-  EncodedSignedTransaction,
-} from './types/transactions/encoded';
-import { MultisigMetadata } from './types/multisig';
+  encodedMultiSigToEncodingData,
+  encodedMultiSigFromEncodingData,
+  ENCODED_MULTISIG_SCHEMA,
+} from './types/transactions/encoded.js';
 
-interface LogicSigStorageStructure {
-  logic: Uint8Array;
-  args: Uint8Array[];
-  sig?: Uint8Array;
-  msig?: EncodedMultisig;
-}
+// base64regex is the regex to test for base64 strings
+const base64regex =
+  /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
 
 /** sanityCheckProgram performs heuristic program validation:
  * check if passed in bytes are Algorand address or is B64 encoded, rather than Teal bytes
@@ -39,12 +45,12 @@ export function sanityCheckProgram(program: Uint8Array) {
   );
 
   if (isAsciiPrintable) {
-    const programStr = Buffer.from(program).toString();
+    const programStr = new TextDecoder().decode(program);
 
     if (isValidAddress(programStr))
       throw new Error('requesting program bytes, get Algorand address');
 
-    if (Buffer.from(programStr, 'base64').toString('base64') === programStr)
+    if (base64regex.test(programStr))
       throw new Error('program should not be b64 encoded');
 
     throw new Error(
@@ -53,34 +59,50 @@ export function sanityCheckProgram(program: Uint8Array) {
   }
 }
 
+const programTag = new TextEncoder().encode('Program');
+
 /**
  LogicSig implementation
 
  LogicSig cannot sign transactions in all cases.  Instead, use LogicSigAccount as a safe, general purpose signing mechanism.  Since LogicSig does not track the provided signature's public key, LogicSig cannot sign transactions when delegated to a non-multisig account _and_ the sender is not the delegating account.
  */
-export class LogicSig implements LogicSigStorageStructure {
-  tag = Buffer.from('Program');
+export class LogicSig implements encoding.Encodable {
+  static readonly encodingSchema = new NamedMapSchema(
+    allOmitEmpty([
+      {
+        key: 'l',
+        valueSchema: new ByteArraySchema(),
+      },
+      {
+        key: 'arg',
+        valueSchema: new ArraySchema(new ByteArraySchema()),
+      },
+      {
+        key: 'sig',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(64)),
+      },
+      {
+        key: 'msig',
+        valueSchema: new OptionalSchema(ENCODED_MULTISIG_SCHEMA),
+      },
+    ])
+  );
 
   logic: Uint8Array;
   args: Uint8Array[];
   sig?: Uint8Array;
   msig?: EncodedMultisig;
 
-  constructor(
-    program: Uint8Array,
-    programArgs?: Array<Uint8Array | Buffer> | null
-  ) {
+  constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null) {
     if (
       programArgs &&
       (!Array.isArray(programArgs) ||
-        !programArgs.every(
-          (arg) => arg.constructor === Uint8Array || Buffer.isBuffer(arg)
-        ))
+        !programArgs.every((arg) => arg.constructor === Uint8Array))
     ) {
       throw new TypeError('Invalid arguments');
     }
 
-    let args: Uint8Array[] | undefined;
+    let args: Uint8Array[] = [];
     if (programArgs != null)
       args = programArgs.map((arg) => new Uint8Array(arg));
 
@@ -92,27 +114,32 @@ export class LogicSig implements LogicSigStorageStructure {
     this.msig = undefined;
   }
 
-  // eslint-disable-next-line camelcase
-  get_obj_for_encoding() {
-    const obj: EncodedLogicSig = {
-      l: this.logic,
-    };
-    if (this.args) {
-      obj.arg = this.args;
-    }
-    if (this.sig) {
-      obj.sig = this.sig;
-    } else if (this.msig) {
-      obj.msig = this.msig;
+  // eslint-disable-next-line class-methods-use-this
+  getEncodingSchema(): encoding.Schema {
+    return LogicSig.encodingSchema;
+  }
+
+  toEncodingData(): Map<string, unknown> {
+    const data = new Map<string, unknown>([
+      ['l', this.logic],
+      ['arg', this.args],
+      ['sig', this.sig],
+    ]);
+    if (this.msig) {
+      data.set('msig', encodedMultiSigToEncodingData(this.msig));
     }
-    return obj;
+    return data;
   }
 
-  // eslint-disable-next-line camelcase
-  static from_obj_for_encoding(encoded: EncodedLogicSig) {
-    const lsig = new LogicSig(encoded.l, encoded.arg);
-    lsig.sig = encoded.sig;
-    lsig.msig = encoded.msig;
+  static fromEncodingData(data: unknown): LogicSig {
+    if (!(data instanceof Map)) {
+      throw new Error(`Invalid decoded logic sig: ${data}`);
+    }
+    const lsig = new LogicSig(data.get('l'), data.get('arg'));
+    lsig.sig = data.get('sig');
+    if (data.get('msig')) {
+      lsig.msig = encodedMultiSigFromEncodingData(data.get('msig'));
+    }
     return lsig;
   }
 
@@ -131,7 +158,7 @@ export class LogicSig implements LogicSigStorageStructure {
       return false;
     }
 
-    const toBeSigned = utils.concatArrays(this.tag, this.logic);
+    const toBeSigned = utils.concatArrays(programTag, this.logic);
 
     if (!this.sig && !this.msig) {
       const hash = nacl.genericHash(toBeSigned);
@@ -142,17 +169,17 @@ export class LogicSig implements LogicSigStorageStructure {
       return nacl.verify(toBeSigned, this.sig, publicKey);
     }
 
-    return verifyMultisig(toBeSigned, this.msig, publicKey);
+    return verifyMultisig(toBeSigned, this.msig!, publicKey);
   }
 
   /**
    * Compute hash of the logic sig program (that is the same as escrow account address) as string address
    * @returns String representation of the address
    */
-  address() {
-    const toBeSigned = utils.concatArrays(this.tag, this.logic);
+  address(): Address {
+    const toBeSigned = utils.concatArrays(programTag, this.logic);
     const hash = nacl.genericHash(toBeSigned);
-    return address.encodeAddress(new Uint8Array(hash));
+    return new Address(Uint8Array.from(hash));
   }
 
   /**
@@ -164,9 +191,7 @@ export class LogicSig implements LogicSigStorageStructure {
     if (msig == null) {
       this.sig = this.signProgram(secretKey);
     } else {
-      const subsigs = msig.addrs.map((addr) => ({
-        pk: address.decodeAddress(addr).publicKey,
-      }));
+      const subsigs = pksFromAddresses(msig.addrs).map((pk) => ({ pk }));
 
       this.msig = {
         v: msig.version,
@@ -192,7 +217,7 @@ export class LogicSig implements LogicSigStorageStructure {
   }
 
   signProgram(secretKey: Uint8Array) {
-    const toBeSigned = utils.concatArrays(this.tag, this.logic);
+    const toBeSigned = utils.concatArrays(programTag, this.logic);
     const sig = nacl.sign(toBeSigned, secretKey);
     return sig;
   }
@@ -217,20 +242,32 @@ export class LogicSig implements LogicSigStorageStructure {
     return [sig, index];
   }
 
-  toByte() {
-    return encoding.encode(this.get_obj_for_encoding());
+  toByte(): Uint8Array {
+    return encoding.encodeMsgpack(this);
   }
 
-  static fromByte(encoded: ArrayLike<any>) {
-    const decodedObj = encoding.decode(encoded) as EncodedLogicSig;
-    return LogicSig.from_obj_for_encoding(decodedObj);
+  static fromByte(encoded: ArrayLike<any>): LogicSig {
+    return encoding.decodeMsgpack(encoded, LogicSig);
   }
 }
 
 /**
  * Represents an account that can sign with a LogicSig program.
  */
-export class LogicSigAccount {
+export class LogicSigAccount implements encoding.Encodable {
+  static readonly encodingSchema = new NamedMapSchema(
+    allOmitEmpty([
+      {
+        key: 'lsig',
+        valueSchema: LogicSig.encodingSchema,
+      },
+      {
+        key: 'sigkey',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(32)),
+      },
+    ])
+  );
+
   lsig: LogicSig;
   sigkey?: Uint8Array;
 
@@ -243,44 +280,48 @@ export class LogicSigAccount {
    *   this LogicSig.
    * @param args - An optional array of arguments for the program.
    */
-  constructor(program: Uint8Array, args?: Array<Uint8Array | Buffer> | null) {
+  constructor(program: Uint8Array, args?: Array<Uint8Array> | null) {
     this.lsig = new LogicSig(program, args);
     this.sigkey = undefined;
   }
 
-  // eslint-disable-next-line camelcase
-  get_obj_for_encoding() {
-    const obj: EncodedLogicSigAccount = {
-      lsig: this.lsig.get_obj_for_encoding(),
-    };
-    if (this.sigkey) {
-      obj.sigkey = this.sigkey;
-    }
-    return obj;
+  // eslint-disable-next-line class-methods-use-this
+  getEncodingSchema(): encoding.Schema {
+    return LogicSigAccount.encodingSchema;
   }
 
-  // eslint-disable-next-line camelcase
-  static from_obj_for_encoding(encoded: EncodedLogicSigAccount) {
-    const lsigAccount = new LogicSigAccount(encoded.lsig.l, encoded.lsig.arg);
-    lsigAccount.lsig = LogicSig.from_obj_for_encoding(encoded.lsig);
-    lsigAccount.sigkey = encoded.sigkey;
+  toEncodingData(): Map<string, unknown> {
+    return new Map<string, unknown>([
+      ['lsig', this.lsig.toEncodingData()],
+      ['sigkey', this.sigkey],
+    ]);
+  }
+
+  static fromEncodingData(data: unknown): LogicSigAccount {
+    if (!(data instanceof Map)) {
+      throw new Error(`Invalid decoded logic sig account: ${data}`);
+    }
+    const value = data as Map<string, unknown>;
+    const lsig = LogicSig.fromEncodingData(value.get('lsig'));
+    const lsigAccount = new LogicSigAccount(lsig.logic, lsig.args);
+    lsigAccount.lsig = lsig; // Restore other properties of the lsig
+    lsigAccount.sigkey = value.get('sigkey') as Uint8Array;
     return lsigAccount;
   }
 
   /**
    * Encode this object into msgpack.
    */
-  toByte() {
-    return encoding.encode(this.get_obj_for_encoding());
+  toByte(): Uint8Array {
+    return encoding.encodeMsgpack(this);
   }
 
   /**
    * Decode a msgpack object into a LogicSigAccount.
    * @param encoded - The encoded LogicSigAccount.
    */
-  static fromByte(encoded: ArrayLike<any>) {
-    const decodedObj = encoding.decode(encoded) as EncodedLogicSigAccount;
-    return LogicSigAccount.from_obj_for_encoding(decodedObj);
+  static fromByte(encoded: ArrayLike<any>): LogicSigAccount {
+    return encoding.decodeMsgpack(encoded, LogicSigAccount);
   }
 
   /**
@@ -300,7 +341,7 @@ export class LogicSigAccount {
    */
   verify() {
     const addr = this.address();
-    return this.lsig.verify(address.decodeAddress(addr).publicKey);
+    return this.lsig.verify(addr.publicKey);
   }
 
   /**
@@ -312,7 +353,7 @@ export class LogicSigAccount {
    * If the LogicSig is not delegated to another account, this will return an
    *  escrow address that is the hash of the LogicSig's program code.
    */
-  address() {
+  address(): Address {
     if (this.lsig.sig && this.lsig.msig) {
       throw new Error(
         'LogicSig has too many signatures. At most one of sig or msig may be present'
@@ -323,7 +364,7 @@ export class LogicSigAccount {
       if (!this.sigkey) {
         throw new Error('Signing key for delegated account is missing');
       }
-      return address.encodeAddress(this.sigkey);
+      return new Address(this.sigkey);
     }
 
     if (this.lsig.msig) {
@@ -332,7 +373,7 @@ export class LogicSigAccount {
         threshold: this.lsig.msig.thr,
         pks: this.lsig.msig.subsig.map((subsig) => subsig.pk),
       };
-      return address.encodeAddress(address.fromMultisigPreImg(msigMetadata));
+      return addressFromMultisigPreImg(msigMetadata);
     }
 
     return this.lsig.address();
@@ -378,156 +419,67 @@ export class LogicSigAccount {
   }
 }
 
-function signLogicSigTransactionWithAddress(
-  txn: txnBuilder.Transaction,
-  lsig: LogicSig,
-  lsigAddress: Uint8Array
-) {
-  if (!lsig.verify(lsigAddress)) {
-    throw new Error(
-      'Logic signature verification failed. Ensure the program and signature are valid.'
-    );
-  }
-
-  const signedTxn: EncodedSignedTransaction = {
-    lsig: lsig.get_obj_for_encoding(),
-    txn: txn.get_obj_for_encoding(),
-  };
-
-  if (!nacl.bytesEqual(lsigAddress, txn.from.publicKey)) {
-    signedTxn.sgnr = Buffer.from(lsigAddress);
-  }
-
-  return {
-    txID: txn.txID().toString(),
-    blob: encoding.encode(signedTxn),
-  };
-}
-
-/**
- * signLogicSigTransactionObject takes a transaction and a LogicSig object and
- * returns a signed transaction.
- *
- * @param txn - The transaction to sign.
- * @param lsigObject - The LogicSig object that will sign the transaction.
- *
- * @returns Object containing txID and blob representing signed transaction.
- */
-export function signLogicSigTransactionObject(
-  txn: txnBuilder.Transaction,
-  lsigObject: LogicSig | LogicSigAccount
-) {
-  let lsig: LogicSig;
-  let lsigAddress: Uint8Array;
-
-  if (lsigObject instanceof LogicSigAccount) {
-    lsig = lsigObject.lsig;
-    lsigAddress = address.decodeAddress(lsigObject.address()).publicKey;
-  } else {
-    lsig = lsigObject;
-
-    if (lsig.sig) {
-      // For a LogicSig with a non-multisig delegating account, we cannot derive
-      // the address of that account from only its signature, so assume the
-      // delegating account is the sender. If that's not the case, the signing
-      // will fail.
-      lsigAddress = txn.from.publicKey;
-    } else if (lsig.msig) {
-      const msigMetadata = {
-        version: lsig.msig.v,
-        threshold: lsig.msig.thr,
-        pks: lsig.msig.subsig.map((subsig) => subsig.pk),
-      };
-      lsigAddress = address.fromMultisigPreImg(msigMetadata);
-    } else {
-      lsigAddress = address.decodeAddress(lsig.address()).publicKey;
-    }
-  }
-
-  return signLogicSigTransactionWithAddress(txn, lsig, lsigAddress);
-}
-
-/**
- * signLogicSigTransaction takes a transaction and a LogicSig object and returns
- * a signed transaction.
- *
- * @param txn - The transaction to sign.
- * @param lsigObject - The LogicSig object that will sign the transaction.
- *
- * @returns Object containing txID and blob representing signed transaction.
- * @throws error on failure
- */
-export function signLogicSigTransaction(
-  txn: txnBuilder.TransactionLike,
-  lsigObject: LogicSig | LogicSigAccount
-) {
-  const algoTxn = txnBuilder.instantiateTxnIfNeeded(txn);
-  return signLogicSigTransactionObject(algoTxn, lsigObject);
-}
-
 /**
  * logicSigFromByte accepts encoded logic sig bytes and attempts to call logicsig.fromByte on it,
  * returning the result
  */
-export function logicSigFromByte(encoded: Uint8Array) {
-  return LogicSig.fromByte(encoded);
+export function logicSigFromByte(encoded: Uint8Array): LogicSig {
+  return encoding.decodeMsgpack(encoded, LogicSig);
 }
 
-const SIGN_PROGRAM_DATA_PREFIX = Buffer.from('ProgData');
+const SIGN_PROGRAM_DATA_PREFIX = new TextEncoder().encode('ProgData');
 
 /**
  * tealSign creates a signature compatible with ed25519verify opcode from program hash
- * @param sk - uint8array with secret key
- * @param data - buffer with data to sign
+ * @param sk - Uint8Array with secret key
+ * @param data - Uint8Array with data to sign
  * @param programHash - string representation of teal program hash (= contract address for LogicSigs)
  */
 export function tealSign(
   sk: Uint8Array,
-  data: Uint8Array | Buffer,
-  programHash: string
+  data: Uint8Array,
+  programHash: string | Address
 ) {
-  const parts = utils.concatArrays(
-    address.decodeAddress(programHash).publicKey,
-    data
-  );
-  const toBeSigned = Buffer.from(
-    utils.concatArrays(SIGN_PROGRAM_DATA_PREFIX, parts)
-  );
+  const programAddr =
+    typeof programHash === 'string'
+      ? Address.fromString(programHash)
+      : programHash;
+  const parts = utils.concatArrays(programAddr.publicKey, data);
+  const toBeSigned = utils.concatArrays(SIGN_PROGRAM_DATA_PREFIX, parts);
   return nacl.sign(toBeSigned, sk);
 }
 
 /**
  * verifyTealSign verifies a signature as would the ed25519verify opcode
- * @param data - buffer with original signed data
+ * @param data - Uint8Array with original signed data
  * @param programHash - string representation of teal program hash (= contract address for LogicSigs)
  * @param sig - uint8array with the signature to verify (produced by tealSign/tealSignFromProgram)
  * @param pk - uint8array with public key to verify against
  */
 export function verifyTealSign(
-  data: Uint8Array | Buffer,
-  programHash: string,
+  data: Uint8Array,
+  programHash: string | Address,
   sig: Uint8Array,
   pk: Uint8Array
 ) {
-  const parts = utils.concatArrays(
-    address.decodeAddress(programHash).publicKey,
-    data
-  );
-  const toBeSigned = Buffer.from(
-    utils.concatArrays(SIGN_PROGRAM_DATA_PREFIX, parts)
-  );
+  const programAddr =
+    typeof programHash === 'string'
+      ? Address.fromString(programHash)
+      : programHash;
+  const parts = utils.concatArrays(programAddr.publicKey, data);
+  const toBeSigned = utils.concatArrays(SIGN_PROGRAM_DATA_PREFIX, parts);
   return nacl.verify(toBeSigned, sig, pk);
 }
 
 /**
  * tealSignFromProgram creates a signature compatible with ed25519verify opcode from raw program bytes
  * @param sk - uint8array with secret key
- * @param data - buffer with data to sign
- * @param program - buffer with teal program
+ * @param data - Uint8Array with data to sign
+ * @param program - Uint8Array with teal program
  */
 export function tealSignFromProgram(
   sk: Uint8Array,
-  data: Uint8Array | Buffer,
+  data: Uint8Array,
   program: Uint8Array
 ) {
   const lsig = new LogicSig(program);