Introducción

Además de nuestro panel web, Stamping.io tiene la capacidad de realizar el sellado de evidencia o ejecutar una función de cualquier contrato inteligente implementado en cadenas de bloques públicas a través de una integración utilizando la API de estampado. Para obtener acceso a nuestra API, debe tener una cuenta de STAMPING API donde puede obtener un token de acceso utilizando 3 métodos: (Versión 2.1) autenticación básica, (Versión 2.2) Autenticación Bearer con firmado con curva elíptica o (Nodo propio) con identidad digital (servidor o personas)

El Endpoint del servidor API Stamping puede ser centralizado (https://api.stamping.io) o descentralizado (su propia IP o dominio). En ambos casos proporciona la siguiente funcionalidad:

Autenticación con nuestro servicio (Basic o Bearer Authentication).
Permite publicar evidencia digital basada en un hash tipo SHA256 en blockchains públicas como: LACChain, POA Network, Fantom, Avalanche, Ethereum, Binance Smart Chain, Polygon o cualquier red blockchain basada en Ethereum Virtual Machine (EVM).
Interactúe (SEND/CALL) con cualquier contrato inteligente que se implemente en cadenas de bloques públicas como: LACChain, POA Network, Fantom, Avalanche, Ethereum, Binance Smart Chain, Polygon o cualquier red de cadena de bloques basada en Ethereum Virtual Machine (EVM).
Todos nuestros endpoints devuelven objetos JSON y nuestros certificados se devuelven en formato PDF.

Proporciona información del árbol Merkle a partir del estampado de un hash SHA256 que se ha anclado en cualquiera de las redes de cadena de bloques que admite Stamping.IO; si la transacción ha sido incluida en un bloque con las confirmaciones correspondientes, también es posible obtener información de la transacción (TX) de cada uno de los anclajes y el sello de tiempo respectivo.
Obtén un certificado digital con los metadatos de tus sellos y podrás compartir los certificados en PDF, este certificado se emite por cada transacción (hash SHA256) o por cada bloque creado dentro de Stamping.io.

SST - Stacking & Stamping Technology

Esta tecnología se utiliza para anclar evidencia digital basada en hashes SHA256, cuyo objetivo es reducir el tiempo de respuesta entre una aplicación que envía la transacción y la validación en las diferentes blockchains públicas.

Por ejemplo, si desea enviar evidencia digital a un contrato implementado en la red LACChain, el tiempo promedio para que la transacción sea aceptada y validada puede tomar dos (2) segundos; sin embargo, existe otra limitación que puede hacer que tarde más: el gas, lo que puede llevar a que la transacción sea rechazada o pase al siguiente bloque, lo que podría demorar dos segundos adicionales. Debido a que esta red no tiene precio de gas, podría haber una congestión que obligue a ingresar a los siguientes bloques, lo que lleva a la aplicación a esperar un largo tiempo hasta tener confirmación de que la transacción ha sido aceptada.

La tecnología SST de Stamping.io permite recibir transacciones en microsegundos, otorga un identificador que representa una promesa (TRXID), cada diez (10) minutos, un motor automatizado procederá a emitir las transacciones a las diferentes blockchains públicas, luego la aplicación podrá consultar información de anclaje utilizando Stamping API.

La tecnología Stamping.io está preparada para recibir gran cantidad de transacciones a escala industrial.

AUTENTICACIÓN BASICA

{{domain}}/stamp/

Enviar evidencia digital en Blockchains públicas

La llamada a la API "STAMP" publicará un hash en las cadenas de bloques públicas de Stamping.io. Este Endpoint también le permitirá almacenar metadatos en su sello: tipo de transacción, datos, hash2, hash3, currículum, referencia, latitud, longitud, URL o hasta. Los parámetros from & to se utilizan para compartir información de mensajes anonimizados y cifrados entre dos o más usuarios.

Puede pasar su token de acceso a través del parámetro &token si no desea utilizar la forma predeterminada de pasar un token a través de encabezados. Si desea deshabilitar la pila SST, puede enviar el parámetro async=false, en cuyo caso la transacción se registrará inmediatamente en la red blockchain de LACChain.

URL

https://api.stamping.io/stamp/?async={false | true (default)}&token={access_token}

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
evidence	Hash SHA256 del documento o datos que se desea estampar	f76809f8f7ac62f94bf554533fff70b42253ef357dc7c415019aa9cef92e15d8
async	Indicador para enviar una transacción sincrónica o asincrona. Si envia true (evidencia digital), el sistema encola la transacción y cada 10 minutos será anclada en las redes blockchain, si envía false, el sistema va a enviar esta transacción a la red blockchain de lacchain.	true or false
token	Token de acceso. Te permite identificarte sin necesidad de enviar información de autenticidad en la cabecera.	e94e0dcf378c0dc219c51305efd8d

Opcional

Parámetro	Descripción	Ejemplo
data	Datos de metadatos asociados a la evidencia. Puede ser encriptado, base64 o hexadecimal y puede estar en cualquier formato: XML, JSON o TEXT. El tamaño máximo es de 2048 bytes. Por favor, no envíe datos binarios de imágenes, fotos o videos.	{"id":"1939", "name":"x183.jMK", "type":"C38"}
transactionType	Tipo de transacción. Puede ingresar una etiqueta o espacio de nombres que le permita escribir sus registros.	pe.stamping.app
hash2	Hash SHA256 alternativo que puede estar asociado con la transacción.	533fff70b42253ef357dc7c415019aa9cef92e15d8f76809f8f7ac62f94bf554
hash3	Hash SHA256 alternativo que puede estar asociado con la transacción.	76809f8f7ac62f94bf554533fff70b42253ef357dc7c415019aa9cef92e15d8f
resume	Asunto de la transacción	certificate of studies
url	URL que puede estar asociada con la transacción. Se suele introducir la URL del documento o un informe de consulta de los datos que se han inmutado en la cadena de bloques.	https://stamping.io/files/mydocument.pdf
reference	TRXID de otra transacción a la que se hace referencia en esta transacción. Permite crear transacciones anidadas o trazabilidad de registros.	561fcbc753d95104667cbc1e4123f98ebe690ade
lat	Latitud (georreferenciación) donde se captura la evidencia digital.	-12.046373
long	Longitud (georreferenciación) donde se captura la evidencia digital.	-77.042755
to	ID de usuario (asignado por Stamping.io) de la cuenta que recibe la transacción. Este código se obtiene al crear una cuenta en la API Stamping. Por lo general, se usa cuando desea enviar una transacción a otro usuario.	fjZLakFM4HS8afF3mu0XtKVZYjaj

Respuesta

{
"code":"200: OK",
"message":"Mensaje de estado de ejecución.",
"version":"Versión de la Stamping API",
"nonce":"Código usado por Stamping.io para el firmado de la trsancción",
"async":true | false,
"trxid":"TRANSACTION_ID de Stamping.io",
"timestamp":Sello de tiempo de la transacción de Stamping.io,
"blockNumber":"Número de bloque en la red LACChain (funciona cuando async=false)",
"lacchainId":"Hash SHA256 de la transacción en la red LACChain (funciona cuando async=false)",
"credential":"JSON - Credencial verificable (W3C y EIP712&EIP1812) (funciona cuando async=false)">
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/stamp/?async=true&evidence=<hash SHA256>',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic <Token Access>'
  ),
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/stamp/?async=true&evidence=<hash SHA256&gt");
xhr.setRequestHeader("Authorization", "Basic <Token Access>");
xhr.send();

Validador de transacciones

Si desea validar sus transacciones, puede dirigir la URI de su código QR a la siguiente URL: https://stamping.io/es/view/?<TrxID>

Información importante

Si envía la URI de una imagen en el valor del parámetro URL, esa imagen se mostrará en el visor; sin embargo, si envía un URI de documento PDF, se mostrará la imagen de la primera página del documento. En ambos casos, se muestra al usuario la posibilidad de compartirlo en redes sociales o descargar el valor de la URL original.
Si envía la URI de un sitio web en el parámetro URL, el sistema mostrará al usuario solo el enlace de acceso.

Por ejemplo: https://stamping.io/es/view/?55ca301eb527cb16bfa18b60a03d9c49a0eeb748

Si necesita crear el QR antes de enviar la transacción a Stamping.io, puede calcular el TrxID de la siguiente manera:
SHA1(<SHA256 hash del documento o datos>)

{{domain}}/stamp/get/

Obtenga evidencia digital en Blockchains públicas

Obtenga los datos del registro en las cadenas de bloques públicas. Puede obtener los datos de la transacción buscando por TRXID, HASH SHA256 del documento o datos sellados o por el TRXID de la referencia de rastreo.

URL

https://api.stamping.io/stamp/get/?

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
byTrxid	TRXID de la transacción. Valor obtenido en el proceso de estampado.	123f98ebe690ade561fcbc753d95104667cbc1e4

Opcional

Parámetro	Descripción	Ejemplo
byHash	Hash SHA256 del documento o datos estampados.	08234748cb6621b441639231d6149f3527cff55038f33d29a72151d277668a00
byReference	TRXID de una transacción asociada a esta transacción.	123f98ebe690ade561fcbc753d95104667cbc1e4

Respuesta

{
"code":"200 (OK)",
"message":"Mensaje de error de Stamping API",
"version":"Versión de Stamping API",
"trxid":"TRANSACTION_ID de Stamping.io",
"result":"JSON (JSON-RESGETSTAMP)- Datos de la transacción y su registro en la cadena de bloques",
"references":"Datos de la transacción de referencia y su registro en la cadena de bloques",
}

EJEMPLO - JSON Response

JSON-RESGETSTAMP

URL : https://api.stamping.io/stamp/get/?byTrxid=123f98ebe690ade561fcbc753d95104667cbc1e4

Método : GET

					        
"result": {
        "integrity": {
            "evidence": "f76809f8f7ac62f94bf554533fff70b42253ef357dc7c415019aa9cef92e15d8",
            "hash2": "",
            "hash3": "",
            "token": "b078afeae53cda3d17d1ea1e6ea13",
            "tx_lacchain": "0xd1e0b26ebac1604b75586461e03f6e2692a402310a025d90502841530cab2579",
            "transactionType": "CreateBlock",
            "hashType": "SHA256",
            "subject": "",
            "url": "",
            "data": "Crea nuevo bloque "
        },
        "ownership": {
            "userId": "mu0XtKVZYjajfjZLakFM4HS8afF3",
            "owner": "",
            "address": "0xdead00000000000000000000000000000000dead",
            "reference": "NONE",
            "lat": "0",
            "long": "0",
            "to": ""
        },
        "existence": {
            "timestamp": "1643762281000",
            "anchored": "2022-02-01 19:40:04",
            "ip": "66.7.220.3"
        },
        "blockchains": {
            "recipient": "anchored",
            "number": "3610709",
            "certificate": {
                "transaction": "https://api.stamping.io/hash/certificate/?hash=f76809f8f7ac62f94bf554533fff70b42253ef357dc7c415019aa9cef92e15d8"
            },
            "block": "https://api.stamping.io/hash/certificate/?hash=32b0beaa0029673237aa7a424d72fc09135c98167e0725d27026cedb9387ee40"
        },
        "tree": {
            "hash": "08234748cb6621b441639231d6149f3527cff55038f33d29a72151d277668a00",
            "number": "7332733"
        },
        "block": {
            "hashblock": "0e4dc029bd67b1a7dcf60532b693f485dbf9c9bde90bd6ebdc37f847ee4559be",
            "number": "43322",
            "count": "21"
        },
        "networks": {
            "mainnet": {
                "polygon": "",
                "stamping": "bc8f5b8d7f6668a0f4f3014f9e307519fadf6999"
            },
            "testnet": {
                "ropsten": "",
                "Binance Smart Chain (BSC)": "0x985d80030b75825db226d6700426a7d5d789148e797719cdef4b5146ba7605e6",
                "avalanche": "0x8ebfdefc9e449e9752c7d5d585c8bd0222676fce0e31ef49a19420373600b8ab",
                "lacchain": "0x820321890e179d5825ce9fe2bee8f4cd83125496d829179dcbee17b45df0a25a"
            }
        }
    }
},

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/stamp/get/?byTrxid=<TRXID>',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var data = "";
var xhr = new XMLHttpRequest();
xhr.withCredentials = false;
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/stamp/get/?byTrxid=<TRXID>");
xhr.send(data);

