API methods

Utility Functions

Generate Signatures

Before using API methods that require signatures, you'll need to generate them using the provided utility function:

import (
    onemoney "github.com/1Money-Co/1money-go-sdk"
    "github.com/ethereum/go-ethereum/common"
    "math/big"
)

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Example: Generate signature for a payment transaction
paymentPayload := onemoney.PaymentPayload{
    ChainID:   1,
    Nonce:     1,
    Recipient: common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Value:     big.NewInt(1000000000),
    Token:     common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
}

signature, err := client.SignMessage(paymentPayload, privateKey)
if err != nil {
    // Handle error
    panic("Failed to generate signature: " + err.Error())
}

// The signature object will have the correct r, s, v format
fmt.Printf("Generated signature: %+v\n", signature)

Get Account Nonce

address := "0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"
account, err := client.GetAccount(address)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Account nonce: %d\n", account.Nonce)

Get Token Metadata

tokenAddress := "0x2cd8999Be299373D7881f4aDD11510030ad1412F"
tokenMetadata, err := client.GetToken(tokenAddress)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Token metadata: %+v\n", tokenMetadata)

Get Current Checkpoint

checkpoint, err := client.GetCheckpointNumber()
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Current checkpoint number: %d\n", checkpoint.Number)

Transaction Methods

Estimate Transaction Fee

fromAddress := "0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"
value := "1000000000"
tokenAddress := "0x2cd8999Be299373D7881f4aDD11510030ad1412F"

fee, err := client.GetEstimateFee(fromAddress, tokenAddress, value)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Estimated fee: %s\n", fee.Fee)

Get Transaction Details

txHash := "0xf55f9525be94633b56f954d3252d52b8ef42f5fd5f9491b243708471c15cc40c"
transaction, err := client.GetTransactionByHash(txHash)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Transaction details: %+v\n", transaction)

Get Transaction Receipt

txHash := "0xf55f9525be94633b56f954d3252d52b8ef42f5fd5f9491b243708471c15cc40c"
receipt, err := client.GetTransactionReceipt(txHash)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Transaction receipt: %+v\n", receipt)

Payment Methods

Submit Payment Transaction

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create payment payload
payload := onemoney.PaymentPayload{
    ChainID:   1,
    Nonce:     1,
    Recipient: common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Value:     big.NewInt(1000000000),
    Token:     common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create payment request
req := &onemoney.PaymentRequest{
    PaymentPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Submit payment
response, err := client.SendPayment(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Payment transaction hash: %s\n", response.Hash)

Cancel Transaction

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create cancel payload
payload := onemoney.CancelPayload{
    ChainID: 1,
    Nonce:   1,
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create cancel request
req := &onemoney.CancelRequest{
    CancelPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Submit cancellation
response, err := client.CancelTransaction(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Cancellation transaction hash: %s\n", response.Hash)

Token Management Methods

Issue New Token

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create token issue payload
payload := onemoney.TokenIssuePayload{
    ChainID:         1,
    Nonce:           1,
    Name:            "My Token",
    Symbol:          "MTK",
    Decimals:        18,
    MasterAuthority: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create issue token request
req := &onemoney.IssueTokenRequest{
    TokenIssuePayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Issue token
response, err := client.IssueToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Token issued: %+v\n", response)

Mint Tokens

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create mint payload
payload := onemoney.TokenMintPayload{
    ChainID:   1,
    Nonce:     1,
    Token:     common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Recipient: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
    Value:     big.NewInt(1000000000000000000), // 1 token with 18 decimals
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create mint request
req := &onemoney.MintTokenRequest{
    TokenMintPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Mint tokens
response, err := client.MintToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Mint transaction hash: %s\n", response.Hash)

Burn Tokens

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create burn payload
payload := onemoney.TokenBurnPayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Value:   big.NewInt(1000000000000000000), // 1 token with 18 decimals
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create burn request
req := &onemoney.BurnTokenRequest{
    TokenBurnPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Burn tokens
response, err := client.BurnToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Burn transaction hash: %s\n", response.Hash)

Update Token Metadata

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create metadata payload
payload := onemoney.UpdateMetadataPayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Name:    "Updated Token Name",
    URI:     "https://example.com/metadata",
    AdditionalMetadata: []onemoney.AdditionalMetadata{
        {
            Key:   "website",
            Value: "https://example.com",
        },
    },
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create metadata update request
req := &onemoney.UpdateMetadataRequest{
    UpdateMetadataPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update metadata
response, err := client.UpdateTokenMetadata(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Metadata update transaction hash: %s\n", response.Hash)

Set Token Blacklist Status

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create blacklist payload
payload := onemoney.TokenBlacklistPayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Address: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
    Action:  onemoney.Blacklist, // Use onemoney.Whitelist to remove from blacklist
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create blacklist request
req := &onemoney.SetTokenBlacklistRequest{
    TokenBlacklistPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update blacklist status
response, err := client.SetTokenBlacklist(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Blacklist update transaction hash: %s\n", response.Hash)

Grant Token Authority

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create authority payload
payload := onemoney.TokenAuthorityPayload{
    ChainID:        1,
    Nonce:          1,
    Token:          common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    AuthorityAddress: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
    Action:         onemoney.Grant, // Use onemoney.Revoke to remove authority
    AuthorityType:  onemoney.MasterMint,
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create authority request
req := &onemoney.TokenAuthorityRequest{
    TokenAuthorityPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update authority
response, err := client.SetTokenAuthority(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Authority update transaction hash: %s\n", response.Hash)

Pause/Unpause Token

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create pause payload
payload := onemoney.TokenPausePayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Action:  onemoney.Pause, // Use onemoney.Unpause to unpause
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create pause request
req := &onemoney.TokenPauseRequest{
    TokenPausePayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update pause status
response, err := client.PauseToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Pause status update transaction hash: %s\n", response.Hash)

Error Handling

All API methods return an error as the second return value. Always check for errors before using the returned data:

result, err := client.GetCheckpointNumber()
if err != nil {
    // Handle the error appropriately
    log.Fatalf("API request failed: %v", err)
}
// Use result safely now that we've checked for errors
fmt.Printf("Current checkpoint: %d\n", result.Number)