feat: add support for create token transaction

src/template/transaction/context.ts

@@ -10,7 +10,7 @@
 import Input from '../../models/input';
 import Output from '../../models/output';
 import transactionUtils from '../../utils/transaction';
-import { DEFAULT_TX_VERSION, NATIVE_TOKEN_UID } from '../../constants';
+import { CREATE_TOKEN_TX_VERSION, DEFAULT_TX_VERSION, NATIVE_TOKEN_UID } from '../../constants';
 
 export interface TokenBalance {
   tokens: OutputValueType;
@@ -22,63 +22,63 @@
   balance: Record<string, TokenBalance>;
 
   constructor() {
     this.balance = {};
   }
 
   getTokenBalance(token: string): TokenBalance {
     if (!this.balance[token]) {
       this.balance[token] = {
         tokens: 0n,
         mint_authorities: 0,
         melt_authorities: 0,
       };
     }
 
     return this.balance[token];
   }
 
   setTokenBalance(token: string, balance: TokenBalance) {
     this.balance[token] = balance;
   }
 
   addInput(tx: IHistoryTx, index: number) {
     if (tx.outputs.length <= index) {
       throw new Error('Index does not exist on tx outputs');
     }
     const output = tx.outputs[index];
     const { token } = output;
     const balance = this.getTokenBalance(token);
 
     if (transactionUtils.isAuthorityOutput(output)) {
       if (transactionUtils.isMint(output)) {
         balance.mint_authorities += 1;
       }
 
       if (transactionUtils.isMelt(output)) {
         balance.melt_authorities += 1;
       }
     } else {
       balance.tokens += output.value;
     }
 
     this.setTokenBalance(token, balance);
   }
 
   addOutput(amount: OutputValueType, token: string) {
     const balance = this.getTokenBalance(token);
     balance.tokens -= amount;
     this.setTokenBalance(token, balance);
   }
 
   addOutputAuthority(count: number, token: string, authority: 'mint'|'melt') {
     const balance = this.getTokenBalance(token);
     if (authority === 'mint') {
       balance.mint_authorities -= count;
     }
     if (authority === 'melt') {
       balance.melt_authorities -= count;
     }
     this.setTokenBalance(token, balance);
   }
 }
 
@@ -108,58 +108,76 @@
   debug: boolean;
 
   constructor(logger?: ILogger, debug: boolean = false) {
     this.inputs = [];
     this.outputs = [];
     this.tokens = [];
     this.version = DEFAULT_TX_VERSION;
     this.signalBits = 0;
     this.balance = new TxBalance();
     this.vars = {};
     this._logs = [];
     this._logger = logger ?? getDefaultLogger();
     this.debug = debug;
   }
 
   log(message: string): void {
     this._logs.push(message);
     if (this.debug) {
       this._logger.info(message);
     }
   }
 
   get logArray(): string[] {
     return this._logs;
   }
 
+  useCreateTxContext() {
+    if (this.tokens.length !== 0) {
+      throw new Error(`Trying to build a create token tx with ${this.tokens.length} tokens on the array`);
+    }
+    this.version = CREATE_TOKEN_TX_VERSION;
+  }
+
+  getTokenDataFor(token: string, useCreatedToken: boolean) {
+    if (useCreatedToken) {
+      this.useCreateTxContext();
+      return 1;
+    }
+    return this.addToken(token);
+  }
+
   addToken(token: string) {
     if (token === NATIVE_TOKEN_UID) {
       return 0;
     }
+    if (this.version === CREATE_TOKEN_TX_VERSION) {
+      throw new Error(`Cannot add a custom token to a CREATE_TOKEN_TX`);
+    }
     const index = this.tokens.indexOf(token);
     if (index > -1) {
       // Token is already on the list.
       return index + 1;
     }
     // Token is not on the list, adding now
     this.tokens.push(token);
     return this.tokens.length;
   }
 
   addInput(position: number, ...inputs: Input[]) {
     if (position === -1) {
       this.inputs.push(...inputs);
       return;
     }
 
     this.inputs.splice(position, 0, ...inputs);
   }
 
   addOutput(position: number, ...outputs: Output[]) {
     if (position === -1) {
       this.outputs.push(...outputs);
       return;
     }
 
     this.outputs.splice(position, 0, ...outputs);
   }
 }