AUTENTICACIÓN BEARER

{{domain}}/v2/auth/

Obtener un token de autorización

Permite obtener un token de acceso bearer para el uso de STAMPING API. Tenga en cuenta que solo es compatible con la versión 2.0.

URL

https://api.stamping.io/auth/

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
client_id	Llave pública del usuario en StampingIO. Se obtiene del panel de usuario (Data Wallet) en Stamping API.	HphUvRHiPB1932XKQBxnav3ZY2Wc
consumidor	Identificador del cliente. Se obtiene del panel de usuario (Data Wallet) en Stamping API.	5129361614377512936
api_key	Clave de acceso del cliente. Se obtiene del panel de usuario (Data Wallet) en Stamping API.	bf99d83504d13f36fae52aeec38b2592a6533de0e59c50c77474b586965
duracion	Tiempo en milisegundos de duración del token de acceso.	25000

Respuesta

					        
{
    "result": "OK",
    "data": {
        "token": "eyJhbGciOiAiI6ICIweDc...IwYjExMTNlZQ==",
        "ip": "201.240.82.3",
        "method": "POST"
    }
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/v2/auth/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS =>'{
    "userid":"{userid}",
    "accountid":"{accoundid}",
    "apikey": "{apikey}",
    "duration": {duration in milliseconds}
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json'
  ),
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var data = JSON.stringify({
  "userid": "{userid}",
  "accountid": "{accoundid}",
  "apikey": "{apikey}",
  "duration": {duration in milliseconds}
});
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/v2/auth/");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);

{{domain}}/v2/stamp/

Enviar evidencia digital en Blockchains públicas

Puede pasar su token de acceso a través de encabezados. Si desea deshabilitar el encolamiento de nuestra tecnología SST, puede enviar el parámetro async=false, en cuyo caso la transacción se registrará inmediatamente en la red blockchain de LACChain.

URL

https://api.stamping.io/v2/stamp/

Autenticación

BEARER

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
evidence	Hash SHA256 del documento o datos que se desea estampar	f76809f8f7ac62f94bf554533fff70b42253ef357dc7c415019aa9cef92e15d8
async	Indicador para enviar una transacción sincrónica o asincrona. Si envia true (evidencia digital), el sistema encola la transacción y cada 10 minutos será anclada en las redes blockchain, si envía false, el sistema va a enviar esta transacción a la red blockchain de lacchain.	true or false

Opcional

Parámetro	Descripción	Ejemplo
data	Datos de metadatos asociados a la evidencia. Puede ser encriptado, base64 o hexadecimal y puede estar en cualquier formato: XML, JSON o TEXT. El tamaño máximo es de 2048 bytes. Por favor, no envíe datos binarios de imágenes, fotos o videos.	{"id":"1939", "name":"x183.jMK", "type":"C38"}
transactionType	Tipo de transacción. Puede ingresar una etiqueta o espacio de nombres que le permita escribir sus registros.	pe.stamping.app
hash2	Hash SHA256 alternativo que puede estar asociado con la transacción.	533fff70b42253ef357dc7c415019aa9cef92e15d8f76809f8f7ac62f94bf554
hash3	Hash SHA256 alternativo que puede estar asociado con la transacción.	76809f8f7ac62f94bf554533fff70b42253ef357dc7c415019aa9cef92e15d8f
resume	Asunto de la transacción	certificate of studies
url	URL que puede estar asociada con la transacción. Se suele introducir la URL del documento o un informe de consulta de los datos que se han inmutado en la cadena de bloques.	https://stamping.io/files/mydocument.pdf
reference	TRXID de otra transacción a la que se hace referencia en esta transacción. Permite crear transacciones anidadas o trazabilidad de registros.	561fcbc753d95104667cbc1e4123f98ebe690ade
lat	Latitud (georreferenciación) donde se captura la evidencia digital.	-12.046373
long	Longitud (georreferenciación) donde se captura la evidencia digital.	-77.042755
to	ID de usuario (asignado por Stamping.io) de la cuenta que recibe la transacción. Este código se obtiene al crear una cuenta en la API Stamping. Por lo general, se usa cuando desea enviar una transacción a otro usuario.	fjZLakFM4HS8afF3mu0XtKVZYjaj

Respuesta

{
"code":"200: OK",
"message":"Mensaje de estado de ejecución.",
"version":"Versión de la Stamping API",
"nonce":"Código usado por Stamping.io para el firmado de la trsancción",
"async":true | false,
"trxid":"TRANSACTION_ID de Stamping.io",
"timestamp":Sello de tiempo de la transacción de Stamping.io,
"blockNumber":"Número de bloque en la red LACChain (funciona cuando async=false)",
"lacchainId":"Hash SHA256 de la transacción en la red LACChain (funciona cuando async=false)",
"credential":"JSON - Credencial verificable (W3C y EIP712&EIP1812) (funciona cuando async=false)">
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/v2/stamp/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS =>'{
    "evidence":"7f07775272d27e74ceac6117a59da8e74081a4e09b5c9baa2e3e4660f2a652fb",
    "async":"true"
}',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Bearer eyJhbGciOiAiRUNEU0EiLCJ0eXA...DY5ZmZmNTllYzhmZWIwYjExMTNlZQ==',
    'Content-Type: application/json'
  ),
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var data = JSON.stringify({
  "evidence": "7f07775272d27e74ceac6117a59da8e74081a4e09b5c9baa2e3e4660f2a652fb",
  "async": "true"
});
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/v2/stamp/");
xhr.setRequestHeader("Authorization", "Bearer eyJhbGciOiAiRUN...mZmNjVlMDY5ZmZmNTllYzhmZWIwYjExMTNlZQ==");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);

Validador de transacciones

Si desea validar sus transacciones, puede dirigir la URI de su código QR a la siguiente URL: https://stamping.io/es/view/?<TrxID>

Información importante

Si envía la URI de una imagen en el valor del parámetro URL, esa imagen se mostrará en el visor; sin embargo, si envía un URI de documento PDF, se mostrará la imagen de la primera página del documento. En ambos casos, se muestra al usuario la posibilidad de compartirlo en redes sociales o descargar el valor de la URL original.
Si envía la URI de un sitio web en el parámetro URL, el sistema mostrará al usuario solo el enlace de acceso.

Por ejemplo: https://stamping.io/es/view/?55ca301eb527cb16bfa18b60a03d9c49a0eeb748

Si necesita crear el QR antes de enviar la transacción a Stamping.io, puede calcular el TrxID de la siguiente manera:
SHA1(<SHA256 hash del documento o datos>)

CONTRATOS

DESCRIPCIÓN

Estas APIs le permite interactuar con contratos que se encuentren desplegados en redes públicas. Con estas APIs podrá realizar consultas (CALL) o enviar transacciones (SEND) en aquellos contratos que previamente haya registrado su ABI en STAMPING API.

PASOS

Despliegue su contrato Lo primero que debe hacer es crear su contrato y deberá desplegarlo en una red Blockchain pública ¡Suena lógico!, Pues no, en STAMPING.IO todo es muy fácil, si desea usar los contratos estándares que pone a su disposición STAMPING a través de una API de creación de contratos NFT (ERC721) o ERC20. Tenga en cuenta que si crea los contratos estándares usando STAMPING API ya no necesitará registrar el ABI.
Registre su ABI Debe hacer un encode del ABI de su contrato en base64, luego utilice nuestra api {{domain}}/contract/abi/base64
Integre sus apicaciones Puede usar STAMPING API para hacer consultas {{domain}}/contract/call o para enviar transacciones {{domain}}/contract/send

CONSIDERACIONES

El gas para realizar transacciones debe ser cubierto por el emisor.
Esta solución es para el uso de una billetera caliente; sin embargo, STAMPING API tambien permite integrarse con 0xAddress, con metamask o con cualquier otra billetera fria.
Los contratos que usted cree (personalizados) deben estar creados y su ABI debe estar registrado antes de ser utlizados.
Cuide su llave privada, recuerde que está trabajando con billeteras calientes. La seguridad de la custodia y su correcto uso es 100% suya.

CONTRATO DE EJEMPLO

Vamos a crear un contrato que será desplegado en una red de prueba de ethereum. Este contrato permite registrar distintos hash SHA256 asociados a direcciones del emisor. Es un ejemplo muy sencillo pero nos ayudará a comprender como usar STAMPING API.

CODIGO DEL CONTRATO

Usted puede recrearlo usando remix

CÓDIGO EN SOLIDITY

