[PAY-2689] Send tips via SDK (behind feature flag)

packages/common/src/services/remote-config/feature-flags.ts

@@ -58,6 +58,8 @@ export enum FeatureFlags {
  TIKTOK_NATIVE_AUTH = 'tiktok_native_auth',
  PREMIUM_ALBUMS_ENABLED = 'premium_albums_enabled',
  REWARDS_COOLDOWN = 'rewards_cooldown',
+ USE_SDK_TIPS = 'use_sdk_tips',
+ USE_SDK_REWARDS = 'use_sdk_rewards',
  DISCOVERY_TIP_REACTIONS = 'discovery_tip_reactions'
 }
 
@@ -132,5 +134,7 @@ export const flagDefaults: FlagDefaults = {
  [FeatureFlags.TIKTOK_NATIVE_AUTH]: true,
  [FeatureFlags.PREMIUM_ALBUMS_ENABLED]: false,
  [FeatureFlags.REWARDS_COOLDOWN]: false,
+ [FeatureFlags.USE_SDK_TIPS]: false,
+ [FeatureFlags.USE_SDK_REWARDS]: false,
  [FeatureFlags.DISCOVERY_TIP_REACTIONS]: false
 }

packages/discovery-provider/plugins/pedalboard/apps/solana-relay/src/routes/relay/relay.ts

@@ -25,8 +25,22 @@ const connections = config.solanaEndpoints.map(
  (endpoint) => new Connection(endpoint)
 )
 
-const delay = async (ms: number) => {
- return await new Promise((resolve) => setTimeout(() => resolve, ms))
+const delay = async (ms: number, options?: { signal: AbortSignal }) => {
+ const signal = options?.signal
+ return new Promise<void>((resolve, reject) => {
+ if (signal?.aborted) {
+ reject()
+ }
+ const listener = () => {
+ clearTimeout(timer)
+ reject()
+ }
+ const timer = setTimeout(() => {
+ signal?.removeEventListener('abort', listener)
+ resolve()
+ }, ms)
+ signal?.addEventListener('abort', listener)
+ })
 }
 
 const getFeePayerKeyPair = (feePayerPublicKey?: PublicKey) => {
@@ -104,54 +118,75 @@ const sendTransactionWithRetries = async ({
  logger: Logger
 }) => {
  const serializedTx = transaction.serialize()
- const connection = connections[0]
 
- const createRetryPromise = async (): Promise<void> => {
- let retryCount = 0
- while (true) {
- await delay(RETRY_DELAY_MS)
- // Explicitly not awaited, sent in the background
- logger.info({ retryCount }, 'Attempting send...')
- try {
- Promise.any(
- connections.map((connection) =>
- connection.sendRawTransaction(serializedTx, sendOptions)
- )
- )
- } catch (error) {
- logger.warn(
- { error, retryCount, rpcEndpoint: connection.rpcEndpoint },
- `Failed retry...`
+ let retryCount = 0
+ const createRetryPromise = async (signal: AbortSignal): Promise<void> => {
+ while (!signal.aborted) {
+ Promise.any(
+ connections.map((connection) =>
+ connection.sendRawTransaction(serializedTx, {
+ skipPreflight: true,
+ maxRetries: 0,
+ ...sendOptions
+ })
  )
- }
+ ).catch((error) => {
+ logger.warn({ error, retryCount }, `Failed retry...`)
+ })
+ await delay(RETRY_DELAY_MS)
+ retryCount++
  }
  }
 
- const createTimeoutPromise = async () => {
+ const createTimeoutPromise = async (signal: AbortSignal) => {
  await delay(RETRY_TIMEOUT_MS)
- logger.error('Timed out sending transaction')
+ if (!signal.aborted) {
+ logger.error('Timed out sending transaction')
+ }
  }
 
  const start = Date.now()
+ const connection = connections[0]
+ const abortController = new AbortController()
+ try {
+ if (!sendOptions?.skipPreflight) {
+ const simulatedRes = await connection.simulateTransaction(transaction)
+ if (simulatedRes.value.err) {
+ logger.error(
+ { error: simulatedRes.value.err },
+ 'Transaction simulation failed'
+ )
+ throw simulatedRes.value.err
+ }
+ }
 
- const res = await Promise.race([
- createRetryPromise(),
- connection.confirmTransaction(confirmationStrategy, commitment),
-createTimeoutPromise()
-])
-
-const end = Date.now()
-const elapsedMs = end - start
+const res = await Promise.race([
+createRetryPromise(abortController.signal),
+connection.confirmTransaction(
+ { ...confirmationStrategy, abortSignal: abortController.signal },
+ commitment
+ ),
+ createTimeoutPromise(abortController.signal)
+ ])
 
- if (!res || res.value.err) {
+ if (!res || res.value.err) {
+ throw res?.value.err ?? 'Transaction polling timed out.'
+ }
+ logger.info({ commitment }, 'Transaction sent successfully')
+ return confirmationStrategy.signature
+ } catch (error) {
+ logger.error({ error }, 'Transaction failed to send')
+ throw error
+ } finally {
+ // Stop the other operations
+ abortController.abort()
+ const end = Date.now()
+ const elapsedMs = end - start
  logger.info(
- { error: res?.value.err ?? 'timeout', commitment, elapsedMs },
- 'Transaction failed to send'
+ { elapsedMs, retryCount },
+ 'sendTransactionWithRetries completed.'
  )
- throw new Error('Transaction failed to send')
  }
- logger.info({ commitment, elapsedMs }, 'Transaction sent successfully')
- return confirmationStrategy.signature
 }
 
 export const relay = async (
@@ -188,7 +223,10 @@ export const relay = async (
  const signature = base58.encode(transaction.signatures[0])
 
  const logger = res.locals.logger.child({ signature })
- logger.info('Sending transaction...')
+ logger.info(
+ { rpcEndpoints: connections.map((c) => c.rpcEndpoint) },
+ 'Sending transaction...'
+ )
  const confirmationStrategy = { ...strategy, signature }
  await sendTransactionWithRetries({
  transaction,
@@ -220,6 +258,11 @@ export const relay = async (
  await forwardTransaction(logger, formattedResponse)
  logger.info('Request finished.')
  } catch (e) {
- next(e)
+ if (!res.writableEnded && e) {
+ res.status(500).send({ error: e })
+ next()
+ } else {
+ next(e)
+ }
  }
 }

packages/libs/src/sdk/services/AntiAbuseOracle/AntiAbuseOracle.ts

@@ -19,6 +19,7 @@ export class AntiAbuseOracle extends BaseAPI implements AntiAbuseOracleService {
  constructor({ antiAbuseOracleSelector }: AntiAbuseOracleConfig) {
  super(
  new runtime.Configuration({
+ basePath: '',
  fetchApi: fetch,
  middleware: [antiAbuseOracleSelector.createMiddleware()]
  })

packages/spl/src/layout-utils.ts

@@ -57,7 +57,7 @@ export class BorshString extends Layout<string> {
 
  getSpan(b: Uint8Array, offset = 0): number {
  if (!b) {
- return this.maxLength
+ return u32().span + this.maxLength
  }
  const length = u32().decode(b, offset)
  return u32().span + length