@splashprotocol/remote-builder 2.0.0-beta.6

package/.turbo/turbo-build.log

@@ -0,0 +1,62 @@
+
+yarn run v1.22.22
+warning package.json: No license field
+$ 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 Target: esnext
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+
+[4:36:02 PM]  WARN  ▲ [WARNING] The condition "types" here will never be used as it comes after both "import" and "require" [package.json]
+
+    package.json:16:6:
+      16 │       "types": "./dist/index.d.ts"
+         ╵       ~~~~~~~
+
+  The "import" condition comes earlier and will be used for all "import" statements:
+
+    package.json:15:6:
+      15 │       "import": "./dist/index.js",
+         ╵       ~~~~~~~~
+
+  The "require" condition comes earlier and will be used for all "require" calls:
+
+    package.json:14:6:
+      14 │       "require": "./dist/index.cjs",
+         ╵       ~~~~~~~~~
+
+
+
+
+[4:36:02 PM]  WARN  ▲ [WARNING] The condition "types" here will never be used as it comes after both "import" and "require" [package.json]
+
+    package.json:16:6:
+      16 │       "types": "./dist/index.d.ts"
+         ╵       ~~~~~~~
+
+  The "import" condition comes earlier and will be used for all "import" statements:
+
+    package.json:15:6:
+      15 │       "import": "./dist/index.js",
+         ╵       ~~~~~~~~
+
+  The "require" condition comes earlier and will be used for all "require" calls:
+
+    package.json:14:6:
+      14 │       "require": "./dist/index.cjs",
+         ╵       ~~~~~~~~~
+
+
+
+CJS dist/index.cjs 2.58 KB
+CJS ⚡️ Build success in 29ms
+ESM dist/index.js 1.47 KB
+ESM ⚡️ Build success in 29ms
+DTS Build start
+DTS ⚡️ Build success in 830ms
+DTS dist/index.d.ts  1.87 KB
+DTS dist/index.d.cts 1.87 KB
+✨  Done in 1.71s.

package/dist/index.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RemoteTransaction: () => RemoteTransaction,
+  SignedRemoteTransaction: () => SignedRemoteTransaction,
+  SplashRemoteBuilder: () => SplashRemoteBuilder
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/models/RemoteTransaction/RemoteTransaction.ts
+var RemoteTransaction = class _RemoteTransaction {
+  constructor(serialization, builder) {
+    this.builder = builder;
+    this.serialization = serialization;
+  }
+  static new(serialization, builder) {
+    return new _RemoteTransaction(serialization, builder);
+  }
+  /**
+   * Transaction serialization
+   * @type {S}
+   */
+  serialization;
+  sign() {
+    return this.builder.sign(this);
+  }
+  signAndSubmit() {
+    return this.sign().then((srt) => srt.submit());
+  }
+};
+
+// src/builders/SplashRemoteBuilder.ts
+var SplashRemoteBuilder = class _SplashRemoteBuilder {
+  static new(api) {
+    return new _SplashRemoteBuilder(api);
+  }
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  sign() {
+    throw new Error("not implemented.");
+  }
+  submit() {
+    throw new Error("not implemented.");
+  }
+  trade() {
+    return Promise.resolve(RemoteTransaction.new("", this));
+  }
+};
+
+// src/core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts
+var SignedRemoteTransaction = class _SignedRemoteTransaction {
+  constructor(serialization, builder) {
+    this.builder = builder;
+    this.serialization = serialization;
+  }
+  static new(serialization, builder) {
+    return new _SignedRemoteTransaction(serialization, builder);
+  }
+  /**
+   * Transaction serialization
+   * @type {S}
+   */
+  serialization;
+  submit() {
+    return this.builder.submit(this);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RemoteTransaction,
+  SignedRemoteTransaction,
+  SplashRemoteBuilder
+});

package/dist/index.d.cts

