algosdk 1.24.0 → 1.24.1

package/src/abi/contract.ts

@@ -0,0 +1,51 @@
+import { ABIMethod, ABIMethodParams, getMethodByName } from './method';
+
+export interface ABIContractNetworkInfo {
+  appID: number;
+}
+
+export interface ABIContractNetworks {
+  [network: string]: ABIContractNetworkInfo;
+}
+
+export interface ABIContractParams {
+  name: string;
+  desc?: string;
+  networks?: ABIContractNetworks;
+  methods: ABIMethodParams[];
+}
+
+export class ABIContract {
+  public readonly name: string;
+  public readonly description?: string;
+  public readonly networks: ABIContractNetworks;
+  public readonly methods: ABIMethod[];
+
+  constructor(params: ABIContractParams) {
+    if (
+      typeof params.name !== 'string' ||
+      !Array.isArray(params.methods) ||
+      (params.networks && typeof params.networks !== 'object')
+    ) {
+      throw new Error('Invalid ABIContract parameters');
+    }
+
+    this.name = params.name;
+    this.description = params.desc;
+    this.networks = params.networks ? { ...params.networks } : {};
+    this.methods = params.methods.map((method) => new ABIMethod(method));
+  }
+
+  toJSON(): ABIContractParams {
+    return {
+      name: this.name,
+      desc: this.description,
+      networks: this.networks,
+      methods: this.methods.map((method) => method.toJSON()),
+    };
+  }
+
+  getMethodByName(name: string): ABIMethod {
+    return getMethodByName(this.methods, name);
+  }
+}

package/src/abi/index.ts

@@ -0,0 +1,6 @@
+export * from './abi_type';
+export * from './contract';
+export * from './interface';
+export * from './method';
+export * from './transaction';
+export * from './reference';

package/src/abi/interface.ts

@@ -0,0 +1,35 @@
+import { ABIMethod, ABIMethodParams, getMethodByName } from './method';
+
+export interface ABIInterfaceParams {
+  name: string;
+  desc?: string;
+  methods: ABIMethodParams[];
+}
+
+export class ABIInterface {
+  public readonly name: string;
+  public readonly description?: string;
+  public readonly methods: ABIMethod[];
+
+  constructor(params: ABIInterfaceParams) {
+    if (typeof params.name !== 'string' || !Array.isArray(params.methods)) {
+      throw new Error('Invalid ABIInterface parameters');
+    }
+
+    this.name = params.name;
+    this.description = params.desc;
+    this.methods = params.methods.map((method) => new ABIMethod(method));
+  }
+
+  toJSON(): ABIInterfaceParams {
+    return {
+      name: this.name,
+      desc: this.description,
+      methods: this.methods.map((method) => method.toJSON()),
+    };
+  }
+
+  getMethodByName(name: string): ABIMethod {
+    return getMethodByName(this.methods, name);
+  }
+}

package/src/abi/method.ts