{
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract HASHRegistry {
    mapping (bytes32=>address) public  hashByAddress; //Listado de los hashes registrados por un address
    function setHash(bytes32 _hash) external {
        hashByAddress[_hash]= msg.sender;
    }
}

Una vez que haya compilado y desplegado este contrato debe obtener el ABI del contrato, tal como se muestra en la siguiente imagen:

Al hacer clic en el botón que dice ABI, se va a copiar un JSON con la interfaz pública del contrato en el portapapeles, ustede puede usar un editor para encodear en base64, por ejemplo: https://www.base64encode.org/

Luego debe registrarlo en STAMPING API usando /contract/abi/base64 y listo. Ya puede realizar transacciones o consultas a ese contrato.

{{domain}}/contract/abi/base64

Permite registrar el ABI de un contracto encodeado en base64

Para que las aplicaciones puedan interactuar directamente con un contrato desplagado en una blockchain pública, se requiere registrar el ABI del contrato. Esta API REST le permite regitrar una ABI desde un archivo base64.

URL

https://api.stamping.io/contract/abi/base64

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
contract	Dirección del contrato.	0x75D2ff8D06A84717E979D7A9499Da4D3D82625ED
abi	ABI encodeado en base64.	Mz273hs...uj3K==

Respuesta

{
{
    "code": 200,
    "message": "ok",
    "data": {
        "fileABI": "./0x75D2ff8D06A84717E979D7A9499Da4D3D82625ED.abi"
    }
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/contract/abi/base64/?token=eTF24rNygb...bdHjduY&contract=0x75D2ff8D06A84717E979D7A9499Da4D3D82625ED&abi=WwoJewoJCSJpbnB1dHMiOi...I6ICJmdW5jdGlvbiIKCX0KXQ==',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/contract/abi/base64/?token=eTF24rNygb...DbdHjduY&contract=0x75D2ff8D06A84717E979D7A9499Da4D3D82625ED&abi=WwoJewoJCSJpbnB1dHMiOiBbCgkJCXsK...5jdGlvbiIKCX0KXQ==");
xhr.send();

{{domain}}/contract/send

Permite realizar una transacción (send) a un contracto

Las aplicaciones pueden ejecutar cualquier función dentro de alguna red blockchain soportada por STAMPING API. Puede usar este método para ejecutar una transacción en cualquier función de un contrato (sendSignedTransaction).

URL

https://api.stamping.io/contract/send/

Autenticación

BEARER / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
contract	Dirección del contrato.	0xD9dfEA30f55eB81A839F4EAba8D21CE6416074ff
method	Método o función del contrato que se desea ejecutar.	data
param1..param10	Parámetros de la función o método.	Value1...
node	Nodo de la red blockchain que se va a ejecutar.	https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/
chainid	Identificador de la red blockchain que se va a ejecutar.	95/
privateKey	Llave privada que ejecutará la transacción, si desea utilizar la variable getPrivateKey() para que utilice la billetera caliente de STAMPING API. Si no envia este dato le devuelve el resultado en "data" para que oyeda ser firmado por una billetera fria y env+iado a la red blockchain.	getPrivateKey()/

Respuesta

{
{
    "code": 200,
    "message": "ok, los datos han sido firmados y enviados a la cadena de bloques ",
    "data": {
        "blockHash": "0x3802ec1e7cfec1e4717613ad141a384fd0855220ea5be8fdff3dffbbe765e991",
        "blockNumber": 36354652,
        "contractAddress": null,
        "cumulativeGasUsed": 22680,
        "from": "0xfbb472d5b85621e38979771fe195847baa14e8e1",
        "gasUsed": 22680,
        "logs": [],
        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        "status": true,
        "to": "0xd9dfea30f55eb81a839f4eaba8d21ce6416074ff",
        "transactionHash": "0x4ed5a00480891a79c9dcf0aa3f09a33ad81457069d2fbc7cc252afdf17e490a4",
        "transactionIndex": 0
    }
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/contract/send/?token=eTF24r...ApDbdHjduY&contract=0xD9dfEA30f55eB81A839F4EAba8D21CE6416074ff&method=data&param1=0x828831030210E162b68296b31e2d0fa964d5D404&node=http://{IP}:4545&chainid=648529&privateKey=getPrivateKey()',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/contract/send/?token=eTF24rN...bdHjduY&contract=0xD9dfEA30f55eB81A839F4EAba8D21CE6416074ff&method=data&param1=0x828831030210E162b68296b31e2d0fa964d5D404&node=http://{IP}:4545&chainid=648529&privateKey=getPrivateKey()");
xhr.send();

{{domain}}/contract/call

Permite realizar un call a un contracto

Las aplicaciones pueden consultar cualquier funcion dentro de alguna red blockchain soportada por STAMPING API. Puede usar este método para consultar el saldo de un token ERC20 (balanceOf(0xAddress)) o ver datos anclados en un contrato.

URL

https://api.stamping.io/contract/call/

Autenticación

BEARER / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
contract	Dirección del contrato.	0xD9dfEA30f55eB81A839F4EAba8D21CE6416074ff
method	Método o función del contrato que se desea ejecutar.	data
param1..param10	Parámetros de la función o método.	Value1...
node	Nodo de la red blockchain que se va a ejecutar.	https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/

Respuesta

{
    "code": 200,
    "message": "ok",
    "method": "data",
    "mode": "call",
    "data": {
        "0": "Prueba2",
        "1": "1641500947",
        "hash": "Prueba2",
        "timestamp": "1641500947"
    }
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/contract/call/?token=eTF24rNygbYIJz2LJApDbdHjduY∓contract=0xD9dfEA30f55eB81A839F4EAba8D21CE6416074ff∓method=data∓param1=0x828831030210E162b68296b31e2d0fa964d5D404∓node=https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/contract/call/?token=eTF24rNygbYIJz2LJApDbdHjduY&contract=0xD9dfEA30f55eB81A839F4EAba8D21CE6416074ff∓method=data∓param1=0x828831030210E162b68296b31e2d0fa964d5D404∓node=https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/");
xhr.send();

TOKEN FUNGIBLES (ERC20/BEP20)

DESCRIPCION

Binance Smart Chain tiene un estándar de token BEP20 que funciona de manera similar al estándar ERC20 de Ethereum. BEP20 es un estándar de token amigable para los desarrolladores que permite a cualquier persona implementar monedas o tokens digitales fungibles en Binance Smart Chain. Además, los activos digitales líderes en otras cadenas se pueden transferir a Binance Smart Chain en forma de tokens BEP20 vinculados. Por ejemplo, puede usar Binance Bridge para intercambiar bitcoin (BTC) por tokens BTCB (BEP20) respaldados por BTC. Los tokens BTCB (BEP20) se pueden implementar en protocolos DeFi para obtener rendimiento en bitcoin. Lo mismo ocurre con ETH, XRP, DOGE y muchos más.

PASOS

Crear token Lo primero que debe hacer es crear su contrato, utilice el API: /contract/erc20/create/, debe enviar los datos del contrato a crear como la cantidad de suministro, el nombre del token, etc y el contrato será creado en forma automática.
Integre sus apicaciones Puede usar STAMPING API para hacer consultas {{domain}}/contract/call o para enviar transacciones {{domain}}/contract/send. Tambien puede hacer uso de las APIs especificas para manejo de tokens del tipo ERC20.

CONSIDERACIONES

El gas para realizar transacciones debe ser cubierto por el emisor.
Esta solución es para el uso de una billetera caliente; sin embargo, STAMPING API tambien permite integrarse con 0xAddress, con metamask o con cualquier otra billetera fria.
Los contratos que usted cree (personalizados) deben estar creados y su ABI debe estar registrado antes de ser utlizados.
Cuide su llave privada, recuerde que está trabajando con billeteras calientes. La seguridad de la custodia y su correcto uso es 100% suya.

FUNCIONES

Como ya se mencionó, el estándar de token BEP-20 se modeló a partir del ERC-20 de Ethereum, por lo que son compatibles. Algunas funciones comunes a ambos estándares incluyen:

totalSupply. Esto devuelve el número total de tokens disponibles en un contrato.
balanceOf. Esto devuelve el número de tokens disponibles en una dirección de usuario específica.
transfer. Esta función se utiliza para transferir tokens entre usuarios y requiere que la persona que invoca la función sea el propietario de los tokens.
transferFrom. diferente a transferir, esta función se utiliza para automatizar transferencias por personas o contratos aprobados. Por ejemplo, es posible que prefiera autorizar los servicios a los que está suscrito para deducir los pagos automáticamente en lugar de hacerlo manualmente.
approve. Esto se usa para limitar la cantidad de tokens que cualquier contrato inteligente puede retirar de su saldo.
allowance. Una vez que un contrato inteligente está autorizado para gastar una cierta cantidad de sus tokens, el prestación La función se puede utilizar para comprobar si hay alguna parte no gastada.
name. Esto se utiliza para adjuntar un nombre legible por humanos al token, como «Binance Coin».
symbol. Los tokens también pueden tener símbolos como «BNB».
decimal. Básicamente, esta función establece el número de posiciones decimales en las que se puede dividir un token. Cuantos más decimales, más divisible es una ficha.

CODIGO DEL CONTRATO

Usted puede recrearlo manualmente si desea usando: remix

CÓDIGO EN SOLIDITY

pragma solidity 0.5.16;

interface IBEP20 {
  /**
   * @dev Returns the amount of tokens in existence.
   */
  function totalSupply() external view returns (uint256);

  /**
   * @dev Returns the token decimals.
   */
  function decimals() external view returns (uint8);

  /**
   * @dev Returns the token symbol.
   */
  function symbol() external view returns (string memory);

  /**
  * @dev Returns the token name.
  */
  function name() external view returns (string memory);

  /**
   * @dev Returns the bep token owner.
   */
  function getOwner() external view returns (address);

  /**
   * @dev Returns the amount of tokens owned by `account`.
   */
  function balanceOf(address account) external view returns (uint256);

  /**
   * @dev Moves `amount` tokens from the caller's account to `recipient`.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transfer(address recipient, uint256 amount) external returns (bool);

  /**
   * @dev Returns the remaining number of tokens that `spender` will be
   * allowed to spend on behalf of `owner` through {transferFrom}. This is
   * zero by default.
   *
   * This value changes when {approve} or {transferFrom} are called.
   */
  function allowance(address _owner, address spender) external view returns (uint256);

  /**
   * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * IMPORTANT: Beware that changing an allowance with this method brings the risk
   * that someone may use both the old and the new allowance by unfortunate
   * transaction ordering. One possible solution to mitigate this race
   * condition is to first reduce the spender's allowance to 0 and set the
   * desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   *
   * Emits an {Approval} event.
   */
  function approve(address spender, uint256 amount) external returns (bool);

  /**
   * @dev Moves `amount` tokens from `sender` to `recipient` using the
   * allowance mechanism. `amount` is then deducted from the caller's
   * allowance.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

  /**
   * @dev Emitted when `value` tokens are moved from one account (`from`) to
   * another (`to`).
   *
   * Note that `value` may be zero.
   */
  event Transfer(address indexed from, address indexed to, uint256 value);

  /**
   * @dev Emitted when the allowance of a `spender` for an `owner` is set by
   * a call to {approve}. `value` is the new allowance.
   */
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
  // Empty internal constructor, to prevent people from mistakenly deploying
  // an instance of this contract, which should be used via inheritance.
  constructor () internal { }

  function _msgSender() internal view returns (address payable) {
    return msg.sender;
  }

  function _msgData() internal view returns (bytes memory) {
    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    return msg.data;
  }
}

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
  /**
   * @dev Returns the addition of two unsigned integers, reverting on
   * overflow.
   *
   * Counterpart to Solidity's `+` operator.
   *
   * Requirements:
   * - Addition cannot overflow.
   */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, "SafeMath: addition overflow");

    return c;
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   * - Subtraction cannot overflow.
   */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, "SafeMath: subtraction overflow");
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   * - Subtraction cannot overflow.
   */
  function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
  }

  /**
   * @dev Returns the multiplication of two unsigned integers, reverting on
   * overflow.
   *
   * Counterpart to Solidity's `*` operator.
   *
   * Requirements:
   * - Multiplication cannot overflow.
   */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
  }

  /**
   * @dev Returns the integer division of two unsigned integers. Reverts on
   * division by zero. The result is rounded towards zero.
   *
   * Counterpart to Solidity's `/` operator. Note: this function uses a
   * `revert` opcode (which leaves remaining gas untouched) while Solidity
   * uses an invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return div(a, b, "SafeMath: division by zero");
  }

  /**
   * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
   * division by zero. The result is rounded towards zero.
   *
   * Counterpart to Solidity's `/` operator. Note: this function uses a
   * `revert` opcode (which leaves remaining gas untouched) while Solidity
   * uses an invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    // Solidity only automatically asserts when dividing by 0
    require(b > 0, errorMessage);
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * Reverts when dividing by zero.
   *
   * Counterpart to Solidity's `%` operator. This function uses a `revert`
   * opcode (which leaves remaining gas untouched) while Solidity uses an
   * invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    return mod(a, b, "SafeMath: modulo by zero");
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * Reverts with custom message when dividing by zero.
   *
   * Counterpart to Solidity's `%` operator. This function uses a `revert`
   * opcode (which leaves remaining gas untouched) while Solidity uses an
   * invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b != 0, errorMessage);
    return a % b;
  }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
  address private _owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  /**
   * @dev Initializes the contract setting the deployer as the initial owner.
   */
  constructor () internal {
    address msgSender = _msgSender();
    _owner = msgSender;
    emit OwnershipTransferred(address(0), msgSender);
  }

  /**
   * @dev Returns the address of the current owner.
   */
  function owner() public view returns (address) {
    return _owner;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(_owner == _msgSender(), "Ownable: caller is not the owner");
    _;
  }

  /**
   * @dev Leaves the contract without owner. It will not be possible to call
   * `onlyOwner` functions anymore. Can only be called by the current owner.
   *
   * NOTE: Renouncing ownership will leave the contract without an owner,
   * thereby removing any functionality that is only available to the owner.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);
  }

  /**
   * @dev Transfers ownership of the contract to a new account (`newOwner`).
   * Can only be called by the current owner.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    _transferOwnership(newOwner);
  }

  /**
   * @dev Transfers ownership of the contract to a new account (`newOwner`).
   */
  function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  }
}

