Configura tu servidor para interactuar con el widget de Fluz JS

La instalación del widget de Javascript de Fluz es relativamente sencilla. Debes incrustar o importar el Javascript en una página de tu sitio. Una vez que el javascript haya cargado, puedes vincular un elemento de la UI para abrir el modal de javascript incluido como parte del javascript importado. También debes incluir un JWT que preautorice al usuario a completar una transacción en particular, como se describe a continuación.

Crea un token de “Transacción preaprobada”.

Dado que el usuario está interactuando con la plataforma de Fluz para mover dinero hacia y desde tu cuenta de gasto, cualquier interacción con el widget debe incluir un token JWT firmado que, en efecto, “preautoriza” al usuario para completar la transacción. Lo que esto significa es que, por ejemplo, si el usuario “abc123” tiene $50 en su cuenta de operador que desea retirar a Fluz, generas un patToken que Fluz puede usar para validar la transacción y el monto. Este patToken contiene el amount, tu apiKey, el transactionType, el externalId, datos del usuario y luego un JTI. Este token se firma con tu apiSecret que se puede encontrar en los detalles de tu app en la sección for-developers de Fluz.

key	value
amount	el monto en dólares y centavos con el que el usuario está aprobado para transaccionar
transactionType	`DEPOSIT` o `WITHDRAW`. `DEPOSIT` significa que el usuario está ingresando dinero a Fluz y luego moviéndolo a tu cuenta de gasto de operador. `WITHDRAW` significa que el usuario está haciendo un pago desde tu cuenta de gasto de operador hacia su cuenta de Fluz.
apiKey	la clave de API de tu app
externalId	Tu identificador único para tu usuario. Puede ser un userId, accountId, número de teléfono, dirección de correo electrónico: lo que uses en tu sistema. Proporcionaremos esto cuando te enviemos información como eventos de webhook, para que puedas mapear al usuario en tu sistema.
jti	un UUID v4 que se genera cuando procedes a firmar el token. Usamos este token para idempotencia. Puedes leer más en la especificación oficial de jti.
phoneNumber (optional)	una cadena con el número de teléfono del usuario. Si se envía, el usuario omitirá el paso Enter the phone number del inicio de sesión/registro y pasará directamente al paso Enter the two-factor-authentication code
firstName (optional)	una cadena con el nombre del usuario
lastName (optional)	una cadena con el apellido del usuario
email (optional)	una cadena con el correo electrónico del usuario
username (optional)	una cadena con el nombre de usuario

Fragmentos de código para generar el JWT

JavaScript

import jwt from 'jsonwebtoken';

const { sign } = jwt;
const amount = 0; // Pass in the amount here
const transactionType = ""; // DEPOSIT or WITHDRAW
const externalId = ""; // This is your unique identifier. It might be a userID, accountID.

const jti = uuidv4();

const secret = ""; // Your api secret

const generatedToken = sign({
  amount,
  apiKey: "", // Your apiKey
  transactionType,
  externalId,
  jti,
}, secret, { expiresIn: '1 day' });

Ruby

Instalación: gem install jwt

require 'jwt'
require 'securerandom'

amount = 0 # Pass in the amount here
transaction_type = "" # DEPOSIT or WITHDRAW
external_id = "" # This is your unique identifier. It might be a userID, accountID.

jti = SecureRandom.uuid

secret = "" # Your api secret

payload = {
  amount: amount,
  apiKey: "", # Your apiKey
  transactionType: transaction_type,
  externalId: external_id,
  jti: jti,
  exp: Time.now.to_i + (24 * 60 * 60) # 1 day
}

generated_token = JWT.encode(payload, secret, 'HS256')
puts generated_token

Python

Instalación: pip install PyJWT

import jwt
import uuid
from datetime import datetime, timedelta

amount = 0  # Pass in the amount here
transaction_type = "" # DEPOSIT or WITHDRAW
external_id = ""  # This is your unique identifier. It might be a userID, accountID.

jti = str(uuid.uuid4())

secret = ""  # Your API_SECRET. Please reach out to your Fluz account manager if you do not have this.