@@ -0,0 +1,186 @@
+import { genericHash } from '../nacl/naclWrappers';
+import { ABIType, ABITupleType } from './abi_type';
+import { ABITransactionType, abiTypeIsTransaction } from './transaction';
+import { ABIReferenceType, abiTypeIsReference } from './reference';
+
+function parseMethodSignature(
+  signature: string
+): { name: string; args: string[]; returns: string } {
+  const argsStart = signature.indexOf('(');
+  if (argsStart === -1) {
+    throw new Error(`Invalid method signature: ${signature}`);
+  }
+
+  let argsEnd = -1;
+  let depth = 0;
+  for (let i = argsStart; i < signature.length; i++) {
+    const char = signature[i];
+
+    if (char === '(') {
+      depth += 1;
+    } else if (char === ')') {
+      if (depth === 0) {
+        // unpaired parenthesis
+        break;
+      }
+
+      depth -= 1;
+      if (depth === 0) {
+        argsEnd = i;
+        break;
+      }
+    }
+  }
+
+  if (argsEnd === -1) {
+    throw new Error(`Invalid method signature: ${signature}`);
+  }
+
+  return {
+    name: signature.slice(0, argsStart),
+    args: ABITupleType.parseTupleContent(
+      signature.slice(argsStart + 1, argsEnd)
+    ),
+    returns: signature.slice(argsEnd + 1),
+  };
+}
+
+export interface ABIMethodArgParams {
+  type: string;
+  name?: string;
+  desc?: string;
+}
+
+export interface ABIMethodReturnParams {
+  type: string;
+  desc?: string;
+}
+
+export interface ABIMethodParams {
+  name: string;
+  desc?: string;
+  args: ABIMethodArgParams[];
+  returns: ABIMethodReturnParams;
+}
+
+export type ABIArgumentType = ABIType | ABITransactionType | ABIReferenceType;
+
+export type ABIReturnType = ABIType | 'void';
+
+export class ABIMethod {
+  public readonly name: string;
+  public readonly description?: string;
+  public readonly args: Array<{
+    type: ABIArgumentType;
+    name?: string;
+    description?: string;
+  }>;
+
+  public readonly returns: { type: ABIReturnType; description?: string };
+
+  constructor(params: ABIMethodParams) {
+    if (
+      typeof params.name !== 'string' ||
+      typeof params.returns !== 'object' ||
+      !Array.isArray(params.args)
+    ) {
+      throw new Error('Invalid ABIMethod parameters');
+    }
+
+    this.name = params.name;
+    this.description = params.desc;
+    this.args = params.args.map(({ type, name, desc }) => {
+      if (abiTypeIsTransaction(type) || abiTypeIsReference(type)) {
+        return {
+          type,
+          name,
+          description: desc,
+        };
+      }
+
+      return {
+        type: ABIType.from(type),
+        name,
+        description: desc,
+      };
+    });
+    this.returns = {
+      type:
+        params.returns.type === 'void'
+          ? params.returns.type
+          : ABIType.from(params.returns.type),
+      description: params.returns.desc,
+    };
+  }
+
+  getSignature(): string {
+    const args = this.args.map((arg) => arg.type.toString()).join(',');
+    const returns = this.returns.type.toString();
+    return `${this.name}(${args})${returns}`;
+  }
+
+  getSelector(): Uint8Array {
+    const hash = genericHash(this.getSignature());
+    return new Uint8Array(hash.slice(0, 4));
+  }
+
+  txnCount(): number {
+    let count = 1;
+    for (const arg of this.args) {
+      if (typeof arg.type === 'string' && abiTypeIsTransaction(arg.type)) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+
+  toJSON(): ABIMethodParams {
+    return {
+      name: this.name,
+      desc: this.description,
+      args: this.args.map(({ type, name, description }) => ({
+        type: type.toString(),
+        name,
+        desc: description,
+      })),
+      returns: {
+        type: this.returns.type.toString(),
+        desc: this.returns.description,
+      },
+    };
+  }
+
+  static fromSignature(signature: string): ABIMethod {
+    const { name, args, returns } = parseMethodSignature(signature);
+
+    return new ABIMethod({
+      name,
+      args: args.map((arg) => ({ type: arg })),
+      returns: { type: returns },
+    });
+  }
+}
+
+export function getMethodByName(methods: ABIMethod[], name: string): ABIMethod {
+  if (
+    methods === null ||
+    !Array.isArray(methods) ||
+    !methods.every((item) => item instanceof ABIMethod)
+  )
+    throw new Error('Methods list provided is null or not the correct type');
+
+  const filteredMethods = methods.filter((m: ABIMethod) => m.name === name);
+  if (filteredMethods.length > 1)
+    throw new Error(
+      `found ${
+        filteredMethods.length
+      } methods with the same name ${filteredMethods
+        .map((m: ABIMethod) => m.getSignature())
+        .join(',')}`
+    );
+
+  if (filteredMethods.length === 0)
+    throw new Error(`found 0 methods with the name ${name}`);
+
+  return filteredMethods[0];
+}

package/src/abi/reference.ts

@@ -0,0 +1,24 @@
+export enum ABIReferenceType {
+  /**
+   * Account reference type
+   */
+  account = 'account',
+
+  /**
+   * Application reference type
+   */
+  application = 'application',
+
+  /**
+   * Asset reference type
+   */
+  asset = 'asset',
+}
+
+export function abiTypeIsReference(type: any): type is ABIReferenceType {
+  return (
+    type === ABIReferenceType.account ||
+    type === ABIReferenceType.application ||
+    type === ABIReferenceType.asset
+  );
+}

package/src/abi/transaction.ts

@@ -0,0 +1,61 @@
+import { Transaction } from '../transaction';
+
+export enum ABITransactionType {
+  /**
+   * Any transaction type
+   */
+  any = 'txn',
+
+  /**
+   * Payment transaction type
+   */
+  pay = 'pay',
+
+  /**
+   * Key registration transaction type
+   */
+  keyreg = 'keyreg',
+
+  /**
+   * Asset configuration transaction type
+   */
+  acfg = 'acfg',
+
+  /**
+   * Asset transfer transaction type
+   */
+  axfer = 'axfer',
+
+  /**
+   * Asset freeze transaction type
+   */
+  afrz = 'afrz',
+
+  /**
+   * Application transaction type
+   */
+  appl = 'appl',
+}
+
+export function abiTypeIsTransaction(type: any): type is ABITransactionType {
+  return (
+    type === ABITransactionType.any ||
+    type === ABITransactionType.pay ||
+    type === ABITransactionType.keyreg ||
+    type === ABITransactionType.acfg ||
+    type === ABITransactionType.axfer ||
+    type === ABITransactionType.afrz ||
+    type === ABITransactionType.appl
+  );
+}
+
+export function abiCheckTransactionType(
+  type: ABITransactionType,
+  txn: Transaction
+): boolean {
+  if (type === ABITransactionType.any) {
+    return true;
+  }
+
+  return txn.type && txn.type.toString() === type.toString();
+}

package/src/account.ts

@@ -0,0 +1,12 @@
+import * as nacl from './nacl/naclWrappers';
+import * as address from './encoding/address';
+import Account from './types/account';
+
+/**
+ * generateAccount returns a new Algorand address and its corresponding secret key
+ */
+export default function generateAccount(): Account {
+  const keys = nacl.keyPair();
+  const encodedPk = address.encodeAddress(keys.publicKey);
+  return { addr: encodedPk, sk: keys.secretKey };
+}

package/src/bid.ts

@@ -0,0 +1,95 @@
+import * as address from './encoding/address';
+import * as encoding from './encoding/encoding';
+import * as nacl from './nacl/naclWrappers';
+import * as utils from './utils/utils';
+import { Address } from './types/address';
+
+interface BidStorageStructure {
+  bidderKey: Address;
+  bidAmount: number;
+  bidID: number;
+  auctionKey: Address;
+  auctionID: number;
+  maxPrice: number;
+}
+
+export type BidOptions = Omit<
+  BidStorageStructure,
+  'bidderKey' | 'auctionKey'
+> & {
+  bidderKey: string;
+  auctionKey: string;
+};
+
+/**
+ * Bid enables construction of Algorand Auctions Bids
+ * */
+export default class Bid implements BidStorageStructure {
+  name = 'Bid';
+  tag = Buffer.from([97, 66]); // "aB"
+
+  bidderKey: Address;
+  bidAmount: number;
+  bidID: number;
+  auctionKey: Address;
+  auctionID: number;
+  maxPrice: number;
+
+  constructor({
+    bidderKey,
+    bidAmount,
+    bidID,
+    auctionKey,
+    auctionID,
+    maxPrice,
+  }: BidOptions) {
+    const decodedBidderKey = address.decodeAddress(bidderKey);
+    const decodedAuctionKey = address.decodeAddress(auctionKey);
+
+    if (!Number.isSafeInteger(bidAmount) || bidAmount < 0)
+      throw Error('Bid amount must be positive and 2^53-1');
+    if (!Number.isSafeInteger(bidID) || bidID < 0)
+      throw Error('BidID must be positive and 2^53-1');
+    if (!Number.isSafeInteger(auctionID) || auctionID < 0)
+      throw Error('auctionID must be positive');
+
+    Object.assign(this, {
+      bidderKey: decodedBidderKey,
+      bidAmount,
+      bidID,
+      auctionKey: decodedAuctionKey,
+      auctionID,
+      maxPrice,
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  get_obj_for_encoding() {
+    return {
+      bidder: Buffer.from(this.bidderKey.publicKey),
+      cur: this.bidAmount,
+      price: this.maxPrice,
+      id: this.bidID,
+      auc: Buffer.from(this.auctionKey.publicKey),
+      aid: this.auctionID,
+    };
+  }
+
+  signBid(sk: Uint8Array) {
+    const encodedMsg = encoding.encode(this.get_obj_for_encoding());
+    const toBeSigned = Buffer.from(utils.concatArrays(this.tag, encodedMsg));
+    const sig = nacl.sign(toBeSigned, sk);
+
+    // construct signed message
+    const sBid = {
+      sig: Buffer.from(sig),
+      bid: this.get_obj_for_encoding(),
+    };
+
+    const note = {
+      t: 'b',
+      b: sBid,
+    };
+    return new Uint8Array(encoding.encode(note));
+  }
+}

package/src/boxStorage.ts

@@ -0,0 +1,42 @@
+import { EncodedBoxReference } from './types';
+import { BoxReference } from './types/transactions/base';
+
+function translateBoxReference(
+  reference: BoxReference,
+  foreignApps: number[],
+  appIndex: number
+): EncodedBoxReference {
+  const referenceId = reference.appIndex;
+  const referenceName = reference.name;
+  const isOwnReference = referenceId === 0 || referenceId === appIndex;
+  let index = 0;
+
+  if (foreignApps != null) {
+    // Foreign apps start from index 1; index 0 is its own app ID.
+    index = foreignApps.indexOf(referenceId) + 1;
+  }
+  // Check if the app referenced is itself after checking the foreign apps array.
+  // If index is zero, then the app ID was not found in the foreign apps array
+  // or the foreign apps array was null.
+  if (index === 0 && !isOwnReference) {
+    // Error if the app is trying to reference a foreign app that was not in
+    // its own foreign apps array.
+    throw new Error(`Box ref with appId ${referenceId} not in foreign-apps`);
+  }
+  return { i: index, n: referenceName };
+}
+
+/**
+ * translateBoxReferences translates an array of BoxReferences with app IDs
+ * into an array of EncodedBoxReferences with foreign indices.
+ */
+export function translateBoxReferences(
+  references: BoxReference[] | undefined,
+  foreignApps: number[],
+  appIndex: number
+): EncodedBoxReference[] {
+  if (references == null) return [];
+  return references.map((bx) =>
+    translateBoxReference(bx, foreignApps, appIndex)
+  );
+}