@tari-project/tarijs 0.4.0 → 0.4.1

package/packages/tarijs/src/templates/Pool.ts

@@ -0,0 +1,42 @@
+import { TariMethodDefinition, WorkspaceArg } from "@tari-project/tarijs-builders";
+import { TemplateFactory } from "./TemplateFactory";
+
+interface CreatePool extends TariMethodDefinition {
+  methodName: "create_pool";
+  args?: [string, string];
+}
+
+interface AddLiquidityMethod extends TariMethodDefinition {
+  methodName: "add_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface RemoveLiquidityMethod extends TariMethodDefinition {
+  methodName: "remove_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface SwapMethod extends TariMethodDefinition {
+  methodName: "swap";
+  args?: (WorkspaceArg | string)[];
+}
+
+export class PoolTemplate extends TemplateFactory {
+  public createPool: CreatePool;
+  public addLiquidity: AddLiquidityMethod;
+  public removeLiquidity: RemoveLiquidityMethod;
+  public swap: SwapMethod;
+
+  constructor(public templateAddress: string) {
+    super(templateAddress);
+    this._initFunctions();
+    this._initMethods();
+  }
+
+  protected _initFunctions(): void {}
+  protected _initMethods(): void {
+    this.addLiquidity = this._defineMethod<AddLiquidityMethod>("add_liquidity");
+    this.removeLiquidity = this._defineMethod<RemoveLiquidityMethod>("remove_liquidity");
+    this.swap = this._defineMethod<SwapMethod>("swap");
+  }
+}

package/packages/tarijs/src/templates/Tariswap.ts

@@ -0,0 +1,101 @@
+import {
+  Amount,
+  ConfidentialWithdrawProof,
+  ResourceAddress,
+  TariFunctionDefinition,
+  TariMethodDefinition,
+  WorkspaceArg,
+} from "@tari-project/tarijs-builders";
+import { TemplateFactory } from "./TemplateFactory";
+
+interface NewPoolFunction extends TariFunctionDefinition {
+  functionName: "new";
+  args?: [ResourceAddress, ResourceAddress, Amount];
+}
+
+interface MintFunction extends TariFunctionDefinition {
+  functionName: "mint";
+  args?: [Amount];
+}
+
+interface MintWithSymbolFunction extends TariFunctionDefinition {
+  functionName: "mint_with_symbol";
+  args?: [Amount, string];
+}
+
+interface PayFeeMethod extends TariMethodDefinition {
+  methodName: "pay_fee";
+  args?: [string];
+}
+
+interface PayFeeConfidentialMethod extends TariMethodDefinition {
+  methodName: "pay_fee_confidential";
+  args?: [ConfidentialWithdrawProof];
+}
+
+interface TotalSupplyMethod extends TariMethodDefinition {
+  methodName: "total_supply";
+  args?: [];
+}
+
+interface WithdrawMethod extends TariMethodDefinition {
+  methodName: "withdraw";
+  args?: [string, string];
+}
+
+interface AddLiquidityMethod extends TariMethodDefinition {
+  methodName: "add_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface RemoveLiquidityMethod extends TariMethodDefinition {
+  methodName: "remove_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface DepositMethod extends TariMethodDefinition {
+  methodName: "deposit";
+  args?: WorkspaceArg[];
+}
+
+interface SwapMethod extends TariMethodDefinition {
+  methodName: "swap";
+  args?: (WorkspaceArg | string)[];
+}
+
+export class TariswapTemplate extends TemplateFactory {
+  public newPool: NewPoolFunction;
+  public mint: MintFunction;
+  public mintWithSymbol: MintWithSymbolFunction;
+  public totalSupply: TotalSupplyMethod;
+  public payFee: PayFeeMethod;
+  public payFeeConfidential: PayFeeConfidentialMethod;
+  public withdraw: WithdrawMethod;
+  public addLiquidity: AddLiquidityMethod;
+  public removeLiquidity: RemoveLiquidityMethod;
+  public deposit: DepositMethod;
+  public swap: SwapMethod;
+
+  constructor(public templateAddress: string) {
+    super(templateAddress);
+    this._initFunctions();
+    this._initMethods();
+  }
+
+  protected _initFunctions(): void {
+    this.newPool = this._defineFunction<NewPoolFunction>("new");
+    this.mint = this._defineFunction<MintFunction>("mint");
+    this.mintWithSymbol = this._defineFunction<MintWithSymbolFunction>("mint_with_symbol");
+  }
+
+  protected _initMethods(): void {
+    this.totalSupply = this._defineMethod<TotalSupplyMethod>("total_supply");
+    this.payFee = this._defineMethod<PayFeeMethod>("pay_fee");
+    this.payFeeConfidential = this._defineMethod<PayFeeConfidentialMethod>("pay_fee_confidential");
+    this.withdraw = this._defineMethod<WithdrawMethod>("withdraw");
+    this.addLiquidity = this._defineMethod<AddLiquidityMethod>("add_liquidity");
+    this.removeLiquidity = this._defineMethod<RemoveLiquidityMethod>("remove_liquidity");
+    this.deposit = this._defineMethod<DepositMethod>("deposit");
+    this.swap = this._defineMethod<SwapMethod>("swap");
+  }
+}

