ecash-lib 3.2.0 → 4.0.1

package/src/token/alp.parse.ts

@@ -9,7 +9,7 @@ import {
     ALP_LOKAD_ID,
     ALP_MAX_SIZE,
     ALP_STANDARD,
-    AlpTokenType,
+    AlpTokenType_Number,
     MintData,
 } from './alp.js';
 import {
@@ -30,7 +30,7 @@ export interface AlpGenesis {
     /** "GENESIS" */
     txType: typeof GENESIS_STR;
     /** Token type of the token to create */
-    tokenType: AlpTokenType;
+    tokenType: AlpTokenType_Number;
     /** Info about the token */
     genesisInfo: GenesisInfo;
     /** Which tokens/mint baton to create initially */
@@ -42,7 +42,7 @@ export interface AlpMint {
     /** "MINT" */
     txType: typeof MINT_STR;
     /** Token type of the token to mint */
-    tokenType: AlpTokenType;
+    tokenType: AlpTokenType_Number;
     /** Token ID of the token to mint */
     tokenId: string;
     /** Which tokens/mint baton to create  */
@@ -54,7 +54,7 @@ export interface AlpSend {
     /** "SEND" */
     txType: typeof SEND_STR;
     /** Token type of the token to send */
-    tokenType: AlpTokenType;
+    tokenType: AlpTokenType_Number;
     /** Token ID of the token to send */
     tokenId: string;
     /** Array of the number of token atoms to send to the outputs at 1 to N */
@@ -68,7 +68,7 @@ export interface AlpBurn {
     /** Token type of the token to burn */
     tokenId: string;
     /** Token ID of the token to burn */
-    tokenType: AlpTokenType;
+    tokenType: AlpTokenType_Number;
     /** How many tokens should be burned */
     burnAtoms: bigint;
 }
@@ -138,7 +138,7 @@ export function parseAlp(pushdata: Uint8Array): AlpData | undefined {
     }
 }
 
-function readGenesis(bytes: Bytes, tokenType: AlpTokenType): AlpGenesis {
+function readGenesis(bytes: Bytes, tokenType: AlpTokenType_Number): AlpGenesis {
     const tokenTicker = bytesToStr(readVarBytes(bytes, 'tokenTicker'));
     const tokenName = bytesToStr(readVarBytes(bytes, 'tokenName'));
     const url = bytesToStr(readVarBytes(bytes, 'url'));
@@ -162,7 +162,7 @@ function readGenesis(bytes: Bytes, tokenType: AlpTokenType): AlpGenesis {
     };
 }
 
-function readMint(bytes: Bytes, tokenType: AlpTokenType): AlpMint {
+function readMint(bytes: Bytes, tokenType: AlpTokenType_Number): AlpMint {
     const tokenId = readTokenId(bytes);
     const mintData = readMintData(bytes);
     ensureEnd(bytes, 'MINT');
@@ -174,7 +174,7 @@ function readMint(bytes: Bytes, tokenType: AlpTokenType): AlpMint {
     };
 }
 
-function readSend(bytes: Bytes, tokenType: AlpTokenType): AlpSend {
+function readSend(bytes: Bytes, tokenType: AlpTokenType_Number): AlpSend {
     const tokenId = readTokenId(bytes);
     const sendAtomsArray = readAtomsArray(bytes, 'sendAtomsArray');
     ensureEnd(bytes, 'SEND');
@@ -186,7 +186,7 @@ function readSend(bytes: Bytes, tokenType: AlpTokenType): AlpSend {
     };
 }
 
-function readBurn(bytes: Bytes, tokenType: AlpTokenType): AlpBurn {
+function readBurn(bytes: Bytes, tokenType: AlpTokenType_Number): AlpBurn {
     const tokenId = readTokenId(bytes);
     const burnAtoms = readU48(bytes, 'burnAtoms');
     ensureEnd(bytes, 'BURN');

package/src/token/alp.ts

@@ -18,12 +18,43 @@ export const ALP_LOKAD_ID = strToBytes(ALP_LOKAD_ID_STR);
 /** ALP standard token type number */
 export const ALP_STANDARD = 0;
 
+export type AlpTokenType_Number = typeof ALP_STANDARD;
+
 /** Supported ALP token types */
-export type AlpTokenType = typeof ALP_STANDARD;
+export interface AlpTokenType {
+    protocol: 'ALP';
+    type: AlpTokenType_Type;
+    number: number;
+}
+/** Possible ALP token types returned by chronik */
+export type AlpTokenType_Type =
+    | 'ALP_TOKEN_TYPE_STANDARD'
+    | 'ALP_TOKEN_TYPE_UNKNOWN';
 
 /** ALP limits lengths/sizes to this number, e.g. the number of outputs */
 export const ALP_MAX_SIZE = 127;
 
+export const ALP_TOKEN_TYPE_STANDARD: AlpTokenType = {
+    protocol: 'ALP',
+    type: 'ALP_TOKEN_TYPE_STANDARD',
+    number: ALP_STANDARD,
+};
+
+/**
+ * Although ALP_MAX_SIZE is 127, in practice we can only
+ * handle 29 ALP outputs in a single OP_RETURN given the curent
+ * 223-byte OP_RETURN size limit, and even this assumes
+ * we are only working with 1 ALP token.
+ *
+ * For example an ALP tx that sends multiple tokens cannot support
+ * 29 token outputs as the instructions will require more than 223
+ * bytes in the OP_RETURN.
+ *
+ * So, this is an upper bound on ALP outputs per current mempool
+ * acceptance rules
+ */
+export const ALP_POLICY_MAX_OUTPUTS = 29;
+
 /** Mint data specifying mint amounts (in atoms) and batons of a GENESIS/MINT tx */
 export interface MintData {
     /**

package/src/token/common.ts

@@ -3,6 +3,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 import { strToBytes } from '../io/str.js';
+import { AlpTokenType } from './alp.js';
+import { SlpTokenType } from './slp.js';
 
 /** GENESIS tx type: Creates a new token ID */
 export const GENESIS_STR = 'GENESIS';
@@ -52,3 +54,16 @@ export interface GenesisInfo {
     /** decimals of the token, i.e. how many decimal places the token should be displayed with. */
     decimals?: number;
 }
+
+/**
+ * SLP/ALP token type.
+ *
+ * See `TokenType` in chronik-client.
+ */
+export type TokenType = SlpTokenType | AlpTokenType | UnknownTokenType;
+
+export interface UnknownTokenType {
+    protocol: 'UNKNOWN';
+    type: 'UNKNOWN';
+    number: 0;
+}

package/src/token/slp.parse.ts

@@ -27,7 +27,7 @@ import {
     SLP_MINT_VAULT_SCRIPTHASH_NUM_BYTES,
     SLP_NFT1_CHILD,
     SLP_NFT1_GROUP,
-    SlpTokenType,
+    SlpTokenType_Number,
 } from './slp.js';
 
 /** Parsed SLP GENESIS OP_RETURN Script */
@@ -35,7 +35,7 @@ export interface SlpGenesis {
     /** "GENESIS" */
     txType: typeof GENESIS_STR;
     /** Token type of the token to create */
-    tokenType: SlpTokenType;
+    tokenType: SlpTokenType_Number;
     /** Info about the token */
     genesisInfo: GenesisInfo;
     /** Number of token atoms to initially mint to out_idx=1 */
@@ -81,7 +81,7 @@ export interface SlpSend {
     /** "SEND" */
     txType: typeof SEND_STR;
     /** Token type of the token to send */
-    tokenType: SlpTokenType;
+    tokenType: SlpTokenType_Number;
     /** Token ID of the token to send */
     tokenId: string;
     /** Array of the number of token atoms to send to the outputs at 1 to N */
@@ -93,7 +93,7 @@ export interface SlpBurn {
     /** "BURN" */
     txType: typeof BURN_STR;
     /** Token type of the token to burn */
-    tokenType: SlpTokenType;
+    tokenType: SlpTokenType_Number;
     /** Token ID of the token to burn */
     tokenId: string;
     /** How many tokens should be burned */
@@ -190,7 +190,10 @@ export function parseSlp(opreturnScript: Script): SlpData | undefined {
     }
 }
 
-function nextGenesis(ops: ScriptOpIter, tokenType: SlpTokenType): SlpGenesis {
+function nextGenesis(
+    ops: ScriptOpIter,
+    tokenType: SlpTokenType_Number,
+): SlpGenesis {
     // Parse genesis info
     const tokenTicker = bytesToStr(nextBytesRequired(ops, 'tokenTicker'));
     const tokenName = bytesToStr(nextBytesRequired(ops, 'tokenName'));
@@ -243,7 +246,7 @@ function nextGenesis(ops: ScriptOpIter, tokenType: SlpTokenType): SlpGenesis {
     };
 }
 
-function nextMint(ops: ScriptOpIter, tokenType: SlpTokenType): SlpMint {
+function nextMint(ops: ScriptOpIter, tokenType: SlpTokenType_Number): SlpMint {
     const tokenId = nextTokenId(ops);
     if (tokenType === SLP_MINT_VAULT) {
         const additionalAtomsArray = nextSlpAtomsArray(ops);
@@ -271,7 +274,7 @@ function nextMint(ops: ScriptOpIter, tokenType: SlpTokenType): SlpMint {
     }
 }
 
-function nextSend(ops: ScriptOpIter, tokenType: SlpTokenType): SlpSend {
+function nextSend(ops: ScriptOpIter, tokenType: SlpTokenType_Number): SlpSend {
     const tokenId = nextTokenId(ops);
     const sendAtomsArray = nextSlpAtomsArray(ops);
     return {
@@ -282,7 +285,7 @@ function nextSend(ops: ScriptOpIter, tokenType: SlpTokenType): SlpSend {
     };
 }
 
-function nextBurn(ops: ScriptOpIter, tokenType: SlpTokenType): SlpBurn {
+function nextBurn(ops: ScriptOpIter, tokenType: SlpTokenType_Number): SlpBurn {
     const tokenId = nextTokenId(ops);
     const burnAtoms = parseSlpAtoms(nextBytesRequired(ops, 'burnAtoms'));
     nextEnd(ops, 'BURN');

package/src/token/slp.ts

@@ -36,12 +36,32 @@ export const SLP_MAX_SEND_OUTPUTS = 19;
 export const SLP_ATOMS_NUM_BYTES = 8;
 
 /** Supported SLP token types */
-export type SlpTokenType =
+export interface SlpTokenType {
+    protocol: 'SLP';
+    type: SlpTokenType_Type;
+    number: SlpTokenType_Number;
+}
+
+/** Possible SLP token types returned by chronik */
+export type SlpTokenType_Type =
+    | 'SLP_TOKEN_TYPE_FUNGIBLE'
+    | 'SLP_TOKEN_TYPE_MINT_VAULT'
+    | 'SLP_TOKEN_TYPE_NFT1_GROUP'
+    | 'SLP_TOKEN_TYPE_NFT1_CHILD'
+    | 'SLP_TOKEN_TYPE_UNKNOWN';
+
+export type SlpTokenType_Number =
     | typeof SLP_FUNGIBLE
     | typeof SLP_MINT_VAULT
     | typeof SLP_NFT1_CHILD
     | typeof SLP_NFT1_GROUP;
 
+export const SLP_TOKEN_TYPE_FUNGIBLE: SlpTokenType = {
+    protocol: 'SLP',
+    type: 'SLP_TOKEN_TYPE_FUNGIBLE',
+    number: SLP_FUNGIBLE,
+};
+
 /** Build an SLP GENESIS OP_RETURN, creating a new SLP token */
 export function slpGenesis(
     tokenType: number,