@splashprotocol/remote-builder 2.0.0-beta.8 → 2.0.0-beta.80

package/.turbo/turbo-build.log

@@ -4,13 +4,13 @@
 $ tsup src/index.ts --format esm,cjs --dts --clean
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
-CLI tsup v8.3.0
+CLI tsup v8.4.0
 CLI Target: esnext
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
 
-[4:51:26 PM]  WARN  ▲ [WARNING] The condition "types" here will never be used as it comes after both "import" and "require" [package.json]
+ WARN  ▲ [WARNING] The condition "types" here will never be used as it comes after both "import" and "require" [package.json]       2:10:33 PM
 
     package.json:16:6:
       16 │       "types": "./dist/index.d.ts"
@@ -31,7 +31,7 @@
 
 
 
-[4:51:26 PM]  WARN  ▲ [WARNING] The condition "types" here will never be used as it comes after both "import" and "require" [package.json]
+ WARN  ▲ [WARNING] The condition "types" here will never be used as it comes after both "import" and "require" [package.json]       2:10:33 PM
 
     package.json:16:6:
       16 │       "types": "./dist/index.d.ts"
@@ -51,12 +51,12 @@
 
 
 
-ESM dist/index.js 1.47 KB
-ESM ⚡️ Build success in 25ms
-CJS dist/index.cjs 2.58 KB
-CJS ⚡️ Build success in 25ms
-DTS Build start
-DTS ⚡️ Build success in 937ms
-DTS dist/index.d.ts  1.87 KB
-DTS dist/index.d.cts 1.87 KB
-✨  Done in 1.43s.
+CJS dist/index.cjs 3.70 KB
+CJS ⚡️ Build success in 24ms
+ESM dist/index.js 2.39 KB
+ESM ⚡️ Build success in 24ms
+DTS Build start
+DTS ⚡️ Build success in 1129ms
+DTS dist/index.d.ts  2.78 KB
+DTS dist/index.d.cts 2.78 KB
+✨  Done in 1.76s.

package/dist/index.cjs