package/packages/tarijs/src/templates/TemplateFactory.ts

@@ -0,0 +1,22 @@
+import { TariFunctionDefinition, TariMethodDefinition } from "@tari-project/tarijs-builders";
+
+export abstract class TemplateFactory {
+  constructor(public templateAddress: string) {}
+
+  public _defineFunction<T extends TariFunctionDefinition>(name: T["functionName"]): T {
+    return {
+      templateAddress: this.templateAddress,
+      functionName: name,
+    } as T;
+  }
+
+  public _defineMethod<T extends TariMethodDefinition>(name: T["methodName"]): T {
+    return {
+      componentAddress: this.templateAddress,
+      methodName: name,
+    } as T;
+  }
+
+  protected abstract _initFunctions(): void;
+  protected abstract _initMethods(): void;
+}

package/packages/tarijs/src/templates/TestFaucet.ts

@@ -0,0 +1,72 @@
+import { Amount, ConfidentialWithdrawProof, TariFunctionDefinition, TariMethodDefinition } from "@tari-project/tarijs-builders";
+import { TemplateFactory } from "./TemplateFactory";
+
+interface MintFunction extends TariFunctionDefinition {
+  functionName: "mint";
+  args?: [string];
+}
+
+interface MintWithSymbolFunction extends TariFunctionDefinition {
+  functionName: "mint_with_symbol";
+  args?: [amount: string, symbol: string];
+}
+
+interface PayFeeMethod extends TariMethodDefinition {
+  methodName: "pay_fee";
+  args?: [Amount];
+}
+
+interface PayFeeConfidentialMethod extends TariMethodDefinition {
+  methodName: "pay_fee_confidential";
+  args?: [ConfidentialWithdrawProof];
+}
+
+interface TakeFreeCoinsMethod extends TariMethodDefinition {
+  methodName: "take_free_coins";
+  args?: [];
+}
+
+interface TakeFreeCoinsConfidentialMethod extends TariMethodDefinition {
+  methodName: "take_free_coins_confidential";
+  args?: [ConfidentialWithdrawProof];
+}
+
+interface BurnCoinsMethod extends TariMethodDefinition {
+  methodName: "burn_coins";
+  args?: [BigInt];
+}
+
+interface TotalSupplyMethod extends TariMethodDefinition {
+  methodName: "total_supply";
+  args?: [];
+}
+
+export class TestFaucet extends TemplateFactory {
+  public mint: MintFunction;
+  public mintWithSymbol: MintWithSymbolFunction;
+  public takeFreeCoins: TakeFreeCoinsMethod;
+  public takeFreeCoinsConfidential: TakeFreeCoinsConfidentialMethod;
+  public burnCoins: BurnCoinsMethod;
+  public totalSupply: TotalSupplyMethod;
+  public payFee: PayFeeMethod;
+  public payFeeConfidential: PayFeeConfidentialMethod;
+
+  constructor(public templateAddress: string) {
+    super(templateAddress);
+    this._initFunctions();
+    this._initMethods();
+  }
+  protected _initFunctions(): void {
+    this.mint = this._defineFunction<MintFunction>("mint");
+    this.mintWithSymbol = this._defineFunction<MintWithSymbolFunction>("mint_with_symbol");
+  }
+  protected _initMethods(): void {
+    this.takeFreeCoins = this._defineMethod<TakeFreeCoinsMethod>("take_free_coins");
+    this.takeFreeCoinsConfidential =
+      this._defineMethod<TakeFreeCoinsConfidentialMethod>("take_free_coins_confidential");
+    this.burnCoins = this._defineMethod<BurnCoinsMethod>("burn_coins");
+    this.totalSupply = this._defineMethod<TotalSupplyMethod>("total_supply");
+    this.payFee = this._defineMethod<PayFeeMethod>("pay_fee");
+    this.payFeeConfidential = this._defineMethod<PayFeeConfidentialMethod>("pay_fee_confidential");
+  }
+}

