fix: add type definitions

package.json

@@ -15,6 +15,7 @@
   ],
   "main": "./dist/node/index.js",
   "browser": "./dist/browser/bigchaindb-driver.cjs2.min.js",
+  "types": "./types/index.d.ts",
   "sideEffects": false,
   "scripts": {
     "lint": "eslint .",

types/Ed25519Keypair.d.ts

@@ -0,0 +1,10 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+export default class Ed25519Keypair {
+  publicKey: string;
+  privateKey: string;
+
+  constructor(seed?: Buffer);
+}

types/baseRequest.d.ts

@@ -0,0 +1,31 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+export interface RequestConfig {
+  headers?: Record<string, string | string[]>;
+  jsonBody?: Record<string, any>;
+  query?: Record<string, any>;
+  method?: 'GET' | ' POST' | 'PUT';
+  urlTemplateSpec?: any[] | Record<string, any>;
+  [key: string]: any;
+}
+
+export function ResponseError(
+  message: string,
+  status?: number,
+  requestURI?: string
+): void;
+
+declare function timeout<T = Response>(
+  ms: number,
+  promise: Promise<T>
+): Promise<T>;
+
+declare function handleResponse(res: Response): Response;
+
+export default function baseRequest(
+  url: string,
+  config: RequestConfig = {},
+  requestTimeout?: number
+): Promise<Response>;

types/connection.d.ts

@@ -0,0 +1,162 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+import type { RequestConfig } from './baseRequest';
+import type { Node } from './request';
+import type Transport from './transport';
+import type {
+  CreateTransaction,
+  TransactionOperations,
+  TransferTransaction,
+  TransactionCommon,
+} from './transaction';
+
+declare const HEADER_BLACKLIST = ['content-type'];
+declare const DEFAULT_NODE = 'http://localhost:9984/api/v1/';
+declare const DEFAULT_TIMEOUT = 20000; // The default value is 20 seconds
+
+export interface InputNode {
+  endpoint: string;
+}
+
+export enum Endpoints {
+  blocks = 'blocks',
+  blocksDetail = 'blocksDetail',
+  outputs = 'outputs',
+  transactions = 'transactions',
+  transactionsSync = 'transactionsSync',
+  transactionsAsync = 'transactionsAsync',
+  transactionsCommit = 'transactionsCommit',
+  transactionsDetail = 'transactionsDetail',
+  assets = 'assets',
+  metadata = 'metadata',
+}
+
+export interface EndpointsUrl {
+  [Endpoints.blocks]: 'blocks';
+  [Endpoints.blocksDetail]: 'blocks/%(blockHeight)s';
+  [Endpoints.outputs]: 'outputs';
+  [Endpoints.transactions]: 'transactions';
+  [Endpoints.transactionsSync]: 'transactions?mode=sync';
+  [Endpoints.transactionsAsync]: 'transactions?mode=async';
+  [Endpoints.transactionsCommit]: 'transactions?mode=commit';
+  [Endpoints.transactionsDetail]: 'transactions/%(transactionId)s';
+  [Endpoints.assets]: 'assets';
+  [Endpoints.metadata]: 'metadata';
+}
+
+export interface EndpointsResponse<
+  O = TransactionOperations.CREATE,
+  A = Record<string, any>,
+  M = Record<string, any>
+> {
+  [Endpoints.blocks]: number[];
+  [Endpoints.blocksDetail]: {
+    height: number;
+    transactions: (CreateTransaction | TransferTransaction)[];
+  };
+  [Endpoints.outputs]: {
+    transaction_id: string;
+    output_index: number;
+  }[];
+  [Endpoints.transactions]: O extends TransactionOperations.CREATE
+    ? CreateTransaction[]
+    : O extends TransactionOperations.TRANSFER
+    ? TransferTransaction[]
+    : (CreateTransaction | TransferTransaction)[];
+  [Endpoints.transactionsSync]: O extends TransactionOperations.CREATE
+    ? CreateTransaction<A, M>
+    : TransferTransaction<M>;
+  [Endpoints.transactionsAsync]: O extends TransactionOperations.CREATE
+    ? CreateTransaction<A, M>
+    : TransferTransaction<M>;
+  [Endpoints.transactionsCommit]: O extends TransactionOperations.CREATE
+    ? CreateTransaction<A, M>
+    : TransferTransaction<M>;
+  [Endpoints.transactionsDetail]: O extends TransactionOperations.CREATE
+    ? CreateTransaction<A, M>
+    : TransferTransaction<M>;
+  [Endpoints.assets]: { id: string; data: Record<string, any> }[];
+  [Endpoints.metadata]: { id: string; metadata: Record<string, any> }[];
+}
+
+export default class Connection {
+  private transport: Transport;
+  private normalizedNodes: Node[];
+  private headers: Record<string, string | string[]>;
+
+  constructor(
+    nodes: string | InputNode | (string | InputNode)[],
+    headers: Record<string, string | string[]> = {},
+    timeout?: number
+  );
+
+  static normalizeNode(
+    node: string | InputNode,
+    headers: Record<string, string | string[]>
+  ): Node;
+
+  static getApiUrls<E = Endpoint>(endpoint: E): EndpointsUrl[E];
+
+  private _req<E = Endpoint, O = Record<string, any>>(
+    path: EndpointsUrl[E],
+    options: RequestConfig = {}
+  ): Promise<O>;
+
+  getBlock(
+    blockHeight: number | string
+  ): Promise<EndpointsUrl[Endpoints.blocksDetail]>;
+
+  getTransaction<O = TransactionOperations.CREATE>(
+    transactionId: string
+  ): Promise<EndpointsUrl<O>[Endpoints.transactionsDetail]>;
+
+  listBlocks(transactionId: string): Promise<EndpointsUrl[Endpoints.blocks]>;
+
+  listOutputs(
+    publicKey: string,
+    spent?: boolean
+  ): Promise<EndpointsUrl[Endpoints.outputs]>;
+
+  listTransactions<O = TransactionOperations.CREATE>(
+    assetId: string,
+    operation: O
+  ): Promise<EndpointsUrl<O>[Endpoints.transactions]>;
+
+  postTransaction<
+    O = TransactionOperations.CREATE,
+    A = Record<string, any>,
+    M = Record<string, any>
+  >(
+    transaction: TransactionCommon<O>
+  ): Promise<EndpointsUrl<O, A, M>[Endpoints.transactionsCommit]>;
+
+  postTransactionSync<
+    O = TransactionOperations.CREATE,
+    A = Record<string, any>,
+    M = Record<string, any>
+  >(
+    transaction: TransactionCommon<O>
+  ): Promise<EndpointsUrl<O, A, M>[Endpoints.transactionsSync]>;
+
+  postTransactionAsync<
+    O = TransactionOperations.CREATE,
+    A = Record<string, any>,
+    M = Record<string, any>
+  >(
+    transaction: TransactionCommon<O>
+  ): Promise<EndpointsUrl<O, A, M>[Endpoints.transactionsAsync]>;
+
+  postTransactionCommit<
+    O = TransactionOperations.CREATE,
+    A = Record<string, any>,
+    M = Record<string, any>
+  >(
+    transaction: TransactionCommon<O>
+  ): Promise<EndpointsUrl<O, A, M>[Endpoints.transactionsCommit]>;
+
+  searchAssets(search: string): Promise<EndpointsUrl[Endpoints.assets]>;
+
+  searchMetadata(search: string): Promise<EndpointsUrl[Endpoints.metadata]>;
+}

types/index.d.ts

@@ -0,0 +1,11 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+import Ed25519Keypair from './Ed25519Keypair'
+import Connection from './connection'
+import Transaction from './transaction'
+import ccJsonLoad from './utils/ccJsonLoad'
+import ccJsonify from './utils/ccJsonify'
+
+export { ccJsonLoad, ccJsonify, Connection, Ed25519Keypair, Transaction } 

types/request.d.ts

@@ -0,0 +1,32 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+import type { RequestConfig } from './baseRequest';
+
+export interface Node {
+  endpoint: string;
+  headers: Record<string, string | string[]>;
+}
+
+export default class Request {
+  private node: Node;
+  private backoffTime: number;
+  private retries: number;
+  private connectionError?: Error;
+
+  constructor(node: Node);
+
+  async request<O = Record<string, any>>(
+    urlPath: string,
+    config: RequestConfig = {},
+    timeout?: number,
+    maxBackoffTime?: number
+  ): Promise<O>;
+
+  updateBackoffTime(maxBackoffTime: number): void;
+
+  getBackoffTimedelta(): number;
+
+  static sleep(ms: number): void;
+}

types/sanitize.d.ts

@@ -0,0 +1,25 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+declare type FilterFn = (val: any, key?: string) => void;
+
+declare function filterFromObject<I = Record<string, any>>(
+  obj: I,
+  filter: Array | FilterFn,
+  conf: { isInclusion?: boolean } = {}
+): Partial<I>;
+
+declare function applyFilterOnObject<I = Record<string, any>>(
+  obj: I,
+  filterFn?: FilterFn
+): Partial<I>;
+
+declare function selectFromObject<I = Record<string, any>>(
+  obj: I,
+  filter: Array | FilterFn
+): Partial<I>;
+
+export default function sanitize<I = Record<string, any>>(
+  obj: I
+): Partial<I> | I;

types/transaction.d.ts

@@ -0,0 +1,206 @@
+import type {
+  Ed25519Sha256,
+  Fulfillment,
+  PreimageSha256,
+  ThresholdSha256,
+} from 'crypto-conditions';
+import {
+  Ed25519Sha256JSONCondition,
+  JSONCondition,
+  PreimageSha256JSONCondition,
+  ThresholdSha256JSONCondition,
+} from './utils/ccJsonify';
+
+export interface TransactionInput {
+  fulfillment: string;
+  fulfills: {
+    output_index: number;
+    transaction_id: string;
+  } | null;
+  owners_before: string[];
+}
+
+export interface TransactionOutput {
+  amount: string;
+  // TODO: specifiy JSON conditions
+  condition: any[];
+  public_keys: string[];
+}
+
+export enum TransactionOperations {
+  CREATE = 'CREATE',
+  TRANSFER = 'TRANSFER',
+}
+
+export interface TransactionCommon<
+  O = TransactionOperations,
+  A = Record<string, unknown>,
+  M = Record<string, unknown>
+> {
+  id?: string;
+  inputs: TransactionInput[];
+  outputs: TransactionOutput[];
+  version: string;
+  metadata: M;
+  operation: O;
+  asset: TransactionAssetMap<O, A>;
+}
+
+export interface TransactionCommonSigned<
+  O = TransactionOperations,
+  A = Record<string, unknown>,
+  M = Record<string, unknown>
+> extends Omit<TransactionCommon<O, A, M>, 'id'> {
+  id: string;
+}
+
+export type TransactionAssetMap<
+  Operation,
+  A = Record<string, unknown>
+> = Operation extends TransactionOperations.CREATE
+  ? {
+      data: A;
+    }
+  : {
+      id: string;
+    };
+
+export interface CreateTransaction<
+  A = Record<string, unknown>,
+  M = Record<string, unknown>
+> extends TransactionCommon<TransactionOperations.CREATE, A, M> {
+  id: string;
+  asset: TransactionAssetMap<TransactionOperations.CREATE, A>;
+  operation: TransactionOperations.CREATE;
+}
+
+export interface TransferTransaction<M = Record<string, unknown>>
+  extends TransactionCommon<TransactionOperations.TRANSFER, any, M> {
+  id: string;
+  asset: TransactionAssetMap<TransactionOperations.TRANSFER>;
+  operation: TransactionOperations.TRANSFER;
+}
+
+interface TxTemplate {
+  id: null;
+  operation: null;
+  outputs: [];
+  inputs: [];
+  metadata: null;
+  asset: null;
+  version: '2.0';
+}
+
+declare function DelegateSignFunction(
+  serializedTransaction: string,
+  input: TransactionInput,
+  index?: number
+): string;
+
+export default class Transaction {
+  static serializeTransactionIntoCanonicalString(
+    transaction: CreateTransaction | TransferTransaction
+  ): string;
+
+  static makeEd25519Condition(
+    publicKey: string,
+    json = true
+  ): Ed25519Sha256JSONCondition;
+
+  static makeEd25519Condition(publicKey: string, json = false): Ed25519Sha256;
+
+  // static makeEd25519Condition(publicKey: string): Ed25519Sha256JSONCondition;
+
+  static makeEd25519Condition(
+    publicKey: string,
+    json?: boolean
+  ): Ed25519Sha256 | Ed25519Sha256JSONCondition;
+
+  static makeSha256Condition(
+    preimage: string,
+    json = true
+  ): PreimageSha256JSONCondition;
+
+  static makeSha256Condition(preimage: string, json = false): PreimageSha256;
+
+  // static makeSha256Condition(preimage: string): PreimageSha256JSONCondition;
+
+  static makeSha256Condition(
+    preimage: string,
+    json?: boolean
+  ): PreimageSha256 | PreimageSha256JSONCondition;
+
+  static makeThresholdCondition(
+    threshold: number,
+    subconditions: (string | Fulfillment)[],
+    json = true
+  ): ThresholdSha256JSONCondition;
+
+  static makeThresholdCondition(
+    threshold: number,
+    subconditions: (string | Fulfillment)[],
+    json = false
+  ): ThresholdSha256;
+
+  // static makeThresholdCondition(
+  //   threshold: number,
+  //   subconditions: (string | Fulfillment)[]
+  // ): ThresholdSha256JSONCondition;
+
+  static makeThresholdCondition(
+    threshold: number,
+    subconditions: (string | Fulfillment)[],
+    json?: boolean
+  ): ThresholdSha256 | ThresholdSha256JSONCondition;
+
+  static makeInputTemplate(
+    publicKeys: string[],
+    fulfills?: TransactionInput['fulfills'],
+    fulfillment?: TransactionInput['fulfillment']
+  ): TransactionInput;
+
+  static makeOutput(
+    condition: JSONCondition,
+    amount: string
+  ): TransactionOutput;
+
+  static makeTransactionTemplate(): TxTemplate;
+
+  static makeTransaction<
+    O extends keyof TransactionOperations,
+    A = Record<string, any>,
+    M = Record<string, any>
+  >(
+    operation: O,
+    asset: A,
+    metadata: M,
+    outputs: TransactionOutput[],
+    inputs: TransactionInput[]
+  ): TransactionCommon<O, A, M>;
+
+  static makeCreateTransaction<
+    A = Record<string, any>,
+    M = Record<string, any>
+  >(
+    asset: A,
+    metadata: M,
+    outputs: TransactionOutput[],
+    ...issuers: string[]
+  ): CreateTransaction<A, M>;
+
+  static makeTransferTransaction<M = Record<string, any>>(
+    unspentOutputs: TransactionOutput[],
+    outputs: TransactionOutput[],
+    metadata: M
+  ): TransferTransaction<M>;
+
+  static signTransaction<O = TransactionOperations.CREATE>(
+    transaction: TransactionCommon<O>,
+    ...privateKeys: string[]
+  ): TransactionCommonSigned<O>;
+
+  static delegateSignTransaction<O = TransactionOperations.CREATE>(
+    transaction: TransactionCommon<O>,
+    signFn: DelegateSignFunction
+  ): TransactionCommonSigned<O>;
+}

types/transport.d.ts

@@ -0,0 +1,21 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+import Request, { Node } from './request';
+import type { RequestConfig } from './baseRequest';
+
+export default class Transport {
+  private connectionPool: Request[];
+  private timeout: number;
+  private maxBackoffTime: number;
+
+  constructor(nodes: Node[], timeout: number);
+
+  pickConnection(): Request;
+
+  async forwardRequest<O = Record<string, any>>(
+    path: string,
+    config: RequestConfig
+  ): Promise<O>;
+}

types/utils/ccJsonLoad.d.ts

@@ -0,0 +1,11 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+import type { Condition, Fulfillment } from 'crypto-conditions';
+import type { JSONCondition } from './ccJsonify';
+
+// TODO: improve returned type accuracy
+export default function ccJsonLoad<T = TypeId.Ed25519Sha256>(
+  conditionJson: JSONCondition[T]
+): Condition | Fulfillment;

types/utils/ccJsonify.d.ts

@@ -0,0 +1,48 @@
+// Copyright BigchainDB GmbH and BigchainDB contributors
+// SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+// Code is Apache-2.0 and docs are CC-BY-4.0
+
+import type { Condition, Fulfillment } from 'crypto-conditions';
+import type { TypeId } from 'crypto-conditions/types/types';
+
+interface BaseJSONCondition {
+  details: {
+    type: TypeName;
+    hash?: string;
+    max_fulfillment_length?: number;
+    type?: 'fulfillement' | 'condition';
+    [key: string]: any;
+  };
+  uri: string;
+}
+
+interface Ed25519Sha256JSONCondition extends BaseJSONCondition {
+  details: { type: TypeName.Ed25519Sha256; publicKey?: string };
+}
+
+interface PreimageSha256JSONCondition extends BaseJSONCondition {
+  details: {
+    type: TypeName.PreimageSha256;
+    type_id: 0;
+    bitmask: 3;
+    preimage?: string;
+    type?: 'fulfillement';
+  };
+}
+
+interface ThresholdSha256JSONCondition extends BaseJSONCondition {
+  details: {
+    type: TypeName.ThresholdSha256;
+    subConditions: (Ed25519Sha256JSONCondition | PreimageSha256JSONCondition)[];
+  };
+}
+
+export interface JSONCondition {
+  [TypeId.ThresholdSha256]: ThresholdSha256JSONCondition;
+  [TypeId.PreimageSha256]: PreimageSha256JSONCondition;
+  [TypeId.Ed25519Sha256]: Ed25519Sha256JSONCondition;
+}
+
+export default function ccJsonify<T = TypeId.Ed25519Sha256>(
+  fulfillment: Fulfillment | Condition
+): JSONCondition[T];