src/template/transaction/executor.ts

@@ -47,19 +47,19 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof RawInputInstruction>
 ) {
   ctx.log(`Begin RawInputInstruction: ${JSONBigInt.stringify(ins)}`);
   const position = ins.position;
   const txId = getVariable<string>(ins.txId, ctx.vars, RawInputInstruction.shape.txId);
   const index = getVariable<number>(ins.index, ctx.vars, RawInputInstruction.shape.index);
   ctx.log(`index(${index}), txId(${txId})`);
 
   // Find the original transaction from the input
   const origTx = await interpreter.getTx(txId);
   // Add balance to the ctx.balance
   ctx.balance.addInput(origTx, index);
 
   const input = new Input(txId, index);
   ctx.addInput(position, input);
 }
 
 /**
@@ -70,54 +70,54 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof UtxoSelectInstruction>
 ) {
   ctx.log(`Begin UtxoSelectInstruction: ${JSONBigInt.stringify(ins)}`);
   const position = ins.position;
   const fill = getVariable<bigint>(ins.fill, ctx.vars, UtxoSelectInstruction.shape.fill);
   const token = getVariable<string>(ins.token, ctx.vars, UtxoSelectInstruction.shape.token);
   const address = getVariable<string|undefined>(ins.address, ctx.vars, UtxoSelectInstruction.shape.address);
   ctx.log(`fill(${fill}), address(${address}), token(${token})`);
 
   const autoChange = ins.autoChange;
 
   // Find utxos
   const options: IGetUtxosOptions = { token };
   if (address) {
     options.filter_address = address;
   }
   const { changeAmount, utxos } = await interpreter.getUtxos(fill, options);
 
   // Add utxos as inputs on the transaction
   const inputs: Input[] = [];
   for (const utxo of utxos) {
     ctx.log(`Found utxo with ${utxo.value} of ${utxo.tokenId}`);
     ctx.log(`Create input ${utxo.index} / ${utxo.txId}`);
     inputs.push(new Input(utxo.txId, utxo.index));
   }
 
   // First, update balance
   for (const input of inputs) {
     const origTx = await interpreter.getTx(input.hash);
     ctx.balance.addInput(origTx, input.index);
   }
 
   // Then add inputs to context
   ctx.addInput(position, ...inputs);
 
   ctx.log(`changeAmount: ${changeAmount}`);
 
   if (autoChange && changeAmount) {
     // get change address
     let changeAddress = getVariable<string|undefined>(ins.changeAddress, ctx.vars, UtxoSelectInstruction.shape.changeAddress);
     if (!changeAddress) {
       changeAddress = await interpreter.getChangeAddress(ctx);
     }
     ctx.log(`Creating change for address: ${changeAddress}`);
     // Token should only be on the array if present on the outputs
     const tokenData = ctx.addToken(token);
     const script = createOutputScriptFromAddress(changeAddress, interpreter.getNetwork());
     const output = new Output(changeAmount, script, { tokenData });
     ctx.balance.addOutput(changeAmount, token);
     ctx.addOutput(-1, output);
   }
 }
 
@@ -129,47 +129,47 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof AuthoritySelectInstruction>
 ) {
   ctx.log(`Begin AuthoritySelectInstruction: ${JSONBigInt.stringify(ins)}`);
   const position = ins.position ?? -1;
   const authority = ins.authority;
   const token = getVariable<string>(ins.token, ctx.vars, AuthoritySelectInstruction.shape.token);
   const count = getVariable<number>(ins.count, ctx.vars,AuthoritySelectInstruction.shape.count);
   const address = getVariable<string|undefined>(ins.address, ctx.vars,AuthoritySelectInstruction.shape.address);
   ctx.log(`count(${count}), address(${address}), token(${token})`);
 
   let authoritiesInt = 0n;
   if (authority === 'mint') {
     authoritiesInt += 1n;
   }
   if (authority === 'melt') {
     authoritiesInt += 2n;
   }
 
   // Find utxos
   const options: IGetUtxosOptions = {
     token,
     authorities: authoritiesInt,
   };
   if (address) {
     options.filter_address = address;
   }
   const utxos = await interpreter.getAuthorities(count, options);
 
   // Add utxos as inputs on the transaction
   const inputs: Input[] = [];
   for (const utxo of utxos) {
     ctx.log(`Found authority utxo ${utxo.authorities} of ${token}`);
     ctx.log(`Create input ${utxo.index} / ${utxo.txId}`);
     inputs.push(new Input(utxo.txId, utxo.index));
   }
   // First, update balance
   for (const input of inputs) {
     const origTx = await interpreter.getTx(input.hash);
     ctx.balance.addInput(origTx, input.index);
   }
 
   // Then add inputs to context
   ctx.addInput(position, ...inputs);
 }
 
 /**
@@ -180,49 +180,54 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof RawOutputInstruction>
 ) {
   ctx.log(`Begin RawOutputInstruction: ${JSONBigInt.stringify(ins)}`);
-  const { position, authority } = ins;
+  const { position, authority, useCreatedToken } = ins;
   const scriptStr = getVariable<string>(ins.script, ctx.vars,RawOutputInstruction.shape.script);
   const script = Buffer.from(scriptStr, 'hex');
   const token = getVariable<string>(ins.token, ctx.vars,RawOutputInstruction.shape.token);
   const timelock = getVariable<number|undefined>(ins.timelock, ctx.vars, RawOutputInstruction.shape.timelock);
 
-  // Add token to tokens array
-  const tokenIndex = ctx.addToken(token);
-  let tokenData = tokenIndex;
+  let tokenData: number;
+  if (useCreatedToken) {
+    ctx.useCreateTxContext()
+    tokenData = 1;
+  } else {
+    // Add token to tokens array
+    tokenData = ctx.addToken(token);
+  }
 
   let amount: OutputValueType|undefined = 0n;
   switch (authority) {
     case 'mint':
       amount = TOKEN_MINT_MASK;
       tokenData |= TOKEN_AUTHORITY_MASK;
       break;
     case 'melt':
       amount = TOKEN_MELT_MASK;
       tokenData |= TOKEN_AUTHORITY_MASK;
       break;
     default: {
       amount = getVariable<bigint|undefined>(ins.amount, ctx.vars,RawOutputInstruction.shape.amount);
       break;
     }
 
   }
   ctx.log(`amount(${amount}) timelock(${timelock}) script(${script}) token(${token})`);
   if (!amount) {
     throw new Error('Raw token output missing amount');
   }
 
   // Add balance to the ctx.balance
   if (authority) {
     ctx.log(`Creating authority output`);
     ctx.balance.addOutputAuthority(1, token, authority);
   } else {
     ctx.log(`Creating token output`);
     ctx.balance.addOutput(amount, token);
   }
 
   const output = new Output(amount, script, { timelock, tokenData });
   ctx.addOutput(position, output);
 }
 
 /**
@@ -233,22 +238,30 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof DataOutputInstruction>
 ) {
   ctx.log(`Begin DataOutputInstruction: ${JSONBigInt.stringify(ins)}`);
-  const position = ins.position;
+  const { position, useCreatedToken } = ins;
   const data = getVariable<string>(ins.data, ctx.vars,DataOutputInstruction.shape.data);
   const token = getVariable<string>(ins.token, ctx.vars,DataOutputInstruction.shape.token);
-  ctx.log(`Creating data(${data}) output of token(${token})`);
+  ctx.log(`Creating data(${data}) output`);
 
-  // Add token to tokens array
-  const tokenData = ctx.addToken(token);
+  let tokenData: number;
+  if (useCreatedToken) {
+    ctx.log(`Using created token`);
+    ctx.useCreateTxContext()
+    tokenData = 1;
+  } else {
+    ctx.log(`Using token(${token})`);
+    // Add token to tokens array
+    tokenData = ctx.addToken(token);
+  }
 
   // Add balance to the ctx.balance
   ctx.balance.addOutput(1n, token);
 
   const dataScript = new ScriptData(data);
   const script = dataScript.createScript();
   const output = new Output(1n, script, { tokenData });
   ctx.addOutput(position, output);
 }
 
 /**
@@ -259,23 +272,31 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof TokenOutputInstruction>
 ) {
   ctx.log(`Begin TokenOutputInstruction: ${JSONBigInt.stringify(ins)}`);
-  const position = ins.position;
+  const { position, useCreatedToken } = ins;
   const token = getVariable<string>(ins.token, ctx.vars,TokenOutputInstruction.shape.token);
   const address = getVariable<string>(ins.address, ctx.vars,TokenOutputInstruction.shape.address);
   const timelock = getVariable<number|undefined>(ins.timelock, ctx.vars, TokenOutputInstruction.shape.timelock);
   const amount = getVariable<bigint>(ins.amount, ctx.vars, TokenOutputInstruction.shape.amount);
-  ctx.log(`Creating token output with amount(${amount}) address(${address}) timelock(${timelock}) token(${token})`);
+  ctx.log(`Creating token output with amount(${amount}) address(${address}) timelock(${timelock})`);
 
-  // Add token to tokens array
-  const tokenData = ctx.addToken(token);
+  let tokenData: number;
+  if (useCreatedToken) {
+    ctx.log(`Using created token`);
+    ctx.useCreateTxContext()
+    tokenData = 1;
+  } else {
+    ctx.log(`Using token(${token})`);
+    // Add token to tokens array
+    tokenData = ctx.addToken(token);
+  }
 
   // Add balance to the ctx.balance
   ctx.balance.addOutput(amount, token);
 
   const script = createOutputScriptFromAddress(address, interpreter.getNetwork());
   const output = new Output(amount, script, { timelock, tokenData });
   ctx.addOutput(position, output);
 }
 
 /**
@@ -286,38 +307,46 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof AuthorityOutputInstruction>
 ) {
   ctx.log(`Begin AuthorityOutputInstruction: ${JSONBigInt.stringify(ins)}`);
-  const { authority, position } = ins;
+  const { authority, position, useCreatedToken } = ins;
   const token = getVariable<string>(ins.token, ctx.vars, AuthorityOutputInstruction.shape.token);
   const address = getVariable<string>(ins.address, ctx.vars,AuthorityOutputInstruction.shape.address);
   const timelock = getVariable<number|undefined>(ins.timelock, ctx.vars, AuthorityOutputInstruction.shape.timelock);
   const count = getVariable<number>(ins.count, ctx.vars, AuthorityOutputInstruction.shape.count);
-  ctx.log(`Creating count(${count}) ${authority} authority outputs with address(${address}) timelock(${timelock}) token(${token})`);
+  ctx.log(`Creating count(${count}) "${authority}" authority outputs with address(${address}) timelock(${timelock})`);
 
-  // Add token to tokens array
-  let tokenData = ctx.addToken(token);
+  let tokenData: number;
+  if (useCreatedToken) {
+    ctx.log(`Using created token`);
+    ctx.useCreateTxContext()
+    tokenData = 1;
+  } else {
+    ctx.log(`Using token(${token})`);
+    // Add token to tokens array
+    tokenData = ctx.addToken(token);
+  }
 
   let amount: OutputValueType|undefined = 0n;
   switch(authority) {
     case 'mint':
       amount = TOKEN_MINT_MASK;
       tokenData |= TOKEN_AUTHORITY_MASK;
       break;
     case 'melt':
       amount = TOKEN_MELT_MASK;
       tokenData |= TOKEN_AUTHORITY_MASK;
       break;
     default:
       throw new Error('Authority token output missing `authority`');
   }
 
   // Add balance to the ctx.balance
   ctx.balance.addOutputAuthority(count, token, authority);
 
   const script = createOutputScriptFromAddress(address, interpreter.getNetwork());
   const output = new Output(amount, script, { timelock, tokenData });
   // Creates `count` outputs that are copies of the `output`
   ctx.addOutput(position, ...Array(count).fill(output));
 }
 
 /**
@@ -328,18 +357,18 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof ShuffleInstruction>
 ) {
   ctx.log(`Begin ShuffleInstruction: ${JSONBigInt.stringify(ins)}`);
   const { target } = ins;
 
   // The token array should never be shuffled since outputs have a "pointer" to the token position
   // on the token array, so shuffling would make the outputs target different outputs.
 
   if (target === 'inputs' || target === 'all') {
     ctx.inputs = shuffle(ctx.inputs);
   }
 
   if (target === 'outputs' || target === 'all') {
     ctx.outputs = shuffle(ctx.outputs);
   }
 }
 
@@ -351,56 +380,56 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof ChangeInstruction>
 ) {
   ctx.log(`Begin ChangeInstruction: ${JSONBigInt.stringify(ins)}`);
   const token = getVariable<string|undefined>(ins.token, ctx.vars,ChangeInstruction.shape.token);
   const address = getVariable<string|undefined>(ins.address, ctx.vars,ChangeInstruction.shape.address) ?? await interpreter.getChangeAddress(ctx);
   const timelock = getVariable<number|undefined>(ins.timelock, ctx.vars, ChangeInstruction.shape.timelock);
   ctx.log(`address(${address}) timelock(${timelock}) token(${token})`);
 
   const tokensToCheck: string[] = [];
   if (token) {
     tokensToCheck.push(token);
   } else {
     // Check HTR and all tokens on the transaction
     tokensToCheck.push(NATIVE_TOKEN_UID);
     for (const tk in ctx.tokens) {
       tokensToCheck.push(tk);
     }
   }
 
   const script = createOutputScriptFromAddress(address, interpreter.getNetwork());
 
   for (const tokenUid of tokensToCheck) {
     const balance = ctx.balance.getTokenBalance(tokenUid);
     const tokenData = ctx.addToken(tokenUid);
     if (balance.tokens > 0) {
       // Need to create a token output
       // Add balance to the ctx.balance
       ctx.balance.addOutput(balance.tokens, tokenUid);
 
       // Creates an output with the value of the outstanding balance
       const output = new Output(balance.tokens, script, { timelock, tokenData });
       ctx.addOutput(-1, output);
     }
 
     if (balance.mint_authorities > 0) {
       // Need to create a token output
       // Add balance to the ctx.balance
       ctx.balance.addOutputAuthority(balance.mint_authorities, tokenUid, 'mint');
 
       // Creates an output with the value of the outstanding balance
       const output = new Output(TOKEN_MINT_MASK, script, { timelock, tokenData });
       ctx.addOutput(-1, ...Array(balance.mint_authorities).fill(output));
     }
 
     if (balance.melt_authorities > 0) {
       // Need to create a token output
       // Add balance to the ctx.balance
       ctx.balance.addOutputAuthority(balance.melt_authorities, tokenUid, 'melt');
 
       // Creates an output with the value of the outstanding balance
       const output = new Output(TOKEN_MELT_MASK, script, { timelock, tokenData });
       ctx.addOutput(-1, ...Array(balance.melt_authorities).fill(output));
     }
   }
 }
@@ -413,24 +442,24 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof ConfigInstruction>
 ) {
   ctx.log(`Begin ConfigInstruction: ${JSONBigInt.stringify(ins)}`);
   const version = getVariable<number|undefined>(ins.version, ctx.vars, ConfigInstruction.shape.version);
   const signalBits = getVariable<number|undefined>(ins.signalBits, ctx.vars, ConfigInstruction.shape.signalBits);
   const tokenName = getVariable<string|undefined>(ins.tokenName, ctx.vars, ConfigInstruction.shape.tokenName);
   const tokenSymbol = getVariable<string|undefined>(ins.tokenSymbol, ctx.vars, ConfigInstruction.shape.tokenSymbol);
   ctx.log(`version(${version}) signalBits(${signalBits}) tokenName(${tokenName}) tokenSymbol(${tokenSymbol})`);
 
   if (version) {
     ctx.version = version;
   }
   if (signalBits) {
     ctx.signalBits = signalBits;
   }
   if (tokenName) {
     ctx.tokenName = tokenName;
   }
   if (tokenSymbol) {
     ctx.tokenSymbol = tokenSymbol;
   }
 }
 
@@ -442,34 +471,34 @@
   ctx: TxTemplateContext,
   ins: z.infer<typeof SetVarInstruction>
 ) {
   ctx.log(`Begin SetVarInstruction: ${JSONBigInt.stringify(ins)}`);
   if (!ins.action) {
     ctx.log(`Setting ${ins.name} with ${ins.value}`);
     ctx.vars[ins.name] = ins.value;
     return;
   }
 
   if (ins.action === 'get_wallet_address') {
     // Validate options and get token variable
     const options = SetVarGetWalletAddressOpts.default({}).parse(ins.options);
     const token = getVariable<string>(options.token, ctx.vars, SetVarGetWalletAddressOpts.shape.token);
     options.token = token;
     // Call action with valid options
     const address = await getWalletAddress(interpreter, ctx, options);
     ctx.log(`Setting ${ins.name} with ${address}`);
     ctx.vars[ins.name] = address;
     return;
   }
   if (ins.action === 'get_wallet_balance') {
     // Validate options and get token variable
     const options = SetVarGetWalletBalanceOpts.default({}).parse(ins.options);
     const token = getVariable<string>(options.token, ctx.vars, SetVarGetWalletBalanceOpts.shape.token);
     options.token = token;
     // Call action with valid options
     const balance = await getWalletBalance(interpreter, ctx, options);
     ctx.vars[ins.name] = balance;
     ctx.log(`Setting ${ins.name} with ${balance}`);
     return;
   }
   throw new Error('Invalid setvar command');
 }

src/template/transaction/instructions.ts

@@ -8,8 +8,8 @@
 import { NATIVE_TOKEN_UID } from '../../constants';
 import { z } from 'zod';
 
 const TEMPLATE_REFERENCE_RE = /\{([\w\d]+)\}/;
 export const TemplateRef = z.string().regex(TEMPLATE_REFERENCE_RE);
 
 /**
  * If the key matches a template reference (i.e. `{name}`) it returns the variable of that name.
@@ -40,42 +40,42 @@
   vars: Record<string, unknown>,
   schema: T,
 ): S {
   let val = ref; // type should be: string | S
   const parsed = TemplateRef.safeParse(ref);
   if (parsed.success) {
     const match = parsed.data.match(TEMPLATE_REFERENCE_RE);
     if (match !== null) {
       const key = match[1];
       if (!vars[key]) {
         throw new Error(`Variable ${key} not found in available variables`);
       }
       // We assume that the variable in the context is of type S and we validate this.
       // The case where a `{...}` string is saved is not possible since we do not
       // allow this type of string as variable.
       val = vars[key] as S;
     }
   }
 
   return schema.parse(val) as S;
 }
 
 // Transaction IDs and Custom Tokens are sha256 hex encoded
 export const Sha256HexSchema = z.string().regex(/^[a-fA-F0-9]{64}$/);
 export const TxIdSchema = Sha256HexSchema;
 export const CustomTokenSchema = Sha256HexSchema;
 // If we want to represent all tokens we need to include the native token uid 00
 export const TokenSchema = z.string().regex(/^[a-fA-F0-9]{64}|00$/);
 // Addresses are base58 with length 34, may be 35 depending on the choice of version byte
 export const AddressSchema = z.string().regex(/^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{34,35}$/);
 
 export const RawInputInstruction = z.object({
   type: z.literal('input/raw'),
   position: z.number().default(-1),
   index: TemplateRef.or(z.coerce.number()),
   txId: TemplateRef.or(TxIdSchema),
 });
 
 export const UtxoSelectInstruction = z.object({
   type: z.literal('input/utxo'),
   position: z.number().default(-1),
   fill: TemplateRef.or(z.coerce.bigint()),
@@ -85,7 +85,7 @@
   changeAddress: TemplateRef.or(AddressSchema.optional()),
 });
 
 export const AuthoritySelectInstruction = z.object({
   type: z.literal('input/authority'),
   position: z.number().default(-1),
   authority: z.enum(['mint', 'melt']),
@@ -94,7 +94,7 @@
   address: TemplateRef.or(AddressSchema.optional()),
 });
 
 export const RawOutputInstruction = z.object({
   type: z.literal('output/raw'),
   position: z.number().default(-1),
   amount: TemplateRef.or(z.coerce.bigint().optional()),
@@ -102,9 +102,10 @@
   token: TemplateRef.or(TokenSchema.default('00')),
   timelock: TemplateRef.or(z.coerce.number().optional()),
   authority: z.enum(['mint', 'melt']).optional(),
+  useCreatedToken: z.boolean().default(false),
 });
 
 export const TokenOutputInstruction = z.object({
   type: z.literal('output/token'),
   position: z.number().default(-1),
   amount: TemplateRef.or(z.coerce.bigint()),
@@ -112,9 +113,10 @@
   address: TemplateRef.or(AddressSchema),
   timelock: TemplateRef.or(z.coerce.number().optional()),
   checkAddress: z.boolean().optional(),
+  useCreatedToken: z.boolean().default(false),
 });
 
 export const AuthorityOutputInstruction = z.object({
   type: z.literal('output/authority'),
   position: z.number().default(-1),
   count: TemplateRef.or(z.coerce.number().default(1)),
@@ -123,28 +125,30 @@
   address: TemplateRef.or(AddressSchema),
   timelock: TemplateRef.or(z.coerce.number().optional()),
   checkAddress: z.boolean().optional(),
+  useCreatedToken: z.boolean().default(false),
 });
 
 export const DataOutputInstruction = z.object({
   type: z.literal('output/data'),
   position: z.number().default(-1),
   data: TemplateRef.or(z.string()),
   token: TemplateRef.or(TokenSchema.default(NATIVE_TOKEN_UID)),
+  useCreatedToken: z.boolean().default(false),
 });
 
 export const ShuffleInstruction = z.object({
   type: z.literal('action/shuffle'),
   target: z.enum(['inputs', 'outputs', 'all']),
 });
 
 export const ChangeInstruction = z.object({
   type: z.literal('action/change'),
   token: TemplateRef.or(TokenSchema.optional()),
   address: TemplateRef.or(AddressSchema.optional()),
   timelock: TemplateRef.or(z.coerce.number().optional()),
 });
 
 export const CompleteTxInstruction = z.object({
   type: z.literal('action/complete'),
   token: TemplateRef.or(TokenSchema.optional()),
   address: TemplateRef.or(z.string().optional()),
@@ -152,7 +156,7 @@
   timelock: TemplateRef.or(z.coerce.number()).optional(),
 });
 
 export const ConfigInstruction = z.object({
   type: z.literal('action/config'),
   version: TemplateRef.or(z.number().optional()),
   signalBits: TemplateRef.or(z.number().optional()),
@@ -160,20 +164,20 @@
   tokenSymbol: TemplateRef.or(z.string().optional()),
 });
 
 export const SetVarGetWalletAddressOpts = z.object({
   unused: z.boolean().optional(),
   withBalance: z.number().optional(),
   authority: z.enum(['mint', 'melt']).optional(),
   token: TemplateRef.or(TokenSchema.default(NATIVE_TOKEN_UID)),
 });
 
 export const SetVarGetWalletBalanceOpts = z.object({
   token: TemplateRef.or(TokenSchema.default('00')),
 });
 
 export const SetVarOptions = z.union([SetVarGetWalletAddressOpts, SetVarGetWalletBalanceOpts]);
 
 export const SetVarInstruction = z.object({
   type: z.literal('action/setvar'),
   name: z.string().regex(/[\d\w]+/),
   value: z.any().optional(),
@@ -181,7 +185,7 @@
   options: SetVarOptions.optional(),
 });
 
 export const TxTemplateInstruction = z.discriminatedUnion('type', [
   RawInputInstruction,
   UtxoSelectInstruction,
   AuthoritySelectInstruction,
@@ -197,5 +201,5 @@
 ]);
 export type TxTemplateInstructionType = z.infer<typeof TxTemplateInstruction>;
 
 export const TransactionTemplate = z.array(TxTemplateInstruction);
 export type TransactionTemplateType = z.infer<typeof TransactionTemplate>;