@ultraos/wallet-sdk 0.0.2

package/src/lib/ultra-wallet-sdk.spec.ts

@@ -0,0 +1,90 @@
+import { UltraWalletSDK } from './ultra-wallet-sdk';
+import { ExtensionProvider, WebProvider } from './providers';
+import * as detectionUtils from './utils/detection';
+import { ConnectParams, PurchaseItemType } from './interfaces';
+
+jest.mock('./providers/extension-provider/extension.provider');
+jest.mock('./providers/web-provider/web.provider');
+jest.mock('./utils/detection');
+
+describe('UltraWalletSDK', () => {
+  let sdk: UltraWalletSDK;
+  let connectSpy: jest.Mock;
+  let disconnectSpy: jest.Mock;
+  let signMessageSpy: jest.Mock;
+  let signTransactionSpy: jest.Mock;
+  let getChainIdSpy: jest.Mock;
+  let purchaseItemSpy: jest.Mock;
+
+  beforeEach(() => {
+    connectSpy = jest.fn();
+    disconnectSpy = jest.fn();
+    signMessageSpy = jest.fn();
+    signTransactionSpy = jest.fn();
+    getChainIdSpy = jest.fn();
+    purchaseItemSpy = jest.fn();
+
+    (detectionUtils.isExtensionAvailable as jest.Mock).mockReturnValue(true);
+    (ExtensionProvider as jest.Mock).mockImplementation(() => ({
+      connect: connectSpy,
+      disconnect: disconnectSpy,
+      signMessage: signMessageSpy,
+      signTransaction: signTransactionSpy,
+      getChainId: getChainIdSpy,
+      purchaseItem: purchaseItemSpy,
+    }));
+  });
+
+  it('should use ExtensionProvider when extension is available', () => {
+    sdk = new UltraWalletSDK();
+    expect(sdk).toBeTruthy();
+  });
+
+  it('should use WebProvider when extension is not available', () => {
+    (detectionUtils.isExtensionAvailable as jest.Mock).mockReturnValue(false);
+    (WebProvider as unknown as jest.Mock).mockImplementation(() => ({
+      connect: connectSpy,
+    }));
+
+    sdk = new UltraWalletSDK({ environment: 'testnet' });
+    expect(sdk).toBeTruthy();
+  });
+
+  it('should delegate connect to the provider', async () => {
+    sdk = new UltraWalletSDK();
+    const params: ConnectParams = { onlyIfTrusted: true };
+    await sdk.connect(params);
+    expect(connectSpy).toHaveBeenCalledWith(params);
+  });
+
+  it('should delegate disconnect to the provider', async () => {
+    sdk = new UltraWalletSDK();
+    await sdk.disconnect();
+    expect(disconnectSpy).toHaveBeenCalled();
+  });
+
+  it('should delegate signMessage to the provider', async () => {
+    sdk = new UltraWalletSDK();
+    await sdk.signMessage('hello');
+    expect(signMessageSpy).toHaveBeenCalledWith('hello');
+  });
+
+  it('should delegate signTransaction to the provider', async () => {
+    sdk = new UltraWalletSDK();
+    const transaction = { contract: 'test', action: 'test', data: {}, authorizations: [] };
+    await sdk.signTransaction(transaction);
+    expect(signTransactionSpy).toHaveBeenCalledWith(transaction);
+  });
+
+  it('should delegate getChainId to the provider', async () => {
+    sdk = new UltraWalletSDK();
+    await sdk.getChainId();
+    expect(getChainIdSpy).toHaveBeenCalled();
+  });
+
+  it('should delegate purchaseItem to the provider', async () => {
+    sdk = new UltraWalletSDK();
+    await sdk.purchaseItem(PurchaseItemType.UNIQ_FACTORY, 'item123');
+    expect(purchaseItemSpy).toHaveBeenCalledWith('UniqFactory', 'item123');
+  });
+});

package/src/lib/ultra-wallet-sdk.ts

@@ -0,0 +1,67 @@
+import {
+  BlockchainTransaction,
+  ConnectParams,
+  ConnectResult,
+  PurchaseItemResult,
+  PurchaseItemType,
+  SignMessageResult,
+  SignTransactionResult,
+  UltraResponse,
+  UltraWalletProvider,
+  UltraWalletSdkOptions,
+} from './interfaces';
+import { ExtensionProvider, WebProvider } from './providers';
+import { isExtensionAvailable } from './utils/detection';
+
+/**
+ * UltraWalletClient acts as a Facade for interacting with the Ultra Wallet.
+ * It provides a unified API regardless of the underlying provider implementation (Extension or Web).
+ */
+export class UltraWalletSDK {
+  private provider: UltraWalletProvider;
+
+  /**
+   * Constructs an UltraWalletClient instance.
+   * If the Ultra Wallet Extension is available (window.ultra), it will be used automatically.
+   * If the Extension is not available, the Web Wallet provider will be initialized using the given network options.
+   *
+   * @param {UltraWalletSdkOptions} [options] - Configuration options for the Web Wallet fallback (environment or custom URL).
+   */
+  constructor(private readonly options?: UltraWalletSdkOptions) {
+    this.provider = this.resolveWalletProvider();
+  }
+
+  connect(params?: ConnectParams): Promise<UltraResponse<ConnectResult>> {
+    return this.provider.connect(params);
+  }
+
+  disconnect(): Promise<UltraResponse<boolean>> {
+    return this.provider.disconnect();
+  }
+
+  signMessage(message: string): Promise<UltraResponse<SignMessageResult>> {
+    return this.provider.signMessage(message);
+  }
+
+  signTransaction(
+    transaction: BlockchainTransaction | BlockchainTransaction[],
+  ): Promise<UltraResponse<SignTransactionResult>> {
+    return this.provider.signTransaction(transaction);
+  }
+
+  getChainId(): Promise<UltraResponse<string>> {
+    return this.provider.getChainId();
+  }
+
+  purchaseItem(itemType: PurchaseItemType, itemId: string): Promise<UltraResponse<PurchaseItemResult>> {
+    return this.provider.purchaseItem(itemType, itemId);
+  }
+
+  private resolveWalletProvider(): UltraWalletProvider {
+    if (isExtensionAvailable()) {
+      return new ExtensionProvider();
+    } else {
+      return new WebProvider(this.options);
+    }
+  }
+}

package/src/lib/utils/chain-validator.ts

@@ -0,0 +1,6 @@
+import UltraWalletSdkConfig from '../config/ultra-wallet-sdk.config';
+
+export function isValidChain(targetNetwork: string, walletChainId: string): boolean {
+  const { chainId } = UltraWalletSdkConfig.networkInfo[targetNetwork] || {};
+  return !chainId || chainId === walletChainId;
+}

package/src/lib/utils/detection.ts

@@ -0,0 +1,3 @@
+export function isExtensionAvailable(): boolean {
+  return typeof window !== 'undefined' && 'ultra' in window;
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "target": "es2020"
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": ["chrome"]
+  },
+  "files": ["src/index.ts"],
+  "exclude": ["src/**/*.spec.ts", "jest.config.ts", "src/**/*.test.ts"]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": ["jest"]
+  },
+  "include": ["**/*.spec.ts", "**/*.d.ts"]
+}