package/{dist/utils.js → packages/tarijs/src/utils.ts}

@@ -1,4 +1,4 @@
-export function toHexString(byteArray) {
+export function toHexString(byteArray: any): string {
     if (Array.isArray(byteArray)) {
         return Array.from(byteArray, function (byte) {
             return ('0' + (byte & 0xff).toString(16)).slice(-2);
@@ -13,10 +13,11 @@ export function toHexString(byteArray) {
     }
     return 'Unsupported type';
 }
-export function fromHexString(hexString) {
+
+export function fromHexString(hexString: string) {
     let res = [];
     for (let i = 0; i < hexString.length; i += 2) {
         res.push(Number('0x' + hexString.substring(i, i + 2)));
     }
     return res;
-}
+}

package/packages/tarijs/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "target": "ESNext",
+    "moduleResolution": "Bundler",
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "references": [
+    {
+      "path": "../builders"
+    },
+    {
+      "path": "../metamask_provider"
+    },
+    {
+      "path": "../tari_permissions"
+    },
+    {
+      "path": "../tari_provider"
+    },
+    {
+      "path": "../tari_universe"
+    },
+    {
+      "path": "../tarijs_types"
+    },
+    {
+      "path": "../wallet_daemon"
+    },
+    {
+      "path": "../walletconnect"
+    }
+  ]
+}

package/packages/tarijs/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+import { loadEnv } from 'vite';
+
+export default defineConfig({
+  root: '.',
+  test: {
+    env: loadEnv("", "./integration-tests/", ""),
+  },
+});

package/packages/tarijs_types/moon.yml

@@ -0,0 +1,55 @@
+language: "typescript"
+platform: "node"
+type: "library"
+
+fileGroups:
+  configs:
+    - "tsconfig.json"
+    - "package.json"
+    - "eslint.config.ts"
+  sources:
+    - "src/**/*"
+  tests:
+    - "integration-tests/**/*"
+
+tasks:
+  build:
+    command: "pnpm run build"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+    outputs:
+      - "dist"
+  format:
+    command: "pnpm run format"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"
+    options:
+      runInCI: false
+  lint:
+    command: "pnpm run lint:fix"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"
+    options:
+      runInCI: false
+    deps:
+      - "build"
+
+  lintCheck:
+    command: "pnpm run lint"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"
+    deps:
+      - "build"
+  formatCheck:
+    command: "pnpm run format:check"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"

package/packages/tarijs_types/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@tari-project/tarijs-types",
+  "version": "0.4.0",
+  "description": "",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@tari-project/typescript-bindings": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
+  },
+  "files": [
+    "/dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts"
+}

package/packages/tarijs_types/src/Amount.ts

@@ -0,0 +1,113 @@
+export class Amount {
+  private value: number;
+
+  constructor(value: number) {
+    this.value = value;
+  }
+
+  public static readonly MAX: Amount = new Amount(Number.MAX_SAFE_INTEGER);
+
+  public static newAmount(amount: number): Amount {
+    return new Amount(amount);
+  }
+
+  public static zero(): Amount {
+    return new Amount(0);
+  }
+
+  public isZero(): boolean {
+    return this.value === 0;
+  }
+
+  public isPositive(): boolean {
+    return this.value >= 0;
+  }
+
+  public isNegative(): boolean {
+    return !this.isPositive();
+  }
+
+  public getValue(): number {
+    return this.value;
+  }
+
+  public getStringValue(): string {
+    return this.value.toString();
+  }
+
+  public checkedAdd(other: Amount): Amount | null {
+    const result = this.value + other.value;
+    if (result < Number.MIN_SAFE_INTEGER || result > Number.MAX_SAFE_INTEGER) {
+      return null;
+    }
+    return new Amount(result);
+  }
+
+  public saturatingAdd(other: Amount): Amount {
+    return new Amount(Math.min(Number.MAX_SAFE_INTEGER, Math.max(Number.MIN_SAFE_INTEGER, this.value + other.value)));
+  }
+
+  public checkedSub(other: Amount): Amount | null {
+    const result = this.value - other.value;
+    if (result < Number.MIN_SAFE_INTEGER || result > Number.MAX_SAFE_INTEGER) {
+      return null;
+    }
+    return new Amount(result);
+  }
+
+  public saturatingSub(other: Amount): Amount {
+    return new Amount(Math.min(Number.MAX_SAFE_INTEGER, Math.max(Number.MIN_SAFE_INTEGER, this.value - other.value)));
+  }
+
+  public saturatingSubPositive(other: Amount): Amount {
+    const result = this.value - other.value;
+    return result < 0 ? new Amount(0) : new Amount(result);
+  }
+
+  public checkedSubPositive(other: Amount): Amount | null {
+    if (this.isNegative() || other.isNegative()) {
+      return null;
+    }
+    if (this.value < other.value) {
+      return null;
+    }
+    return new Amount(this.value - other.value);
+  }
+
+  public checkedMul(other: Amount): Amount | null {
+    const result = this.value * other.value;
+    if (result < Number.MIN_SAFE_INTEGER || result > Number.MAX_SAFE_INTEGER) {
+      return null;
+    }
+    return new Amount(result);
+  }
+
+  public saturatingMul(other: Amount): Amount {
+    return new Amount(Math.min(Number.MAX_SAFE_INTEGER, Math.max(Number.MIN_SAFE_INTEGER, this.value * other.value)));
+  }
+
+  public checkedDiv(other: Amount): Amount | null {
+    if (other.value === 0) {
+      throw new Error("Division by zero");
+    }
+    const result = this.value / other.value;
+    if (result < Number.MIN_SAFE_INTEGER || result > Number.MAX_SAFE_INTEGER) {
+      return null;
+    }
+    return new Amount(result);
+  }
+
+  public saturatingDiv(other: Amount): Amount {
+    if (other.value === 0) {
+      throw new Error("Division by zero");
+    }
+    return new Amount(Math.min(Number.MAX_SAFE_INTEGER, Math.max(Number.MIN_SAFE_INTEGER, this.value / other.value)));
+  }
+
+  public asU64Checked(): number | null {
+    if (this.value < 0) {
+      return null;
+    }
+    return this.value as number;
+  }
+}

package/packages/tarijs_types/src/Arg.ts

@@ -0,0 +1,3 @@
+//TODO refactor Arg type (https://github.com/tari-project/tari.js/issues/29)
+// take a look at typescript-bindings first
+export type Arg = any;

package/packages/tarijs_types/src/ComponentAddress.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+//TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
+export type ComponentAddress = string;

package/packages/tarijs_types/src/ConfidentialClaim.ts

@@ -0,0 +1,9 @@
+import type { ConfidentialWithdrawProof } from "./ConfidentialWithdrawProof";
+
+export interface ConfidentialClaim {
+  publicKey: string;
+  outputAddress: string;
+  rangeProof: Array<number>;
+  proofOfKnowledge: string;
+  withdrawProof?: ConfidentialWithdrawProof;
+}

package/packages/tarijs_types/src/ConfidentialOutput.ts

@@ -0,0 +1,9 @@
+import type { ElgamalVerifiableBalance } from "./ElgamalVerifiableBalance";
+
+export interface ConfidentialOutput {
+  commitment: string;
+  stealthPublicNonce: string;
+  encrypted_data: Array<number>;
+  minimumValuePromise: number;
+  viewableBalance?: ElgamalVerifiableBalance;
+}

package/packages/tarijs_types/src/ConfidentialOutputStatement.ts

@@ -0,0 +1,10 @@
+import type { Amount } from "./Amount";
+import type { ConfidentialStatement } from "./ConfidentialStatement";
+
+export interface ConfidentialOutputStatement {
+  outputStatement?: ConfidentialStatement;
+  changeStatement?: ConfidentialStatement;
+  rangeProof: Array<number>;
+  outputRevealedAmount: Amount;
+  changeRevealedAmount: Amount;
+}

package/packages/tarijs_types/src/ConfidentialStatement.ts

@@ -0,0 +1,9 @@
+import type { ViewableBalanceProof } from "./ViewableBalanceProof";
+
+export interface ConfidentialStatement {
+  commitment: Array<number>;
+  senderPublicNonce: Array<number>;
+  encryptedData: Array<number>;
+  minimumValuePromise: number;
+  viewableBalanceProof?: ViewableBalanceProof;
+}

package/packages/tarijs_types/src/ConfidentialWithdrawProof.ts

@@ -0,0 +1,8 @@
+import type { ConfidentialOutputStatement } from "./ConfidentialOutputStatement";
+
+export interface ConfidentialWithdrawProof {
+  inputs: Array<Uint8Array>;
+  inputRevealedAmount: number;
+  outputProof: ConfidentialOutputStatement;
+  balanceProof: Array<number>;
+}

package/packages/tarijs_types/src/ElgamalVerifiableBalance.ts

@@ -0,0 +1,4 @@
+export interface ElgamalVerifiableBalance {
+  encrypted: string;
+  public_nonce: string;
+}

package/packages/tarijs_types/src/Epoch.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+// TODO https://github.com/tari-project/tari.js/issues/29
+export type Epoch = number;

package/packages/tarijs_types/src/FinalizeResult.ts

@@ -0,0 +1,17 @@
+import { FeeReceipt, InstructionResult, LogEntry, RejectReason } from "@tari-project/typescript-bindings";
+import { SubstateDiff } from "./SubstateDiff";
+
+export type TxResultAccept = { Accept: SubstateDiff };
+export type TxResultAcceptFeeRejectRest = { AcceptFeeRejectRest: [SubstateDiff, RejectReason] };
+export type TxResultReject = { Reject: RejectReason };
+
+export type FinalizeResultStatus = TxResultAccept | TxResultAcceptFeeRejectRest | TxResultReject;
+
+export interface FinalizeResult {
+  transaction_hash: Uint8Array;
+  events: Array<Event>;
+  logs: Array<LogEntry>;
+  execution_results: Array<InstructionResult>;
+  result: FinalizeResultStatus;
+  fee_receipt: FeeReceipt;
+}

package/packages/tarijs_types/src/Instruction.ts

@@ -0,0 +1,29 @@
+import { ComponentAddress, LogLevel } from "@tari-project/typescript-bindings";
+import { Arg } from "./Arg";
+import { ConfidentialClaim } from "./ConfidentialClaim";
+import { Amount } from "./Amount";
+import { ConfidentialOutput } from "./ConfidentialOutput";
+import { TemplateAddress } from "./TemplateAddress";
+
+export type Instruction =
+  | CreateAccount
+  | CallFunction
+  | CallMethod
+  | PutLastInstructionOutputOnWorkspace
+  | EmitLog
+  | ClaimBurn
+  | ClaimValidatorFees
+  | DropAllProofsInWorkspace
+  | CreateFreeTestCoins;
+
+export type CreateAccount = { CreateAccount: { owner_public_key: string; workspace_bucket: string | null } };
+export type CallFunction = { CallFunction: { template_address: TemplateAddress; function: string; args: Array<Arg> } };
+export type CallMethod = { CallMethod: { component_address: ComponentAddress; method: string; args: Array<Arg> } };
+export type PutLastInstructionOutputOnWorkspace = { PutLastInstructionOutputOnWorkspace: { key: number[] } };
+export type EmitLog = { EmitLog: { level: LogLevel; message: string } };
+export type ClaimBurn = { ClaimBurn: { claim: ConfidentialClaim } };
+export type ClaimValidatorFees = { ClaimValidatorFees: { epoch: number; validator_public_key: string } };
+export type DropAllProofsInWorkspace = "DropAllProofsInWorkspace";
+export type CreateFreeTestCoins = {
+  CreateFreeTestCoins: { revealed_amount: Amount; output: ConfidentialOutput | null };
+};

package/packages/tarijs_types/src/ResourceAddress.ts

@@ -0,0 +1,3 @@
+//TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
+
+export type ResourceAddress = string;

package/packages/tarijs_types/src/SubstateDiff.ts

@@ -0,0 +1,9 @@
+import { Substate, SubstateId } from "@tari-project/typescript-bindings";
+
+export type UpSubstates = Array<[SubstateId, Substate]>;
+export type DownSubstates = Array<[SubstateId, number]>;
+
+export interface SubstateDiff {
+  up_substates: UpSubstates;
+  down_substates: DownSubstates;
+}

package/packages/tarijs_types/src/SubstateRequirement.ts

@@ -0,0 +1,6 @@
+import { SubstateId } from "@tari-project/typescript-bindings";
+
+export interface SubstateRequirement {
+  substateId: SubstateId;
+  version?: number;
+}

package/packages/tarijs_types/src/TemplateAddress.ts

@@ -0,0 +1,3 @@
+//TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
+
+export type TemplateAddress = string;

package/packages/tarijs_types/src/Transaction.ts

@@ -0,0 +1,16 @@
+import { Instruction } from "./Instruction";
+import { SubstateRequirement } from "./SubstateRequirement";
+import { Epoch } from "./Epoch";
+import { VersionedSubstateId } from "./VersionedSubstateId";
+import { TransactionSignature } from "./TransactionSignature";
+
+export interface Transaction {
+  id: string;
+  feeInstructions: Array<Instruction>;
+  instructions: Array<Instruction>;
+  inputs: Array<SubstateRequirement>;
+  minEpoch?: Epoch;
+  maxEpoch?: Epoch;
+  signatures: Array<TransactionSignature>;
+  filledInputs: Array<VersionedSubstateId>;
+}