@tari-project/tarijs 0.1.21 → 0.1.22

package/dist/builders/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult } from "./submitTransaction";
+export { fromWorkspace, toWorkspace } from "./workspace";

package/dist/builders/helpers/index.js

@@ -0,0 +1,2 @@
+export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult } from "./submitTransaction";
+export { fromWorkspace, toWorkspace } from "./workspace";

package/dist/builders/helpers/submitTransaction.d.ts

@@ -0,0 +1,13 @@
+import { TariProvider } from "../../providers";
+import { TariUniverseProvider } from "../../providers/tari_universe";
+import { SubmitTransactionRequest, SubstateRequirement } from "../../providers/types";
+import { Transaction, TransactionResult } from "../types";
+import { DownSubstates, UpSubstates } from "../types/SubstateDiff";
+import { SubmitTxResult } from "../types/TransactionResult";
+export declare function buildTransactionRequest(transaction: Transaction, accountId: number, requiredSubstates: SubstateRequirement[], inputRefs?: never[], isDryRun?: boolean): SubmitTransactionRequest;
+export declare function submitAndWaitForTransaction(provider: TariProvider, req: SubmitTransactionRequest): Promise<SubmitTxResult>;
+export declare function waitForTransactionResult(provider: TariProvider | TariUniverseProvider, transactionId: string): Promise<TransactionResult>;
+export declare function getAcceptResultSubstates(txResult: TransactionResult): {
+    upSubstates: UpSubstates;
+    downSubstates: DownSubstates;
+} | undefined;

package/dist/builders/helpers/submitTransaction.js

@@ -0,0 +1,59 @@
+import { TransactionStatus } from "../types";
+export function buildTransactionRequest(transaction, accountId, requiredSubstates, inputRefs = [], isDryRun = false) {
+    return {
+        //TODO refactor SubTxReq type to not use 'object[]' and types match
+        // https://github.com/tari-project/tari.js/issues/25
+        account_id: accountId,
+        instructions: transaction.instructions,
+        fee_instructions: transaction.feeInstructions,
+        inputs: transaction.inputs,
+        input_refs: inputRefs,
+        required_substates: requiredSubstates,
+        is_dry_run: isDryRun,
+        min_epoch: transaction.minEpoch ?? null,
+        max_epoch: transaction.maxEpoch ?? null,
+    };
+}
+export async function submitAndWaitForTransaction(provider, req) {
+    try {
+        const response = await provider.submitTransaction(req);
+        const result = await waitForTransactionResult(provider, response.transaction_id);
+        return {
+            response,
+            result,
+        };
+    }
+    catch (e) {
+        throw new Error(`Transaction failed: ${e}`);
+    }
+}
+export async function waitForTransactionResult(provider, transactionId) {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const resp = await provider.getTransactionResult(transactionId);
+        const FINALIZED_STATUSES = [
+            TransactionStatus.Accepted,
+            TransactionStatus.Rejected,
+            TransactionStatus.InvalidTransaction,
+            TransactionStatus.OnlyFeeAccepted,
+            TransactionStatus.DryRun,
+        ];
+        if (resp.status == TransactionStatus.Rejected) {
+            throw new Error(`Transaction rejected: ${JSON.stringify(resp.result)}`);
+        }
+        if (FINALIZED_STATUSES.includes(resp.status)) {
+            return resp; //TODO fix: type mismatch (https://github.com/tari-project/tari.js/issues/29)
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+}
+export function getAcceptResultSubstates(txResult) {
+    const result = txResult.result?.result;
+    if (result && isAccept(result)) {
+        return { upSubstates: result.Accept.up_substates, downSubstates: result.Accept.down_substates };
+    }
+    return undefined;
+}
+function isAccept(result) {
+    return "Accept" in result;
+}

package/dist/builders/helpers/workspace.d.ts

@@ -0,0 +1,23 @@
+import { WorkspaceArg } from "../types";
+/**
+ *
+ * @param key workspace name
+ * @returns encoded Uint8Array value
+ * @example
+ * key: "0"   -> [ 48 ]
+ * key: "0.0" -> [ 48, 46, 48 ]
+ * key: "0.1" -> [ 48, 46, 49 ]
+ *
+ * key: "bucket"   -> [ 98, 117, 99, 107, 101, 116 ]
+ * key: "bucket.0" -> [ 98, 117, 99, 107, 101, 116, 46, 48 ]
+ * key: "bucket.1" -> [ 98, 117, 99, 107, 101, 116, 46, 49 ]
+ */
+export declare function toWorkspace(key: string): number[];
+/**
+ *
+ * @param key workspace name
+ * @returns formatted Workspace data
+ * @example
+ * key: "bucket" -> { Workspace: [ 98, 117, 99, 107, 101, 116 ] }
+ */
+export declare function fromWorkspace(key: string): WorkspaceArg;

package/dist/builders/helpers/workspace.js

@@ -0,0 +1,29 @@
+/**
+ *
+ * @param key workspace name
+ * @returns encoded Uint8Array value
+ * @example
+ * key: "0"   -> [ 48 ]
+ * key: "0.0" -> [ 48, 46, 48 ]
+ * key: "0.1" -> [ 48, 46, 49 ]
+ *
+ * key: "bucket"   -> [ 98, 117, 99, 107, 101, 116 ]
+ * key: "bucket.0" -> [ 98, 117, 99, 107, 101, 116, 46, 48 ]
+ * key: "bucket.1" -> [ 98, 117, 99, 107, 101, 116, 46, 49 ]
+ */
+export function toWorkspace(key) {
+    const encoder = new TextEncoder();
+    return Array.from(encoder.encode(key));
+}
+/**
+ *
+ * @param key workspace name
+ * @returns formatted Workspace data
+ * @example
+ * key: "bucket" -> { Workspace: [ 98, 117, 99, 107, 101, 116 ] }
+ */
+export function fromWorkspace(key) {
+    const encoder = new TextEncoder();
+    const encodedKey = encoder.encode(key);
+    return { Workspace: Array.from(encodedKey) };
+}

package/dist/builders/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export { TransactionBuilder, TransactionRequest } from "./transaction";
+export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult, fromWorkspace, toWorkspace, } from "./helpers";