@@ -18,28 +18,42 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
+  InsufficientCollateralError: () => InsufficientCollateralError,
+  InsufficientFundsErrorForChange: () => InsufficientFundsErrorForChange,
+  NoCollateralError: () => NoCollateralError,
   RemoteTransaction: () => RemoteTransaction,
   SignedRemoteTransaction: () => SignedRemoteTransaction,
   SplashRemoteBuilder: () => SplashRemoteBuilder
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/core/models/RemoteTransaction/RemoteTransaction.ts
 var RemoteTransaction = class _RemoteTransaction {
-  constructor(serialization, builder) {
+  constructor(serialization, builder, additionalData, partial) {
     this.builder = builder;
+    this.partial = partial;
     this.serialization = serialization;
+    this.additionalData = additionalData;
   }
-  static new(serialization, builder) {
-    return new _RemoteTransaction(serialization, builder);
+  static new(serialization, builder, additionalData, partial) {
+    return new _RemoteTransaction(
+      serialization,
+      builder,
+      additionalData,
+      partial
+    );
   }
   /**
    * Transaction serialization
    * @type {S}
    */
   serialization;
+  /**
+   * Transaction additional data
+   */
+  additionalData;
   sign() {
     return this.builder.sign(this);
   }
@@ -64,30 +78,54 @@ var SplashRemoteBuilder = class _SplashRemoteBuilder {
     throw new Error("not implemented.");
   }
   trade() {
-    return Promise.resolve(RemoteTransaction.new("", this));
+    return Promise.resolve(RemoteTransaction.new("", this, void 0));
+  }
+  cancelOperation(outputReference) {
+    console.log(outputReference);
+    return Promise.resolve(RemoteTransaction.new("", this, void 0));
   }
 };
 
 // src/core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts
 var SignedRemoteTransaction = class _SignedRemoteTransaction {
-  constructor(serialization, builder) {
+  constructor(serialization, builder, additionalData) {
     this.builder = builder;
     this.serialization = serialization;
+    this.additionalData = additionalData;
   }
-  static new(serialization, builder) {
-    return new _SignedRemoteTransaction(serialization, builder);
+  static new(serialization, builder, additionalData) {
+    return new _SignedRemoteTransaction(serialization, builder, additionalData);
   }
   /**
    * Transaction serialization
    * @type {S}
    */
   serialization;
+  /**
+   * Transaction additional data
+   */
+  additionalData;
   submit() {
     return this.builder.submit(this);
   }
 };
+
+// src/core/errors/InsufficientCollateralError.ts
+var InsufficientCollateralError = class extends Error {
+};
+
+// src/core/errors/NoCollateralError.ts
+var NoCollateralError = class extends Error {
+};
+
+// src/core/errors/InsufficientFundsErrorForChange.ts
+var InsufficientFundsErrorForChange = class extends Error {
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  InsufficientCollateralError,
+  InsufficientFundsErrorForChange,
+  NoCollateralError,
   RemoteTransaction,
   SignedRemoteTransaction,
   SplashRemoteBuilder

package/dist/index.d.cts

@@ -1,14 +1,18 @@
 import { Api, Backend, SplashBackend } from '@splashprotocol/api';
-import { TransactionHash, CborHexString } from '@splashprotocol/core';
+import { TransactionHash, CborHexString, OutputReference, OutputReferenceHash } from '@splashprotocol/core';
 
-declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData> {
     private builder;
-    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): SignedRemoteTransaction<S, RB>;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData>(serialization: S, builder: RB, additionalData: AdditionalData): SignedRemoteTransaction<S, RB, AdditionalData>;
     /**
      * Transaction serialization
      * @type {S}
      */
     readonly serialization: S;
+    /**
+     * Transaction additional data
+     */
+    readonly additionalData: AdditionalData;
     private constructor();
     submit(): Promise<TransactionHash>;
 }
@@ -16,32 +20,47 @@ declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}
 /**
  * Remote transaction representation
  */
-declare class RemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+declare class RemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData> {
     private builder;
-    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): RemoteTransaction<S, RB>;
+    readonly partial?: boolean | undefined;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData>(serialization: S, builder: RB, additionalData: AdditionalData, partial?: boolean): RemoteTransaction<S, RB, AdditionalData>;
     /**
      * Transaction serialization
      * @type {S}
      */
     readonly serialization: S;
+    /**
+     * Transaction additional data
+     */
+    readonly additionalData: AdditionalData;
     private constructor();
-    sign(): Promise<SignedRemoteTransaction<S, RB>>;
+    sign(): Promise<SignedRemoteTransaction<S, RB, AdditionalData>>;
     signAndSubmit(): Promise<TransactionHash>;
 }
 
 interface RemoteBuilder<A extends Api<Backend<{}>>, S> {
     readonly api: A;
-    sign(tx: RemoteTransaction<S, RemoteBuilder<A, S>>): Promise<SignedRemoteTransaction<S, RemoteBuilder<A, S>>>;
-    submit(signedTx: SignedRemoteTransaction<S, RemoteBuilder<A, S>>): Promise<TransactionHash>;
+    sign<AD>(tx: RemoteTransaction<S, RemoteBuilder<A, S>, AD>): Promise<SignedRemoteTransaction<S, RemoteBuilder<A, S>, AD>>;
+    submit<AD>(signedTx: SignedRemoteTransaction<S, RemoteBuilder<A, S>, AD>): Promise<TransactionHash>;
 }
 
 declare class SplashRemoteBuilder implements RemoteBuilder<Api<SplashBackend>, CborHexString> {
     static new(api: Api<SplashBackend>): SplashRemoteBuilder;
     readonly api: Api<SplashBackend>;
     private constructor();
-    sign(): Promise<SignedRemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>>>;
+    sign(): Promise<SignedRemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>, any>>;
     submit(): Promise<TransactionHash>;
-    trade(): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>>>;
+    trade(): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>, any>>;
+    cancelOperation(outputReference: OutputReference | OutputReferenceHash): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>, any>>;
+}
+
+declare class InsufficientCollateralError extends Error {
+}
+
+declare class NoCollateralError extends Error {
+}
+
+declare class InsufficientFundsErrorForChange extends Error {
 }
 
-export { type RemoteBuilder, RemoteTransaction, SignedRemoteTransaction, SplashRemoteBuilder };
+export { InsufficientCollateralError, InsufficientFundsErrorForChange, NoCollateralError, type RemoteBuilder, RemoteTransaction, SignedRemoteTransaction, SplashRemoteBuilder };

package/dist/index.d.ts

@@ -1,14 +1,18 @@
 import { Api, Backend, SplashBackend } from '@splashprotocol/api';
-import { TransactionHash, CborHexString } from '@splashprotocol/core';
+import { TransactionHash, CborHexString, OutputReference, OutputReferenceHash } from '@splashprotocol/core';
 
-declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData> {
     private builder;
-    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): SignedRemoteTransaction<S, RB>;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData>(serialization: S, builder: RB, additionalData: AdditionalData): SignedRemoteTransaction<S, RB, AdditionalData>;
     /**
      * Transaction serialization
      * @type {S}
      */
     readonly serialization: S;
+    /**
+     * Transaction additional data
+     */
+    readonly additionalData: AdditionalData;
     private constructor();
     submit(): Promise<TransactionHash>;
 }
@@ -16,32 +20,47 @@ declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}
 /**
  * Remote transaction representation
  */
