@portal-hq/web 3.12.0 → 3.13.0-alpha.0

package/lib/esm/integrations/ramps/noah/index.test.js

@@ -0,0 +1,151 @@
+/**
+ * @jest-environment jsdom
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Mpc from '../../../mpc';
+import Noah from '.';
+import portalMock from '../../../__mocks/portal/portal';
+import { mockHost } from '../../../__mocks/constants';
+const TRUSTED_KYC_HOST = 'kyc.example';
+const openTrustedUrl = (url) => {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch (_a) {
+        throw new Error('Invalid hostedUrl');
+    }
+    if (parsed.protocol !== 'https:' || parsed.hostname !== TRUSTED_KYC_HOST) {
+        throw new Error('Untrusted hostedUrl origin');
+    }
+    return window.open(parsed.toString(), '_blank', 'noopener,noreferrer');
+};
+describe('Noah', () => {
+    let mpc;
+    let noah;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portalMock.host = mockHost;
+        mpc = new Mpc({
+            portal: portalMock,
+        });
+        noah = new Noah({ mpc });
+    });
+    it('should call mpc.initiateKyc with the request', () => __awaiter(void 0, void 0, void 0, function* () {
+        const spy = jest.spyOn(mpc, 'initiateKyc').mockResolvedValue({
+            data: {
+                hostedUrl: 'https://kyc.example',
+            },
+        });
+        const openSpy = jest.spyOn(window, 'open').mockImplementation(() => null);
+        const body = { returnUrl: 'https://app.example/cb' };
+        const result = yield noah.initiateKyc(body);
+        expect(spy).toHaveBeenCalledWith(body);
+        expect(result.data.hostedUrl).toBe('https://kyc.example');
+        openTrustedUrl(result.data.hostedUrl);
+        expect(openSpy).toHaveBeenCalledWith('https://kyc.example/', '_blank', 'noopener,noreferrer');
+        openSpy.mockRestore();
+    }));
+    it('should call mpc.initiatePayin', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = {
+            fiatCurrency: 'USD',
+            cryptoCurrency: 'USDC_TEST',
+            network: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+            destinationAddress: 'SoLAddr1111111111111111111111111111111111111',
+        };
+        const spy = jest.spyOn(mpc, 'initiatePayin').mockResolvedValue({
+            data: { payinId: 'p1', bankDetails: {} },
+        });
+        yield noah.initiatePayin(req);
+        expect(spy).toHaveBeenCalledWith(req);
+    }));
+    it('should call mpc.simulatePayin with sandbox body', () => __awaiter(void 0, void 0, void 0, function* () {
+        const sim = {
+            paymentMethodId: 'pm-1',
+            fiatAmount: '10',
+            fiatCurrency: 'USD',
+        };
+        const spy = jest.spyOn(mpc, 'simulatePayin').mockResolvedValue({
+            data: {},
+        });
+        yield noah.simulatePayin(sim);
+        expect(spy).toHaveBeenCalledWith(sim);
+    }));
+    it('should call mpc.getPayoutCountries', () => __awaiter(void 0, void 0, void 0, function* () {
+        const spy = jest.spyOn(mpc, 'getPayoutCountries').mockResolvedValue({
+            data: { countries: [] },
+        });
+        yield noah.getPayoutCountries();
+        expect(spy).toHaveBeenCalled();
+    }));
+    it('should call mpc.getPayoutChannels', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = {
+            country: 'US',
+            cryptoCurrency: 'USDC_TEST',
+            fiatCurrency: 'USD',
+            fiatAmount: '10',
+        };
+        const spy = jest.spyOn(mpc, 'getPayoutChannels').mockResolvedValue({
+            data: [],
+        });
+        yield noah.getPayoutChannels(req);
+        expect(spy).toHaveBeenCalledWith(req);
+    }));
+    it('should call mpc.getPayoutChannelForm', () => __awaiter(void 0, void 0, void 0, function* () {
+        const spy = jest
+            .spyOn(mpc, 'getPayoutChannelForm')
+            .mockResolvedValue({ data: {} });
+        yield noah.getPayoutChannelForm('ch-1');
+        expect(spy).toHaveBeenCalledWith('ch-1');
+    }));
+    it('should call mpc.getPayoutQuote', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = {
+            channelId: 'ch-1',
+            cryptoCurrency: 'USDC_TEST',
+            fiatAmount: '10',
+        };
+        const spy = jest.spyOn(mpc, 'getPayoutQuote').mockResolvedValue({
+            data: {
+                payoutId: 'out-1',
+                formSessionId: 'fs-1',
+                cryptoAmountEstimate: '10',
+                totalFee: '0.01',
+            },
+        });
+        yield noah.getPayoutQuote(req);
+        expect(spy).toHaveBeenCalledWith(req);
+    }));
+    it('should call mpc.initiatePayout', () => __awaiter(void 0, void 0, void 0, function* () {
+        const expiry = new Date(Date.now() + 24 * 60 * 60 * 1000)
+            .toISOString()
+            .replace(/\.\d{3}Z$/, 'Z');
+        const nonce = `nonce-${Date.now()}-${Math.floor(Math.random() * 1e9)}`;
+        const req = {
+            payoutId: 'p1',
+            sourceAddress: 'SoLAddr1111111111111111111111111111111111111',
+            expiry,
+            nonce,
+            network: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+        };
+        const spy = jest.spyOn(mpc, 'initiatePayout').mockResolvedValue({
+            data: { destinationAddress: 'dest', conditions: [] },
+        });
+        yield noah.initiatePayout(req);
+        expect(spy).toHaveBeenCalledWith(req);
+    }));
+    it('should call mpc.getPaymentMethods', () => __awaiter(void 0, void 0, void 0, function* () {
+        const spy = jest.spyOn(mpc, 'getPaymentMethods').mockResolvedValue({
+            data: { paymentMethods: [] },
+        });
+        yield noah.getPaymentMethods();
+        expect(spy).toHaveBeenCalled();
+    }));
+});

package/lib/esm/mpc/index.js

@@ -11,7 +11,7 @@ import { PortalMpcError } from './errors';
 import { sdkLogger } from '../logger';
 import { BackupMethods, } from '../index';
 import { generateTraceId } from '../shared/trace';
-const WEB_SDK_VERSION = '3.12.0';
+const WEB_SDK_VERSION = '3.13.0-alpha.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -515,6 +515,100 @@ class Mpc {
             });
         });
     }
+    /**
+     * Noah ramp: postMessage bridge to the Portal iframe (connect-api).
+     * Application code should call `portal.ramps.noah` instead of Mpc directly.
+     */
+    initiateKyc(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:initiateKyc',
+                errorMessage: 'portal:noah:initiateKycError',
+                resultMessage: 'portal:noah:initiateKycResult',
+                data,
+            });
+        });
+    }
+    initiatePayin(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:initiatePayin',
+                errorMessage: 'portal:noah:initiatePayinError',
+                resultMessage: 'portal:noah:initiatePayinResult',
+                data,
+            });
+        });
+    }
+    simulatePayin(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:simulatePayin',
+                errorMessage: 'portal:noah:simulatePayinError',
+                resultMessage: 'portal:noah:simulatePayinResult',
+                data,
+            });
+        });
+    }
+    getPayoutCountries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:getPayoutCountries',
+                errorMessage: 'portal:noah:getPayoutCountriesError',
+                resultMessage: 'portal:noah:getPayoutCountriesResult',
+                data: {},
+            });
+        });
+    }
+    getPayoutChannels(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:getPayoutChannels',
+                errorMessage: 'portal:noah:getPayoutChannelsError',
+                resultMessage: 'portal:noah:getPayoutChannelsResult',
+                data,
+            });
+        });
+    }
+    getPayoutChannelForm(channelId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:getPayoutChannelForm',
+                errorMessage: 'portal:noah:getPayoutChannelFormError',
+                resultMessage: 'portal:noah:getPayoutChannelFormResult',
+                data: channelId,
+            });
+        });
+    }
+    getPayoutQuote(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:getPayoutQuote',
+                errorMessage: 'portal:noah:getPayoutQuoteError',
+                resultMessage: 'portal:noah:getPayoutQuoteResult',
+                data,
+            });
+        });
+    }
+    initiatePayout(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:initiatePayout',
+                errorMessage: 'portal:noah:initiatePayoutError',
+                resultMessage: 'portal:noah:initiatePayoutResult',
+                data,
+            });
+        });
+    }
+    getPaymentMethods() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:noah:getPaymentMethods',
+                errorMessage: 'portal:noah:getPaymentMethodsError',
+                resultMessage: 'portal:noah:getPaymentMethodsResult',
+                data: {},
+            });
+        });
+    }
     getSwapsQuoteV2(data, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.handleRequestToIframeAndPost({

package/lib/esm/shared/types/index.js

@@ -13,5 +13,6 @@ export * from './api';
 export * from './yieldxyz';
 export * from './zero-x';
 export * from './lifi';
+export * from './noah';
 export * from './hypernative';
 export * from './blockaid';

package/lib/esm/shared/types/noah.js

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

package/noah-types.d.ts

@@ -0,0 +1,28 @@
+export type {
+  NoahAmountConditionRow,
+  NoahGetPaymentMethodsResponse,
+  NoahGetPaymentMethodsResponseData,
+  NoahGetPayoutChannelFormResponse,
+  NoahGetPayoutChannelsRequest,
+  NoahGetPayoutChannelsResponse,
+  NoahGetPayoutCountriesResponse,
+  NoahGetPayoutQuoteRequest,
+  NoahGetPayoutQuoteResponse,
+  NoahGetPayoutQuoteResponseData,
+  NoahInitiateKycRequest,
+  NoahInitiateKycResponse,
+  NoahInitiateKycResponseData,
+  NoahInitiatePayinRequest,
+  NoahInitiatePayinResponse,
+  NoahInitiatePayinResponseData,
+  NoahInitiatePayoutRequest,
+  NoahInitiatePayoutResponse,
+  NoahInitiatePayoutResponseData,
+  NoahPayoutConditionBlock,
+  NoahSingleOnchainDepositSourceTriggerInput,
+  NoahSimulatePayinRequest,
+  NoahSimulatePayinResponse,
+  NoahSimulatePayinResponseData,
+  NoahSolanaCaipId,
+  PortalApiSuccessEnvelope,
+} from './src/shared/types/noah'

package/package.json

@@ -3,7 +3,7 @@
   "description": "Portal MPC Support for Web",
   "author": "Portal Labs, Inc.",
   "homepage": "https://portalhq.io/",
-  "version": "3.12.0",
+  "version": "3.13.0-alpha.0",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -15,6 +15,7 @@
     "tsconfig.json",
     "hypernative.d.ts",
     "lifi-types.d.ts",
+    "noah-types.d.ts",
     "yieldxyz-types.d.ts",
     "zero-x.d.ts",
     "types.d.ts",
@@ -57,5 +58,6 @@
   },
   "dependencies": {
     "@solana/web3.js": "^1.91.8"
-  }
+  },
+  "stableVersion": "3.12.0"
 }