package/dist/builders/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export { TransactionBuilder, TransactionRequest } from "./transaction";
+export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult, fromWorkspace, toWorkspace, } from "./helpers";

package/dist/builders/transaction/TransactionBuilder.d.ts

@@ -0,0 +1,44 @@
+import { Builder, TariFunctionDefinition, TariMethodDefinition } from "../types/Builder";
+import { ComponentAddress, ConfidentialClaim, ConfidentialWithdrawProof, Instruction, ResourceAddress, SubstateRequirement, Transaction, UnsignedTransaction } from "../types";
+export declare class TransactionBuilder implements Builder {
+    private unsignedTransaction;
+    private signatures;
+    constructor();
+    callFunction<T extends TariFunctionDefinition>(func: T, args: Exclude<T["args"], undefined>): this;
+    callMethod<T extends TariMethodDefinition>(method: T, args: Exclude<T["args"], undefined>): this;
+    createAccount(ownerPublicKey: string, workspaceBucket?: string): this;
+    createProof(account: ComponentAddress, resourceAddress: ResourceAddress): this;
+    claimBurn(claim: ConfidentialClaim): this;
+    /**
+     * The `SaveVar` method replaces
+     * `PutLastInstructionOutputOnWorkspace: { key: Array<number> }`
+     * to make saving variables easier.
+     */
+    saveVar(key: string): this;
+    /**
+     * Adds a fee instruction that calls the `take_fee` method on a component.
+     * This method must exist and return a Bucket with containing revealed confidential XTR resource.
+     * This allows the fee to originate from sources other than the transaction sender's account.
+     * The fee instruction will lock up the `max_fee` amount for the duration of the transaction.
+     */
+    feeTransactionPayFromComponent(componentAddress: ComponentAddress, maxFee: string): this;
+    /**
+     * Adds a fee instruction that calls the `take_fee_confidential` method on a component.
+     * This method must exist and return a Bucket with containing revealed confidential XTR resource.
+     * This allows the fee to originate from sources other than the transaction sender's account.
+     */
+    feeTransactionPayFromComponentConfidential(componentAddress: ComponentAddress, proof: ConfidentialWithdrawProof): this;
+    dropAllProofsInWorkspace(): this;
+    withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this;
+    withFeeInstructions(instructions: Instruction[]): this;
+    withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => TransactionBuilder): this;
+    addInstruction(instruction: Instruction): this;
+    addFeeInstruction(instruction: Instruction): this;
+    withInstructions(instructions: Instruction[]): this;
+    addInput(inputObject: SubstateRequirement): this;
+    withInputs(inputs: SubstateRequirement[]): this;
+    withMinEpoch(minEpoch: number): this;
+    withMaxEpoch(maxEpoch: number): this;
+    buildUnsignedTransaction(): UnsignedTransaction;
+    build(): Transaction;
+}