contract BEP20Token is Context, IBEP20, Ownable {
  using SafeMath for uint256;

  mapping (address => uint256) private _balances;

  mapping (address => mapping (address => uint256)) private _allowances;

  uint256 private _totalSupply;
  uint8 private _decimals;
  string private _symbol;
  string private _name;

  constructor(uint256 totalSupply,
  uint8 decimals,
  string memory symbol,
  string memory name) public {
    _name = name;
    _symbol = symbol;
    _decimals = decimals;
    _totalSupply = totalSupply;
    _balances[msg.sender] = _totalSupply;

    emit Transfer(address(0), msg.sender, _totalSupply);
  }

  /**
   * @dev Returns the bep token owner.
   */
  function getOwner() external view returns (address) {
    return owner();
  }

  /**
   * @dev Returns the token decimals.
   */
  function decimals() external view returns (uint8) {
    return _decimals;
  }

  /**
   * @dev Returns the token symbol.
   */
  function symbol() external view returns (string memory) {
    return _symbol;
  }

  /**
  * @dev Returns the token name.
  */
  function name() external view returns (string memory) {
    return _name;
  }

  /**
   * @dev See {BEP20-totalSupply}.
   */
  function totalSupply() external view returns (uint256) {
    return _totalSupply;
  }

  /**
   * @dev See {BEP20-balanceOf}.
   */
  function balanceOf(address account) external view returns (uint256) {
    return _balances[account];
  }

  /**
   * @dev See {BEP20-transfer}.
   *
   * Requirements:
   *
   * - `recipient` cannot be the zero address.
   * - the caller must have a balance of at least `amount`.
   */
  function transfer(address recipient, uint256 amount) external returns (bool) {
    _transfer(_msgSender(), recipient, amount);
    return true;
  }

  /**
   * @dev See {BEP20-allowance}.
   */
  function allowance(address owner, address spender) external view returns (uint256) {
    return _allowances[owner][spender];
  }

  /**
   * @dev See {BEP20-approve}.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function approve(address spender, uint256 amount) external returns (bool) {
    _approve(_msgSender(), spender, amount);
    return true;
  }

  /**
   * @dev See {BEP20-transferFrom}.
   *
   * Emits an {Approval} event indicating the updated allowance. This is not
   * required by the EIP. See the note at the beginning of {BEP20};
   *
   * Requirements:
   * - `sender` and `recipient` cannot be the zero address.
   * - `sender` must have a balance of at least `amount`.
   * - the caller must have allowance for `sender`'s tokens of at least
   * `amount`.
   */
  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
    return true;
  }

  /**
   * @dev Atomically increases the allowance granted to `spender` by the caller.
   *
   * This is an alternative to {approve} that can be used as a mitigation for
   * problems described in {BEP20-approve}.
   *
   * Emits an {Approval} event indicating the updated allowance.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
    return true;
  }

  /**
   * @dev Atomically decreases the allowance granted to `spender` by the caller.
   *
   * This is an alternative to {approve} that can be used as a mitigation for
   * problems described in {BEP20-approve}.
   *
   * Emits an {Approval} event indicating the updated allowance.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   * - `spender` must have allowance for the caller of at least
   * `subtractedValue`.
   */
  function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
    return true;
  }

  /**
   * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
   * the total supply.
   *
   * Requirements
   *
   * - `msg.sender` must be the token owner
   */
  function mint(uint256 amount) public onlyOwner returns (bool) {
    _mint(_msgSender(), amount);
    return true;
  }

  /**
   * @dev Moves tokens `amount` from `sender` to `recipient`.
   *
   * This is internal function is equivalent to {transfer}, and can be used to
   * e.g. implement automatic token fees, slashing mechanisms, etc.
   *
   * Emits a {Transfer} event.
   *
   * Requirements:
   *
   * - `sender` cannot be the zero address.
   * - `recipient` cannot be the zero address.
   * - `sender` must have a balance of at least `amount`.
   */
  function _transfer(address sender, address recipient, uint256 amount) internal {
    require(sender != address(0), "BEP20: transfer from the zero address");
    require(recipient != address(0), "BEP20: transfer to the zero address");

    _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
    _balances[recipient] = _balances[recipient].add(amount);
    emit Transfer(sender, recipient, amount);
  }

  /** @dev Creates `amount` tokens and assigns them to `account`, increasing
   * the total supply.
   *
   * Emits a {Transfer} event with `from` set to the zero address.
   *
   * Requirements
   *
   * - `to` cannot be the zero address.
   */
  function _mint(address account, uint256 amount) internal {
    require(account != address(0), "BEP20: mint to the zero address");

    _totalSupply = _totalSupply.add(amount);
    _balances[account] = _balances[account].add(amount);
    emit Transfer(address(0), account, amount);
  }

  /**
   * @dev Destroys `amount` tokens from `account`, reducing the
   * total supply.
   *
   * Emits a {Transfer} event with `to` set to the zero address.
   *
   * Requirements
   *
   * - `account` cannot be the zero address.
   * - `account` must have at least `amount` tokens.
   */
  function _burn(address account, uint256 amount) internal {
    require(account != address(0), "BEP20: burn from the zero address");

    _balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
    _totalSupply = _totalSupply.sub(amount);
    emit Transfer(account, address(0), amount);
  }

  /**
   * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
   *
   * This is internal function is equivalent to `approve`, and can be used to
   * e.g. set automatic allowances for certain subsystems, etc.
   *
   * Emits an {Approval} event.
   *
   * Requirements:
   *
   * - `owner` cannot be the zero address.
   * - `spender` cannot be the zero address.
   */
  function _approve(address owner, address spender, uint256 amount) internal {
    require(owner != address(0), "BEP20: approve from the zero address");
    require(spender != address(0), "BEP20: approve to the zero address");

    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
  }

  /**
   * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
   * from the caller's allowance.
   *
   * See {_burn} and {_approve}.
   */ 
  function _burnFrom(address account, uint256 amount) internal {
    _burn(account, amount);
    _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
  }
}

Una vez que haya compilado y desplegado este contrato debe obtener el ABI del contrato, en el caso de usar el API de creación de token ERC20, no será necesario registrar el ABI.

{{domain}}/contract/erc20/create/

Crea un contrato fungible

Permite crear un contrato BEP20 compatible con ERC20.

URL

https://api.stamping.io/contract/erc20/create/

Método

POST/GET

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
node	Nodo de la red blockchain a la que se desea consultar.	https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/
totalSupply	Total de tokens disponibles en un contrato.	1000000000000000000
decimals	Número de posiciones decimales en las que se puede dividir un token. Cuantos más decimales, más divisible es una ficha.	18
name	Se utiliza para adjuntar un nombre legible por humanos al token, como «Binance Coin».	MY TOKEN
symbol	Simbolo del token a crear.	MYTOKEN
gas	Gas a utilizar para la creación del contrato. Si envia cero o vacio el sistema lo creará con 9000000	8000000
chainId	Identificador de la red blockchain. Si envía vacío tomará por defecto la red de LACCHAIN: 648529	97
privateKey	Llave privada con la que se crea el contrato. El address de esta llave privada será el owner del contrato y el que reciba el suministro de tokens	0x7f07775272d27...3e4660f2a652fb

Respuesta

					        
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "code": "200",
        "message": "Ok",
        "contract": "0x50f0C1Cb722355C2AC86C07629A6634Bb490384f",
        "data": {
            "blockHash": "0xffcbe9167236f91e9d04608e622bc50a26427a8f236a74e117ffaf31ee18fcb5",
            "blockNumber": 16737938,
            "contractAddress": "0x50f0C1Cb722355C2AC86C07629A6634Bb490384f",
            "cumulativeGasUsed": 3778736,
            "from": "0xfbb472d5b85621e38979771fe195847baa14e8e1",
            "gasUsed": 1580883,
            "logs": [
                {
                    "address": "0x50f0C1Cb722355C2AC86C07629A6634Bb490384f",
                    "topics": [
                        "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",
                        "0x0000000000000000000000000000000000000000000000000000000000000000",
                        "0x000000000000000000000000fbb472d5b85621e38979771fe195847baa14e8e1"
                    ],
                    "data": "0x",
                    "blockNumber": 16737938,
                    "transactionHash": "0x515d3b5e5816d1cbd1c86f1bf938226660091bcc097ceec2b9b7f1f4d5e7d1dc",
                    "transactionIndex": 8,
                    "blockHash": "0xffcbe9167236f91e9d04608e622bc50a26427a8f236a74e117ffaf31ee18fcb5",
                    "logIndex": 38,
                    "removed": false,
                    "id": "log_1f6f2e07"
                },
                {
                    "address": "0x50f0C1Cb722355C2AC86C07629A6634Bb490384f",
                    "topics": [
                        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                        "0x0000000000000000000000000000000000000000000000000000000000000000",
                        "0x000000000000000000000000fbb472d5b85621e38979771fe195847baa14e8e1"
                    ],
                    "data": "0x00000000000000000000000000000000000000000000000000038d7ea4c68000",
                    "blockNumber": 16737938,
                    "transactionHash": "0x515d3b5e5816d1cbd1c86f1bf938226660091bcc097ceec2b9b7f1f4d5e7d1dc",
                    "transactionIndex": 8,
                    "blockHash": "0xffcbe9167236f91e9d04608e622bc50a26427a8f236a74e117ffaf31ee18fcb5",
                    "logIndex": 39,
                    "removed": false,
                    "id": "log_b64fd0c7"
                }
            ],
            "logsBloom": "0x00000000000000000000000200000000000000000000000000800000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000001000000000000000000000000000000000004020000000000000000000800000000000000000000000010000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000002000000000010000000000000000000000000000000000000000020000000000000000000000008000000000000000000000000000000000000000000",
            "status": true,
            "to": null,
            "transactionHash": "0x515d3b5e5816d1cbd1c86f1bf938226660091bcc097ceec2b9b7f1f4d5e7d1dc",
            "transactionIndex": 8,
            "type": "0x0"
        }
    },
    "request_method": "POST",
    "ip": "201.240.82.3",
    "timestamp": 1644814331000
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/contract/erc20/create/?token=eTF24rNy...dHjduY&totalSupply=1000000000000000&decimals=10&name=My%20Token&symbol=MTOKEN&gas=9000000&chainId=97&node=https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/&privateKey=0x7f07775272d27e74...a2e3e4660f2a652fb',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/contract/erc20/create/?token=eTF24rNy...dHjduY&totalSupply=1000000000000000&decimals=10&name=My%20Token&symbol=MTOKEN&gas=9000000&chainId=97&node=https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/&privateKey=0x7f07775272d27e74...a2e3e4660f2a652fb");
xhr.send();

