@alephium/web3 0.2.0-rc.10 → 0.2.0-rc.11

package/src/contract/events.ts

@@ -16,14 +16,14 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { ContractEvent } from '../api/api-alephium'
+import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
-export class EventSubscription extends Subscription<ContractEvent> {
+export class EventSubscription extends Subscription<node.ContractEvent> {
   readonly contractAddress: string
   private fromCount: number
 
-  constructor(options: SubscribeOptions<ContractEvent>, contractAddress: string, fromCount?: number) {
+  constructor(options: SubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
     super(options)
     this.contractAddress = contractAddress
     this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
@@ -67,7 +67,7 @@ export class EventSubscription extends Subscription<ContractEvent> {
 }
 
 export function subscribeToEvents(
-  options: SubscribeOptions<ContractEvent>,
+  options: SubscribeOptions<node.ContractEvent>,
   contractAddress: string,
   fromCount?: number
 ): EventSubscription {

package/src/contract/ralph.ts

@@ -17,9 +17,9 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Buffer } from 'buffer/'
+import { Val } from '../api'
 import { bs58, isHexString } from '../utils'
-import { node } from '../api'
-import { Fields, Val } from './contract'
+import { Fields, FieldsSig } from './contract'
 
 const bigIntZero = BigInt(0)
 
@@ -236,7 +236,7 @@ export function encodeScriptField(tpe: string, value: Val): Uint8Array {
 
 const scriptFieldRegex = /\{([0-9]*)\}/g
 
-export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: FieldsSig): string {
   return bytecodeTemplate.replace(scriptFieldRegex, (_, fieldIndex: string) => {
     const fieldName = fieldsSig.names[`${fieldIndex}`]
     const fieldType = fieldsSig.types[`${fieldIndex}`]
@@ -249,7 +249,7 @@ export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fi
   })
 }
 
-export function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+export function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: FieldsSig): string {
   const fieldsEncoded = fieldsSig.names.flatMap((fieldName, fieldIndex) => {
     const fieldType = fieldsSig.types[`${fieldIndex}`]
     if (fieldName in fields) {

package/src/signer/signer.ts

@@ -17,14 +17,24 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ec as EC } from 'elliptic'
-import { NodeProvider } from '../api'
+import {
+  fromApiNumber256,
+  fromApiTokens,
+  NodeProvider,
+  Number256,
+  toApiNumber256,
+  toApiNumber256Optional,
+  toApiTokens,
+  Token
+} from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
 import { Eq, assertType } from '../utils'
 import blake from 'blakejs'
-import { Token } from '../api/api-alephium'
 import { getCurrentNodeProvider } from '../global'
 
+export type OutputRef = node.OutputRef
+
 const ec = new EC('secp256k1')
 
 export interface SignResult {
@@ -50,13 +60,13 @@ export type GetAccountsResult = Account[]
 
 export interface SignTransferTxParams {
   signerAddress: string
-  destinations: node.Destination[]
-  utxos?: node.OutputRef[]
+  destinations: Destination[]
+  utxos?: OutputRef[]
   gasAmount?: number
-  gasPrice?: string
+  gasPrice?: Number256
   submitTx?: boolean
 }
-assertType<Eq<SignTransferTxParams, TxBuildParams<node.BuildTransaction>>>()
+assertType<Eq<keyof SignTransferTxParams, keyof TxBuildParams<node.BuildTransaction>>>()
 export interface SignTransferTxResult {
   fromGroup: number
   toGroup: number
@@ -69,14 +79,14 @@ assertType<Eq<SignTransferTxResult, SignResult>>()
 export interface SignDeployContractTxParams {
   signerAddress: string
   bytecode: string
-  initialAttoAlphAmount?: string
+  initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
-  issueTokenAmount?: string
+  issueTokenAmount?: Number256
   gasAmount?: number
-  gasPrice?: string
+  gasPrice?: Number256
   submitTx?: boolean
 }
-assertType<Eq<SignDeployContractTxParams, TxBuildParams<node.BuildDeployContractTx>>>()
+assertType<Eq<keyof SignDeployContractTxParams, keyof TxBuildParams<node.BuildDeployContractTx>>>()
 export interface SignDeployContractTxResult {
   fromGroup: number
   toGroup: number
@@ -92,12 +102,12 @@ export interface SignExecuteScriptTxParams {
   signerAddress: string
   bytecode: string
   attoAlphAmount?: string
-  tokens?: node.Token[]
+  tokens?: Token[]
   gasAmount?: number
   gasPrice?: string
   submitTx?: boolean
 }
-assertType<Eq<SignExecuteScriptTxParams, TxBuildParams<node.BuildExecuteScriptTx>>>()
+assertType<Eq<keyof SignExecuteScriptTxParams, keyof TxBuildParams<node.BuildExecuteScriptTx>>>()
 export interface SignExecuteScriptTxResult {
   fromGroup: number
   toGroup: number
@@ -177,9 +187,12 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
     return (await this.getAccounts())[0].address
   }
 
-  async submitTransaction(unsignedTx: string, txHash: string, signerAddress?: string): Promise<SubmissionResult> {
+  async submitTransaction(unsignedTx: string, signerAddress?: string): Promise<SubmissionResult> {
+    const decoded = await this.provider.transactions.postTransactionsDecodeUnsignedTx({ unsignedTx: unsignedTx })
+    const txId = decoded.unsignedTx.txId
+
     const address = typeof signerAddress !== 'undefined' ? signerAddress : await this.defaultSignerAddress()
-    const signature = await this.signRaw(address, txHash)
+    const signature = await this.signRaw(address, txId)
     const params: node.SubmitTransaction = { unsignedTx: unsignedTx, signature: signature }
     return this.provider.transactions.postTransactionsSubmit(params)
   }
@@ -207,7 +220,12 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
   }
 
   async buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult> {
-    return this.provider.transactions.postTransactionsBuild(await this.usePublicKey(params))
+    const data: node.BuildTransaction = {
+      ...(await this.usePublicKey(params)),
+      destinations: toApiDestinations(params.destinations),
+      gasPrice: toApiNumber256Optional(params.gasPrice)
+    }
+    return this.provider.transactions.postTransactionsBuild(data)
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
@@ -221,7 +239,14 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
   }
 
   async buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult> {
-    return this.provider.contracts.postContractsUnsignedTxDeployContract(await this.usePublicKey(params))
+    const data: node.BuildDeployContractTx = {
+      ...(await this.usePublicKey(params)),
+      initialAttoAlphAmount: toApiNumber256Optional(params.initialAttoAlphAmount),
+      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
+      issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
+      gasPrice: toApiNumber256Optional(params.gasPrice)
+    }
+    return this.provider.contracts.postContractsUnsignedTxDeployContract(data)
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
@@ -230,7 +255,11 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
   }
 
   async buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult> {
-    return this.provider.contracts.postContractsUnsignedTxExecuteScript(await this.usePublicKey(params))
+    const data: node.BuildExecuteScriptTx = {
+      ...(await this.usePublicKey(params)),
+      tokens: toApiTokens(params.tokens)
+    }
+    return this.provider.contracts.postContractsUnsignedTxExecuteScript(data)
   }
 
   // in general, wallet should show the decoded information to user for confirmation
@@ -312,3 +341,24 @@ export function verifySignedMessage(message: string, publicKey: string, signatur
   const messageHash = blake.blake2b(extendedMessage, undefined, 32)
   return verifyHexString(utils.binToHex(messageHash), publicKey, signature)
 }
+
+export interface Destination {
+  address: string
+  attoAlphAmount: Number256
+  tokens?: Token[]
+  lockTime?: number
+  message?: string
+}
+assertType<Eq<keyof Destination, keyof node.Destination>>
+
+export function toApiDestination(data: Destination): node.Destination {
+  return { ...data, attoAlphAmount: toApiNumber256(data.attoAlphAmount), tokens: toApiTokens(data.tokens) }
+}
+
+export function toApiDestinations(data: Destination[]): node.Destination[] {
+  return data.map(toApiDestination)
+}
+
+export function fromApiDestination(data: node.Destination): Destination {
+  return { ...data, attoAlphAmount: fromApiNumber256(data.attoAlphAmount), tokens: fromApiTokens(data.tokens) }
+}

package/src/transaction/status.ts

@@ -16,9 +16,11 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { TxStatus } from '../api/api-alephium'
+import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
+export type TxStatus = node.TxStatus
+
 export class TxStatusSubscription extends Subscription<TxStatus> {
   readonly txId: string
   readonly fromGroup?: number

package/templates/base/package.json

@@ -12,7 +12,7 @@
     "stop-devnet": "node scripts/stop-devnet.js"
   },
   "dependencies": {
-    "@alephium/web3": "0.2.0-rc.9"
+    "@alephium/web3": "0.2.0-rc.11"
   },
   "devDependencies": {
     "@types/elliptic": "^6.4.13",

package/templates/base/src/greeter.ts

@@ -9,7 +9,7 @@ async function greet() {
   web3.setCurrentNodeProvider('http://127.0.0.1:22973')
   await Project.build()
 
-  const greeter = Project.contract('greeter/greeter.ral')
+  const greeter = Project.contract('Greeter')
 
   const testParams: TestContractParams = {
     initialFields: { btcPrice: 1 }
@@ -24,10 +24,10 @@ async function greet() {
   console.log(deployTx.fromGroup)
   console.log(deployTx.toGroup)
 
-  const submitResult = await signer.submitTransaction(deployTx.unsignedTx, deployTx.txId)
+  const submitResult = await signer.submitTransaction(deployTx.unsignedTx)
   console.log(submitResult)
 
-  const main = Project.script('greeter_main.ral')
+  const main = Project.script('GreeterMain')
 
   const mainScriptTx = await main.transactionForDeployment(signer, {
     initialFields: { greeterContractId: greeterContractId }
@@ -35,7 +35,7 @@ async function greet() {
   console.log(mainScriptTx.fromGroup)
   console.log(mainScriptTx.toGroup)
 
-  const mainSubmitResult = await signer.submitTransaction(mainScriptTx.unsignedTx, mainScriptTx.txId)
+  const mainSubmitResult = await signer.submitTransaction(mainScriptTx.unsignedTx)
   console.log(mainSubmitResult)
 }
 

package/templates/react/package.json

@@ -12,7 +12,7 @@
     "@types/node": "^16.11.26",
     "@types/react": "^18.0.3",
     "@types/react-dom": "^18.0.0",
-    "@alephium/web3": "0.2.0-rc.9",
+    "@alephium/web3": "0.2.0-rc.11",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "react-scripts": "5.0.1",