package/dist/builders/transaction/TransactionBuilder.js

@@ -0,0 +1,164 @@
+//   Copyright 2024 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+import { toWorkspace } from "../helpers";
+import { TransactionRequest } from "./TransactionRequest";
+export class TransactionBuilder {
+    unsignedTransaction;
+    signatures;
+    constructor() {
+        this.unsignedTransaction = {
+            feeInstructions: [],
+            instructions: [],
+            inputs: [],
+            filledInputs: [],
+            minEpoch: undefined,
+            maxEpoch: undefined,
+        };
+        this.signatures = [];
+    }
+    callFunction(func, args) {
+        return this.addInstruction({
+            CallFunction: {
+                template_address: func.templateAddress,
+                function: func.functionName,
+                args,
+            },
+        });
+    }
+    callMethod(method, args) {
+        return this.addInstruction({
+            CallMethod: {
+                component_address: method.componentAddress,
+                method: method.methodName,
+                args,
+            },
+        });
+    }
+    createAccount(ownerPublicKey, workspaceBucket) {
+        return this.addInstruction({
+            CreateAccount: {
+                owner_public_key: ownerPublicKey,
+                workspace_bucket: workspaceBucket ?? null,
+            },
+        });
+    }
+    createProof(account, resourceAddress) {
+        return this.addInstruction({
+            CallMethod: {
+                component_address: account,
+                method: "create_proof_for_resource",
+                args: [resourceAddress],
+            },
+        });
+    }
+    claimBurn(claim) {
+        return this.addInstruction({
+            ClaimBurn: {
+                claim,
+            },
+        });
+    }
+    /**
+     * The `SaveVar` method replaces
+     * `PutLastInstructionOutputOnWorkspace: { key: Array<number> }`
+     * to make saving variables easier.
+     */
+    saveVar(key) {
+        return this.addInstruction({
+            PutLastInstructionOutputOnWorkspace: {
+                key: toWorkspace(key),
+            },
+        });
+    }
+    /**
+     * Adds a fee instruction that calls the `take_fee` method on a component.
+     * This method must exist and return a Bucket with containing revealed confidential XTR resource.
+     * This allows the fee to originate from sources other than the transaction sender's account.
+     * The fee instruction will lock up the `max_fee` amount for the duration of the transaction.
+     */
+    feeTransactionPayFromComponent(componentAddress, maxFee) {
+        return this.addFeeInstruction({
+            CallMethod: {
+                component_address: componentAddress,
+                method: "pay_fee",
+                args: [maxFee],
+            },
+        });
+    }
+    /**
+     * Adds a fee instruction that calls the `take_fee_confidential` method on a component.
+     * This method must exist and return a Bucket with containing revealed confidential XTR resource.
+     * This allows the fee to originate from sources other than the transaction sender's account.
+     */
+    feeTransactionPayFromComponentConfidential(componentAddress, proof) {
+        return this.addFeeInstruction({
+            CallMethod: {
+                component_address: componentAddress,
+                method: "pay_fee_confidential",
+                args: [proof],
+            },
+        });
+    }
+    dropAllProofsInWorkspace() {
+        return this.addInstruction("DropAllProofsInWorkspace");
+    }
+    withUnsignedTransaction(unsignedTransaction) {
+        this.unsignedTransaction = unsignedTransaction;
+        this.signatures = [];
+        return this;
+    }
+    withFeeInstructions(instructions) {
+        this.unsignedTransaction.feeInstructions = instructions;
+        this.signatures = [];
+        return this;
+    }
+    withFeeInstructionsBuilder(builder) {
+        const newBuilder = builder(new TransactionBuilder());
+        this.unsignedTransaction.feeInstructions = newBuilder.unsignedTransaction.instructions;
+        this.signatures = [];
+        return this;
+    }
+    addInstruction(instruction) {
+        this.unsignedTransaction.instructions.push(instruction);
+        this.signatures = [];
+        return this;
+    }
+    addFeeInstruction(instruction) {
+        this.unsignedTransaction.feeInstructions.push(instruction);
+        this.signatures = [];
+        return this;
+    }
+    withInstructions(instructions) {
+        this.unsignedTransaction.instructions.push(...instructions);
+        this.signatures = [];
+        return this;
+    }
+    addInput(inputObject) {
+        this.unsignedTransaction.inputs.push(inputObject);
+        this.signatures = [];
+        return this;
+    }
+    withInputs(inputs) {
+        this.unsignedTransaction.inputs.push(...inputs);
+        this.signatures = [];
+        return this;
+    }
+    withMinEpoch(minEpoch) {
+        this.unsignedTransaction.minEpoch = minEpoch;
+        // Reset the signatures as they are no longer valid
+        this.signatures = [];
+        return this;
+    }
+    withMaxEpoch(maxEpoch) {
+        this.unsignedTransaction.maxEpoch = maxEpoch;
+        // Reset the signatures as they are no longer valid
+        this.signatures = [];
+        return this;
+    }
+    buildUnsignedTransaction() {
+        return this.unsignedTransaction;
+    }
+    build() {
+        return new TransactionRequest(this.unsignedTransaction, this.signatures);
+    }
+}