Integrar aplicaciones

Si usted desea interactuar aplicaciones con el contrato creado del tipo ERC20 debe usar el API: /contract/call o /contract/send. Por ejemplo :

balanceOf(address account)

Ver el balance de la dirección: 0xFBb472d5B85621e38979771fe195847bAA14e8E1 del contrato: 0xcCb528C518b10eb4361AB0f5DcD4bcB22C3D48f8 en Binance Smart Chain (BSC)

$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/contract/call/?token=eTF24rNygb...bdHjduY&contract=0xcCb528C518b10eb4361AB0f5DcD4bcB22C3D48f8&method=balanceOf¶m1=0xFBb472d5B85621e38979771fe195847bAA14e8E1&node=https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Respuesta

					        
{
    "code": 200,
    "message": "ok",
    "method": "balanceOf",
    "mode": "call",
    "data": "1000000000000000"
}

owner

Ver el owner del contrato: 0xcCb528C518b10eb4361AB0f5DcD4bcB22C3D48f8 en Binance Smart Chain (BSC)

$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/contract/call/?token=eTF24rNygb...bdHjduY&contract=0xcCb528C518b10eb4361AB0f5DcD4bcB22C3D48f8&method=owner&node=https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Respuesta

					        
{
    "code": 200,
    "message": "ok",
    "method": "owner",
    "mode": "call",
    "data": "0xFBb472d5B85621e38979771fe195847bAA14e8E1"
}

transfer(address recipient, uint256 amount)

Transfiere 100 tokens (con 18 decimales) a la dirección 0xBb356fb1BD60eb3Dd4Aea121FB6aa8AF193FFcE2 del token del contrato: 0xcCb528C518b10eb4361AB0f5DcD4bcB22C3D48f8 en Binance Smart Chain (BSC)

$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/contract/send/?token=eTF24rNygb...bdHjduY&contract=0xcCb528C518b10eb4361AB0f5DcD4bcB22C3D48f8&method=transfer¶m1=0xBb356fb1BD60eb3Dd4Aea121FB6aa8AF193FFcE2¶m2=100000000000000000000&node=https://data-seed-preBinance Smart Chain (BSC)-1-s1.binance.org:8545/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Respuesta

					        
{
    "code": 200,
    "message": "ok, los datos están pendientes de firma",
    "data": {
        "to": "0xcCb528C518b10eb4361AB0f5DcD4bcB22C3D48f8",
        "data": "0xa9059cbb000000000000000000000000bb356fb1bd60eb3dd4aea121fb6aa8af193ffce2000000000000000000000000000000000000000000000000000000174876e800",
        "value": "0x0",
        "chainId": "",
        "gas": "0x7a120",
        "gasLimit": "0x7a120"
    }
}

Tenga en cuenta que al no enviar la llave privada se devuelve el código objeto TX para que pueda ser firmado por el titular de los tokens y luego debe ser enviado a la red blockchain. Si desea que se envie la transferencia puede enviar la llave privada con el parámetro privateKey.

AFIRMACIONES VERIFICABLES

DESCRIPCIÓN

Estas APIs le permite crear afirmaciones verificables de 4 tipos:

Normal: Son credenciales verificables basadas en la W3C y se registra cada transacción dentro de la blockchain para gestión del estado de la credencial y sello de tiempo (fecha cierta)
Mini: Son credenciales verificables basadas en la W3C, que utilizan a la blockchain para sello de tiempo de la credencial. Cada transacción no se registra en la blockchain, pero puede ser consultada para verificar si ha sido revocada
Micro: Son credenciales reducidas basadas en el estándar de Stamping.io, que utilizan a la blockchain para sello de tiempo de la credencial. Cada transacción no se registra en la blockchain, pero puede ser consultada para verificar si ha sido revocada
Minizip: Son credenciales reducidas zipeadas basadas en el estándar de Stamping.io, que utilizan a la blockchain para sello de tiempo de la credencial. Cada transacción no se registra en la blockchain, pero puede ser consultada para verificar si ha sido revocada

PASOS

Si va a crear un proyecto donde trabajará con credenciales verificables deberá seguir los siguientes pasos:

Cree un credencial Con la finalidad de que esta pueda ser generada de acuerdo al tipo de credencial que desea utilizar, estas credenciales son almacenadas en el nodo de Stamping.io
Comparta la credencial Si ustede genera las credenciales en batch, guarde el trxid que se genera, este identidicador le permitirá regenerar la credencial para transferirla al titular, en caso que usted las genere en tiempo de ejecución, puede usar esta API para crear un URL de transferencia
Valide credenciales Con esta API usted puede verificar la autenticidad de una afirmación, considere que esta API REST no requiere de autenticación, por lo que pyede compartirla con otras aplicaciones

{{domain}}/credential/create

Permite crear afirmaciones verificables

URL

https://api.stamping.io/credential/create

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
id	URI del Identificador del titular, puede usar @uuid si desea crear un código autogenerado.	pe.dni.10203040
idcredential	URI del Identificador de la credencial, puede usar @uuid si desea crear un código autogenerado.	cod.29399
mode	Tipo de credencial: normal (por defecto), mini, micro o minizip.	micro
validFrom	Fecha y hora en forma UNIX para iniciar la vigencia de inicion de la afirmación	8900000000
validTo	Fecha y hora en forma UNIX para finalizar la vigencia de inicion de la afirmación	9900000000
data	Datos de la afirmación verificable (subject). No se puede tener un parametro "id"	{"rat":"1344"}

Respuesta

{
    "code": 200,
    "message": "ok",
    "action": "registerCredential",
    "hash": {
        "stamp": "0x874631306b22177fe44c341ef0a5caebf79141a5cd96c3a3382a4464bffd3787",
        "credentialHashSimple": "0x874631306b22177fe44c341ef0a5caebf79141a5cd96c3a3382a4464bffd3787"
    },
    "trxid": "935e6a96201e209120923678bf299aaa89017f99",
    "lacchainId": "0x",
    "credential": {
        /*Datos de la credencial*/
    },
    "timestamp": 1647840006
}

Donde:

action Contiene el tipo de acción (registerCredential: La credencial es nueva y getCredential: La credencial ya existía)
hash Contiene los hahes firmados (stamp: Hash EIP712 cuando es Normal, caso contario es similar a credentialHashSimple y credentialHashSimple: El hash simple del contenido de la credencial)
trxid Identificador de Stamping.io para verificar el estado del registro en la blockchain, cuando la credencial no es de tipo normal, el registro no se guarda instantaneamente en la Blockchain, sino es enviado al encolador SST de Stamping.io
credential Datos de la afirmación verificable creada

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/credential/create/?id=@uuid&idcredential=@uuid&mode=micro&validFrom=89000000000&validTo=9900000000&data=%7B%22x%22:%220x5Ed4a09BAa906883c74889B7d242637ed6F8510c%22%7D&token=',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/credential/create/?id=@uuid&idcredential=@uuid&mode=micro&validFrom=89000000000&validTo=9900000000&data=%7B%22x%22:%220x5Ed4a09BAa906883c74889B7d242637ed6F8510c%22%7D&token=");
xhr.send();

{{domain}}/credential/get

Permite leer una credencial almacenada en el servidor

Tenga en cuenta que si usted usa el nodo público de STAMPING API, esta credencial puede ser accedida siempre que usted le otorgue el código de acceso, el mismo que solo podrá ser usado una vez. Puede usar este método para crear un URL de un sólo uso usando un algoritmo de hash camaleón. Mayor información de como usar este necanismo debe contactarse con el área de soporte de STAMPINGIO.

URL

https://api.stamping.io/credential/get/

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
trxid	Identificado de Stamping.io para consultar la afirmación verificable	935e6a96201e209120923678bf299aaa89017f99
mode	Modo de presentación de la credencial. Soporta 2 tipos: json (Se muestra como un documento JSON), base64 (se muestra el documento JSON codificado en base base64) y cert (se muestra como un certificado - reservado para clientes que lo solicitan)	json

Respuesta

Modo JSON - Credencial de tipo normal

{
    "@context": [
        "https://www.w3.org/2018/credentials/v1"
    ],
    "id": "http://stamping.io/credentials/4352edc5-3149-4a0e-9b7c-b4e54e296e28",
    "type": [
        "VerifiableCredential",
        "Evidence"
    ],
    "issuer": "did:ethr:lacchain:0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
    "issuanceDate": "4790-04-19T14:13:20.000Z",
    "expirationDate": "2283-09-20T08:00:00.000Z",
    "credentialSubject": {
        "x": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
        "id": "did:ethr:lacchain:0xB2196207C03e61408f27d5ED95e2f69605F0CA41"
    },
    "credentialStatus": {
        "id": "0xD6192F205bc4F1ad25824A35C644CEE3B283916d",
        "contract": "0xD6192F205bc4F1ad25824A35C644CEE3B283916d",
        "type": "SmartContract",
        "method": "status",
        "event": "CredentialStatusChanged"
    },
    "proof": [
        {
            "type": "EcdsaSecp256k1Signature2019",
            "proofPurpose": "assertionMethod",
            "verificationMethod": "did:ethr:lacchain:0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
            "networkId": "0x9e551",
            "domain": "0xD6192F205bc4F1ad25824A35C644CEE3B283916d",
            "proofValue": {
                "type": "serverEIP712",
                "address": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
                "value": "0x4bc5bdd07c57de587f33eafa5fde7fa8ab7ca3cd45dc61daa686e44f758087ab75418ce2a847e0a6b89afdc4d59ace8e90010b43e214d143490db8bd0fb9d4431b"
            }
        },
        {
            "type": "serverSimple",
            "address": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
            "value": "0x8e3c2b6fb5c931e21df4812f99def2b03c1d3e02183ea5baa8e442032085a83a4f08876c1d495c17fe9586df2205d2fb77ab02e4014c48805b509331b90c112e1c"
        }
    ]
}

Modo JSON - Credencial de tipo mini