-declare class RemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+declare class RemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData> {
     private builder;
-    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): RemoteTransaction<S, RB>;
+    readonly partial?: boolean | undefined;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData>(serialization: S, builder: RB, additionalData: AdditionalData, partial?: boolean): RemoteTransaction<S, RB, AdditionalData>;
     /**
      * Transaction serialization
      * @type {S}
      */
     readonly serialization: S;
+    /**
+     * Transaction additional data
+     */
+    readonly additionalData: AdditionalData;
     private constructor();
-    sign(): Promise<SignedRemoteTransaction<S, RB>>;
+    sign(): Promise<SignedRemoteTransaction<S, RB, AdditionalData>>;
     signAndSubmit(): Promise<TransactionHash>;
 }
 
 interface RemoteBuilder<A extends Api<Backend<{}>>, S> {
     readonly api: A;
-    sign(tx: RemoteTransaction<S, RemoteBuilder<A, S>>): Promise<SignedRemoteTransaction<S, RemoteBuilder<A, S>>>;
-    submit(signedTx: SignedRemoteTransaction<S, RemoteBuilder<A, S>>): Promise<TransactionHash>;
+    sign<AD>(tx: RemoteTransaction<S, RemoteBuilder<A, S>, AD>): Promise<SignedRemoteTransaction<S, RemoteBuilder<A, S>, AD>>;
+    submit<AD>(signedTx: SignedRemoteTransaction<S, RemoteBuilder<A, S>, AD>): Promise<TransactionHash>;
 }
 
 declare class SplashRemoteBuilder implements RemoteBuilder<Api<SplashBackend>, CborHexString> {
     static new(api: Api<SplashBackend>): SplashRemoteBuilder;
     readonly api: Api<SplashBackend>;
     private constructor();
-    sign(): Promise<SignedRemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>>>;
+    sign(): Promise<SignedRemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>, any>>;
     submit(): Promise<TransactionHash>;
-    trade(): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>>>;
+    trade(): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>, any>>;
+    cancelOperation(outputReference: OutputReference | OutputReferenceHash): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>, any>>;
+}
+
+declare class InsufficientCollateralError extends Error {
+}
+
+declare class NoCollateralError extends Error {
+}
+
+declare class InsufficientFundsErrorForChange extends Error {
 }
 
-export { type RemoteBuilder, RemoteTransaction, SignedRemoteTransaction, SplashRemoteBuilder };
+export { InsufficientCollateralError, InsufficientFundsErrorForChange, NoCollateralError, type RemoteBuilder, RemoteTransaction, SignedRemoteTransaction, SplashRemoteBuilder };

package/dist/index.js