package/dist/builders/transaction/TransactionRequest.d.ts

@@ -0,0 +1,27 @@
+import { Epoch, Instruction, SubstateRequirement, Transaction, TransactionId, TransactionSignature, UnsignedTransaction, VersionedSubstateId } from "../types";
+export declare class TransactionRequest implements Transaction {
+    id: TransactionId;
+    feeInstructions: Array<Instruction>;
+    instructions: Array<Instruction>;
+    inputs: Array<SubstateRequirement>;
+    signatures: Array<TransactionSignature>;
+    unsignedTransaction: UnsignedTransaction;
+    minEpoch?: Epoch;
+    maxEpoch?: Epoch;
+    filledInputs: VersionedSubstateId[];
+    constructor(unsignedTransaction: UnsignedTransaction, signatures: TransactionSignature[]);
+    private calculateHash;
+    withFilledInputs(filled_inputs: Array<VersionedSubstateId>): this;
+    getId(): TransactionId;
+    checkId(): boolean;
+    getUnsignedTransaction(): UnsignedTransaction;
+    getFeeInstructions(): Instruction[];
+    getInstructions(): Instruction[];
+    getSignatures(): TransactionSignature[];
+    getHash(): string;
+    getInputs(): SubstateRequirement[];
+    getFilledInputs(): VersionedSubstateId[];
+    getFilledInputsMut(): VersionedSubstateId[];
+    getMinEpoch(): Epoch | undefined;
+    getMaxEpoch(): Epoch | undefined;
+}

package/dist/builders/transaction/TransactionRequest.js