@@ -0,0 +1,47 @@
+import { Api, Backend, SplashBackend } from '@splashprotocol/api';
+import { TransactionHash, CborHexString } from '@splashprotocol/core';
+
+declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+    private builder;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): SignedRemoteTransaction<S, RB>;
+    /**
+     * Transaction serialization
+     * @type {S}
+     */
+    readonly serialization: S;
+    private constructor();
+    submit(): Promise<TransactionHash>;
+}
+
+/**
+ * Remote transaction representation
+ */
+declare class RemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+    private builder;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): RemoteTransaction<S, RB>;
+    /**
+     * Transaction serialization
+     * @type {S}
+     */
+    readonly serialization: S;
+    private constructor();
+    sign(): Promise<SignedRemoteTransaction<S, RB>>;
+    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>;
+}
+
+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>>>;
+    submit(): Promise<TransactionHash>;
+    trade(): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>>>;
+}
+
+export { type RemoteBuilder, RemoteTransaction, SignedRemoteTransaction, SplashRemoteBuilder };

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import { Api, Backend, SplashBackend } from '@splashprotocol/api';
+import { TransactionHash, CborHexString } from '@splashprotocol/core';
+
+declare class SignedRemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+    private builder;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): SignedRemoteTransaction<S, RB>;
+    /**
+     * Transaction serialization
+     * @type {S}
+     */
+    readonly serialization: S;
+    private constructor();
+    submit(): Promise<TransactionHash>;
+}
+
+/**
+ * Remote transaction representation
+ */
+declare class RemoteTransaction<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>> {
+    private builder;
+    static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(serialization: S, builder: RB): RemoteTransaction<S, RB>;
+    /**
+     * Transaction serialization
+     * @type {S}
+     */
+    readonly serialization: S;
+    private constructor();
+    sign(): Promise<SignedRemoteTransaction<S, RB>>;
+    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>;
+}
+
+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>>>;
+    submit(): Promise<TransactionHash>;
+    trade(): Promise<RemoteTransaction<CborHexString, RemoteBuilder<Api<SplashBackend>, CborHexString>>>;
+}
+
+export { type RemoteBuilder, RemoteTransaction, SignedRemoteTransaction, SplashRemoteBuilder };

package/dist/index.js