{
    "@context": [
        "https://www.w3.org/2018/credentials/v1"
    ],
    "id": "3c083699-57a8-4967-8d27-fb83f27d5347",
    "type": "VerifiableCredential",
    "issuer": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
    "issuanceDate": "4790-04-19T14:13:20.000Z",
    "expirationDate": "2283-09-20T08:00:00.000Z",
    "credentialSubject": {
        "x": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
        "id": "0x345B782C75f6B96d9519CED1332F20e383742943"
    },
    "proof": [
        {
            "type": "serverSimple",
            "value": "0xc7c1b7d052b84cb9d39682f3017e7ebcda37101ab9f4868525196e4d7dc11f2b393b4e86a01fb8e690534de7ac0f3cd986ddbb2b61908408ccde4d17bfe8f4431c"
        }
    ]
}

Modo JSON - Credencial de tipo micro

{
    "r": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
    "i": "4790-04-19T14:13:20.000Z",
    "e": "2283-09-20T08:00:00.000Z",
    "d": {
        "x": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c"
    },
    "p": "0xd77668fe5ef501520a77e9e2030ec7dc6c37bcf16b9b89590ebff2fd6886f16b15b311a5c296525b0b351602f0144de74ccf5f96bf0dae43ac3f2581144c90a71b"
}

Modo JSON - Credencial de tipo minizip

{
    "@context": [
        "https://www.w3.org/2018/credentials/v1"
    ],
    "id": "12e21044-94a0-449a-8cdc-7be8afaaab29",
    "type": "VerifiableCredential",
    "issuer": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
    "issuanceDate": "4790-04-19T14:13:20.000Z",
    "expirationDate": "2283-09-20T08:00:00.000Z",
    "credentialSubject": {
        "x": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
        "id": "0x7eF0B187abE780BFD945a5b5A563619c6b32aBC7"
    },
    "proof": [
        {
            "type": "serverSimple",
            "value": "0x58a2010f59cc0c20bc27ddbe3f4982668a156ef097fa7567403fc9508f00ec4501fdb32bb9a2a2bdcc968a932dc21f6be1aa8a364c67934ea1da1f2c99dfd8e61c"
        }
    ]
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/credential/get/?trxid=f751a03a7e09aadb8c43aa0f112d7744b8b1aebf&mode=json',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/credential/get/?trxid=f751a03a7e09aadb8c43aa0f112d7744b8b1aebf&mode=json");
xhr.send();

{{domain}}/credential/validate/

Permite validar la integridad y autenticidad de una afirmación verificable

Para que una afirmacion pueda ser verificada se necesita los datos o asunto de la credencial y la firma que desea validar. Por el momento esta API Rest solo soporta validaciones de afirmaciones de tipo: mini y micro. Si desea validar una credencial verificable (tipo normal) se recomienda hacer uso de las API REST para verificarlo en el contrato de la red Blockchain.

URL

https://api.stamping.io/credential/validate/

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
data	Se envia los datos de la credencial sin espacios y tal como se genero la credencial. Use alguna opción similar a la función JSON.stringify() en javascript.	{"x": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c"}
proof	Prueba de firmado. Es la firma realizada por el emisor	0xd77668fe5ef501520a77e9e2030ec7dc6c37bcf16b9b89590ebff2fd6886f16b15b311a5c296525b0b351602f0144de74ccf5f96bf0dae43ac3f2581144c90a71b

Respuesta

{
    "code": 200,
    "message": "ok",
    "data": {
        "address": "0x5Ed4a09BAa906883c74889B7d242637ed6F8510c",
        "hash": "0xd7b744fae4ac812206c6d8a0eacfc2acb355b10bb3c5463a0ab50a30f9cad170",
        "trxid": "f751a03a7e09aadb8c43aa0f112d7744b8b1aebf",
        "blockchain": {
            /*Datos de la cadena de bloque*/
    }
}

Donde:

address muestra la dirección del firmante, si no coincide con el emisor de la credencial, es por que la firma es incorrecta o los datos han sido alterados. Para evitar falsos negativos, es importante que valide que los datos enviados son los mismos que se encuentran en elemento "credentialsubject" o en "d" (en el caso de las afirmaciones de tipo micro)
hash es el hash SHA256 calculado para la prueba de firmado. Por favor verifique que es igual al hash de los datos enviados.
blockchain es un documento JSON que contiene los datos de registro de la blockchain y que permite realizar una prueba de existencia y sellado de tiempo, es similar al resultado de la API /stamp/get/.

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/credential/validate/?data=%7B%22x%22:%220x5Ed4a09BAa906883c74889B7d242637ed6F8510c%22,%22id%22:%220x7eF0B187abE780BFD945a5b5A563619c6b32aBC7%22%7D&proof=0x58a2010f59cc0c20bc27ddbe3f4982668a156ef097fa7567403fc9508f00ec4501fdb32bb9a2a2bdcc968a932dc21f6be1aa8a364c67934ea1da1f2c99dfd8e61c',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/credential/validate/?data=%7B%22x%22:%220x5Ed4a09BAa906883c74889B7d242637ed6F8510c%22,%22id%22:%220x7eF0B187abE780BFD945a5b5A563619c6b32aBC7%22%7D&proof=0x58a2010f59cc0c20bc27ddbe3f4982668a156ef097fa7567403fc9508f00ec4501fdb32bb9a2a2bdcc968a932dc21f6be1aa8a364c67934ea1da1f2c99dfd8e61c");
xhr.send();

UTILITARIOS

DESCRIPCIÓN

Estas APIs le ayuda a realizar funciones simples dentro de una red blockchain:

Obtener llaves criptográficas
Calcular un hash del tipo keccak256
Recuperar la dirección que realizó un firmado
Recuperar la dirección que realizó el firmado de una transacción soportada por la Blockchain. Cada transacción no se registra en la blockchain, pero puede ser consultada para verificar si ha sido revocada
Firmar datos arbitrarios
Firmar datos arbitrarios de una transacción
Obtener el balance de una dirección dentro de una red Blockchain
Obtener la cantidad de bloques en una red blockchain
Obtener la información de una transacción
Envia una transacción a la red

{{domain}}/util/keys/create/

Obtener llaves criptográficas

Permite crear llaves criptográficas para firmado y cifrado

URL

https://api.stamping.io/util/keys/create/

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
pwd	Clave o HASH usado como llave privada. Si no se envía este parámetro, se genera una llave aleatoria.	123f98ebe690ade561fcbc753d95104667cbc1e4

Respuesta

					        
{
    "code": "200",
    "message": "Cryptographic keys created successfully",
    "id": "0xd75e844605ca08ee54b30124d13cde6958fc4c3ea81d8ddb3010d9f6ac2eaf96",
    "ECDSA": {
        "privateKey": "0x3a3c898c4ad58c9139723ec2e2a711c0482a4e14021337970846a7bc5ce3b21e",
        "publicKey": "0x5B03A0670BD2EEaC00590d11fF894C721e372416",
        "use": "Blockchain transaction signing"
    },
    "RSA": {
        "privateKey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
        "publicKey": "2D2D2D2D2D424547494E205055424C4943204B45592D2D2D2D2D0A4D494942496A414E42676B71686B6947397730424151454641414F43415138414D49494243674B43415145417579575972344C78656D576367733350746743320A5759577A7973503549374854723770694241764C43706C657673584E6168326A56646C746C67444C6C4174574F61547278737264574F732B6367784557386C550A5844484A457978765942506A3268794F504375365433535531516A786B646B4B637959445737464849666E373877496365796A784544613752546769424E32320A2B4C362B706B5A4A49575A34323272534D4271706248465355666A6E4B48764E36482F3938374E5A77646E516B443673484277574D6C44547A497A66357630360A6967334C726E4338743965426E72376555646466686B7A726B5854326A313146303964752B3675417672346A707463647A754B624B43436B6467756B56364D590A46325730786F4176754361426E364C636356372F43657646366B2F73366F4F79486152377A576973416E34454733454B4B584C55304D436E667274495166314B0A4D774944415141420A2D2D2D2D2D454E44205055424C4943204B45592D2D2D2D2D0A",
        "use": "Data encryption"
    }
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/keys/create/?pwd=123f98ebe690ade561fcbc753d95104667cbc1e4',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/util/keys/create/");
xhr.send();

{{domain}}/util/keys/hashMessage

Permite calcular el hash keccak256 de un mensaje

Los datos se descodificarán en UTF-8 HEX y se codificarán con keccak256. Aplica un hash al mensaje dado para pasar la función web3.eth.accounts.recover(), se envolverán de la siguiente manera:
"\x19Ethereum Signed Message:\n" + message.length + message

eth.hashMessage("Hello World")
> "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2"

// the below results in the same hash
eth.hashMessage(utils.utf8ToHex("Hello World"))
> "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2"

URL

https://api.stamping.io/util/keys/hashMessage

Autenticación

BASIC / TOKEN

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
message	Mensaje que se desea calcular el hash SHA256. Si es HEX, se decodificará antes en UTF8.	HolaMundo

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "hash": "0xc960e883755d564275aa8ef4f1d44417095754d86cb184446e7197292c514894"
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644768583000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/keys/hashMessage/?message=HolaMundo&token=eTF24rNyg...dHjduY',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));

$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/util/keys/hashMessage/?message=HolaMundo&token=eTF24rNy...bdHjduY");
xhr.send();

{{domain}}/util/keys/recover

Permite recuperar la dirección que realizó un firmado

Recupera la dirección de Ethereum que se utilizó para firmar los datos proporcionados.

URL

https://api.stamping.io/util/keys/recover

Autenticación

BASIC / TOKEN

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
message	Mensaje que se desea calcular el hash SHA256. Si es HEX, se decodificará antes en UTF8.	HolaMundo
signature	Mensaje firmado. La firma codificada RLP sin procesar, O el parámetro 2-4 como valores v, r, s.	0x373894..337AB

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "addressServer": "0x6d31de1f7f9ede2d05bad46006f5fde7322e199c933e59447c63cae843b02cf0",
        "publicKey": "0x68FD251AF9bc07694fd8e591Ec4002bdebfcd2Da"
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644770452000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'api.stamping.io/util/keys/recover/?message=0x02e50bba306029c27d2f1feee61805c67627d2777c3bb3fcb4885e33a02cb07d∓token=eTF24rNyg...dHjduY&signature=0x3250f3a53c9b3a7c824fbe852a2385ba7e981f7bb15d27d09b6f0d534bfedd1a487d0d2011ab5f5ec8e6b8f84170dec2fa66b0af2b978e46483aeca269abec3c1c',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "api.stamping.io/util/keys/recover/?message=0x02e50bba306029c27d2f1feee61805c67627d2777c3bb3fcb4885e33a02cb07d&token=eTF24rNy...pDbdHjduY&signature=0x3250f3a53c9b3a7c824fbe852a2385ba7e981f7bb15d27d09b6f0d534bfedd1a487d0d2011ab5f5ec8e6b8f84170dec2fa66b0af2b978e46483aeca269abec3c1c");

xhr.send();

{{domain}}/util/keys/recoverTX

Permite recuperar la dirección que realizó el firmado de una transacción soportada por la Blockchain.

Recupera la dirección de Ethereum que se utilizó para firmar la transacción codificada RLP ((prefijo de longitud recursiva).

URL

https://api.stamping.io/util/keys/recover

Autenticación

BASIC / TOKEN

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
signature	Mensaje firmado. La firma codificada RLP sin procesar, O el parámetro 2-4 como valores v, r, s.	0x373894..337AB

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "address": "0x79FaB16aEF7Ae4f6fC81Ea57A0278A5ae4985A8a"
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644775405000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'api.stamping.io/util/keys/recoverTX/?token=eTF24rNyg...dHjduY&signature=0xf8a4808083895440947318f1852d39843227ff3fb5ee4f1dde9b12b18d80b84230783730636639333439336338346231613462343334386165396539326166303233366666303430336530333662306361393236333830653032616535346339326281e6a03863d4fa7267c163cb655ecd9e1fb7d06e6d6d148fe8cab9d227afc178220b0aa047df49a43ccaebd6c9c36dd03e197951ba0ca394dd3ade3be411957e24ba974c',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "api.stamping.io/util/keys/recover/?token=eTF24rNy...pDbdHjduY&signature=0xf8a4808083895440947318f1852d39843227ff3fb5ee4f1dde9b12b18d80b84230783730636639333439336338346231613462343334386165396539326166303233366666303430336530333662306361393236333830653032616535346339326281e6a03863d4fa7267c163cb655ecd9e1fb7d06e6d6d148fe8cab9d227afc178220b0aa047df49a43ccaebd6c9c36dd03e197951ba0ca394dd3ade3be411957e24ba974c");

xhr.send();

{{domain}}/util/keys/sign

Permite firmar datos arbitrarios

El valor pasado como parámetro de datos se descodificará en UTF-8 HEX y se ajustará de la siguiente manera:
"\x19Ethereum Signed Message:\n" + message.length + message

eth.hashMessage("Hello World")
> "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2"

// the below results in the same hash
eth.hashMessage(utils.utf8ToHex("Hello World"))
> "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2"

URL

https://api.stamping.io/util/keys/hashMessage

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
message	Mensaje que se desea calcular el hash SHA256. Si es HEX, se decodificará antes en UTF8.	HolaMundo
privateKey	Llave privada. Puede enviar vacio este parámetro y se usará en forma automática getPrivateKey() para obtener la llave privada de la billetera caliente	0x224..333

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "message": "0x02e50bba306029c27d2f1feee61805c67627d2777c3bb3fcb4885e33a02cb07d",
        "messageHash": "0x929103af32c8bb98fc1a7f5ec492524a8ad509e127c29e7c0defaba68957c15d",
        "signature": "0x0987f22e7e1c7887586b708f95d8bbca7ec568846a9d92cc4448b5617471b0740977a183585f650595056829ffb469b584c74181ebb5533fc2b48dc87b1fcdb01b",
        "r": "0x0987f22e7e1c7887586b708f95d8bbca7ec568846a9d92cc4448b5617471b074",
        "s": "0x0977a183585f650595056829ffb469b584c74181ebb5533fc2b48dc87b1fcdb0",
        "v": "0x1b",
        "addressFrom": "0x5f420fbd91fb75a0ef93a642d5b85811ad0c0251c8bea27480767d4e6c17e21b",
        "addressFromSignature": "0x87577b45af640e97f65c57abc86d67400e62cd81dc0b4e41bef0e63c15966446705878491029091091db78b293890521a867b79e7687adf50895886c8110ca6c1c"
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644771102000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/keys/sign/?message=HolaMundo&token=eTF24rNyg...dHjduY&privateKey=0x1234...abcd',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
));

$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/util/keys/sign/?message=HolaMundo&token=eTF24rNy...bdHjduY&privateKey=0x1234...abcd");
xhr.send();

{{domain}}/util/keys/signTX

Permite firmar datos arbitrarios de una transacción

Firma una transacción soportada por las redes blockchain basadas en Ethereum Virtual Machine (EVM) firmada con una clave privada determinada. Se necesita un objeto TX con una estructura similar a la siguiente:

{
    to: '0xF0109fC8DF283027b6285cc889F5aA624EaC1F55',
    value: '1000000000',
    gas: '2000000',
    gasPrice: '234567897654321',
    data: "0x111111",
    chainId: 1
}

Descripción

to Contiene el address del destino de la transacción, puede ser una billetera o un contrato
value Cantidad de criptomonedas que desea transferir (no olvidar que debe tener los ceros de los decimales), tenga en cuenta no todos los contratos reciben criptomonedas, por lo que puede enviar cero (0).
gas Gas de la transacción. Puede precindir del parámetro y tomar la cantidad por defecto.
gasPrice Precio del Gas de la transacción.
noce Número de transacción de la cuenta. El valor cero indica que se debe tomar el siguiente valor.
chainId Identificador de la Red blockchain. Considere que esta transacción solo será firmada y no enviada a un red blockchain, si usted se equivoca en la red o el nodo blockchain a utilizar, puede perder sus fichas o criptomonedas.

URL

https://api.stamping.io/util/keys/hashMessage

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
chainId	Identificador de la red. LACCHAIN: 648529 ETHEREUM: 1, Binance Smart Chain (BSC): 56.	648529
nonce	El nonce a usar al firmar esta transacción. El valor predeterminado usará web3.eth.getTransactionCount() .	0
gas	El gas proporcionado por la transacción	200000
gasPrice	El precio del gas establecido por esta transacción, si está vacío, usará web3.eth.getGasPrice()	200
value	El valor de la transacción en wei.	200
data	Los datos de llamada de la transacción, pueden estar vacíos para transferencias de valores simples.	0x0000000000000010000000111
privateKey	Llave privada. Puede enviar vacio este parámetro y se usará en forma automática getPrivateKey() para obtener la llave privada de la billetera caliente	0x224..333

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "code": 200,
        "message": "Ok",
        "data": {
            "rawMessage": "0xf860808083030d40940ca82c887265a45f81ea19ba0b77479f1e81b91980803ca08b410c1b2d9762d5ffc76fab311be8730b6eae56c886c97d911dc22c02f36368a06ac82b1fa85fc1048477df172813dce2f5ada6cb2c54e4380217e12c99f4adc7",
            "objectTx": {
                "to": "0x0Ca82c887265a45F81ea19Ba0b77479F1E81B919",
                "nonce": "0x00",
                "gas": "0x30d40",
                "chainId": "1",
                "gasPrice": "0x0",
                "networkId": 1
            }
        }
    },
    "request_method": "POST",
    "ip": "201.240.82.3",
    "timestamp": 1644783985000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/keys/signTX/?token=eTF24rNygbY...bdHjduY&privateKey=70cf93493c84b1a4...b0ca926380e02ae54c92b&address=0x0Ca82c887265a45F81ea19Ba0b77479F1E81B919&nonce=0&data=&gas=200000&value=0&chainId=1',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/util/keys/signTX/?token=eTF24rNyg...HjduY&privateKey=70cf93493c84b1a4b4348...926380e02ae54c92b&address=0x0Ca82c887265a45F81ea19Ba0b77479F1E81B919&nonce=0&data=&gas=200000&value=0&chainId=1");