@@ -0,0 +1,67 @@
+///TODO this implementation is not fully done, see:
+/// https://github.com/tari-project/tari-dan/blob/development/dan_layer/transaction/src/transaction.rs
+export class TransactionRequest {
+    id;
+    feeInstructions;
+    instructions;
+    inputs;
+    signatures;
+    unsignedTransaction;
+    minEpoch;
+    maxEpoch;
+    filledInputs;
+    constructor(unsignedTransaction, signatures) {
+        this.id = this.calculateHash();
+        this.feeInstructions = unsignedTransaction.feeInstructions;
+        this.instructions = unsignedTransaction.instructions;
+        this.inputs = unsignedTransaction.inputs;
+        this.signatures = signatures;
+        this.minEpoch = unsignedTransaction.minEpoch;
+        this.maxEpoch = unsignedTransaction.maxEpoch;
+        // Inputs filled by some authority. These are not part of the transaction hash nor the signature
+        this.filledInputs = [];
+    }
+    calculateHash() {
+        return "";
+    }
+    withFilledInputs(filled_inputs) {
+        return { ...this, filled_inputs };
+    }
+    getId() {
+        return this.id;
+    }
+    checkId() {
+        const id = this.calculateHash();
+        return id === this.id;
+    }
+    getUnsignedTransaction() {
+        return this.unsignedTransaction;
+    }
+    getFeeInstructions() {
+        return this.feeInstructions;
+    }
+    getInstructions() {
+        return this.instructions;
+    }
+    getSignatures() {
+        return this.signatures;
+    }
+    getHash() {
+        return this.id;
+    }
+    getInputs() {
+        return this.inputs;
+    }
+    getFilledInputs() {
+        return this.filledInputs;
+    }
+    getFilledInputsMut() {
+        return this.filledInputs;
+    }
+    getMinEpoch() {
+        return this.minEpoch;
+    }
+    getMaxEpoch() {
+        return this.maxEpoch;
+    }
+}

package/dist/builders/transaction/index.d.ts

@@ -0,0 +1,2 @@
+export { TransactionBuilder } from "./TransactionBuilder";
+export { TransactionRequest } from "./TransactionRequest";

package/dist/builders/transaction/index.js

@@ -0,0 +1,2 @@
+export { TransactionBuilder } from "./TransactionBuilder";
+export { TransactionRequest } from "./TransactionRequest";

package/dist/builders/types/Amount.d.ts

@@ -0,0 +1,23 @@
+export declare class Amount {
+    private value;
+    constructor(value: number);
+    static readonly MAX: Amount;
+    static newAmount(amount: number): Amount;
+    static zero(): Amount;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    getValue(): number;
+    getStringValue(): string;
+    checkedAdd(other: Amount): Amount | null;
+    saturatingAdd(other: Amount): Amount;
+    checkedSub(other: Amount): Amount | null;
+    saturatingSub(other: Amount): Amount;
+    saturatingSubPositive(other: Amount): Amount;
+    checkedSubPositive(other: Amount): Amount | null;
+    checkedMul(other: Amount): Amount | null;
+    saturatingMul(other: Amount): Amount;
+    checkedDiv(other: Amount): Amount | null;
+    saturatingDiv(other: Amount): Amount;
+    asU64Checked(): number | null;
+}

package/dist/builders/types/Amount.js

@@ -0,0 +1,93 @@
+export class Amount {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static MAX = new Amount(Number.MAX_SAFE_INTEGER);
+    static newAmount(amount) {
+        return new Amount(amount);
+    }
+    static zero() {
+        return new Amount(0);
+    }
+    isZero() {
+        return this.value === 0;
+    }
+    isPositive() {
+        return this.value >= 0;
+    }
+    isNegative() {
+        return !this.isPositive();
+    }
+    getValue() {
+        return this.value;
+    }
+    getStringValue() {
+        return this.value.toString();
+    }
+    checkedAdd(other) {
+        const result = this.value + other.value;
+        if (result < Number.MIN_SAFE_INTEGER || result > Number.MAX_SAFE_INTEGER) {
+            return null;
+        }
+        return new Amount(result);
+    }
+    saturatingAdd(other) {
+        return new Amount(Math.min(Number.MAX_SAFE_INTEGER, Math.max(Number.MIN_SAFE_INTEGER, this.value + other.value)));
+    }
+    checkedSub(other) {
+        const result = this.value - other.value;
+        if (result < Number.MIN_SAFE_INTEGER || result > Number.MAX_SAFE_INTEGER) {
+            return null;
+        }
+        return new Amount(result);
+    }
+    saturatingSub(other) {
+        return new Amount(Math.min(Number.MAX_SAFE_INTEGER, Math.max(Number.MIN_SAFE_INTEGER, this.value - other.value)));
+    }
+    saturatingSubPositive(other) {
+        const result = this.value - other.value;
+        return result < 0 ? new Amount(0) : new Amount(result);
+    }
+    checkedSubPositive(other) {
+        if (this.isNegative() || other.isNegative()) {
+            return null;
+        }
+        if (this.value < other.value) {
+            return null;
+        }
+        return new Amount(this.value - other.value);
+    }
+    checkedMul(other) {
+        const result = this.value * other.value;
+        if (result < Number.MIN_SAFE_INTEGER || result > Number.MAX_SAFE_INTEGER) {
+            return null;
+        }
+        return new Amount(result);
+    }
+    saturatingMul(other) {
+        return new Amount(Math.min(Number.MAX_SAFE_INTEGER, Math.max(Number.MIN_SAFE_INTEGER, this.value * other.value)));
+    }
+    checkedDiv(other) {
+        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);
+    }
+    saturatingDiv(other) {
+        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)));
+    }
+    asU64Checked() {
+        if (this.value < 0) {
+            return null;
+        }
+        return this.value;
+    }
+}