package/src/index.test.ts

@@ -837,7 +837,7 @@ describe('Portal', () => {
         }),
       ).rejects.toThrow(
         new Error(
-          '[Portal] Invalid "to" Solana address provided, must be 44 characters',
+          '[Portal] Invalid "to" Solana address provided (not a valid public key)',
         ),
       )
     })

package/src/index.ts

@@ -51,6 +51,7 @@ import Mpc from './mpc'
 import Provider, { RequestMethod } from './provider'
 import Yield from './integrations/yield'
 import Trading from './integrations/trading'
+import Ramps from './integrations/ramps'
 import Security from './integrations/security'
 import Delegations from './integrations/delegations'
 import PasskeyService from './passkeys'
@@ -70,6 +71,7 @@ class Portal {
   public host: string
   public mpc: Mpc
   public yield: Yield
+  public ramps: Ramps
   public trading: Trading
   public security: Security
   public evmAccountType: EvmAccountType
@@ -136,6 +138,8 @@ class Portal {
 
     this.yield = new Yield({ mpc: this.mpc })
 
+    this.ramps = new Ramps({ mpc: this.mpc })
+
     this.trading = new Trading({ mpc: this.mpc })
 
     this.security = new Security({ mpc: this.mpc })
@@ -895,6 +899,10 @@ class Portal {
     return response
   }
 
+  /**
+   * Build, sign, and broadcast a native SOL transfer on the given Solana CAIP-2 `chainId`.
+   * `to` must be a valid Solana public key (base58); `lamports` must be a positive integer.
+   */
   public async sendSol({
     chainId,
     to,
@@ -911,10 +919,16 @@ class Portal {
       )
     }
 
-    // Ensure the to address is a valid Solana address.
-    if (!to || typeof to !== 'string' || to.length !== 44) {
+    if (!to || typeof to !== 'string') {
+      throw new Error('[Portal] Invalid "to" Solana address provided')
+    }
+    const toTrimmed = to.trim()
+    let toPublicKey: PublicKey
+    try {
+      toPublicKey = new PublicKey(toTrimmed)
+    } catch {
       throw new Error(
-        '[Portal] Invalid "to" Solana address provided, must be 44 characters',
+        '[Portal] Invalid "to" Solana address provided (not a valid public key)',
       )
     }
 
@@ -956,9 +970,6 @@ class Portal {
     // The sender's public key.
     const fromPublicKey = new PublicKey(solanaAddress)
 
-    // The recipient's public key.
-    const toPublicKey = new PublicKey(to)
-
     // Create a new transaction.
     const transaction = new SolanaTransaction().add(
       SystemProgram.transfer({
@@ -1332,6 +1343,35 @@ export {
   type GetAddressesResponse,
 } from './shared/types'
 
+export type {
+  NoahAmountConditionRow,
+  NoahGetPaymentMethodsResponse,
+  NoahGetPaymentMethodsResponseData,
+  NoahGetPayoutChannelFormResponse,
+  NoahGetPayoutChannelsRequest,
+  NoahGetPayoutChannelsResponse,
+  NoahGetPayoutCountriesResponse,
+  NoahGetPayoutQuoteRequest,
+  NoahGetPayoutQuoteResponse,
+  NoahGetPayoutQuoteResponseData,
+  NoahInitiateKycRequest,
+  NoahInitiateKycResponse,
+  NoahInitiateKycResponseData,
+  NoahInitiatePayinRequest,
+  NoahInitiatePayinResponse,
+  NoahInitiatePayinResponseData,
+  NoahInitiatePayoutRequest,
+  NoahInitiatePayoutResponse,
+  NoahInitiatePayoutResponseData,
+  NoahPayoutConditionBlock,
+  NoahSingleOnchainDepositSourceTriggerInput,
+  NoahSimulatePayinRequest,
+  NoahSimulatePayinResponse,
+  NoahSimulatePayinResponseData,
+  NoahSolanaCaipId,
+  PortalApiSuccessEnvelope,
+} from './shared/types'
+
 export { MpcError, MpcErrorCodes } from './mpc'
 
 export { PortalMpcError } from './mpc/errors'

package/src/integrations/ramps/index.ts

@@ -0,0 +1,10 @@
+import Mpc from '../../mpc'
+import Noah from './noah'
+
+export default class Ramps {
+  public noah: Noah
+
+  constructor({ mpc }: { mpc: Mpc }) {
+    this.noah = new Noah({ mpc })
+  }
+}

package/src/integrations/ramps/noah/index.test.ts

@@ -0,0 +1,159 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import Mpc from '../../../mpc'
+import Noah from '.'
+import portalMock from '../../../__mocks/portal/portal'
+import { mockHost } from '../../../__mocks/constants'
+
+const TRUSTED_KYC_HOST = 'kyc.example'
+
+const openTrustedUrl = (url: string) => {
+  let parsed: URL
+  try {
+    parsed = new URL(url)
+  } catch {
+    throw new Error('Invalid hostedUrl')
+  }
+  if (parsed.protocol !== 'https:' || parsed.hostname !== TRUSTED_KYC_HOST) {
+    throw new Error('Untrusted hostedUrl origin')
+  }
+  return window.open(parsed.toString(), '_blank', 'noopener,noreferrer')
+}
+
+describe('Noah', () => {
+  let mpc: Mpc
+  let noah: Noah
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    portalMock.host = mockHost
+    mpc = new Mpc({
+      portal: portalMock,
+    })
+    noah = new Noah({ mpc })
+  })
+
+  it('should call mpc.initiateKyc with the request', async () => {
+    const spy = jest.spyOn(mpc, 'initiateKyc').mockResolvedValue({
+      data: {
+        hostedUrl: 'https://kyc.example',
+      },
+    })
+    const openSpy = jest.spyOn(window, 'open').mockImplementation(() => null)
+    const body = { returnUrl: 'https://app.example/cb' }
+    const result = await noah.initiateKyc(body)
+    expect(spy).toHaveBeenCalledWith(body)
+    expect(result.data.hostedUrl).toBe('https://kyc.example')
+    openTrustedUrl(result.data.hostedUrl)
+    expect(openSpy).toHaveBeenCalledWith(
+      'https://kyc.example/',
+      '_blank',
+      'noopener,noreferrer',
+    )
+    openSpy.mockRestore()
+  })
+
+  it('should call mpc.initiatePayin', async () => {
+    const req = {
+      fiatCurrency: 'USD',
+      cryptoCurrency: 'USDC_TEST',
+      network: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+      destinationAddress: 'SoLAddr1111111111111111111111111111111111111',
+    }
+    const spy = jest.spyOn(mpc, 'initiatePayin').mockResolvedValue({
+      data: { payinId: 'p1', bankDetails: {} },
+    })
+    await noah.initiatePayin(req)
+    expect(spy).toHaveBeenCalledWith(req)
+  })
+
+  it('should call mpc.simulatePayin with sandbox body', async () => {
+    const sim = {
+      paymentMethodId: 'pm-1',
+      fiatAmount: '10',
+      fiatCurrency: 'USD',
+    }
+    const spy = jest.spyOn(mpc, 'simulatePayin').mockResolvedValue({
+      data: {},
+    })
+    await noah.simulatePayin(sim)
+    expect(spy).toHaveBeenCalledWith(sim)
+  })
+
+  it('should call mpc.getPayoutCountries', async () => {
+    const spy = jest.spyOn(mpc, 'getPayoutCountries').mockResolvedValue({
+      data: { countries: [] },
+    })
+    await noah.getPayoutCountries()
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it('should call mpc.getPayoutChannels', async () => {
+    const req = {
+      country: 'US',
+      cryptoCurrency: 'USDC_TEST',
+      fiatCurrency: 'USD',
+      fiatAmount: '10',
+    }
+    const spy = jest.spyOn(mpc, 'getPayoutChannels').mockResolvedValue({
+      data: [],
+    } as never)
+    await noah.getPayoutChannels(req)
+    expect(spy).toHaveBeenCalledWith(req)
+  })
+
+  it('should call mpc.getPayoutChannelForm', async () => {
+    const spy = jest
+      .spyOn(mpc, 'getPayoutChannelForm')
+      .mockResolvedValue({ data: {} } as never)
+    await noah.getPayoutChannelForm('ch-1')
+    expect(spy).toHaveBeenCalledWith('ch-1')
+  })
+
+  it('should call mpc.getPayoutQuote', async () => {
+    const req = {
+      channelId: 'ch-1',
+      cryptoCurrency: 'USDC_TEST',
+      fiatAmount: '10',
+    }
+    const spy = jest.spyOn(mpc, 'getPayoutQuote').mockResolvedValue({
+      data: {
+        payoutId: 'out-1',
+        formSessionId: 'fs-1',
+        cryptoAmountEstimate: '10',
+        totalFee: '0.01',
+      },
+    })
+    await noah.getPayoutQuote(req)
+    expect(spy).toHaveBeenCalledWith(req)
+  })
+
+  it('should call mpc.initiatePayout', async () => {
+    const expiry = new Date(Date.now() + 24 * 60 * 60 * 1000)
+      .toISOString()
+      .replace(/\.\d{3}Z$/, 'Z')
+    const nonce = `nonce-${Date.now()}-${Math.floor(Math.random() * 1e9)}`
+    const req = {
+      payoutId: 'p1',
+      sourceAddress: 'SoLAddr1111111111111111111111111111111111111',
+      expiry,
+      nonce,
+      network: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+    }
+    const spy = jest.spyOn(mpc, 'initiatePayout').mockResolvedValue({
+      data: { destinationAddress: 'dest', conditions: [] },
+    })
+    await noah.initiatePayout(req)
+    expect(spy).toHaveBeenCalledWith(req)
+  })
+
+  it('should call mpc.getPaymentMethods', async () => {
+    const spy = jest.spyOn(mpc, 'getPaymentMethods').mockResolvedValue({
+      data: { paymentMethods: [] },
+    })
+    await noah.getPaymentMethods()
+    expect(spy).toHaveBeenCalled()
+  })
+})