payload = {
    "amount": amount,
    "apiKey": "", # Your apiKey
    "transactionType": transaction_type,
    "externalId": external_id,
    "jti": jti,
    "exp": datetime.utcnow() + timedelta(days=1)
}

generated_token = jwt.encode(payload, secret, algorithm="HS256")
print(generated_token)

Go

package main

import (
    "fmt"
    "time"
    "github.com/golang-jwt/jwt/v5"
    "github.com/google/uuid"
)

func main() {
    amount := 0 // Pass in the amount here
    transactionType := "" // DEPOSIT or WITHDRAW
    externalId := "" // This is your unique identifier. It might be a userID, accountID.
    
    jti := uuid.New().String()
    
    secret := "" // Your api_secret
    
    claims := jwt.MapClaims{
        "amount":          amount,
        "apiKey":          "", // your api_key
        "transactionType": transactionType,
        "externalId":      externalId,
        "jti":             jti,
        "exp":             time.Now().Add(24 * time.Hour).Unix(),
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    generatedToken, err := token.SignedString([]byte(secret))
    
    if err != nil {
        fmt.Println("Error generating token:", err)
        return
    }
    
    fmt.Println(generatedToken)
}

Java

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class JwtGenerator {
    public static void main(String[] args) {
        int amount = 0; // Pass in the amount here
        String transactionType = ""; // DEPOSIT or WITHDRAW
        String externalId = ""; // This is your unique identifier. It might be a userID, accountID.
        
        String jti = UUID.randomUUID().toString();
        
        String secret = ""; // Your api_secret
        
        Map<String, Object> claims = new HashMap<>();
        claims.put("amount", amount);
        claims.put("apiKey", ""); // your api_key
        claims.put("transactionType", transactionType);
        claims.put("externalId", externalId);
        
        long expirationTime = System.currentTimeMillis() + (24 * 60 * 60 * 1000); // 1 day
        
        String generatedToken = Jwts.builder()
                .setClaims(claims)
                .setId(jti)
                .setExpiration(new Date(expirationTime))
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
        
        System.out.println(generatedToken);
    }
}
     

PHP

<?php

require 'vendor/autoload.php';

use Firebase\JWT\JWT;
use Ramsey\Uuid\Uuid;

$amount = 0; // Pass in the amount here
$transactionType = ""; // DEPOSIT or WITHDRAW
$externalId = ""; // This is your unique identifier. It might be a userID, accountID.

$jti = Uuid::uuid4()->toString();

$secret = ""; // Your api_secret

$payload = [
    "amount" => $amount,
    "apiKey" => "", // your api_key
    "transactionType" => $transactionType,
    "externalId" => $externalId,
    "jti" => $jti,
    "exp" => time() + (24 * 60 * 60) // 1 day
];

$generatedToken = JWT::encode($payload, $secret, 'HS256');
echo $generatedToken;
?>

C# (.NET)

using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using Microsoft.IdentityModel.Tokens;
using System.Text;

class JwtGenerator
{
    static void Main()
    {
        int amount = 0; // Pass in the amount here
        string transactionType = ""; // DEPOSIT or WITHDRAW
        string externalId = ""; // This is your unique identifier. It might be a userID, accountID.
        
        string jti = Guid.NewGuid().ToString();
        
        string secret = ""; // Your api_secret
        
        var claims = new List<Claim>
        {
            new Claim("amount", amount.ToString()),
            new Claim("apiKey", ""), // your api_key
            new Claim("transactionType", transactionType),
            new Claim("externalId", externalId),
            new Claim(JwtRegisteredClaimNames.Jti, jti)
        };
        
        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret));
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
        
        var token = new JwtSecurityToken(
            claims: claims,
            expires: DateTime.UtcNow.AddDays(1),
            signingCredentials: creds
        );
        
        var generatedToken = new JwtSecurityTokenHandler().WriteToken(token);
        Console.WriteLine(generatedToken);
    }
}

​Crea un token de “Transacción preaprobada”.

​Fragmentos de código para generar el JWT

​JavaScript

​Ruby

​Python

​Go

​Java

​PHP

​C# (.NET)