package/dist/builders/types/Arg.d.ts

@@ -0,0 +1 @@
+export type Arg = any;

package/dist/builders/types/Arg.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/types/Builder.d.ts

@@ -0,0 +1,47 @@
+import { TemplateAddress } from "./TemplateAddress";
+import { Arg } from "./Arg";
+import { ComponentAddress, ConfidentialClaim, ConfidentialWithdrawProof, Instruction, ResourceAddress, SubstateRequirement, Transaction, TransactionSignature, UnsignedTransaction } from ".";
+import { TransactionBuilder } from "../transaction";
+export interface TransactionConstructor {
+    new (unsignedTransaction: UnsignedTransaction, signatures: TransactionSignature[]): Transaction;
+}
+export interface TariFunctionDefinition {
+    functionName: string;
+    args?: Arg[];
+    templateAddress: TemplateAddress;
+}
+export interface TariMethodDefinition {
+    methodName: string;
+    args?: Arg[];
+    componentAddress: ComponentAddress;
+}
+export interface TariCreateAccountDefinition {
+    methodName: string;
+    args?: {
+        ownerPublicKey: string;
+        workspaceBucket?: string;
+    };
+}
+export interface Builder {
+    callFunction<T extends TariFunctionDefinition>(func: T, args: Exclude<T["args"], undefined>): this;
+    callMethod<T extends TariMethodDefinition>(method: T, args: Exclude<T["args"], undefined>): this;
+    createAccount(ownerPublicKey: string, workspaceBucket?: string): this;
+    createProof(account: ComponentAddress, resourceAddress: ResourceAddress): this;
+    saveVar(key: string): this;
+    dropAllProofsInWorkspace(): this;
+    claimBurn(claim: ConfidentialClaim): this;
+    addInput(inputObject: SubstateRequirement): this;
+    addInstruction(instruction: Instruction): this;
+    addFeeInstruction(instruction: Instruction): this;
+    withMinEpoch(minEpoch: number): this;
+    withMaxEpoch(maxEpoch: number): this;
+    withInputs(inputs: SubstateRequirement[]): this;
+    withInstructions(instructions: Instruction[]): this;
+    withFeeInstructions(instructions: Instruction[]): this;
+    withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => this): this;
+    withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this;
+    feeTransactionPayFromComponent(componentAddress: ComponentAddress, maxFee: string): this;
+    feeTransactionPayFromComponentConfidential(componentAddress: ComponentAddress, proof: ConfidentialWithdrawProof): this;
+    buildUnsignedTransaction(): UnsignedTransaction;
+    build(): Transaction;
+}

package/dist/builders/types/Builder.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/types/ComponentAddress.d.ts

@@ -0,0 +1 @@
+export type ComponentAddress = string;

package/dist/builders/types/ComponentAddress.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/types/ConfidentialClaim.d.ts

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

package/dist/builders/types/ConfidentialClaim.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/types/ConfidentialOutput.d.ts

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

package/dist/builders/types/ConfidentialOutput.js

@@ -0,0 +1 @@
+export {};