@@ -0,0 +1,65 @@
+// src/core/models/RemoteTransaction/RemoteTransaction.ts
+var RemoteTransaction = class _RemoteTransaction {
+  constructor(serialization, builder) {
+    this.builder = builder;
+    this.serialization = serialization;
+  }
+  static new(serialization, builder) {
+    return new _RemoteTransaction(serialization, builder);
+  }
+  /**
+   * Transaction serialization
+   * @type {S}
+   */
+  serialization;
+  sign() {
+    return this.builder.sign(this);
+  }
+  signAndSubmit() {
+    return this.sign().then((srt) => srt.submit());
+  }
+};
+
+// src/builders/SplashRemoteBuilder.ts
+var SplashRemoteBuilder = class _SplashRemoteBuilder {
+  static new(api) {
+    return new _SplashRemoteBuilder(api);
+  }
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  sign() {
+    throw new Error("not implemented.");
+  }
+  submit() {
+    throw new Error("not implemented.");
+  }
+  trade() {
+    return Promise.resolve(RemoteTransaction.new("", this));
+  }
+};
+
+// src/core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts
+var SignedRemoteTransaction = class _SignedRemoteTransaction {
+  constructor(serialization, builder) {
+    this.builder = builder;
+    this.serialization = serialization;
+  }
+  static new(serialization, builder) {
+    return new _SignedRemoteTransaction(serialization, builder);
+  }
+  /**
+   * Transaction serialization
+   * @type {S}
+   */
+  serialization;
+  submit() {
+    return this.builder.submit(this);
+  }
+};
+export {
+  RemoteTransaction,
+  SignedRemoteTransaction,
+  SplashRemoteBuilder
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@splashprotocol/remote-builder",
+  "version": "2.0.0-beta.6",
+  "type": "module",
+  "description": "Api client of splash protocol",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "jest"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "private": false,
+  "devDependencies": {
+    "@types/jest": "^29.5.13",
+    "jest": "^29.7.0",
+    "jest-node-exports-resolver": "^1.1.6",
+    "ts-jest": "^29.2.5",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/*.spec.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@splashprotocol/api": "2.0.0-beta.4",
+    "@splashprotocol/core": "2.0.0-beta.4"
+  }
+}

package/src/builders/SplashRemoteBuilder.ts

@@ -0,0 +1,41 @@
+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 { SignedRemoteTransaction } from '../core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts';
+
+export class SplashRemoteBuilder
+  implements RemoteBuilder<Api<SplashBackend>, CborHexString>
+{
+  static new(api: Api<SplashBackend>): SplashRemoteBuilder {
+    return new SplashRemoteBuilder(api);
+  }
+
+  readonly api: Api<SplashBackend>;
+
+  private constructor(api: Api<SplashBackend>) {
+    this.api = api;
+  }
+
+  sign(): Promise<
+    SignedRemoteTransaction<
+      CborHexString,
+      RemoteBuilder<Api<SplashBackend>, CborHexString>
+    >
+  > {
+    throw new Error('not implemented.');
+  }
+
+  submit(): Promise<TransactionHash> {
+    throw new Error('not implemented.');
+  }
+
+  trade(): Promise<
+    RemoteTransaction<
+      CborHexString,
+      RemoteBuilder<Api<SplashBackend>, CborHexString>
+    >
+  > {
+    return Promise.resolve(RemoteTransaction.new('', this));
+  }
+}

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

@@ -0,0 +1,25 @@
+import { RemoteTransaction } from './RemoteTransaction.ts';
+import { builderEmulator } from '../../../mocks/RemoteBuilderEmulator.ts';
+import { SignedRemoteTransaction } from '../SignedRemoteTransaction/SignedRemoteTransaction.ts';
+
+test('should creates valid instance of RemoteTransaction', async () => {
+  const remoteTransaction = RemoteTransaction.new('unsigned', builderEmulator);
+
+  expect(remoteTransaction).toBeInstanceOf(RemoteTransaction);
+  expect(remoteTransaction.serialization).toBe('unsigned');
+});
+
+test('sign should returns signed transaction', async () => {
+  const remoteTransaction = RemoteTransaction.new('unsigned', builderEmulator);
+  const signedRemoteTransaction = await remoteTransaction.sign();
+
+  expect(signedRemoteTransaction).toBeInstanceOf(SignedRemoteTransaction);
+  expect(signedRemoteTransaction.serialization).toBe('signed');
+});
+
+test('signAndSubmit should returns transaction hash', async () => {
+  const remoteTransaction = RemoteTransaction.new('unsigned', builderEmulator);
+  const hash = await remoteTransaction.signAndSubmit();
+
+  expect(hash).toBe('submitted');
+});

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

@@ -0,0 +1,40 @@
+import { RemoteBuilder } from '../../types/RemoteBuilder.ts';
+import { Api, Backend } from '@splashprotocol/api';
+import { SignedRemoteTransaction } from '../SignedRemoteTransaction/SignedRemoteTransaction.ts';
+import { TransactionHash } from '@splashprotocol/core';
+
+/**
+ * Remote transaction representation
+ */
+export class RemoteTransaction<
+  S,
+  RB extends RemoteBuilder<Api<Backend<{}>>, S>,
+> {
+  static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(
+    serialization: S,
+    builder: RB,
+  ): RemoteTransaction<S, RB> {
+    return new RemoteTransaction(serialization, builder);
+  }
+
+  /**
+   * Transaction serialization
+   * @type {S}
+   */
+  readonly serialization: S;
+
+  private constructor(
+    serialization: S,
+    private builder: RB,
+  ) {
+    this.serialization = serialization;
+  }
+
+  sign(): Promise<SignedRemoteTransaction<S, RB>> {
+    return this.builder.sign(this) as any;
+  }
+
+  signAndSubmit(): Promise<TransactionHash> {
+    return this.sign().then((srt) => srt.submit());
+  }
+}

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

@@ -0,0 +1,21 @@
+import { builderEmulator } from '../../../mocks/RemoteBuilderEmulator.ts';
+import { SignedRemoteTransaction } from './SignedRemoteTransaction.ts';
+
+test('should creates valid instance of SignedRemoteTransaction', () => {
+  const signedRemoteTransaction = SignedRemoteTransaction.new(
+    'signed',
+    builderEmulator,
+  );
+
+  expect(signedRemoteTransaction).toBeInstanceOf(SignedRemoteTransaction);
+  expect(signedRemoteTransaction.serialization).toBe('signed');
+});
+
+test('submit should returns transaction hash', async () => {
+  const signedRemoteTransaction = SignedRemoteTransaction.new(
+    'signed',
+    builderEmulator,
+  );
+
+  expect(await signedRemoteTransaction.submit()).toBe('submitted');
+});

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

@@ -0,0 +1,32 @@
+import { RemoteBuilder } from '../../types/RemoteBuilder.ts';
+import { Api, Backend } from '@splashprotocol/api';
+import { TransactionHash } from '@splashprotocol/core';
+
+export class SignedRemoteTransaction<
+  S,
+  RB extends RemoteBuilder<Api<Backend<{}>>, S>,
+> {
+  static new<S, RB extends RemoteBuilder<Api<Backend<{}>>, S>>(
+    serialization: S,
+    builder: RB,
+  ): SignedRemoteTransaction<S, RB> {
+    return new SignedRemoteTransaction(serialization, builder);
+  }
+
+  /**
+   * Transaction serialization
+   * @type {S}
+   */
+  readonly serialization: S;
+
+  private constructor(
+    serialization: S,
+    private builder: RB,
+  ) {
+    this.serialization = serialization;
+  }
+
+  submit(): Promise<TransactionHash> {
+    return this.builder.submit(this);
+  }
+}

package/src/core/types/RemoteBuilder.ts

@@ -0,0 +1,16 @@
+import { Api, Backend } from '@splashprotocol/api';
+import { RemoteTransaction } from '../models/RemoteTransaction/RemoteTransaction.ts';
+import { SignedRemoteTransaction } from '../models/SignedRemoteTransaction/SignedRemoteTransaction.ts';
+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>>>;
+
+  submit(
+    signedTx: SignedRemoteTransaction<S, RemoteBuilder<A, S>>,
+  ): Promise<TransactionHash>;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+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';

package/src/mocks/BackendEmulator.ts

@@ -0,0 +1,10 @@
+import { Backend } from '@splashprotocol/api';
+import { AssetInfoMetadata, Network } from '@splashprotocol/core';
+
+export class BackendEmulator implements Backend<BackendEmulator> {
+  network: Network = 'mainnet';
+
+  getAssetMetadata(): Promise<AssetInfoMetadata | undefined> {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/mocks/RemoteBuilderEmulator.ts

@@ -0,0 +1,26 @@
+import { RemoteBuilder } from '../core/types/RemoteBuilder.ts';
+import { BackendEmulator } from './BackendEmulator.ts';
+import { HexString, TransactionHash } from '@splashprotocol/core';
+import { Api, createApi } from '@splashprotocol/api';
+import { SignedRemoteTransaction } from '../core/models/SignedRemoteTransaction/SignedRemoteTransaction.ts';
+
+export class RemoteBuilderEmulator
+  implements RemoteBuilder<Api<BackendEmulator>, HexString>
+{
+  sign(): Promise<
+    SignedRemoteTransaction<
+      HexString,
+      RemoteBuilder<Api<BackendEmulator>, HexString>
+    >
+  > {
+    return Promise.resolve(SignedRemoteTransaction.new('signed', this));
+  }
+  submit(): Promise<TransactionHash> {
+    return Promise.resolve('submitted');
+  }
+
+  constructor(public api: Api<BackendEmulator>) {}
+}
+
+const api = createApi(new BackendEmulator());
+export const builderEmulator = new RemoteBuilderEmulator(api);

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@splashprotocol/typescript-config/base.json",
+  "include": [
+    "./src"
+  ],
+  "exclude": ["dist","node_modules"]
+}