xhr.send();

{{domain}}/util/blockchain/balance

Obtener el balance de una dirección dentro de una red Blockchain

Permite obtener el balance de criptomonedas que tiene una determina dirección en una red blockchain basadas en Ethereum Virtual Machine (EVM)

URL

https://api.stamping.io/util/blockchain/balance

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
address	Dirección a la que se desea consultar el balance	0x1234...abcd
node	Nodo de la red blockchain a la que se desea consultar.	https://Binance Smart Chain (BSC)-dataseed1.binance.org

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "balance": 1321874500000000,
        "balanceANSI": 0.0013218745
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644787794000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/blockchain/balance/?token=eTF24rNygbY...bdHjduY&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org&address=0x0Ca82c887265a45F81ea19Ba0b77479F1E81B919',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/util/blockchain/balance/?token=eTF24rNygbY...bdHjduY&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org&address=0x0Ca82c887265a45F81ea19Ba0b77479F1E81B919");
xhr.send();

{{domain}}/util/blockchain/blocks

Cantidad de bloques

Permite obtener la cantidad de bloques en una red blockchain basadas en Ethereum Virtual Machine (EVM)

URL

https://api.stamping.io/util/blockchain/blocks

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
node	Nodo de la red blockchain a la que se desea consultar.	https://Binance Smart Chain (BSC)-dataseed1.binance.org

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "count": 36402448
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644788074000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/blockchain/blocks/?token=eTF24rNygbYI...bdHjduY&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/util/blockchain/blocks/?token=eTF24rNygbYI...bdHjduY&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org");
xhr.send();

{{domain}}/util/blockchain/receipt

Obtener datos de una transacción

Devuelve el recibo de una transacción por hash de transacción. El recibo no está disponible para transacciones y devoluciones pendientes.

URL

https://api.stamping.io/util/blockchain/receipt

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
tx	Hash de la transacción en la red blockchain basada en EVM.	0xda2ac35042c5f0ce2d99c3998f66231fd820f3c17592b29bdda9221b8029d593
node	Nodo de la red blockchain a la que se desea consultar.	https://Binance Smart Chain (BSC)-dataseed1.binance.org

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "blockHash": "0x5a18091c5fa34e55783b752ffa8c981b8927c3ad62f34780def4b37be0d1dc4b",
        "blockNumber": 15230970,
        "contractAddress": null,
        "cumulativeGasUsed": 15157891,
        "from": "0x70f657164e5b75689b64b7fd1fa275f334f28e18",
        "gasUsed": 27168,
        "logs": [
            {
                "address": "0x0000000000000000000000000000000000001000",
                "topics": [
                    "0x627059660ea01c4733a328effb2294d2f86905bf806da763a89cee254de8bee5"
                ],
                "data": "0x000000000000000000000000000000000000000000000000001cddfc7f776f8e",
                "blockNumber": 15230970,
                "transactionHash": "0xda2ac35042c5f0ce2d99c3998f66231fd820f3c17592b29bdda9221b8029d593",
                "transactionIndex": 103,
                "blockHash": "0x5a18091c5fa34e55783b752ffa8c981b8927c3ad62f34780def4b37be0d1dc4b",
                "logIndex": 347,
                "removed": false,
                "id": "log_65e3f06f"
            },
            {
                "address": "0x0000000000000000000000000000000000001000",
                "topics": [
                    "0x93a090ecc682c002995fad3c85b30c5651d7fd29b0be5da9d784a3302aedc055",
                    "0x00000000000000000000000070f657164e5b75689b64b7fd1fa275f334f28e18"
                ],
                "data": "0x0000000000000000000000000000000000000000000000000103cde07b32ec04",
                "blockNumber": 15230970,
                "transactionHash": "0xda2ac35042c5f0ce2d99c3998f66231fd820f3c17592b29bdda9221b8029d593",
                "transactionIndex": 103,
                "blockHash": "0x5a18091c5fa34e55783b752ffa8c981b8927c3ad62f34780def4b37be0d1dc4b",
                "logIndex": 348,
                "removed": false,
                "id": "log_c64b8aad"
            }
        ],
        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000002010000000000000000000000000000004000020000200000000000000000000080000000000000000000000000000000000000000000000000010000000000000000400000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000010000000000000000000000000000000000000000000000",
        "status": true,
        "to": "0x0000000000000000000000000000000000001000",
        "transactionHash": "0xda2ac35042c5f0ce2d99c3998f66231fd820f3c17592b29bdda9221b8029d593",
        "transactionIndex": 103,
        "type": "0x0"
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644788690000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/blockchain/receipt/?token=eTF24rNygb...duY&tx=0xda2ac35042c5f0ce2d99c3998f66231fd820f3c17592b29bdda9221b8029d593&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/util/blockchain/receipt/?token=eTF24rNygb...duY&tx=0xda2ac35042c5f0ce2d99c3998f66231fd820f3c17592b29bdda9221b8029d593&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org");
xhr.send();