@@ -1,17 +1,28 @@
 // src/core/models/RemoteTransaction/RemoteTransaction.ts
 var RemoteTransaction = class _RemoteTransaction {
-  constructor(serialization, builder) {
+  constructor(serialization, builder, additionalData, partial) {
     this.builder = builder;
+    this.partial = partial;
     this.serialization = serialization;
+    this.additionalData = additionalData;
   }
-  static new(serialization, builder) {
-    return new _RemoteTransaction(serialization, builder);
+  static new(serialization, builder, additionalData, partial) {
+    return new _RemoteTransaction(
+      serialization,
+      builder,
+      additionalData,
+      partial
+    );
   }
   /**
    * Transaction serialization
    * @type {S}
    */
   serialization;
+  /**
+   * Transaction additional data
+   */
+  additionalData;
   sign() {
     return this.builder.sign(this);
   }
@@ -36,29 +47,53 @@ var SplashRemoteBuilder = class _SplashRemoteBuilder {
     throw new Error("not implemented.");
   }
   trade() {
-    return Promise.resolve(RemoteTransaction.new("", this));
+    return Promise.resolve(RemoteTransaction.new("", this, void 0));
+  }
+  cancelOperation(outputReference) {
+    console.log(outputReference);
+    return Promise.resolve(RemoteTransaction.new("", this, void 0));
   }
 };
 
 // src/core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts
 var SignedRemoteTransaction = class _SignedRemoteTransaction {
-  constructor(serialization, builder) {
+  constructor(serialization, builder, additionalData) {
     this.builder = builder;
     this.serialization = serialization;
+    this.additionalData = additionalData;
   }
-  static new(serialization, builder) {
-    return new _SignedRemoteTransaction(serialization, builder);
+  static new(serialization, builder, additionalData) {
+    return new _SignedRemoteTransaction(serialization, builder, additionalData);
   }
   /**
    * Transaction serialization
    * @type {S}
    */
   serialization;
+  /**
+   * Transaction additional data
+   */
+  additionalData;
   submit() {
     return this.builder.submit(this);
   }
 };
+
+// src/core/errors/InsufficientCollateralError.ts
+var InsufficientCollateralError = class extends Error {
+};
+
+// src/core/errors/NoCollateralError.ts
+var NoCollateralError = class extends Error {
+};
+
+// src/core/errors/InsufficientFundsErrorForChange.ts
+var InsufficientFundsErrorForChange = class extends Error {
+};
 export {
+  InsufficientCollateralError,
+  InsufficientFundsErrorForChange,
+  NoCollateralError,
   RemoteTransaction,
   SignedRemoteTransaction,
   SplashRemoteBuilder

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splashprotocol/remote-builder",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0-beta.80",
   "type": "module",
   "description": "Api client of splash protocol",
   "scripts": {
@@ -33,7 +33,8 @@
     ]
   },
   "peerDependencies": {
-    "@splashprotocol/api": "2.0.0-beta.8",
-    "@splashprotocol/core": "2.0.0-beta.8"
+    "@splashprotocol/api": "2.0.0-beta.57",
+    "@splashprotocol/core": "2.0.0-beta.19",
+    "@splashprotocol/browser-wallet": "1.0.0-beta.21"
   }
 }

package/src/builders/SplashRemoteBuilder.ts

@@ -1,7 +1,12 @@
 import { RemoteBuilder } from '../core/types/RemoteBuilder.ts';
 import { Api, SplashBackend } from '@splashprotocol/api';
 import { RemoteTransaction } from '../core/models/RemoteTransaction/RemoteTransaction.ts';
-import { CborHexString, TransactionHash } from '@splashprotocol/core';
+import {
+  CborHexString,
+  OutputReference,
+  OutputReferenceHash,
+  TransactionHash,
+} from '@splashprotocol/core';
 import { SignedRemoteTransaction } from '../core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts';
 
 export class SplashRemoteBuilder
@@ -20,7 +25,8 @@ export class SplashRemoteBuilder
   sign(): Promise<
     SignedRemoteTransaction<
       CborHexString,
-      RemoteBuilder<Api<SplashBackend>, CborHexString>
+      RemoteBuilder<Api<SplashBackend>, CborHexString>,
+      any
     >
   > {
     throw new Error('not implemented.');
@@ -33,9 +39,23 @@ export class SplashRemoteBuilder
   trade(): Promise<
     RemoteTransaction<
       CborHexString,
-      RemoteBuilder<Api<SplashBackend>, CborHexString>
+      RemoteBuilder<Api<SplashBackend>, CborHexString>,
+      any
     >
   > {
-    return Promise.resolve(RemoteTransaction.new('', this));
+    return Promise.resolve(RemoteTransaction.new('', this, undefined));
+  }
+
+  cancelOperation(
+    outputReference: OutputReference | OutputReferenceHash,
+  ): Promise<
+    RemoteTransaction<
+      CborHexString,
+      RemoteBuilder<Api<SplashBackend>, CborHexString>,
+      any
+    >
+  > {
+    console.log(outputReference);
+    return Promise.resolve(RemoteTransaction.new('', this, undefined));
   }
 }

package/src/core/errors/InsufficientCollateralError.ts

@@ -0,0 +1 @@
+export class InsufficientCollateralError extends Error {}

package/src/core/errors/InsufficientFundsErrorForChange.ts

@@ -0,0 +1 @@
+export class InsufficientFundsErrorForChange extends Error {}

package/src/core/errors/NoCollateralError.ts

@@ -0,0 +1 @@
+export class NoCollateralError extends Error {}

package/src/core/models/RemoteTransaction/RemoteTransaction.ts

@@ -9,12 +9,20 @@ import { TransactionHash } from '@splashprotocol/core';
 export class RemoteTransaction<
   S,
   RB extends RemoteBuilder<Api<Backend<{}>>, S>,
+  AdditionalData,
 > {
-  static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(
+  static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData>(
     serialization: S,
     builder: RB,
-  ): RemoteTransaction<S, RB> {
-    return new RemoteTransaction(serialization, builder);
+    additionalData: AdditionalData,
+    partial?: boolean,
+  ): RemoteTransaction<S, RB, AdditionalData> {
+    return new RemoteTransaction(
+      serialization,
+      builder,
+      additionalData,
+      partial,
+    );
   }
 
   /**
@@ -23,14 +31,22 @@ export class RemoteTransaction<
    */
   readonly serialization: S;
 
+  /**
+   * Transaction additional data
+   */
+  readonly additionalData: AdditionalData;
+
   private constructor(
     serialization: S,
     private builder: RB,
+    additionalData: AdditionalData,
+    public readonly partial?: boolean,
   ) {
     this.serialization = serialization;
+    this.additionalData = additionalData;
   }
 
-  sign(): Promise<SignedRemoteTransaction<S, RB>> {
+  sign(): Promise<SignedRemoteTransaction<S, RB, AdditionalData>> {
     return this.builder.sign(this) as any;
   }
 

package/src/core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts

@@ -5,12 +5,14 @@ import { TransactionHash } from '@splashprotocol/core';
 export class SignedRemoteTransaction<
   S,
   RB extends RemoteBuilder<Api<Backend<{}>>, S>,
+  AdditionalData,
 > {
-  static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(
+  static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>, AdditionalData>(
     serialization: S,
     builder: RB,
-  ): SignedRemoteTransaction<S, RB> {
-    return new SignedRemoteTransaction(serialization, builder);
+    additionalData: AdditionalData,
+  ): SignedRemoteTransaction<S, RB, AdditionalData> {
+    return new SignedRemoteTransaction(serialization, builder, additionalData);
   }
 
   /**
@@ -19,11 +21,18 @@ export class SignedRemoteTransaction<
    */
   readonly serialization: S;
 
+  /**
+   * Transaction additional data
+   */
+  readonly additionalData: AdditionalData;
+
   private constructor(
     serialization: S,
     private builder: RB,
+    additionalData: AdditionalData,
   ) {
     this.serialization = serialization;
+    this.additionalData = additionalData;
   }
 
   submit(): Promise<TransactionHash> {

package/src/core/types/RemoteBuilder.ts

@@ -6,11 +6,11 @@ import { TransactionHash } from '@splashprotocol/core';
 export interface RemoteBuilder<A extends Api<Backend<{}>>, S> {
   readonly api: A;
 
-  sign(
-    tx: RemoteTransaction<S, RemoteBuilder<A, S>>,
-  ): Promise<SignedRemoteTransaction<S, RemoteBuilder<A, S>>>;
+  sign<AD>(
+    tx: RemoteTransaction<S, RemoteBuilder<A, S>, AD>,
+  ): Promise<SignedRemoteTransaction<S, RemoteBuilder<A, S>, AD>>;
 
-  submit(
-    signedTx: SignedRemoteTransaction<S, RemoteBuilder<A, S>>,
+  submit<AD>(
+    signedTx: SignedRemoteTransaction<S, RemoteBuilder<A, S>, AD>,
   ): Promise<TransactionHash>;
 }

package/src/index.ts

@@ -2,3 +2,6 @@ export * from './core/types/RemoteBuilder.ts';
 export * from './builders/SplashRemoteBuilder.ts';
 export * from './core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts';
 export * from './core/models/RemoteTransaction/RemoteTransaction.ts';
+export * from './core/errors/InsufficientCollateralError.ts';
+export * from './core/errors/NoCollateralError.ts';
+export * from './core/errors/InsufficientFundsErrorForChange.ts';