{{domain}}/util/blockchain/sendTX

Envia una transacción a la red

Permite enviar una trasacción firmada (rawTransaction) a un nodo de la red blockchain basada en EVM. Si desea firmar una transacción puede usar el API: https://api.stamping.io/util/keys/signTX

URL

https://api.stamping.io/util/blockchain/sendTX

Autenticación

BASIC / TOKEN

Método

POST

Parámetros

Parámetro	Descripción	Ejemplo
token	Token de acceso que se obtiene del panel de STAMPING API	f76809f8f7ac62f94bf554533fff70
rawTransaction	Transacción firmada, generada por ejemplo usando web3.eth.accounts.signTransaction o el API: /util/keys/signTX.	0xda2ac35042c5f...a9221b8029d593
node	Nodo de la red blockchain a la que se desea consultar.	https://Binance Smart Chain (BSC)-dataseed1.binance.org

Respuesta

{
{
    "version": "2.2",
    "code": 200,
    "message": "Ok",
    "data": {
        "blockHash": "0xe3321eb17ff5e8392f096d7e21b82a09524bb7a2334e2db269c7c80eee2f965c",
        "blockNumber": 36411558,
        "contractAddress": null,
        "cumulativeGasUsed": 21000,
        "from": "0x79fab16aef7ae4f6fc81ea57a0278a5ae4985a8a",
        "gasUsed": 21000,
        "logs": [],
        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        "status": true,
        "to": "0x0ca82c887265a45f81ea19ba0b77479f1e81b919",
        "transactionHash": "0xddd08e1f609363ee1688e764f746fce6562c9868b8bb1b5b8a199d71eb6b17c0",
        "transactionIndex": 0
    },
    "request_method": "GET",
    "ip": "201.240.82.3",
    "timestamp": 1644806293000
}

CODIGO DE EJEMPLO

PHP - cURL


$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/util/blockchain/sendTX/?token=eTF24rNygb...duY&rawTransaction=0xda2ac35042c5f0ce2...29bdda9221b8029d593&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/util/blockchain/sendTX/?token=eTF24rNygb...duY&rawTransaction=0xda2ac35042c5f0ce2d99c...c17592b29bdda9221b8029d593&node=https://Binance Smart Chain (BSC)-dataseed1.binance.org");
xhr.send();

GENERICOS

{{domain}}/credits/

Obtener los créditos disponibles en STAMPING API

Muestra la cantidad de paquetes de créditos adquiridos por un usuario, el saldo disponible y el saldo utilizado. Existen 2 tipos: (1) transactions y (2) evidences.

Transactions: Cantidad de transacciones ejecutadas directamente en un smart contract en una red blockchain
Evidences: Cantidad de evidencias digitales enviadas al SST de Stamping y que se agruparon para ser registradas en distintas blockchains públicas.

URL	https://api.stamping.io/credits/
Método	GET
Autenticación	Bearer

Respuesta

					        
{
    "result": "OK",
    "data": {
        "version": "2.2",
        "transactions": {
            "quantity": 6000,
            "used": 565,
            "available": 5435,
            "firstTransaction": "26-02-2021 03:59:40 PM",
            "lastTransaction": "11-02-2022 05:32:49 PM"
        },
        "evidences": {
            "quantity": 50,
            "used": 6,
            "available": 44,
            "firstTransaction": "07-12-2021 02:06:21 AM",
            "lastTransaction": "11-02-2022 07:39:04 PM"
        },
        "packages": [
            {
                "id": "356a192b7913b04c54574d18c28d46e6395428ab",
                "saleDate": "2021-02-27 00:00:00",
                "dueDate": "2022-03-27 00:00:00",
                "transactions": "6000",
                "evidences": "50"
            }
        ],
        "ip": "201.240.82.3",
        "method": "GET"
    }
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/credits/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Bearer eyJhbGciOiAiRUNEU0EiLCJ0...NjVlMDY5ZmZmNTllYzhmZWIwYjExMTNlZQ=='
  ),
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/credits/");
xhr.setRequestHeader("Authorization", "Bearer eyJhbGciOiAiRUNEU0EiLC...ZmNTllYzhmZWIwYjExMTNlZQ==");
xhr.send();

{{domain}}/hash/certificate/

Obtener el certificado de prueba digital

El certificado de evidencia digital se puede obtener de una transacción o de un bloque de anclaje. Se debe enviar el hash SHA256 del documento o los datos anclados o el hash SHA256 del merkle tree treeHash del destinatario. Devuelve el documento PDF del certificado.

URL

https://api.stamping.io/hash/certificate/

Método

GET

Parámetros

Parámetro	Descripción	Ejemplo
hash	Hash SHA256 del documento o dato a registrar	f76809f8f7ac62f94bf554533fff70b42253ef357dc7c415019aa9cef92e15d8

Respuesta

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/hash/certificate/?hash=<hash SHA256>',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/hash/certificate/?hash=<hash SHA256>");
xhr.setRequestHeader("Authorization", "Basic <Token Access>");
xhr.send();

{{domain}}/getTransactions/

Obtener las últimas transacciones del men pool

Muestra una lista de las últimas transacciones que se encuentren en el men pool de Stamping.io (No se encuentren dentro de un bloque de Stamping

URL	https://api.stamping.io/getTransactions/
Método	GET

Respuesta

					        
{
    "code": "200",
    "message": "ok",
    "data": [
        {
            "data": "",
            "id": "536752",
            "trxId": "2c83459940a35cc779b2aef94b8454223c34f1a3",
            "userid": "m7wZf7PKCJOyLoz80EAzxSKSmQW2",
            "evidence": "6b2d9b0178aae75ef8f30d5a3cca4796b289fac871793d8da2c35c6b3295ec2d",
            "hash2": "",
            "hash3": "",
            "timestamp": "1644595517000",
            "subject": "",
            "transactionType": "DEFAULT",
            "ip": "186.74.158.98",
            "lacchain": "0x",
            "address": "0xdead00000000000000000000000000000000dead",
            "bytes": "423",
            "long": "",
            "lat": ""
        },
        {
            "data": "",
            "id": "536751",
            "trxId": "230bdd25ea32782a8b7facfacb59900e67af1766",
            "userid": "m7wZf7PKCJOyLoz80EAzxSKSmQW2",
            "evidence": "4a90de9bd48e066f028dc0bb6d1e7a1e70107742c2b3592d42aee1b5a8309d10",
            "hash2": "",
            "hash3": "",
            "timestamp": "1644595515000",
            "subject": "",
            "transactionType": "DEFAULT",
            "ip": "186.74.158.98",
            "lacchain": "0x",
            "address": "0xdead00000000000000000000000000000000dead",
            "bytes": "423",
            "long": "",
            "lat": ""
        }
    ]
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/getTransactions/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/getTransactions/");
xhr.send();

{{domain}}/block/

Obtener los últimos bloques creados

Muestra un listado de los últinmos bloques que han sido creados en Stamping.io.

URL	https://api.stamping.io/block/
Método	GET

Respuesta

					        
{
    "data": [
        {
            "maxid": "44686",
            "count": "11",
            "id": "44686",
            "hashblock": "5e04218410e364c756734436203b6f0aed257b1b2b57238dc4c09e51abf128f3",
            "hashtree": "0dc1c24b9e13650186f76ea01f4ebf2471d914c3aefce43b9ccc2f624ed9f32d",
            "timestamp": "2022-02-11 11:00:02",
            "blockchain": {
                "mainnet": {
                    "polygon": "",
                    "stamping": "653c9f3d1e8580f1ffb71ee91c17b96e3809b2ff"
                },
                "testnet": {
                    "ropsten": "",
                    "Binance Smart Chain (BSC)": "",
                    "avalanche": "0xa0adb4ad24c2410e39511905c87131a90ec88c9b1dc7f88b9bfddc98888e2007",
                    "lacchain": "0x0d4d861450143cf77045a7ef5c8219c727724b70127684423ae8a039df1ae503"
                }
            }
        },
        {
            "maxid": "44686",
            "count": "10",
            "id": "44685",
            "hashblock": "19264bf53636f820b78563cc38ac5f7d0abc63103e6a945047e36283b1df0c24",
            "hashtree": "395d60933c50086be96d9a5ee2d15cf51d465704eb421fa3b630ee4c4aed24cc",
            "timestamp": "2022-02-11 10:50:01",
            "blockchain": {
                "mainnet": {
                    "polygon": "",
                    "stamping": "12541163a43d081c3c4db581d6d19820769a7e88"
                },
                "testnet": {
                    "ropsten": "0xf172b0c82d7c44c3ddc37794c76ff96833833bf37ab5912ccb12a0467d631b75",
                    "Binance Smart Chain (BSC)": "",
                    "avalanche": "0x815c4a731ff389e6f11ee0d856b056a2b42dbac6c72e0ddc68d0ec23eb709625",
                    "lacchain": "0xdae03ecd779b862761c3e1b807973a0080639ad6d5dd4fdb5a4007949b1e2726"
                }
            }
        }
    ]
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/block/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("POST", "https://api.stamping.io/block/");
xhr.send();

{{domain}}/status/

Obtener el estado de Stamping.io

Realiza una prueba del estado del servicio de Stamping.io

URL	https://api.stamping.io/status/
Método	GET

Respuesta

					        
{
    "result": "KO",
    "data": {
        "version": "2.0",
        "indexador": "activo",
        "cache": "activo",
        "registros": "3710631",
        "ultimo_registro": "11-02-2022 15:39:19 PM UTC (Zona: Lima/Peru)",
        "endosador": "activo",
        "endosador_estado": "Stamping has been successfully transmitted (TRXID[Test]: d1f0c56865c1a99cceea62ba52e7c367f2bafe28)",
        "nodo": "activo",
        "nodo_estado": "Stamping has been successfully transmitted (TX[Test]: 0xddf12e786388ba0b3be24657fb753370864568402899f2819f9f9ea51c2304f6)",
        "block": "36314688",
        "timestamp": "11-02-2022 03:49:06 PM UTC (Zona: Lima/Peru)",
        "ip": "201.240.82.3",
        "method": "GET"
    }
}

CODIGO DE EJEMPLO

PHP - cURL

					        
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.stamping.io/status/',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

Javascript - XHR

var xhr = new XMLHttpRequest();

var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.stamping.io/status/");
xhr.send();

REGRESAR